Add a global setting for the interpreter's escape-character

[zturner]

Summary

This enables Windows to specify paths with backslashes unquoted and fixes many tests as a result. We don't always have control over what type of slashes a path built in python has. For example if os.join() is used it will use backslashes. or if os.path.separator is used. So it's important to be able to have unquoted paths on Windows.

include/lldb/Core/UserSettingsController.h

Properties (const lldb::OptionValuePropertiesSP &collection_sp) :
         m_collection_sp (collection_sp)
     {
     }
     
     virtual
     ~Properties()
     {
     }
-    
+    virtual void
+    Initialize(const PropertyDefinition *definitions);
+    
     virtual lldb::OptionValuePropertiesSP
     GetValueProperties () const
     {
         // This function is virtual in case subclasses want to lazily
         // implement creating the properties.
         return m_collection_sp;
     }
 

include/lldb/Interpreter/CommandInterpreter.h

DefaultToNo (LazyBool flag)
             default:
                 return false;
         }
     }
 };
 
 class CommandInterpreter :
     public Broadcaster,
-    public Properties,
     public IOHandlerDelegate
 {
 public:
 
 
     typedef std::map<std::string, OptionArgVectorSP> OptionArgMap;
 
     enum
public:
     // and have it printed in a reasonable way on screen. If so, use OutputFormattedHelpText 
     void
     OutputHelpText (Stream &stream,
                     const char *command_word,
                     const char *separator,
                     const char *help_text,
                     uint32_t max_word_len);
 
+    Properties &
+    GetProperties ()
+    {
+        return m_properties;
+    }
+
+    static Properties &
+    GetGlobalProperties()
+    {
+        return m_global_properties;
+    }
+
     Debugger &
     GetDebugger ()
     {
         return m_debugger;
     }
     
     ExecutionContext
     GetExecutionContext()
public:
     GetExpandRegexAliases () const;
     
     bool
     GetPromptOnQuit () const;
 
     bool
     GetStopCmdSourceOnError () const;
 
+    static char
+    GetEscapeCharacter();
+
     uint32_t
     GetNumErrors() const
     {
         return m_num_errors;
     }
 
     bool
     GetQuitRequested () const
protected:
     GetCommandSP (const char *cmd, bool include_aliases = true, bool exact = true, StringList *matches = NULL);
 
     
 private:
     
     Error
     PreprocessCommand (std::string &command);
 
+    Properties m_properties;                    // The non-global CommandInterpreter properties.
+    static Properties m_global_properties;      // The global CommandInterpreter properties.
     Debugger &m_debugger;                       // The debugger session that this interpreter is associated with
     ExecutionContextRef m_exe_ctx_ref;          // The current execution context to use when handling commands
     bool m_synchronous_execution;
     bool m_skip_lldbinit_files;
     bool m_skip_app_init_files;
     CommandObject::CommandMap m_command_dict;   // Stores basic built-in commands (they cannot be deleted, removed or overwritten).
     CommandObject::CommandMap m_alias_dict;     // Stores user aliases/abbreviations for commands
     CommandObject::CommandMap m_user_dict;      // Stores user-defined commands

include/lldb/Interpreter/OptionValueProperties.h

//    GetQualifiedName (Stream &strm);
     bool
     SetPropertyAtIndexFromArgs (const ExecutionContext *exe_ctx, uint32_t idx, const Args &args);
     
     bool
     GetPropertyAtIndexAsBoolean (const ExecutionContext *exe_ctx, uint32_t idx, bool fail_value) const;
     
     bool
     SetPropertyAtIndexAsBoolean (const ExecutionContext *exe_ctx, uint32_t idx, bool new_value);
-    
+    char
+    GetPropertyAtIndexAsChar (const ExecutionContext *exe_ctx, uint32_t idx, char fail_value) const;
+
+    bool
+    SetPropertyAtIndexAsChar (const ExecutionContext *exe_ctx, uint32_t idx, char new_value);
+
     OptionValueDictionary *
     GetPropertyAtIndexAsOptionValueDictionary (const ExecutionContext *exe_ctx, uint32_t idx) const;
 
     int64_t
     GetPropertyAtIndexAsEnumeration (const ExecutionContext *exe_ctx, uint32_t idx, int64_t fail_value) const;
     
     bool
     SetPropertyAtIndexAsEnumeration (const ExecutionContext *exe_ctx, uint32_t idx, int64_t new_value);

source/Core/Debugger.cpp

enum
     ePropertyStopDisassemblyDisplay,
     ePropertyStopLineCountAfter,
     ePropertyStopLineCountBefore,
     ePropertyTerminalWidth,
     ePropertyThreadFormat,
     ePropertyUseExternalEditor,
     ePropertyUseColor,
     ePropertyAutoOneLineSummaries,
-    ePropertyEscapeNonPrintables
+    ePropertyEscapeNonPrintables,
 };
 
 Debugger::LoadPluginCallbackType Debugger::g_load_plugin_callback = NULL;
 
 Error
 Debugger::SetPropertyValue (const ExecutionContext *exe_ctx,
                             VarSetOperationType op,
                             const char *property_path,

 
 bool
 Debugger::GetEscapeNonPrintables () const
 {
     const uint32_t idx = ePropertyEscapeNonPrintables;
     return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, true);
 }
 
+
 #pragma mark Debugger
 
 //const DebuggerPropertiesSP &
 //Debugger::GetSettings() const
 //{
 //    return m_properties_sp;
 //}
 //
Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton) :
     m_command_interpreter_ap->Initialize ();
     // Always add our default platform to the platform list
     PlatformSP default_platform_sp (Platform::GetHostPlatform());
     assert (default_platform_sp.get());
     m_platform_list.Append (default_platform_sp, true);
     
     m_collection_sp->Initialize (g_properties);
     m_collection_sp->AppendProperty (ConstString("target"),
-                                     ConstString("Settings specify to debugging targets."),
+                                     ConstString("Settings specific to debugging targets."),
                                      true,
                                      Target::GetGlobalProperties()->GetValueProperties());
     if (m_command_interpreter_ap.get())
     {
         m_collection_sp->AppendProperty (ConstString("interpreter"),
-                                         ConstString("Settings specify to the debugger's command interpreter."),
+                                         ConstString("Settings specific to the debugger's command interpreter."),
                                          true,
-                                         m_command_interpreter_ap->GetValueProperties());
+                                         m_command_interpreter_ap->GetProperties().GetValueProperties());
     }
+    m_collection_sp->AppendProperty (ConstString("interpreter-global"),
+                                     ConstString("Settings for all command interpreters."),
+                                     true,
+                                     CommandInterpreter::GetGlobalProperties().GetValueProperties());
+
     OptionValueSInt64 *term_width = m_collection_sp->GetPropertyAtIndexAsOptionValueSInt64 (NULL, ePropertyTerminalWidth);
     term_width->SetMinimumValue(10);
     term_width->SetMaximumValue(1024);
 
     // Turn off use-color if this is a dumb terminal.
     const char *term = getenv ("TERM");
     if (term && !strcmp (term, "dumb"))
         SetUseColor (false);

source/Core/UserSettingsController.cpp

 #include "lldb/Core/Stream.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionValueString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+void
+Properties::Initialize(const PropertyDefinition *definitions)
+{
+    m_collection_sp->Initialize(definitions);
+}
 
 lldb::OptionValueSP
 Properties::GetPropertyValue (const ExecutionContext *exe_ctx,
                               const char *path,
                               bool will_modify,
                               Error &error) const
 {
     OptionValuePropertiesSP properties_sp (GetValueProperties ());

source/Interpreter/Args.cpp

 {
     m_args.clear();
     m_argv.clear();
     m_args_quote_char.clear();
 
     if (command && command[0])
     {
         static const char *k_space_separators = " \t";
-        static const char *k_space_separators_with_slash_and_quotes = " \t \\'\"";
+        std::string space_separators_with_escape_and_quotes(" \t'\"");
+        space_separators_with_escape_and_quotes.push_back(CommandInterpreter::GetEscapeCharacter());
         const char *arg_end = nullptr;
         const char *arg_pos;
         for (arg_pos = command;
              arg_pos && arg_pos[0];
              arg_pos = arg_end)
         {
             // Skip any leading space separators
             const char *arg_start = ::strspn (arg_pos, k_space_separators) + arg_pos;
if (command && command[0])
             // argument "Hello world!") we remember the first quote character
             // we encounter and use that for the quote character.
             char first_quote_char = '\0';
             char quote_char = '\0';
             bool arg_complete = false;
 
             do
             {
-                arg_end = ::strcspn (arg_pos, k_space_separators_with_slash_and_quotes) + arg_pos;
+                arg_end = ::strcspn (arg_pos, space_separators_with_escape_and_quotes.c_str()) + arg_pos;
 
                 switch (arg_end[0])
                 {
                 default:
-                    assert (!"Unhandled case statement, we must handle this...");
-                    break;
-
-                case '\0':
-                    // End of C string
-                    if (arg_piece_start && arg_piece_start[0])
-                        arg.append (arg_piece_start);
-                    arg_complete = true;
-                    break;
-                    
-                case '\\':
-                    // Backslash character
+                    if (arg_end[0] == CommandInterpreter::GetEscapeCharacter())
+                    {
                         switch (arg_end[1])
                         {
                             case '\0':
                                 arg.append (arg_piece_start);
                                 ++arg_end;
                                 arg_complete = true;
                                 break;
 
                             default:
                                 if (quote_char == '\0')
                                 {
                                     arg.append (arg_piece_start, arg_end - arg_piece_start);
                                     if (arg_end[1] != '\0')
                                     {
                                         arg.append (arg_end + 1, 1);
                                         arg_pos = arg_end + 2;
                                         arg_piece_start = arg_pos;
                                     }
                                 }
                                 else
                                     arg_pos = arg_end + 2;
                                 break;
                         }
+                    }
+                
+                    break;
+
+                case '\0':
+                    // End of C string
+                    if (arg_piece_start && arg_piece_start[0])
+                        arg.append (arg_piece_start);
+                    arg_complete = true;
                     break;
                     
                 case '"':
                 case '\'':
                 case '`':
                     // Quote characters 
                     if (quote_char)
                     {
                         // We found a quote character while inside a quoted
                         // character argument. If it matches our current quote

source/Interpreter/CommandInterpreter.cpp

 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Path.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+#if defined(_WIN32)
+#define DEFAULT_ESCAPE_CHARACTER '#'
+#else
+#define DEFAULT_ESCAPE_CHARACTER '\\'
+#endif
+
 
 static PropertyDefinition
 g_properties[] =
 {
-    { "expand-regex-aliases", OptionValue::eTypeBoolean, true, false, nullptr, nullptr, "If true, regular expression alias commands will show the expanded command that will be executed. This can be used to debug new regular expression alias commands." },
-    { "prompt-on-quit", OptionValue::eTypeBoolean, true, true, nullptr, nullptr, "If true, LLDB will prompt you before quitting if there are any live processes being debugged. If false, LLDB will quit without asking in any case." },
-    { "stop-command-source-on-error", OptionValue::eTypeBoolean, true, true, nullptr, nullptr, "If true, LLDB will stop running a 'command source' script upon encountering an error." },
+    { "expand-regex-aliases", OptionValue::eTypeBoolean, false, false, nullptr, nullptr, "If true, regular expression alias commands will show the expanded command that will be executed. This can be used to debug new regular expression alias commands." },
+    { "prompt-on-quit", OptionValue::eTypeBoolean, false, true, nullptr, nullptr, "If true, LLDB will prompt you before quitting if there are any live processes being debugged. If false, LLDB will quit without asking in any case." },
+    { "stop-command-source-on-error", OptionValue::eTypeBoolean, false, true, nullptr, nullptr, "If true, LLDB will stop running a 'command source' script upon encountering an error." },
+    { nullptr                  , OptionValue::eTypeInvalid, true, 0    , nullptr, nullptr, nullptr }
+};
+
+static PropertyDefinition
+g_global_properties[] =
+{
+    { "escape-character", OptionValue::eTypeChar, true, DEFAULT_ESCAPE_CHARACTER, nullptr, nullptr, "The character LLDB will recognize as an escape character while parsing command arguments" },
     { nullptr                  , OptionValue::eTypeInvalid, true, 0    , nullptr, nullptr, nullptr }
 };
 
 enum
 {
     ePropertyExpandRegexAliases = 0,
     ePropertyPromptOnQuit = 1,
-    ePropertyStopCmdSourceOnError = 2
+    ePropertyStopCmdSourceOnError = 2,
+};
+
+enum
+{
+    eGlobalPropertyEscapeCharacter = 0,
 };
 
+Properties CommandInterpreter::m_global_properties(OptionValuePropertiesSP(new OptionValueProperties(ConstString("interpreter-global"))));
+
+
 ConstString &
 CommandInterpreter::GetStaticBroadcasterClass ()
 {
     static ConstString class_name ("lldb.commandInterpreter");
     return class_name;
 }
 
 CommandInterpreter::CommandInterpreter
 (
     Debugger &debugger,
     ScriptLanguage script_language,
     bool synchronous_execution
 ) :
     Broadcaster (&debugger, "lldb.command-interpreter"),
-    Properties(OptionValuePropertiesSP(new OptionValueProperties(ConstString("interpreter")))),
     IOHandlerDelegate (IOHandlerDelegate::Completion::LLDBCommand),
     m_debugger (debugger),
     m_synchronous_execution (synchronous_execution),
     m_skip_lldbinit_files (false),
     m_skip_app_init_files (false),
     m_script_interpreter_ap (),
     m_command_io_handler_sp (),
     m_comment_char ('#'),
     m_batch_command_mode (false),
     m_truncation_warning(eNoTruncation),
     m_command_source_depth (0),
     m_num_errors(0),
     m_quit_requested(false),
-    m_stopped_for_crash(false)
-
+    m_stopped_for_crash(false),
+    m_properties(OptionValuePropertiesSP(new OptionValueProperties(ConstString("interpreter"))))
 {
     debugger.SetScriptLanguage (script_language);
     SetEventName (eBroadcastBitThreadShouldExit, "thread-should-exit");
     SetEventName (eBroadcastBitResetPrompt, "reset-prompt");
     SetEventName (eBroadcastBitQuitCommandReceived, "quit");    
     CheckInWithManager ();
-    m_collection_sp->Initialize (g_properties);
+    m_properties.Initialize(g_properties);
+    m_global_properties.Initialize(g_global_properties);
 }
 
 bool
 CommandInterpreter::GetExpandRegexAliases () const
 {
     const uint32_t idx = ePropertyExpandRegexAliases;
-    return m_collection_sp->GetPropertyAtIndexAsBoolean (nullptr, idx, g_properties[idx].default_uint_value != 0);
+    return m_properties.GetValueProperties()->GetPropertyAtIndexAsBoolean (nullptr, idx, g_properties[idx].default_uint_value != 0);
 }
 
 bool
 CommandInterpreter::GetPromptOnQuit () const
 {
     const uint32_t idx = ePropertyPromptOnQuit;
-    return m_collection_sp->GetPropertyAtIndexAsBoolean (nullptr, idx, g_properties[idx].default_uint_value != 0);
+    return m_properties.GetValueProperties()->GetPropertyAtIndexAsBoolean (nullptr, idx, g_properties[idx].default_uint_value != 0);
 }
 
 bool
 CommandInterpreter::GetStopCmdSourceOnError () const
 {
     const uint32_t idx = ePropertyStopCmdSourceOnError;
-    return m_collection_sp->GetPropertyAtIndexAsBoolean (nullptr, idx, g_properties[idx].default_uint_value != 0);
+    return m_properties.GetValueProperties()->GetPropertyAtIndexAsBoolean (nullptr, idx, g_properties[idx].default_uint_value != 0);
+}
+
+char
+CommandInterpreter::GetEscapeCharacter()
+{
+    const uint32_t idx = eGlobalPropertyEscapeCharacter;
+    lldb::OptionValuePropertiesSP value_props = m_global_properties.GetValueProperties();
+    return value_props->GetPropertyAtIndexAsChar(NULL, idx, static_cast<char>(g_global_properties[idx].default_uint_value));
 }
 
 void
 CommandInterpreter::Initialize ()
 {
     Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
 
     CommandReturnObject result;

source/Interpreter/OptionValueProperties.cpp

if (property)
         {
             value->SetBooleanValue(new_value);
             return true;
         }
     }
     return false;
 }
 
+char
+OptionValueProperties::GetPropertyAtIndexAsChar (const ExecutionContext *exe_ctx, uint32_t idx, char fail_value) const
+{
+    const Property *property = GetPropertyAtIndex (exe_ctx, false, idx);
+    if (property)
+    {
+        OptionValue *value = property->GetValue().get();
+        if (value)
+            return value->GetCharValue(fail_value);
+    }
+    return fail_value;
+}
+    
+bool
+OptionValueProperties::SetPropertyAtIndexAsChar(const ExecutionContext *exe_ctx, uint32_t idx, char new_value)
+{
+    const Property *property = GetPropertyAtIndex (exe_ctx, true, idx);
+    if (property)
+    {
+        OptionValue *value = property->GetValue().get();
+        if (value)
+        {
+            value->SetCharValue(new_value);
+            return true;
+        }
+    }
+    return false;
+}
+
 OptionValueDictionary *
 OptionValueProperties::GetPropertyAtIndexAsOptionValueDictionary (const ExecutionContext *exe_ctx, uint32_t idx) const
 {
     const Property *property = GetPropertyAtIndex (exe_ctx, false, idx);
     if (property)
         return property->GetValue()->GetAsDictionary();
     return nullptr;
 }

source/Interpreter/Property.cpp

switch (definition.type)
             // value.
             if (definition.default_cstr_value)
                 m_value_sp.reset (new OptionValueBoolean(Args::StringToBoolean (definition.default_cstr_value, false, nullptr)));
             else
                 m_value_sp.reset (new OptionValueBoolean(definition.default_uint_value != 0));
             break;
 
         case OptionValue::eTypeChar:
-            m_value_sp.reset(new OptionValueChar(Args::StringToChar(definition.default_cstr_value, '\0', nullptr)));
+            m_value_sp.reset(new OptionValueChar(static_cast<char>(definition.default_uint_value)));
             break;
 
         case OptionValue::eTypeDictionary:
             // "definition.default_uint_value" is always a OptionValue::Type
             m_value_sp.reset (new OptionValueDictionary(OptionValue::ConvertTypeToMask((OptionValue::Type)definition.default_uint_value)));
             break;
             
         case OptionValue::eTypeEnum: