Add functionality to export settings

[JDevlieghere]

Summary

For the reproducer feature I need to be able to export and import the current LLDB configuration. To realize this I've extended the existing functionality to print settings. With the help of a new formatting option, we can now write the settings and their values to a file structured as regular commands.

Concretely the functionality works as follows:

(lldb) settings export /path/to/file

This file contains a bunch of settings set commands, followed by the setting's name and value.

settings set use-external-editor false
settings set use-color true
settings set auto-one-line-summaries true
settings set auto-indent true

Loading the settings again is as simple as sourcing the newly created file:

(lldb) command source /path/to/file

I had to make a few small changes here to make this work:

• When a value is not set settings set <setting> is equal to settings clear <setting>. This is because not all settings have a meaningful default For example for settings set we used to print unknown which is not a value the user can set.
• I introduced a new printing option and group for printing options as commands. This relates to printing everything on a single line for things like arrays and dicts.

[JDevlieghere]

• Rebase

[teemperor]

Runnings settings export crashes LLDB:

(lldb) down
❲ 8❳ CommandObjectSettingsExport::DoExecute(this=0x0000555555652a80, args=0x00007fffffffd6b8, result=0x00007fffffffdd80) at CommandObjectSettings.cpp:356 ❮liblldb.so.8svn❯
   353      result.SetStatus(eReturnStatusSuccessFinishResult);
   354 
   355      // Open file for dumping the exported settings.
-> 356      const std::string export_path = args.GetArgumentAtIndex(0);
   357      const uint32_t options = File::eOpenOptionWrite |
   358                               File::eOpenOptionTruncate |
   359                               File::eOpenOptionCanCreate;
(lldb) bt
* thread #1, name = 'lldb', stop reason = signal SIGABRT
    ❲ 0❳ __GI_raise ❮libc.so.6❯
    ❲ 1❳ __GI_abort ❮libc.so.6❯
    ❲ 2❳ __gnu_cxx::__verbose_terminate_handler() (.cold.1) at vterminate.cc:95 ❮libstdc++.so.6❯
    ❲ 3❳ __cxxabiv1::__terminate(void (*)()) at eh_terminate.cc:47 ❮libstdc++.so.6❯
    ❲ 4❳ std::terminate() at eh_terminate.cc:57 ❮libstdc++.so.6❯
    ❲ 5❳ __cxxabiv1::__cxa_throw(obj=<unavailable>, tinfo=<unavailable>, dest=<unavailable>)(void *)) at eh_throw.cc:95 ❮libstdc++.so.6❯
    ❲ 6❳ std::__throw_logic_error(char const*) (.cold.0) at functexcept.cc:66 ❮libstdc++.so.6❯
    ❲ 7❳ void std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_construct<char const*>(this="8����, __beg=0x0000000000000000, __end=<unavailable>, (null)=forward_iterator_tag @ 0x00007fffffffd3f0) at basic_string.tcc:212 ❮libstdc++.so.6❯
  * ❲ 8❳ CommandObjectSettingsExport::DoExecute(this=0x0000555555652a80, args=0x00007fffffffd6b8, result=0x00007fffffffdd80) at CommandObjectSettings.cpp:356 ❮liblldb.so.8svn❯
    ❲ 9❳ lldb_private::CommandObjectParsed::Execute(this=0x0000555555652a80, args_string="", result=0x00007fffffffdd80) at CommandObject.cpp:978 ❮liblldb.so.8svn❯
    ❲10❳ lldb_private::CommandInterpreter::HandleCommand(this=0x000055555562be30, command_line="settings export", lazy_add_to_history=eLazyBoolCalculate, result=0x00007fffffffdd80, override_context=0x0000000000000000, repeat_on_empty_command=true, no_context_switching=false) at CommandInterpreter.cpp:1702 ❮liblldb.so.8svn❯
    ❲11❳ lldb_private::CommandInterpreter::IOHandlerInputComplete(this=0x000055555562be30, io_handler=0x0000555555743b60, line="X����) at CommandInterpreter.cpp:2711 ❮liblldb.so.8svn❯
    ❲12❳ lldb_private::IOHandlerEditline::Run(this=0x0000555555743b60) at IOHandler.cpp:562 ❮liblldb.so.8svn❯
    ❲13❳ lldb_private::Debugger::ExecuteIOHandlers(this=0x000055555562a620) at Debugger.cpp:975 ❮liblldb.so.8svn❯
    ❲14❳ lldb_private::CommandInterpreter::RunCommandInterpreter(this=0x000055555562be30, auto_handle_events=true, spawn_thread=false, options=0x00007fffffffe080) at CommandInterpreter.cpp:2911 ❮liblldb.so.8svn❯
    ❲15❳ lldb::SBDebugger::RunCommandInterpreter(this=0x00007fffffffe4c0, auto_handle_events=true, spawn_thread=false) at SBDebugger.cpp:928 ❮liblldb.so.8svn❯
    ❲16❳ Driver::MainLoop(this=0x00007fffffffe4a0) at Driver.cpp:1139 ❮lldb❯
    ❲17❳ main(argc=1, argv=0x00007fffffffe6f8) at Driver.cpp:1244 ❮lldb❯
    ❲18❳ __libc_start_main ❮libc.so.6❯
    ❲19❳ _start ❮lldb❯

[teemperor]

• Running settings export /home/teemperor/foobar1 /home/teemperor/foobar2 will actually just create foobar1, but will not report any error that foobar2 is silently ignored.

• Do we actually have a way to have file completion for the argument? (This doesn't have to be addressed in this review).

• Using tilde in the export path doesn't work. E.g. settings export ~/foo doesn't create a foo file for me on Linux.

[jingham]

To Raphael's points:

Argument completion handlers are set by the command object implementing HandleArgumentCompletion and dispatching to the CommandCompletions::eDiskFileCompletion. An example of this is in CommandObjectProcessLaunch. Note, arguments currently have a kind (as do options) but for historical reasons, those kinds don't automatically bind to completers. Be nice to finish that bit of the design at some point... But till then, this way though boilerplate is straightforward.

The StreamFile constructor doesn't handle ~. Maybe it should? Or you could make a FileSpec, they do handle ~ completion, and there's a StreamFile constructor that takes a FileSpec.

Breakpoints use "breakpoint write" and "breakpoint read" to save themselves. Maybe it would be clearer if we use the same word for saving breakpoints and saving settings?

I also wonder if it would be good to add a "settings {import, read?}" command to go along with the settings {export,write}. It is a little odd to do "settings export" to export the settings, and "command source" to read them back in. That's relying on the accident that you are exporting the settings as commands, which (a) would be better not to tie ourselves to and (b) users shouldn't have to know that...

It also might be nice to have the output file be a -f option and then I could do:

(lldb) settings export -f foo.cmds

to export all settings and:

(lldb) settings export -f foo.cmds target

to export all the target commands, etc... That might be more flexible for ordinary use. If you do that, the easiest way to specify a completer is by using OptionGroupFile.

source/Commands/CommandObjectSettings.cpp

213

"settings clear" also clears the settings value. I'm not sure I'm in favor of having two ways of doing this, especially when the second one is undocumented. Presumably this isn't intrinsic to exporting settings, so it should be done as a separate patch anyway.

319

Shouldn't this be eArgRepeatPlain? You don't do anything in the case where there's no filename argument.

BTW, I don't think these argument repeat counts are actually enforced. They are used to write out the help strings, but not to check incoming arguments for commands so far as I can see. The development of these and the argument kind specifications stalled when the person who originally worked on them left, and is waiting for somebody to pick them back up again.

344

You don't know that you actually got an argument. You should check that here.

[JDevlieghere]

Thanks a lot for the feedback! I clearly overlooked some stuff when inspiring myself on the other CommandObject code.

I've updated the diff:

• Rename functionality to read and write for consistency with breakpoints.
• Add settings read instead of having to source the exported file.
• Deal with zero or multiple arguments. (This is now valid input)
• Fix completion for file path.
• Go through FileSpec to ensure ~ is expanded.
• Add more tests.

[JDevlieghere]

Split off settings set change into separate review: D52772

[JDevlieghere]

Only clear setting when the force flag is set (as suggested offline by @jingham).

[JDevlieghere]

• Back to the right diff.
• Use -f as per the other patch.

[JDevlieghere]

@teemperor Can you have another look?

[teemperor]

Sorry, this somehow didn't show up in my review queue. I think this can land after two minor things are fixed:

• I think unknown arguments to write/read shouldn't be silently ignored.
• And I think we should report an error if writing to the output file fails.

To give a practical example: This command below fails to write to the output file but also doesn't produce any error message.

settings write -f ~/ foo
Note that there is a space behind the /, so we write to a directory (which fails) and we silently ignore the second unknown arg.

[teemperor]

Woops, I wanted to accept in my previous comment.

[JDevlieghere]

Thanks Raphael!

With r345207 the empty behavior only works if you explicitly specify -force. I'll address the second issue before landing this.

include/lldb/Interpreter/OptionValue.h

public:
   } Type;
 
   enum {
     eDumpOptionName = (1u << 0),
     eDumpOptionType = (1u << 1),
     eDumpOptionValue = (1u << 2),
     eDumpOptionDescription = (1u << 3),
     eDumpOptionRaw = (1u << 4),
+    eDumpOptionCommand = (1u << 5),
     eDumpGroupValue = (eDumpOptionName | eDumpOptionType | eDumpOptionValue),
     eDumpGroupHelp =
-        (eDumpOptionName | eDumpOptionType | eDumpOptionDescription)
+        (eDumpOptionName | eDumpOptionType | eDumpOptionDescription),
+    eDumpGroupExport = (eDumpOptionCommand | eDumpOptionName | eDumpOptionValue)
   };
 
   OptionValue()
       : m_callback(nullptr), m_baton(nullptr), m_value_was_set(false) {}
 
   OptionValue(const OptionValue &rhs)
       : m_callback(rhs.m_callback), m_baton(rhs.m_baton),
         m_value_was_set(rhs.m_value_was_set) {}

lit/Settings/TestExport.test

+# This tests writing and reading settings from LLDB.
+
+# Check that the settings can be written to file and read again without
+# altering the values.
+# RUN: %lldb -b -o 'settings write -f %t.foo' -o 'settings read -f %t.foo' -o 'settings export %t.bar' -o 'settings read -f %t.bar' 2>&1 | FileCheck %s --check-prefix SUCCESS
+# RUN: diff -w %t.foo %t.bar
+# SUCCESS-NOT: error:
+
+# Check that exporting target settings only export target settings and nothing else.
+# RUN: %lldb -b -o 'settings write -f %t.target target' 2>&1 | FileCheck %s --check-prefix SUCCESS
+# RUN: cat %t.target | FileCheck %s --check-prefix TARGET
+# TARGET: settings set target
+# TARGET-NOT: settings set platform
+# TARGET-NOT: settings set symbols
+# TARGET-NOT: settings set interpreter
+# TARGET-NOT: settings set plugin
+
+# Check that settings appear twice when appending.
+# RUN: %lldb -b -o 'settings write -a -f %t.append target' -o 'settings write -a -f %t.append target' 2>&1 | FileCheck %s --check-prefix SUCCESS
+# RUN: cat %t.append | FileCheck %s --check-prefix APPEND
+# APPEND: settings set target.language
+# APPEND: settings set target.language
+
+# Check that an error is printed for non-existing setting.
+# RUN: echo "settings set bogus" > %t.bogus_setting
+# RUN: %lldb -b -o 'settings read -f %t.bogus_setting' 2>&1 | FileCheck %s --check-prefix BOGUS-SETTING
+# BOGUS-SETTING: error: invalid value path
+
+# Check that an error is printed for invalid value.
+# RUN: echo "settings set target.language bogus" > %t.bogus_value
+# RUN: %lldb -b -o 'settings read -f %t.bogus_value' 2>&1 | FileCheck %s --check-prefix BOGUS-VALUE
+# BOGUS-VALUE: error: invalid language type

source/Commands/CommandObjectSettings.cpp

bool DoExecute(llvm::StringRef command,
     const char *var_value_cstr =
         Args::StripSpaces(var_value_string, true, false, false);
 
     Status error;
     if (m_options.m_global) {
       error = m_interpreter.GetDebugger().SetPropertyValue(
           nullptr, eVarSetOperationAssign, var_name, var_value_cstr);
     }
 
     if (error.Success()) {
       // FIXME this is the same issue as the one in commands script import
       // we could be setting target.load-script-from-symbol-file which would
       // cause Python scripts to be loaded, which could run LLDB commands (e.g.
       // settings set target.process.python-os-plugin-path) and cause a crash
       // if we did not clear the command's exe_ctx first
       ExecutionContext exe_ctx(m_exe_ctx);
       m_exe_ctx.Clear();
if (!args.empty()) {
           &m_exe_ctx, result.GetOutputStream(), OptionValue::eDumpGroupValue);
     }
 
     return result.Succeeded();
   }
 };
 
 //-------------------------------------------------------------------------
+// CommandObjectSettingsWrite -- Write settings to file
+//-------------------------------------------------------------------------
+
+static constexpr OptionDefinition g_settings_write_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, true,  "file",  'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eDiskFileCompletion, eArgTypeFilename,    "The file into which to write the settings." },
+  { LLDB_OPT_SET_ALL, false, "append",'a', OptionParser::eNoArgument,       nullptr, {}, 0,                                       eArgTypeNone,        "Append to saved settings file if it exists."},
+    // clang-format on
+};
+
+class CommandObjectSettingsWrite : public CommandObjectParsed {
+public:
+  CommandObjectSettingsWrite(CommandInterpreter &interpreter)
+      : CommandObjectParsed(
+            interpreter, "settings export",
+            "Write matching debugger settings and their "
+            "current values to a file that can be read in with "
+            "\"settings read\". Defaults to writing all settings.",
+            nullptr),
+        m_options() {
+    CommandArgumentEntry arg1;
+    CommandArgumentData var_name_arg;
+
+    // Define the first (and only) variant of this arg.
+    var_name_arg.arg_type = eArgTypeSettingVariableName;
+    var_name_arg.arg_repetition = eArgRepeatOptional;
+
+    // There is only one variant this argument could be; put it into the
+    // argument entry.
+    arg1.push_back(var_name_arg);
+
+    // Push the data for the first argument into the m_arguments vector.
+    m_arguments.push_back(arg1);
+  }
+
+  ~CommandObjectSettingsWrite() override = default;
+
+  Options *GetOptions() override { return &m_options; }
+
+  class CommandOptions : public Options {
+  public:
+    CommandOptions() : Options() {}
+
+    ~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 'f':
+        m_filename.assign(option_arg);
+        break;
+      case 'a':
+        m_append = true;
+        break;
+      default:
+        error.SetErrorStringWithFormat("unrecognized option '%c'",
+                                       short_option);
+        break;
+      }
+
+      return error;
+    }
+
+    void OptionParsingStarting(ExecutionContext *execution_context) override {
+      m_filename.clear();
+      m_append = false;
+    }
+
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return llvm::makeArrayRef(g_settings_write_options);
+    }
+
+    // Instance variables to hold the values for command options.
+    std::string m_filename;
+    bool m_append = false;
+  };
+
+protected:
+  bool DoExecute(Args &args, CommandReturnObject &result) override {
+    std::string path(FileSpec(m_options.m_filename, true).GetPath());
+    uint32_t options = File::OpenOptions::eOpenOptionWrite |
+                       File::OpenOptions::eOpenOptionCanCreate;
+    if (m_options.m_append)
+      options |= File::OpenOptions::eOpenOptionAppend;
+    else
+      options |= File::OpenOptions::eOpenOptionTruncate;
+
+    StreamFile out_file(path.c_str(), options,
+                        lldb::eFilePermissionsFileDefault);
+
+    if (!out_file.GetFile().IsValid()) {
+      result.SetStatus(eReturnStatusFailed);
+      return false;
+    }
+
+    // Exporting should not be context sensitive.
+    ExecutionContext clean_ctx;
+
+    if (args.empty()) {
+      m_interpreter.GetDebugger().DumpAllPropertyValues(
+          &clean_ctx, out_file, OptionValue::eDumpGroupExport);
+      return result.Succeeded();
+    }
+
+    for (const auto &arg : args) {
+      Status error(m_interpreter.GetDebugger().DumpPropertyValue(
+          &clean_ctx, out_file, arg.ref, OptionValue::eDumpGroupExport));
+      if (!error.Success()) {
+        result.AppendError(error.AsCString());
+        result.SetStatus(eReturnStatusFailed);
+      }
+    }
+
+    return result.Succeeded();
+  }
+
+private:
+  CommandOptions m_options;
+};
+
+//-------------------------------------------------------------------------
+// CommandObjectSettingsRead -- Read settings from file
+//-------------------------------------------------------------------------
+
+static constexpr OptionDefinition g_settings_read_options[] = {
+    // clang-format off
+  {LLDB_OPT_SET_ALL, true, "file",'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eDiskFileCompletion, eArgTypeFilename,       "The file from which to read the breakpoints." },
+    // clang-format on
+};
+
+class CommandObjectSettingsRead : public CommandObjectParsed {
+public:
+  CommandObjectSettingsRead(CommandInterpreter &interpreter)
+      : CommandObjectParsed(
+            interpreter, "settings read",
+            "Read settings previously saved to a file with \"settings write\".",
+            nullptr),
+        m_options() {}
+
+  ~CommandObjectSettingsRead() override = default;
+
+  Options *GetOptions() override { return &m_options; }
+
+  class CommandOptions : public Options {
+  public:
+    CommandOptions() : Options() {}
+
+    ~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 'f':
+        m_filename.assign(option_arg);
+        break;
+      default:
+        error.SetErrorStringWithFormat("unrecognized option '%c'",
+                                       short_option);
+        break;
+      }
+
+      return error;
+    }
+
+    void OptionParsingStarting(ExecutionContext *execution_context) override {
+      m_filename.clear();
+    }
+
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return llvm::makeArrayRef(g_settings_read_options);
+    }
+
+    // Instance variables to hold the values for command options.
+    std::string m_filename;
+  };
+
+protected:
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    FileSpec file(m_options.m_filename, true);
+    ExecutionContext clean_ctx;
+    CommandInterpreterRunOptions options;
+    options.SetAddToHistory(false);
+    options.SetEchoCommands(false);
+    options.SetPrintResults(true);
+    options.SetStopOnError(false);
+    m_interpreter.HandleCommandsFromFile(file, &clean_ctx, options, result);
+    return result.Succeeded();
+  }
+
+private:
+  CommandOptions m_options;
+};
+
+//-------------------------------------------------------------------------
 // CommandObjectSettingsList -- List settable variables
 //-------------------------------------------------------------------------
 
 class CommandObjectSettingsList : public CommandObjectParsed {
 public:
   CommandObjectSettingsList(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "settings list",
                             "List and describe matching debugger settings.  "
LoadSubCommand(
       CommandObjectSP(new CommandObjectSettingsInsertBefore(interpreter)));
   LoadSubCommand(
       "insert-after",
       CommandObjectSP(new CommandObjectSettingsInsertAfter(interpreter)));
   LoadSubCommand("append",
                  CommandObjectSP(new CommandObjectSettingsAppend(interpreter)));
   LoadSubCommand("clear",
                  CommandObjectSP(new CommandObjectSettingsClear(interpreter)));
+  LoadSubCommand("write",
+                 CommandObjectSP(new CommandObjectSettingsWrite(interpreter)));
+  LoadSubCommand("read",
+                 CommandObjectSP(new CommandObjectSettingsRead(interpreter)));
 }
 
 CommandObjectMultiwordSettings::~CommandObjectMultiwordSettings() = default;

source/Interpreter/OptionValueArray.cpp

void OptionValueArray::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
   if (dump_mask & eDumpOptionType) {
     if ((GetType() == eTypeArray) && (m_type_mask != eTypeInvalid))
       strm.Printf("(%s of %ss)", GetTypeAsCString(),
                   GetBuiltinTypeAsCString(array_element_type));
     else
       strm.Printf("(%s)", GetTypeAsCString());
   }
   if (dump_mask & eDumpOptionValue) {
+    const bool one_line = dump_mask & eDumpOptionCommand;
+    const uint32_t size = m_values.size();
     if (dump_mask & eDumpOptionType)
-      strm.Printf(" =%s", (m_values.size() > 0) ? "\n" : "");
+      strm.Printf(" =%s", (m_values.size() > 0 && !one_line) ? "\n" : "");
+    if (!one_line)
       strm.IndentMore();
-    const uint32_t size = m_values.size();
     for (uint32_t i = 0; i < size; ++i) {
+      if (!one_line) {
         strm.Indent();
         strm.Printf("[%u]: ", i);
+      }
       const uint32_t extra_dump_options = m_raw_value_dump ? eDumpOptionRaw : 0;
       switch (array_element_type) {
       default:
       case eTypeArray:
       case eTypeDictionary:
       case eTypeProperties:
       case eTypeFileSpecList:
       case eTypePathMap:
for (uint32_t i = 0; i < size; ++i) {
       case eTypeString:
       case eTypeUInt64:
       case eTypeUUID:
         // No need to show the type for dictionaries of simple items
         m_values[i]->DumpValue(exe_ctx, strm, (dump_mask & (~eDumpOptionType)) |
                                                   extra_dump_options);
         break;
       }
+
+      if (!one_line) {
         if (i < (size - 1))
           strm.EOL();
+      } else {
+        strm << ' ';
+      }
     }
+    if (!one_line)
       strm.IndentLess();
   }
 }
 
 Status OptionValueArray::SetValueFromString(llvm::StringRef value,
                                             VarSetOperationType op) {
   Args args(value.str());
   Status error = SetArgs(args, op);
   if (error.Success())

source/Interpreter/OptionValueDictionary.cpp

void OptionValueDictionary::DumpValue(const ExecutionContext *exe_ctx,
   if (dump_mask & eDumpOptionType) {
     if (m_type_mask != eTypeInvalid)
       strm.Printf("(%s of %ss)", GetTypeAsCString(),
                   GetBuiltinTypeAsCString(dict_type));
     else
       strm.Printf("(%s)", GetTypeAsCString());
   }
   if (dump_mask & eDumpOptionValue) {
+    const bool one_line = dump_mask & eDumpOptionCommand;
     if (dump_mask & eDumpOptionType)
       strm.PutCString(" =");
 
     collection::iterator pos, end = m_values.end();
 
+    if (!one_line)
       strm.IndentMore();
 
     for (pos = m_values.begin(); pos != end; ++pos) {
       OptionValue *option_value = pos->second.get();
+
+      if (one_line)
+        strm << ' ';
+      else
         strm.EOL();
+
       strm.Indent(pos->first.GetCString());
 
       const uint32_t extra_dump_options = m_raw_value_dump ? eDumpOptionRaw : 0;
       switch (dict_type) {
       default:
       case eTypeArray:
       case eTypeDictionary:
       case eTypeProperties:
for (pos = m_values.begin(); pos != end; ++pos) {
         // No need to show the type for dictionaries of simple items
         strm.PutCString("=");
         option_value->DumpValue(exe_ctx, strm,
                                 (dump_mask & (~eDumpOptionType)) |
                                     extra_dump_options);
         break;
       }
     }
+    if (!one_line)
       strm.IndentLess();
   }
 }
 
 size_t OptionValueDictionary::GetArgs(Args &args) const {
   args.Clear();
   collection::const_iterator pos, end = m_values.end();
   for (pos = m_values.begin(); pos != end; ++pos) {
     StreamString strm;

source/Interpreter/OptionValueFileSpecLIst.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 void OptionValueFileSpecList::DumpValue(const ExecutionContext *exe_ctx,
                                         Stream &strm, uint32_t dump_mask) {
   if (dump_mask & eDumpOptionType)
     strm.Printf("(%s)", GetTypeAsCString());
   if (dump_mask & eDumpOptionValue) {
+    const bool one_line = dump_mask & eDumpOptionCommand;
+    const uint32_t size = m_current_value.GetSize();
     if (dump_mask & eDumpOptionType)
-      strm.Printf(" =%s", m_current_value.GetSize() > 0 ? "\n" : "");
+      strm.Printf(" =%s",
+                  (m_current_value.GetSize() > 0 && !one_line) ? "\n" : "");
+    if (!one_line)
       strm.IndentMore();
-    const uint32_t size = m_current_value.GetSize();
     for (uint32_t i = 0; i < size; ++i) {
+      if (!one_line) {
         strm.Indent();
         strm.Printf("[%u]: ", i);
+      }
       m_current_value.GetFileSpecAtIndex(i).Dump(&strm);
+      if (one_line)
+        strm << ' ';
     }
+    if (!one_line)
       strm.IndentLess();
   }
 }
 
 Status OptionValueFileSpecList::SetValueFromString(llvm::StringRef value,
                                                    VarSetOperationType op) {
   Status error;
   Args args(value.str());
   const size_t argc = args.GetArgumentCount();

source/Interpreter/OptionValueFormatEntity.cpp

 }
 
 void OptionValueFormatEntity::DumpValue(const ExecutionContext *exe_ctx,
                                         Stream &strm, uint32_t dump_mask) {
   if (dump_mask & eDumpOptionType)
     strm.Printf("(%s)", GetTypeAsCString());
   if (dump_mask & eDumpOptionValue) {
     if (dump_mask & eDumpOptionType)
-      strm.PutCString(" = \"");
+      strm.PutCString(" = ");
     std::string escaped;
     EscapeBackticks(m_current_format, escaped);
-    strm << escaped << '"';
+    strm << '"' << escaped << '"';
   }
 }
 
 Status OptionValueFormatEntity::SetValueFromString(llvm::StringRef value_str,
                                                    VarSetOperationType op) {
   Status error;
   switch (op) {
   case eVarSetOperationClear:

source/Interpreter/OptionValueLanguage.cpp

 
 void OptionValueLanguage::DumpValue(const ExecutionContext *exe_ctx,
                                     Stream &strm, uint32_t dump_mask) {
   if (dump_mask & eDumpOptionType)
     strm.Printf("(%s)", GetTypeAsCString());
   if (dump_mask & eDumpOptionValue) {
     if (dump_mask & eDumpOptionType)
       strm.PutCString(" = ");
+    if (m_current_value != eLanguageTypeUnknown)
       strm.PutCString(Language::GetNameForLanguageType(m_current_value));
   }
 }
 
 Status OptionValueLanguage::SetValueFromString(llvm::StringRef value,
                                                VarSetOperationType op) {
   Status error;
   switch (op) {
   case eVarSetOperationClear:

source/Interpreter/Property.cpp

bool Property::DumpQualifiedName(Stream &strm) const {
   }
   return false;
 }
 
 void Property::Dump(const ExecutionContext *exe_ctx, Stream &strm,
                     uint32_t dump_mask) const {
   if (m_value_sp) {
     const bool dump_desc = dump_mask & OptionValue::eDumpOptionDescription;
+    const bool dump_cmd = dump_mask & OptionValue::eDumpOptionCommand;
     const bool transparent = m_value_sp->ValueIsTransparent();
+    if (dump_cmd && !transparent)
+      strm << "settings set -f ";
     if (dump_desc || !transparent) {
       if ((dump_mask & OptionValue::eDumpOptionName) && m_name) {
         DumpQualifiedName(strm);
         if (dump_mask & ~OptionValue::eDumpOptionName)
           strm.PutChar(' ');
       }
     }
     if (dump_desc) {