Add -relative-to-command-file to "command source"

[jingham]

Summary

This option was recently added to "command script import" so that an "organizing" command file can find python script files relative to itself. It's natural to extend this to command files as well as script source files for much the same reason.

[jingham]

The one thing that makes me sad about this is that "command script import" chose "-c" as the short letter for this option, but "-c" was already taken for "command source", so I used -C for "command source".

[JDevlieghere]

In D110601#3026363, @jingham wrote:

The one thing that makes me sad about this is that "command script import" chose "-c" as the short letter for this option, but "-c" was already taken for "command source", so I used -C for "command source".

Maybe it's not too late to change the short letter for command script import, or we could add C as an alias?

lldb/source/Commands/CommandObjectCommands.cpp

156

Seems easy enough to detect, so why not?

[jingham]

Made -C with an absolute path an error, added at test for it.

[JDevlieghere]

LGTM

lldb/source/Commands/CommandObjectCommands.cpp

public:
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   class CommandOptions : public Options {
   public:
     CommandOptions()
         : Options(), m_stop_on_error(true), m_silent_run(false),
-          m_stop_on_continue(true) {}
+          m_stop_on_continue(true), m_cmd_relative_to_command_file(false) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'e':
         error = m_stop_on_error.SetValueFromString(option_arg);
         break;
 
       case 'c':
         error = m_stop_on_continue.SetValueFromString(option_arg);
         break;
 
+      case 'C':
+        m_cmd_relative_to_command_file = true;
+        break;
+
       case 's':
         error = m_silent_run.SetValueFromString(option_arg);
         break;
 
       default:
         llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_stop_on_error.Clear();
       m_silent_run.Clear();
       m_stop_on_continue.Clear();
+      m_cmd_relative_to_command_file.Clear();
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_source_options);
     }
 
     // Instance variables to hold the values for command options.
 
     OptionValueBoolean m_stop_on_error;
     OptionValueBoolean m_silent_run;
     OptionValueBoolean m_stop_on_continue;
+    OptionValueBoolean m_cmd_relative_to_command_file;
   };
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     if (command.GetArgumentCount() != 1) {
       result.AppendErrorWithFormat(
           "'%s' takes exactly one executable filename argument.\n",
           GetCommandName().str().c_str());
       return false;
     }
 
+    FileSpec source_dir = {};
+    if (m_options.m_cmd_relative_to_command_file) {
+      source_dir = GetDebugger().GetCommandInterpreter().GetCurrentSourceDir();
+      if (!source_dir) {
+        result.AppendError("command source -C can only be specified "
+                           "from a command file");
+        result.SetStatus(eReturnStatusFailed);
+        return false;
+      }
+    }
+
     FileSpec cmd_file(command[0].ref());
+    if (source_dir) {
+      // Prepend the source_dir to the cmd_file path:
+      if (!cmd_file.IsRelative()) {
+        result.AppendError("command source -C can only be used "
+                           "with a relative path.");
+        result.SetStatus(eReturnStatusFailed);
+        return false;
+      }
+      cmd_file.MakeAbsolute(source_dir);
+    }
+
     FileSystem::Instance().Resolve(cmd_file);
 
     CommandInterpreterRunOptions options;
     // If any options were set, then use them
     if (m_options.m_stop_on_error.OptionWasSet() ||
         m_options.m_silent_run.OptionWasSet() ||
         m_options.m_stop_on_continue.OptionWasSet()) {
       if (m_options.m_stop_on_continue.OptionWasSet())

lldb/source/Commands/Options.td

 
 let Command = "source" in {
   def source_stop_on_error : Option<"stop-on-error", "e">, Arg<"Boolean">,
     Desc<"If true, stop executing commands on error.">;
   def source_stop_on_continue : Option<"stop-on-continue", "c">, Arg<"Boolean">,
     Desc<"If true, stop executing commands on continue.">;
   def source_silent_run : Option<"silent-run", "s">, Arg<"Boolean">,
     Desc<"If true don't echo commands while executing.">;
+  def cmd_relative_to_command_file : Option<"relative-to-command-file", "C">,
+    Desc<"Resolve non-absolute paths relative to the location of the "
+    "current command file. This argument can only be used when the command is "
+    "being sourced from a file.">;
 }
 
 let Command = "alias" in {
   def alias_help : Option<"help", "h">, Arg<"HelpText">,
     Desc<"Help text for this command">;
   def alias_long_help : Option<"long-help", "H">, Arg<"HelpText">,
     Desc<"Long help text for this command">;
 }

lldb/test/API/commands/command/source/TestCommandSource.py

class CommandSourceTestCase(TestBase):
 
     @no_debug_info_test
     def test_command_source(self):
         """Test that lldb command "command source" works correctly."""
 
         # Sourcing .lldb in the current working directory, which in turn imports
         # the "my" package that defines the date() function.
         self.runCmd("command source .lldb")
+        self.check_results()
         
+    @no_debug_info_test
+    def test_command_source_relative(self):
+        """Test that lldb command "command source" works correctly with relative paths."""
+
+        # Sourcing .lldb in the current working directory, which in turn imports
+        # the "my" package that defines the date() function.
+        self.runCmd("command source commands2.txt")
+        self.check_results()
+        
+    def check_results(self, failure=False):
         # Python should evaluate "my.date()" successfully.
         command_interpreter = self.dbg.GetCommandInterpreter()
         self.assertTrue(command_interpreter, VALID_COMMAND_INTERPRETER)
         result = lldb.SBCommandReturnObject()
         command_interpreter.HandleCommand("script my.date()", result)
 
         import datetime
+        if failure:
+            self.expect(result.GetOutput(), "script my.date() runs successfully",
+                        exe=False, error=True)
+        else: 
             self.expect(result.GetOutput(), "script my.date() runs successfully",
                         exe=False,
                         substrs=[str(datetime.date.today())])
+        
+    @no_debug_info_test
+    def test_command_source_relative_error(self):
+        """Test that 'command source -C' gives an error for a relative path"""
+        source_dir = self.getSourceDir()
+        result = lldb.SBCommandReturnObject()
+        self.runCmd("command source --stop-on-error 1 not-relative.txt")
+        self.check_results(failure=True)

lldb/test/API/commands/command/source/commands2.txt

+command source -C subdir/subcmds.txt

lldb/test/API/commands/command/source/not-relative.txt

+command source -C /tmp/somefile.txt
+script import my

lldb/test/API/commands/command/source/subdir/subcmds.txt

+command source -C ../commands.txt