Get rid of the C-string parameter in DoExecute

[teemperor]

Summary

This patch gets rid of the C-string parameter in the RawCommandObject::DoExecute function,
making the code simpler and less memory unsafe.

There seems to be a assumption in some command objects that this parameter could be a nullptr,
but from what I can see the rest of the API doesn't actually allow this (and other command
objects and related code pieces dereference this parameter without any checks).

Especially CommandObjectRegexCommand has error handling code for a nullptr that is now gone.

[jingham]

I think the CommandObjectRegex check that you took out wasn't something devious or clever, but was just an incomplete (and so buggy) version of the check:

if (command && command[0])

that you've been replacing with:

if (command.empty())

everywhere else in the patch. After all, the error message if you take the failing branch was:

result.AppendError("empty command passed to regular expression command");

So I think instead of taking this line out, you should also convert it to an if(command.empty()) and early return it with the error message you removed.

Other than that, this change looks fine.

[teemperor]

@jingham I thought the same at first, but giving an error command.empty() turns out to be a problem. The command string contains the arguments (but not the command name itself). So when calling for example bt we would hit this error (as there are no args, so command is empty). I think this code was written with the assumption that command contains the whole command line or something like that.

[jingham]

Yeah, you are right about that. The command string presented to commands never contained the command name, that always got stripped off. But I don't think that ever left the command string to be nullptr... So you are right, that was just dead code.

[teemperor]

Davide also approved it offline (thx).

[stella.stamenova]

I am debugging through it right now, but I believe this change caused several tests on Windows with Python 3 to fail. The failures are all related to UTF-8. For example:

UnicodeDecodeError: 'utf-8' codec can't decode byte 0x80 in position 0: invalid start byte

[teemperor]

Sorry, I think I know why this is happening. Give me a bit to make a patch.

lldb/trunk/include/lldb/Interpreter/CommandObject.h

llvm::StringRef help = "", llvm::StringRef syntax = "",
                    uint32_t flags = 0)
       : CommandObject(interpreter, name, help, syntax, flags) {}
 
   ~CommandObjectRaw() override = default;
 
   bool Execute(const char *args_string, CommandReturnObject &result) override;
 
 protected:
-  virtual bool DoExecute(const char *command, CommandReturnObject &result) = 0;
+  virtual bool DoExecute(llvm::StringRef command,
+                         CommandReturnObject &result) = 0;
 
   bool WantsRawCommandString() override { return true; }
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_CommandObject_h_

lldb/trunk/include/lldb/Interpreter/CommandObjectRegexCommand.h

public:
 
   bool AddRegexCommand(const char *re_cstr, const char *command_cstr);
 
   bool HasRegexEntries() const { return !m_entries.empty(); }
 
   int HandleCompletion(CompletionRequest &request) override;
 
 protected:
-  bool DoExecute(const char *command, CommandReturnObject &result) override;
+  bool DoExecute(llvm::StringRef command, CommandReturnObject &result) override;
 
   struct Entry {
     RegularExpression regex;
     std::string command;
   };
 
   typedef std::list<Entry> EntryCollection;
   const uint32_t m_max_matches;

lldb/trunk/include/lldb/Interpreter/ScriptInterpreter.h

private:
     bool m_enable_io;
     bool m_set_lldb_globals;
     bool m_maskout_errors;
   };
 
   virtual bool Interrupt() { return false; }
 
   virtual bool ExecuteOneLine(
-      const char *command, CommandReturnObject *result,
+      llvm::StringRef command, CommandReturnObject *result,
       const ExecuteScriptOptions &options = ExecuteScriptOptions()) = 0;
 
   virtual void ExecuteInterpreterLoop() = 0;
 
   virtual bool ExecuteOneLineWithReturn(
-      const char *in_string, ScriptReturnType return_type, void *ret_value,
+      llvm::StringRef in_string, ScriptReturnType return_type, void *ret_value,
       const ExecuteScriptOptions &options = ExecuteScriptOptions()) {
     return true;
   }
 
   virtual Status ExecuteMultipleLines(
       const char *in_string,
       const ExecuteScriptOptions &options = ExecuteScriptOptions()) {
     Status error;
public:
   }
 
   virtual ConstString
   GetSyntheticTypeName(const StructuredData::ObjectSP &implementor) {
     return ConstString();
   }
 
   virtual bool
-  RunScriptBasedCommand(const char *impl_function, const char *args,
+  RunScriptBasedCommand(const char *impl_function, llvm::StringRef args,
                         ScriptedCommandSynchronicity synchronicity,
                         lldb_private::CommandReturnObject &cmd_retobj,
                         Status &error,
                         const lldb_private::ExecutionContext &exe_ctx) {
     return false;
   }
 
-  virtual bool
-  RunScriptBasedCommand(StructuredData::GenericSP impl_obj_sp, const char *args,
-                        ScriptedCommandSynchronicity synchronicity,
-                        lldb_private::CommandReturnObject &cmd_retobj,
-                        Status &error,
-                        const lldb_private::ExecutionContext &exe_ctx) {
+  virtual bool RunScriptBasedCommand(
+      StructuredData::GenericSP impl_obj_sp, llvm::StringRef args,
+      lldb_private::CommandReturnObject &cmd_retobj, Status &error,
     return false;
   }
 
   virtual bool RunScriptFormatKeyword(const char *impl_function,
                                       Process *process, std::string &output,
                                       Status &error) {
     error.SetErrorString("unimplemented");
     return false;

lldb/trunk/source/Commands/CommandObjectCommands.cpp

(lldb) command alias bl3 breakpoint set -f %1 -l 3
     m_arguments.push_back(arg1);
     m_arguments.push_back(arg2);
     m_arguments.push_back(arg3);
   }
 
   ~CommandObjectCommandsAlias() override = default;
 
 protected:
-  bool DoExecute(const char *raw_command_line,
+  bool DoExecute(llvm::StringRef raw_command_line,
                  CommandReturnObject &result) override {
-    if (!raw_command_line || !raw_command_line[0]) {
+    if (raw_command_line.empty()) {
       result.AppendError("'command alias' requires at least two arguments");
       return false;
     }
 
     ExecutionContext exe_ctx = GetCommandInterpreter().GetExecutionContext();
     m_option_group.NotifyOptionParsingStarting(&exe_ctx);
 
     OptionsWithRaw args_with_suffix(raw_command_line);
llvm::StringRef GetHelpLong() override {
     m_fetched_help_long =
         scripter->GetDocumentationForItem(m_function_name.c_str(), docstring);
     if (!docstring.empty())
       SetHelpLong(docstring);
     return CommandObjectRaw::GetHelpLong();
   }
 
 protected:
-  bool DoExecute(const char *raw_command_line,
+  bool DoExecute(llvm::StringRef raw_command_line,
                  CommandReturnObject &result) override {
     ScriptInterpreter *scripter = m_interpreter.GetScriptInterpreter();
 
     Status error;
 
     result.SetStatus(eReturnStatusInvalid);
 
     if (!scripter ||
llvm::StringRef GetHelpLong() override {
     m_fetched_help_long =
         scripter->GetLongHelpForCommandObject(m_cmd_obj_sp, docstring);
     if (!docstring.empty())
       SetHelpLong(docstring);
     return CommandObjectRaw::GetHelpLong();
   }
 
 protected:
-  bool DoExecute(const char *raw_command_line,
+  bool DoExecute(llvm::StringRef raw_command_line,
                  CommandReturnObject &result) override {
     ScriptInterpreter *scripter = m_interpreter.GetScriptInterpreter();
 
     Status error;
 
     result.SetStatus(eReturnStatusInvalid);
 
     if (!scripter ||

lldb/trunk/source/Commands/CommandObjectExpression.h

protected:
   // IOHandler::Delegate functions
   //------------------------------------------------------------------
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &line) override;
 
   bool IOHandlerIsInputComplete(IOHandler &io_handler,
                                 StringList &lines) override;
 
-  bool DoExecute(const char *command, CommandReturnObject &result) override;
+  bool DoExecute(llvm::StringRef command, CommandReturnObject &result) override;
 
-  bool EvaluateExpression(const char *expr, Stream *output_stream,
+  bool EvaluateExpression(llvm::StringRef expr, Stream *output_stream,
                           Stream *error_stream,
                           CommandReturnObject *result = NULL);
 
   void GetMultilineExpression();
 
   OptionGroupOptions m_option_group;
   OptionGroupFormat m_format_options;
   OptionGroupValueObjectDisplay m_varobj_options;

lldb/trunk/source/Commands/CommandObjectExpression.cpp

CanBeUsedForElementCountPrinting(ValueObject &valobj) {
   CompilerType pointee;
   if (!type.IsPointerType(&pointee))
     return Status("as it does not refer to a pointer");
   if (pointee.IsVoidType())
     return Status("as it refers to a pointer to void");
   return Status();
 }
 
-bool CommandObjectExpression::EvaluateExpression(const char *expr,
+bool CommandObjectExpression::EvaluateExpression(llvm::StringRef expr,
                                                  Stream *output_stream,
                                                  Stream *error_stream,
                                                  CommandReturnObject *result) {
   // Don't use m_exe_ctx as this might be called asynchronously after the
   // command object DoExecute has finished when doing multi-line expression
   // that use an input reader...
   ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
 
void CommandObjectExpression::GetMultilineExpression() {
   if (output_sp) {
     output_sp->PutCString(
         "Enter expressions, then terminate with an empty line to evaluate:\n");
     output_sp->Flush();
   }
   debugger.PushIOHandler(io_handler_sp);
 }
 
-bool CommandObjectExpression::DoExecute(const char *command,
+bool CommandObjectExpression::DoExecute(llvm::StringRef command,
                                         CommandReturnObject &result) {
   m_fixed_expression.clear();
   auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
   m_option_group.NotifyOptionParsingStarting(&exe_ctx);
 
-  if (command[0] == '\0') {
+  if (command.empty()) {
     GetMultilineExpression();
     return result.Succeeded();
   }
 
   OptionsWithRaw args(command);
-  const char *expr = args.GetRawPart().c_str();
+  llvm::StringRef expr = args.GetRawPart();
 
   if (args.HasArgs()) {
     if (!ParseOptionsAndNotify(args.GetArgs(), result, m_option_group, exe_ctx))
       return false;
 
     if (m_repl_option.GetOptionValue().GetCurrentValue()) {
       Target *target = m_interpreter.GetExecutionContext().GetTargetPtr();
       if (target) {
if (m_repl_option.GetOptionValue().GetCurrentValue()) {
                 Language::GetNameForLanguageType(m_command_options.language));
             result.SetError(repl_error);
             return result.Succeeded();
           }
         }
       }
     }
     // No expression following options
-    else if (expr[0] == '\0') {
+    else if (expr.empty()) {
       GetMultilineExpression();
       return result.Succeeded();
     }
   }
 
   Target *target = GetSelectedOrDummyTarget();
   if (EvaluateExpression(expr, &(result.GetOutputStream()),
                          &(result.GetErrorStream()), &result)) {

lldb/trunk/source/Commands/CommandObjectPlatform.cpp

CommandObjectPlatformShell(CommandInterpreter &interpreter)
                          "Run a shell command on the current platform.",
                          "platform shell <shell-command>", 0),
         m_options() {}
 
   ~CommandObjectPlatformShell() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
-  bool DoExecute(const char *raw_command_line,
+  bool DoExecute(llvm::StringRef raw_command_line,
                  CommandReturnObject &result) override {
     ExecutionContext exe_ctx = GetCommandInterpreter().GetExecutionContext();
     m_options.NotifyOptionParsingStarting(&exe_ctx);
 
 
     // Print out an usage syntax on an empty command line.
-    if (raw_command_line[0] == '\0') {
+    if (raw_command_line.empty()) {
       result.GetOutputStream().Printf("%s\n", this->GetSyntax().str().c_str());
       return true;
     }
 
     OptionsWithRaw args(raw_command_line);
     const char *expr = args.GetRawPart().c_str();
 
     if (args.HasArgs())

lldb/trunk/source/Commands/CommandObjectSettings.cpp

if (request.GetCursorIndex() == setting_var_idx) {
           }
         }
       }
     }
     return request.GetMatches().GetSize();
   }
 
 protected:
-  bool DoExecute(const char *command, CommandReturnObject &result) override {
+  bool DoExecute(llvm::StringRef command,
+                 CommandReturnObject &result) override {
     Args cmd_args(command);
 
     // Process possible options.
     if (!ParseOptions(cmd_args, result))
       return false;
 
     const size_t argc = cmd_args.GetArgumentCount();
     if ((argc < 2) && (!m_options.m_global)) {
if (request.GetCursorIndex() < 2)
           completion_str.c_str(), request.GetMatchStartPoint(),
           request.GetMaxReturnElements(), nullptr, word_complete,
           request.GetMatches());
     request.SetWordComplete(word_complete);
     return request.GetMatches().GetSize();
   }
 
 protected:
-  bool DoExecute(const char *command, CommandReturnObject &result) override {
+  bool DoExecute(llvm::StringRef command,
+                 CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
 
     Args cmd_args(command);
 
     // Process possible options.
     if (!ParseOptions(cmd_args, result))
       return false;
 
if (request.GetCursorIndex() < 2)
           request.GetMaxReturnElements(), nullptr, word_complete,
           request.GetMatches());
     request.SetWordComplete(word_complete);
 
     return request.GetMatches().GetSize();
   }
 
 protected:
-  bool DoExecute(const char *command, CommandReturnObject &result) override {
+  bool DoExecute(llvm::StringRef command,
+                 CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
 
     Args cmd_args(command);
     const char *var_name = cmd_args.GetArgumentAtIndex(0);
     if ((var_name == nullptr) || (var_name[0] == '\0')) {
       result.AppendError("'settings replace' command requires a valid variable "
                          "name; No value supplied");
       result.SetStatus(eReturnStatusFailed);
if (request.GetCursorIndex() < 2)
           request.GetMaxReturnElements(), nullptr, word_complete,
           request.GetMatches());
     request.SetWordComplete(word_complete);
 
     return request.GetMatches().GetSize();
   }
 
 protected:
-  bool DoExecute(const char *command, CommandReturnObject &result) override {
+  bool DoExecute(llvm::StringRef command,
+                 CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
 
     Args cmd_args(command);
     const size_t argc = cmd_args.GetArgumentCount();
 
     if (argc < 3) {
       result.AppendError("'settings insert-before' takes more arguments");
       result.SetStatus(eReturnStatusFailed);
if (request.GetCursorIndex() < 2)
           request.GetMaxReturnElements(), nullptr, word_complete,
           request.GetMatches());
     request.SetWordComplete(word_complete);
 
     return request.GetMatches().GetSize();
   }
 
 protected:
-  bool DoExecute(const char *command, CommandReturnObject &result) override {
+  bool DoExecute(llvm::StringRef command,
+                 CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
 
     Args cmd_args(command);
     const size_t argc = cmd_args.GetArgumentCount();
 
     if (argc < 3) {
       result.AppendError("'settings insert-after' takes more arguments");
       result.SetStatus(eReturnStatusFailed);
if (request.GetCursorIndex() < 2)
           request.GetMaxReturnElements(), nullptr, word_complete,
           request.GetMatches());
     request.SetWordComplete(word_complete);
 
     return request.GetMatches().GetSize();
   }
 
 protected:
-  bool DoExecute(const char *command, CommandReturnObject &result) override {
+  bool DoExecute(llvm::StringRef command,
+                 CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     Args cmd_args(command);
     const size_t argc = cmd_args.GetArgumentCount();
 
     if (argc < 2) {
       result.AppendError("'settings append' takes more arguments");
       result.SetStatus(eReturnStatusFailed);
       return false;

lldb/trunk/source/Commands/CommandObjectThread.cpp

CommandObjectThreadReturn(CommandInterpreter &interpreter)
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectThreadReturn() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
-  bool DoExecute(const char *command, CommandReturnObject &result) override {
+  bool DoExecute(llvm::StringRef command,
+                 CommandReturnObject &result) override {
     // I am going to handle this by hand, because I don't want you to have to
     // say:
     // "thread return -- -5".
-    if (command[0] == '-' && command[1] == 'x') {
-      if (command && command[2] != '\0')
+    if (command.startswith("-x")) {
+      if (command.size() != 2U)
         result.AppendWarning("Return values ignored when returning from user "
                              "called expressions");
 
       Thread *thread = m_exe_ctx.GetThreadPtr();
       Status error;
       error = thread->UnwindInnermostExpression();
       if (!error.Success()) {
         result.AppendErrorWithFormat("Unwinding expression failed - %s.",
bool DoExecute(llvm::StringRef command,
     uint32_t frame_idx = frame_sp->GetFrameIndex();
 
     if (frame_sp->IsInlined()) {
       result.AppendError("Don't know how to return from inlined frames.");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
-    if (command && command[0] != '\0') {
+    if (!command.empty()) {
       Target *target = m_exe_ctx.GetTargetPtr();
       EvaluateExpressionOptions options;
 
       options.SetUnwindOnError(true);
       options.SetUseDynamic(eNoDynamicValues);
 
       ExpressionResults exe_results = eExpressionSetupError;
       exe_results = target->EvaluateExpression(command, frame_sp.get(),

lldb/trunk/source/Commands/CommandObjectType.cpp

for (const auto lang_type : languages) {
         }
       }
     }
 
     m_cmd_help_long = stream.GetString();
     return m_cmd_help_long;
   }
 
-  bool DoExecute(const char *raw_command_line,
+  bool DoExecute(llvm::StringRef raw_command_line,
                  CommandReturnObject &result) override {
-    if (!raw_command_line || !raw_command_line[0]) {
+    if (raw_command_line.empty()) {
       result.SetError(
           "type lookup cannot be invoked without a type name as argument");
       return false;
     }
 
     auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
     m_option_group.NotifyOptionParsingStarting(&exe_ctx);
 
CommandObjectFormatterInfo(CommandInterpreter &interpreter,
     StreamString syntax;
     syntax.Printf("type %s info <expr>", formatter_name);
     SetSyntax(syntax.GetString());
   }
 
   ~CommandObjectFormatterInfo() override = default;
 
 protected:
-  bool DoExecute(const char *command, CommandReturnObject &result) override {
+  bool DoExecute(llvm::StringRef command,
+                 CommandReturnObject &result) override {
     TargetSP target_sp = m_interpreter.GetDebugger().GetSelectedTarget();
     Thread *thread = GetDefaultThread();
     if (!thread) {
       result.AppendError("no default thread");
       result.SetStatus(lldb::eReturnStatusFailed);
       return false;
     }
 
     StackFrameSP frame_sp = thread->GetSelectedFrame();
     ValueObjectSP result_valobj_sp;
     EvaluateExpressionOptions options;
     lldb::ExpressionResults expr_result = target_sp->EvaluateExpression(
         command, frame_sp.get(), result_valobj_sp, options);
     if (expr_result == eExpressionCompleted && result_valobj_sp) {
       result_valobj_sp =
           result_valobj_sp->GetQualifiedRepresentationIfAvailable(
               target_sp->GetPreferDynamicValue(),
               target_sp->GetEnableSyntheticValue());
       typename FormatterType::SharedPointer formatter_sp =
           m_discovery_function(*result_valobj_sp);
       if (formatter_sp) {
         std::string description(formatter_sp->GetDescription());
-        result.AppendMessageWithFormat(
-            "%s applied to (%s) %s is: %s\n", m_formatter_name.c_str(),
-            result_valobj_sp->GetDisplayTypeName().AsCString("<unknown>"),
-            command, description.c_str());
+        result.GetOutputStream()
+            << m_formatter_name << " applied to ("
+            << result_valobj_sp->GetDisplayTypeName().AsCString("<unknown>")
+            << ") " << command << " is: " << description << "\n";
         result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
       } else {
-        result.AppendMessageWithFormat(
-            "no %s applies to (%s) %s\n", m_formatter_name.c_str(),
-            result_valobj_sp->GetDisplayTypeName().AsCString("<unknown>"),
-            command);
+        result.GetOutputStream()
+            << "no " << m_formatter_name << " applies to ("
+            << result_valobj_sp->GetDisplayTypeName().AsCString("<unknown>")
+            << ") " << command << "\n";
         result.SetStatus(lldb::eReturnStatusSuccessFinishNoResult);
       }
       return true;
     } else {
       result.AppendError("failed to evaluate expression");
       result.SetStatus(lldb::eReturnStatusFailed);
       return false;
     }

lldb/trunk/source/Commands/CommandObjectWatchpoint.cpp

(lldb) watchpoint set expression -w write -s 1 -- foo + 32
 
   // Overrides base class's behavior where WantsCompletion =
   // !WantsRawCommandString.
   bool WantsCompletion() override { return true; }
 
   Options *GetOptions() override { return &m_option_group; }
 
 protected:
-  bool DoExecute(const char *raw_command,
+  bool DoExecute(llvm::StringRef raw_command,
                  CommandReturnObject &result) override {
     auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
     m_option_group.NotifyOptionParsingStarting(
         &exe_ctx); // This is a raw command, so notify the option group
 
     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
     StackFrame *frame = m_exe_ctx.GetFramePtr();
 
     OptionsWithRaw args(raw_command);
 
     llvm::StringRef expr = args.GetRawPart();
 
     if (args.HasArgs())
       if (!ParseOptionsAndNotify(args.GetArgs(), result, m_option_group,
                                  exe_ctx))
         return false;
 
     // If no argument is present, issue an error message.  There's no way to
     // set a watchpoint.
-    if (llvm::StringRef(raw_command).trim().empty()) {
+    if (raw_command.trim().empty()) {
       result.GetErrorStream().Printf("error: required argument missing; "
                                      "specify an expression to evaulate into "
                                      "the address to watch for\n");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     // If no '-w' is specified, default to '-w write'.

lldb/trunk/source/Interpreter/CommandObjectRegexCommand.cpp

: CommandObjectRaw(interpreter, name, help, syntax),
       m_max_matches(max_matches), m_completion_type_mask(completion_type_mask),
       m_entries(), m_is_removable(is_removable) {}
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 CommandObjectRegexCommand::~CommandObjectRegexCommand() {}
 
-bool CommandObjectRegexCommand::DoExecute(const char *command,
+bool CommandObjectRegexCommand::DoExecute(llvm::StringRef command,
                                           CommandReturnObject &result) {
-  if (command) {
-    EntryCollection::const_iterator pos, end = m_entries.end();
-    for (pos = m_entries.begin(); pos != end; ++pos) {
-      RegularExpression::Match regex_match(m_max_matches);
 
-      if (pos->regex.Execute(command, &regex_match)) {
-        std::string new_command(pos->command);
-        std::string match_str;
-        char percent_var[8];
-        size_t idx, percent_var_idx;
-        for (uint32_t match_idx = 1; match_idx <= m_max_matches; ++match_idx) {
-          if (regex_match.GetMatchAtIndex(command, match_idx, match_str)) {
-            const int percent_var_len =
-                ::snprintf(percent_var, sizeof(percent_var), "%%%u", match_idx);
-            for (idx = 0; (percent_var_idx = new_command.find(
-                               percent_var, idx)) != std::string::npos;) {
-              new_command.erase(percent_var_idx, percent_var_len);
-              new_command.insert(percent_var_idx, match_str);
-              idx += percent_var_idx + match_str.size();
-            }
-          }
-        }
-        // Interpret the new command and return this as the result!
-        if (m_interpreter.GetExpandRegexAliases())
-          result.GetOutputStream().Printf("%s\n", new_command.c_str());
-        // Pass in true for "no context switching".  The command that called us
-        // should have set up the context appropriately, we shouldn't have to
-        // redo that.
-        return m_interpreter.HandleCommand(new_command.c_str(),
-                                           eLazyBoolCalculate, result, nullptr,
-                                           true, true);
-      }
-    }
-    result.SetStatus(eReturnStatusFailed);
-    if (!GetSyntax().empty())
-      result.AppendError(GetSyntax());
-    else
-      result.AppendErrorWithFormat("Command contents '%s' failed to match any "
-                                   "regular expression in the '%s' regex "
-                                   "command.\n",
-                                   command, m_cmd_name.c_str());
-    return false;
-  }
-  result.AppendError("empty command passed to regular expression command");
-  result.SetStatus(eReturnStatusFailed);
+      return m_interpreter.HandleCommand(
+          new_command.c_str(), eLazyBoolCalculate, result, nullptr, true, true);
+    result.GetOutputStream() << "Command contents '" << command
+                             << "' failed to match any "
+                                "regular expression in the '"
+                             << m_cmd_name << "' regex ";
   return false;
 }
 
 bool CommandObjectRegexCommand::AddRegexCommand(const char *re_cstr,
                                                 const char *command_cstr) {
   m_entries.resize(m_entries.size() + 1);
   // Only add the regular expression if it compiles
   if (m_entries.back().regex.Compile(

lldb/trunk/source/Interpreter/CommandObjectScript.h

 class CommandObjectScript : public CommandObjectRaw {
 public:
   CommandObjectScript(CommandInterpreter &interpreter,
                       lldb::ScriptLanguage script_lang);
 
   ~CommandObjectScript() override;
 
 protected:
-  bool DoExecute(const char *command, CommandReturnObject &result) override;
+  bool DoExecute(llvm::StringRef command, CommandReturnObject &result) override;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_CommandObjectScript_h_

lldb/trunk/source/Interpreter/CommandObjectScript.cpp

CommandObjectScript::CommandObjectScript(CommandInterpreter &interpreter,
     : CommandObjectRaw(
           interpreter, "script",
           "Invoke the script interpreter with provided code and display any "
           "results.  Start the interactive interpreter if no code is supplied.",
           "script [<script-code>]") {}
 
 CommandObjectScript::~CommandObjectScript() {}
 
-bool CommandObjectScript::DoExecute(const char *command,
+bool CommandObjectScript::DoExecute(llvm::StringRef command,
                                     CommandReturnObject &result) {
 #ifdef LLDB_DISABLE_PYTHON
   // if we ever support languages other than Python this simple #ifdef won't
   // work
   result.AppendError("your copy of LLDB does not support scripting.");
   result.SetStatus(eReturnStatusFailed);
   return false;
 #else
if (script_interpreter == nullptr) {
     result.SetStatus(eReturnStatusFailed);
     return false;
   }
 
   DataVisualization::ForceUpdate(); // script might change Python code we use
                                     // for formatting.. make sure we keep up to
                                     // date with it
 
-  if (command == nullptr || command[0] == '\0') {
+  if (command.empty()) {
     script_interpreter->ExecuteInterpreterLoop();
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     return result.Succeeded();
   }
 
   // We can do better when reporting the status of one-liner script execution.
   if (script_interpreter->ExecuteOneLine(command, &result))
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
   else
     result.SetStatus(eReturnStatusFailed);
 
   return result.Succeeded();
 #endif
 }

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

CommandObjectProcessGDBRemotePacketMonitor(CommandInterpreter &interpreter)
                          "Send a qRcmd packet through the GDB remote protocol "
                          "and print the response."
                          "The argument passed to this command will be hex "
                          "encoded into a valid 'qRcmd' packet, sent and the "
                          "response will be printed.") {}
 
   ~CommandObjectProcessGDBRemotePacketMonitor() {}
 
-  bool DoExecute(const char *command, CommandReturnObject &result) override {
-    if (command == NULL || command[0] == '\0') {
+  bool DoExecute(llvm::StringRef command,
+                 CommandReturnObject &result) override {
+    if (command.empty()) {
       result.AppendErrorWithFormat("'%s' takes a command string argument",
                                    m_cmd_name.c_str());
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     ProcessGDBRemote *process =
         (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr();
     if (process) {
       StreamString packet;
       packet.PutCString("qRcmd,");
-      packet.PutBytesAsRawHex8(command, strlen(command));
+      packet.PutBytesAsRawHex8(command.data(), command.size());
 
       bool send_async = true;
       StringExtractorGDBRemote response;
       Stream &output_strm = result.GetOutputStream();
       process->GetGDBRemote().SendPacketAndReceiveResponseWithOutputSupport(
           packet.GetString(), response, send_async,
           [&output_strm](llvm::StringRef output) { output_strm << output; });
       result.SetStatus(eReturnStatusSuccessFinishResult);

lldb/trunk/source/Plugins/ScriptInterpreter/None/ScriptInterpreterNone.h

 
 class ScriptInterpreterNone : public ScriptInterpreter {
 public:
   ScriptInterpreterNone(CommandInterpreter &interpreter);
 
   ~ScriptInterpreterNone() override;
 
   bool ExecuteOneLine(
-      const char *command, CommandReturnObject *result,
+      llvm::StringRef command, CommandReturnObject *result,
       const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
 
   void ExecuteInterpreterLoop() override;
 
   //------------------------------------------------------------------
   // Static Functions
   //------------------------------------------------------------------
   static void Initialize();

lldb/trunk/source/Plugins/ScriptInterpreter/None/ScriptInterpreterNone.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 ScriptInterpreterNone::ScriptInterpreterNone(CommandInterpreter &interpreter)
     : ScriptInterpreter(interpreter, eScriptLanguageNone) {}
 
 ScriptInterpreterNone::~ScriptInterpreterNone() {}
 
-bool ScriptInterpreterNone::ExecuteOneLine(const char *command,
+bool ScriptInterpreterNone::ExecuteOneLine(llvm::StringRef command,
                                            CommandReturnObject *,
                                            const ExecuteScriptOptions &) {
   m_interpreter.GetDebugger().GetErrorFile()->PutCString(
       "error: there is no embedded script interpreter in this mode.\n");
   return false;
 }
 
 void ScriptInterpreterNone::ExecuteInterpreterLoop() {

lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h

#endif
 
   ScriptInterpreterPython(CommandInterpreter &interpreter);
 
   ~ScriptInterpreterPython() override;
 
   bool Interrupt() override;
 
   bool ExecuteOneLine(
-      const char *command, CommandReturnObject *result,
+      llvm::StringRef command, CommandReturnObject *result,
       const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
 
   void ExecuteInterpreterLoop() override;
 
   bool ExecuteOneLineWithReturn(
-      const char *in_string, ScriptInterpreter::ScriptReturnType return_type,
-      void *ret_value,
+      llvm::StringRef in_string,
+      ScriptInterpreter::ScriptReturnType return_type, void *ret_value,
       const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
 
   lldb_private::Status ExecuteMultipleLines(
       const char *in_string,
       const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
 
   Status
   ExportFunctionDefinitionToInterpreter(StringList &function_def) override;
#endif
 
   lldb::ValueObjectSP
   GetSyntheticValue(const StructuredData::ObjectSP &implementor) override;
 
   ConstString
   GetSyntheticTypeName(const StructuredData::ObjectSP &implementor) override;
 
   bool
-  RunScriptBasedCommand(const char *impl_function, const char *args,
+  RunScriptBasedCommand(const char *impl_function, llvm::StringRef args,
                         ScriptedCommandSynchronicity synchronicity,
                         lldb_private::CommandReturnObject &cmd_retobj,
                         Status &error,
                         const lldb_private::ExecutionContext &exe_ctx) override;
 
-  bool
-  RunScriptBasedCommand(StructuredData::GenericSP impl_obj_sp, const char *args,
-                        ScriptedCommandSynchronicity synchronicity,
-                        lldb_private::CommandReturnObject &cmd_retobj,
-                        Status &error,
-                        const lldb_private::ExecutionContext &exe_ctx) override;
+  bool RunScriptBasedCommand(
+      StructuredData::GenericSP impl_obj_sp, llvm::StringRef args,
+      lldb_private::CommandReturnObject &cmd_retobj, Status &error,
 
   Status GenerateFunction(const char *signature,
                           const StringList &input) override;
 
   Status GenerateBreakpointCommandCallbackData(StringList &input,
                                                std::string &output) override;
 
   bool GenerateWatchpointCommandCallbackData(StringList &input,

lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

static void ReadThreadBytesReceived(void *baton, const void *src,
   if (src && src_len) {
     Stream *strm = (Stream *)baton;
     strm->Write(src, src_len);
     strm->Flush();
   }
 }
 
 bool ScriptInterpreterPython::ExecuteOneLine(
-    const char *command, CommandReturnObject *result,
+    llvm::StringRef command, CommandReturnObject *result,
     const ExecuteScriptOptions &options) {
   if (!m_valid_session)
     return false;
 
-  if (command && command[0]) {
+  if (!command.empty()) {
     // We want to call run_one_line, passing in the dictionary and the command
     // string.  We cannot do this through PyRun_SimpleString here because the
     // command string may contain escaped characters, and putting it inside
     // another string to pass to PyRun_SimpleString messes up the escaping.  So
     // we use the following more complicated method to pass the command string
     // directly down to Python.
     Debugger &debugger = m_interpreter.GetDebugger();
 
if (join_read_thread) {
       // Now we can close the read end of the pipe
       output_comm.Disconnect();
     }
 
     if (success)
       return true;
 
     // The one-liner failed.  Append the error message.
-    if (result)
+    if (result) {
+      std::string command_str = command.str();
       result->AppendErrorWithFormat(
-          "python failed attempting to evaluate '%s'\n", command);
+          "python failed attempting to evaluate '%s'\n", command_str.c_str());
+    }
     return false;
   }
 
   if (result)
     result->AppendError("empty command passed to python\n");
   return false;
 }
 
if (IsExecutingPython()) {
     }
   }
   if (log)
     log->Printf("ScriptInterpreterPython::Interrupt() python code not running, "
                 "can't interrupt");
   return false;
 }
 bool ScriptInterpreterPython::ExecuteOneLineWithReturn(
-    const char *in_string, ScriptInterpreter::ScriptReturnType return_type,
+    llvm::StringRef in_string, ScriptInterpreter::ScriptReturnType return_type,
     void *ret_value, const ExecuteScriptOptions &options) {
 
   Locker locker(this, ScriptInterpreterPython::Locker::AcquireLock |
                           ScriptInterpreterPython::Locker::InitSession |
                           (options.GetSetLLDBGlobals()
                                ? ScriptInterpreterPython::Locker::InitGlobals
                                : 0) |
                           Locker::NoSTDIN,
bool ScriptInterpreterPython::ExecuteOneLineWithReturn(
 
   if (!locals.IsValid())
     locals = globals;
 
   py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
   if (py_error.IsValid())
     PyErr_Clear();
 
-  if (in_string != nullptr) {
-    { // scope for PythonInputReaderManager
-      // PythonInputReaderManager py_input(options.GetEnableIO() ? this : NULL);
-      py_return.Reset(
-          PyRefType::Owned,
-          PyRun_String(in_string, Py_eval_input, globals.get(), locals.get()));
-      if (!py_return.IsValid()) {
-        py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
-        if (py_error.IsValid())
-          PyErr_Clear();
+  std::string as_string = in_string.str();
+    py_return.Reset(PyRefType::Owned,
+                    PyRun_String(as_string.c_str(), Py_eval_input,
+                                 globals.get(), locals.get()));
 
-        py_return.Reset(PyRefType::Owned,
-                        PyRun_String(in_string, Py_single_input, globals.get(),
-                                     locals.get()));
-      }
-    }
+                      PyRun_String(as_string.c_str(), Py_single_input,
+                                   globals.get(), locals.get()));
 
-    if (py_return.IsValid()) {
-      switch (return_type) {
-      case eScriptReturnTypeCharPtr: // "char *"
-      {
-        const char format[3] = "s#";
-        success = PyArg_Parse(py_return.get(), format, (char **)ret_value);
-        break;
-      }
-      case eScriptReturnTypeCharStrOrNone: // char* or NULL if py_return ==
-                                           // Py_None
-        {
-          const char format[3] = "z";
-          success = PyArg_Parse(py_return.get(), format, (char **)ret_value);
-          break;
-        }
-      case eScriptReturnTypeBool: {
-        const char format[2] = "b";
-        success = PyArg_Parse(py_return.get(), format, (bool *)ret_value);
-        break;
-      }
-      case eScriptReturnTypeShortInt: {
-        const char format[2] = "h";
-        success = PyArg_Parse(py_return.get(), format, (short *)ret_value);
-        break;
-      }
-      case eScriptReturnTypeShortIntUnsigned: {
-        const char format[2] = "H";
-        success =
-            PyArg_Parse(py_return.get(), format, (unsigned short *)ret_value);
-        break;
-      }
-      case eScriptReturnTypeInt: {
-        const char format[2] = "i";
-        success = PyArg_Parse(py_return.get(), format, (int *)ret_value);
-        break;
-      }
-      case eScriptReturnTypeIntUnsigned: {
-        const char format[2] = "I";
-        success =
-            PyArg_Parse(py_return.get(), format, (unsigned int *)ret_value);
-        break;
-      }
-      case eScriptReturnTypeLongInt: {
-        const char format[2] = "l";
-        success = PyArg_Parse(py_return.get(), format, (long *)ret_value);
-        break;
-      }
-      case eScriptReturnTypeLongIntUnsigned: {
-        const char format[2] = "k";
-        success =
-            PyArg_Parse(py_return.get(), format, (unsigned long *)ret_value);
-        break;
-      }
-      case eScriptReturnTypeLongLong: {
-        const char format[2] = "L";
-        success = PyArg_Parse(py_return.get(), format, (long long *)ret_value);
-        break;
-      }
-      case eScriptReturnTypeLongLongUnsigned: {
-        const char format[2] = "K";
-        success = PyArg_Parse(py_return.get(), format,
-                              (unsigned long long *)ret_value);
-        break;
-      }
-      case eScriptReturnTypeFloat: {
-        const char format[2] = "f";
-        success = PyArg_Parse(py_return.get(), format, (float *)ret_value);
-        break;
-      }
-      case eScriptReturnTypeDouble: {
-        const char format[2] = "d";
-        success = PyArg_Parse(py_return.get(), format, (double *)ret_value);
-        break;
-      }
-      case eScriptReturnTypeChar: {
-        const char format[2] = "c";
-        success = PyArg_Parse(py_return.get(), format, (char *)ret_value);
-        break;
-      }
-      case eScriptReturnTypeOpaqueObject: {
-        success = true;
-        PyObject *saved_value = py_return.get();
-        Py_XINCREF(saved_value);
-        *((PyObject **)ret_value) = saved_value;
-        break;
-      }
-      }
+      success = PyArg_Parse(py_return.get(), format, (unsigned int *)ret_value);
+      success =
+          PyArg_Parse(py_return.get(), format, (unsigned long long *)ret_value);
 
-      if (success)
-        ret_success = true;
-      else
-        ret_success = false;
-    }
-  }
 
   py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
   if (py_error.IsValid()) {
     ret_success = false;
     if (options.GetMaskoutErrors()) {
       if (PyErr_GivenExceptionMatches(py_error.get(), PyExc_SyntaxError))
         PyErr_Print();
       PyErr_Clear();

 }
 
 ScriptInterpreterPython::SynchronicityHandler::~SynchronicityHandler() {
   if (m_synch_wanted != eScriptedCommandSynchronicityCurrentValue)
     m_debugger_sp->SetAsyncExecution(m_old_asynch);
 }
 
 bool ScriptInterpreterPython::RunScriptBasedCommand(
-    const char *impl_function, const char *args,
+    const char *impl_function, llvm::StringRef args,
     ScriptedCommandSynchronicity synchronicity,
     lldb_private::CommandReturnObject &cmd_retobj, Status &error,
     const lldb_private::ExecutionContext &exe_ctx) {
   if (!impl_function) {
     error.SetErrorString("no function to execute");
     return false;
   }
 
bool ScriptInterpreterPython::RunScriptBasedCommand(
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession |
                        (cmd_retobj.GetInteractive() ? 0 : Locker::NoSTDIN),
                    Locker::FreeLock | Locker::TearDownSession);
 
     SynchronicityHandler synch_handler(debugger_sp, synchronicity);
 
-    ret_val =
-        g_swig_call_command(impl_function, m_dictionary_name.c_str(),
-                            debugger_sp, args, cmd_retobj, exe_ctx_ref_sp);
+    std::string args_str = args.str();
+    ret_val = g_swig_call_command(impl_function, m_dictionary_name.c_str(),
+                                  debugger_sp, args_str.c_str(), cmd_retobj,
+                                  exe_ctx_ref_sp);
   }
 
   if (!ret_val)
     error.SetErrorString("unable to execute script function");
   else
     error.Clear();
 
   return ret_val;
 }
 
 bool ScriptInterpreterPython::RunScriptBasedCommand(
-    StructuredData::GenericSP impl_obj_sp, const char *args,
+    StructuredData::GenericSP impl_obj_sp, llvm::StringRef args,
     ScriptedCommandSynchronicity synchronicity,
     lldb_private::CommandReturnObject &cmd_retobj, Status &error,
     const lldb_private::ExecutionContext &exe_ctx) {
   if (!impl_obj_sp || !impl_obj_sp->IsValid()) {
     error.SetErrorString("no function to execute");
     return false;
   }
 
bool ScriptInterpreterPython::RunScriptBasedCommand(
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession |
                        (cmd_retobj.GetInteractive() ? 0 : Locker::NoSTDIN),
                    Locker::FreeLock | Locker::TearDownSession);
 
     SynchronicityHandler synch_handler(debugger_sp, synchronicity);
 
+    std::string args_str = args.str();
     ret_val = g_swig_call_command_object(impl_obj_sp->GetValue(), debugger_sp,
-                                         args, cmd_retobj, exe_ctx_ref_sp);
+                                         args_str.c_str(), cmd_retobj,
+                                         exe_ctx_ref_sp);
   }
 
   if (!ret_val)
     error.SetErrorString("unable to execute script function");
   else
     error.Clear();
 
   return ret_val;