[lldb][NFC] Use a StringRef for AddRegexCommand::AddRegexCommand parameters

[teemperor]

Summary

This way we can get rid of this 1024 char buffer workaround.

lldb/include/lldb/Interpreter/CommandObjectRegexCommand.h

CommandObjectRegexCommand(CommandInterpreter &interpreter, llvm::StringRef name,
     llvm::StringRef help, llvm::StringRef syntax,
                             uint32_t max_matches, uint32_t completion_type_mask,
                             bool is_removable);
 
   ~CommandObjectRegexCommand() override;
 
   bool IsRemovable() const override { return m_is_removable; }
 
-  bool AddRegexCommand(const char *re_cstr, const char *command_cstr);
+  bool AddRegexCommand(llvm::StringRef re_cstr, llvm::StringRef command_cstr);
 
   bool HasRegexEntries() const { return !m_entries.empty(); }
 
   void HandleCompletion(CompletionRequest &request) override;
 
 protected:
   bool DoExecute(llvm::StringRef command, CommandReturnObject &result) override;
 

lldb/source/Commands/CommandObjectCommands.cpp

Status AppendRegexSubstitution(const llvm::StringRef &regex_sed,
 
     if (!check_only) {
       std::string regex(std::string(regex_sed.substr(
           first_separator_char_pos + 1,
           second_separator_char_pos - first_separator_char_pos - 1)));
       std::string subst(std::string(regex_sed.substr(
           second_separator_char_pos + 1,
           third_separator_char_pos - second_separator_char_pos - 1)));
-      m_regex_cmd_up->AddRegexCommand(regex.c_str(), subst.c_str());
+      m_regex_cmd_up->AddRegexCommand(regex, subst);
     }
     return error;
   }
 
   void AddRegexCommandToInterpreter() {
     if (m_regex_cmd_up) {
       if (m_regex_cmd_up->HasRegexEntries()) {
         CommandObjectSP cmd_sp(m_regex_cmd_up.release());

lldb/source/Interpreter/CommandInterpreter.cpp

std::unique_ptr<CommandObjectRegexCommand> tbreak_regex_cmd_up(
           2,
           CommandCompletions::eSymbolCompletion |
               CommandCompletions::eSourceFileCompletion,
           false));
 
   if (tbreak_regex_cmd_up) {
     bool success = true;
     for (size_t i = 0; i < num_regexes; i++) {
-      // If you add a resultant command string longer than 1024 characters be
-      // sure to increase the size of this buffer.
-      char buffer[1024];
-      int num_printed =
-          snprintf(buffer, 1024, "%s %s", break_regexes[i][1], "-o 1");
-      lldbassert(num_printed < 1024);
-      UNUSED_IF_ASSERT_DISABLED(num_printed);
+      std::string command = break_regexes[i][1];
+      command += " -o 1";
       success =
-          tbreak_regex_cmd_up->AddRegexCommand(break_regexes[i][0], buffer);
+          tbreak_regex_cmd_up->AddRegexCommand(break_regexes[i][0], command);
       if (!success)
         break;
     }
     success =
         tbreak_regex_cmd_up->AddRegexCommand("^$", "breakpoint list --full");
 
     if (success) {
       CommandObjectSP tbreak_regex_cmd_sp(tbreak_regex_cmd_up.release());

lldb/source/Interpreter/CommandObjectRegexCommand.cpp

bool CommandObjectRegexCommand::DoExecute(llvm::StringRef command,
   else
     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) {
+bool CommandObjectRegexCommand::AddRegexCommand(llvm::StringRef re_cstr,
+                                                llvm::StringRef command_cstr) {
   m_entries.resize(m_entries.size() + 1);
   // Only add the regular expression if it compiles
-  m_entries.back().regex =
-      RegularExpression(llvm::StringRef::withNullAsEmpty(re_cstr));
+  m_entries.back().regex = RegularExpression(re_cstr);
   if (m_entries.back().regex.IsValid()) {
-    m_entries.back().command.assign(command_cstr);
+    m_entries.back().command = command_cstr.str();
     return true;
   }
   // The regex didn't compile...
   m_entries.pop_back();
   return false;
 }
 
 void CommandObjectRegexCommand::HandleCompletion(CompletionRequest &request) {
   if (m_completion_type_mask) {
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), m_completion_type_mask, request, nullptr);
   }
 }