contrib/llvm/tools/lldb/source/Interpreter/CommandReturnObject.cpp

   1 //===-- CommandReturnObject.cpp ---------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Interpreter/CommandReturnObject.h"
  11
  12 #include "lldb/Utility/Status.h"
  13 #include "lldb/Utility/StreamString.h"
  14
  15 using namespace lldb;
  16 using namespace lldb_private;
  17
  18 static void DumpStringToStreamWithNewline(Stream &strm, const std::string &s,
  19                                           bool add_newline_if_empty) {
  20   bool add_newline = false;
  21   if (s.empty()) {
  22     add_newline = add_newline_if_empty;
  23   } else {
  24     // We already checked for empty above, now make sure there is a newline in
  25     // the error, and if there isn't one, add one.
  26     strm.Write(s.c_str(), s.size());
  27
  28     const char last_char = *s.rbegin();
  29     add_newline = last_char != '\n' && last_char != '\r';
  30   }
  31   if (add_newline)
  32     strm.EOL();
  33 }
  34
  35 CommandReturnObject::CommandReturnObject()
  36     : m_out_stream(), m_err_stream(), m_status(eReturnStatusStarted),
  37       m_did_change_process_state(false), m_interactive(true),
  38       m_abnormal_stop_was_expected(false) {}
  39
  40 CommandReturnObject::~CommandReturnObject() {}
  41
  42 void CommandReturnObject::AppendErrorWithFormat(const char *format, ...) {
  43   if (!format)
  44     return;
  45   va_list args;
  46   va_start(args, format);
  47   StreamString sstrm;
  48   sstrm.PrintfVarArg(format, args);
  49   va_end(args);
  50
  51   const std::string &s = sstrm.GetString();
  52   if (!s.empty()) {
  53     Stream &error_strm = GetErrorStream();
  54     error_strm.PutCString("error: ");
  55     DumpStringToStreamWithNewline(error_strm, s, false);
  56   }
  57 }
  58
  59 void CommandReturnObject::AppendMessageWithFormat(const char *format, ...) {
  60   if (!format)
  61     return;
  62   va_list args;
  63   va_start(args, format);
  64   StreamString sstrm;
  65   sstrm.PrintfVarArg(format, args);
  66   va_end(args);
  67
  68   GetOutputStream() << sstrm.GetString();
  69 }
  70
  71 void CommandReturnObject::AppendWarningWithFormat(const char *format, ...) {
  72   if (!format)
  73     return;
  74   va_list args;
  75   va_start(args, format);
  76   StreamString sstrm;
  77   sstrm.PrintfVarArg(format, args);
  78   va_end(args);
  79
  80   GetErrorStream() << "warning: " << sstrm.GetString();
  81 }
  82
  83 void CommandReturnObject::AppendMessage(llvm::StringRef in_string) {
  84   if (in_string.empty())
  85     return;
  86   GetOutputStream() << in_string << "\n";
  87 }
  88
  89 void CommandReturnObject::AppendWarning(llvm::StringRef in_string) {
  90   if (in_string.empty())
  91     return;
  92   GetErrorStream() << "warning: " << in_string << "\n";
  93 }
  94
  95 // Similar to AppendWarning, but do not prepend 'warning: ' to message, and
  96 // don't append "\n" to the end of it.
  97
  98 void CommandReturnObject::AppendRawWarning(llvm::StringRef in_string) {
  99   if (in_string.empty())
 100     return;
 101   GetErrorStream() << in_string;
 102 }
 103
 104 void CommandReturnObject::AppendError(llvm::StringRef in_string) {
 105   if (in_string.empty())
 106     return;
 107   GetErrorStream() << "error: " << in_string << "\n";
 108 }
 109
 110 void CommandReturnObject::SetError(const Status &error,
 111                                    const char *fallback_error_cstr) {
 112   const char *error_cstr = error.AsCString();
 113   if (error_cstr == nullptr)
 114     error_cstr = fallback_error_cstr;
 115   SetError(error_cstr);
 116 }
 117
 118 void CommandReturnObject::SetError(llvm::StringRef error_str) {
 119   if (error_str.empty())
 120     return;
 121
 122   AppendError(error_str);
 123   SetStatus(eReturnStatusFailed);
 124 }
 125
 126 // Similar to AppendError, but do not prepend 'Status: ' to message, and don't
 127 // append "\n" to the end of it.
 128
 129 void CommandReturnObject::AppendRawError(llvm::StringRef in_string) {
 130   if (in_string.empty())
 131     return;
 132   GetErrorStream() << in_string;
 133 }
 134
 135 void CommandReturnObject::SetStatus(ReturnStatus status) { m_status = status; }
 136
 137 ReturnStatus CommandReturnObject::GetStatus() { return m_status; }
 138
 139 bool CommandReturnObject::Succeeded() {
 140   return m_status <= eReturnStatusSuccessContinuingResult;
 141 }
 142
 143 bool CommandReturnObject::HasResult() {
 144   return (m_status == eReturnStatusSuccessFinishResult ||
 145           m_status == eReturnStatusSuccessContinuingResult);
 146 }
 147
 148 void CommandReturnObject::Clear() {
 149   lldb::StreamSP stream_sp;
 150   stream_sp = m_out_stream.GetStreamAtIndex(eStreamStringIndex);
 151   if (stream_sp)
 152     static_cast<StreamString *>(stream_sp.get())->Clear();
 153   stream_sp = m_err_stream.GetStreamAtIndex(eStreamStringIndex);
 154   if (stream_sp)
 155     static_cast<StreamString *>(stream_sp.get())->Clear();
 156   m_status = eReturnStatusStarted;
 157   m_did_change_process_state = false;
 158   m_interactive = true;
 159 }
 160
 161 bool CommandReturnObject::GetDidChangeProcessState() {
 162   return m_did_change_process_state;
 163 }
 164
 165 void CommandReturnObject::SetDidChangeProcessState(bool b) {
 166   m_did_change_process_state = b;
 167 }
 168
 169 bool CommandReturnObject::GetInteractive() const { return m_interactive; }
 170
 171 void CommandReturnObject::SetInteractive(bool b) { m_interactive = b; }