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