Move Args::StringToAddress to Target::EvaluateAddressExpression

[labath]

Summary

StringToAddress could end up evaluating an expression, which is a somewhat
unexpected behavior of a seemingly simple method. I rename it to
EvaluateAddressExpression and move it to the Target class, next to the standard
EvaluateExpression function.

This functionality is now invoked via
execution_context->GetTargetPtr()->EvaluateAddressExpression(). To avoid null
checking the target pointer everywhere, I've added the eCommandRequiresTarget
flag to the commands which didn't have it, and which did not seem to be useful
without a target (disassemble && target modules list).

[jingham]

I liked the fact that all these Argument input type string converters were all in one place, though arguably Args was not the right place. Among other things it made it easy to see that if you were adding a new command that took in an Address, AddressToString was the canonical way to do it. That's less obvious now that this one is a target function, and you would have to go look at another argument to see what it does. I wonder if this problem isn't better solved by moving all the parsing functions somewhere more appropriate (like CommandInterpreter?) and then it isn't surprising what they might do.

[labath]

Yes, that thought occurred to me almost immediately after I submitted this. I'll try to implement something like that instead.

Since this will be just a bunch of static functions with no state, I think we don't even have to put them into an existing class, but instead create a new file/class for holding just this. I just need to figure out a good name for that.

[labath]

This is a version that moves the StringTo*** functions to a new
"OptionArgParser" class. I'm not terribly proud of the name, but I couldn't
think of anything better -- we already have a OptionParser class, so I wanted
to make it clear that this is for parsing the *arguments* of the options.

I deliberately left out three functions out of this move (StringToVersion,
StringToGenericRegister and StringToVersion), as these are not used by the
Interpreter/Command libraries, but things like Host and ProcessGDBRemote, and
so I think they should have a different home.

Let me know what you think.

[jingham]

Except for the to -> To to keep consistent with all the other lldb function naming this looks fine.

Now that they are all together it's easy to see we haven't been consistent in these functions. We really should make ToFormat return the format & take an error reference, and have ToBoolean take an error so callers don't have to cons it up. But that's orthogonal to this patch.

include/lldb/Interpreter/OptionArgParser.h

18–19 ↗

(On Diff #138418)

Should be ToAddress.

[zturner]

I think having all parsing functions in a single place will just move the
layering problem elsewhere, since a bunch of conversion functions for
objects from various libraries will be mushed together into one place.

[jingham]

As long as these functions are used for parsing options args in individual CommandObject implementations, and don't get dragged lower in the stack, I don't think that's a problem. By the time you're getting to individual commands you are on top of pretty much everything else in lldb, and can expect to rely on whatever. And the value of having all the converters gathered in one place so people writing new commands can easily do the right thing when ingesting arguments more than justifies this gathering of disparate elements IMO.

[labath]

I agree with Jim. I deliberately put here only the types that are used for command parsing, since I presume these are the things that the Command/Interpreter modules will depend on (it's not fully clear to me where to draw the line between these two, so it may end up needing to be moved from one to the other in the future, but I think that future will be pretty far away).

I also thought about the case when something else, which is logically lower than Interpreter/Command needs the string conversion functions -- in this case we could put the conversion function in a different module, but still keep the function in OptionArgParser as a wrapper on top of that. This way you would still have all the argument parsing functions in one place, while the things in the other modules (which by definition will not be parsing option arguments, or else they would be in these modules), can call the lower level function directly.

Ultimately, solving the layering of string conversion functions is not my goal here. I would be fully satisfied with breaking even. My goal is to move this stuff out of the Args class, so it can be moved down to Utility, as it is one of the main causes that everything depends on Interpreter (and then everything else).

[labath]

s/toAddress/ToAddress/

[labath]

So, any objections to this patch?

[labath]

Jim, judging by the comment in https://reviews.llvm.org/D44306#1037587 you were fine with this patch except the naming part. Now that that's fixed, I hope this should be fine. Unless I hear from you, I am going to commit this so I can continue with re-layering the Args class.

[jingham]

Yes, with your updated naming, I am fine with this.

[labath]

Thank you.

PS: I will need someone to update the XCode project after this.

lldb/trunk/include/lldb/Interpreter/Args.h

 //===-- Args.h --------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_Command_h_
 #define liblldb_Command_h_
 
 // C Includes
 // C++ Includes
-#include <list>
 #include <string>
 #include <utility>
 #include <vector>
 
 // Other libraries and framework includes
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 // Project includes
 #include "lldb/Utility/Environment.h"
-#include "lldb/Utility/Status.h"
 #include "lldb/lldb-private-types.h"
 #include "lldb/lldb-types.h"
 
 namespace lldb_private {
 
 typedef std::vector<std::tuple<std::string, int, std::string>> OptionArgVector;
 typedef std::shared_ptr<OptionArgVector> OptionArgVectorSP;
 
static bool SInt64ValueIsValidForByteSize(int64_t sval64,
     if (total_byte_size == 8)
       return true;
 
     const int64_t max = ((int64_t)1 << (uint64_t)(total_byte_size * 8 - 1)) - 1;
     const int64_t min = ~(max);
     return min <= sval64 && sval64 <= max;
   }
 
-  static lldb::addr_t StringToAddress(const ExecutionContext *exe_ctx,
-                                      llvm::StringRef s,
-                                      lldb::addr_t fail_value, Status *error);
-
-  static bool StringToBoolean(llvm::StringRef s, bool fail_value,
-                              bool *success_ptr);
-
-  static char StringToChar(llvm::StringRef s, char fail_value,
-                           bool *success_ptr);
-
-  static int64_t StringToOptionEnum(llvm::StringRef s,
-                                    OptionEnumValueElement *enum_values,
-                                    int32_t fail_value, Status &error);
-
-  static lldb::ScriptLanguage
-  StringToScriptLanguage(llvm::StringRef s, lldb::ScriptLanguage fail_value,
-                         bool *success_ptr);
-
-  // TODO: Use StringRef
-  static Status StringToFormat(const char *s, lldb::Format &format,
-                               size_t *byte_size_ptr); // If non-NULL, then a
-                                                       // byte size can precede
-                                                       // the format character
-
   static lldb::Encoding
   StringToEncoding(llvm::StringRef s,
                    lldb::Encoding fail_value = lldb::eEncodingInvalid);
 
   static uint32_t StringToGenericRegister(llvm::StringRef s);
 
   static bool StringToVersion(llvm::StringRef string, uint32_t &major,
                               uint32_t &minor, uint32_t &update);

lldb/trunk/include/lldb/Interpreter/OptionArgParser.h

+//===-- OptionArgParser.h ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_INTERPRETER_OPTIONARGPARSER_H
+#define LLDB_INTERPRETER_OPTIONARGPARSER_H
+
+#include "lldb/lldb-private-types.h"
+
+namespace lldb_private {
+
+struct OptionArgParser {
+  static lldb::addr_t ToAddress(const ExecutionContext *exe_ctx,
+                                llvm::StringRef s, lldb::addr_t fail_value,
+                                Status *error);
+
+  static bool ToBoolean(llvm::StringRef s, bool fail_value, bool *success_ptr);
+
+  static char ToChar(llvm::StringRef s, char fail_value, bool *success_ptr);
+
+  static int64_t ToOptionEnum(llvm::StringRef s,
+                              OptionEnumValueElement *enum_values,
+                              int32_t fail_value, Status &error);
+
+  static lldb::ScriptLanguage ToScriptLanguage(llvm::StringRef s,
+                                               lldb::ScriptLanguage fail_value,
+                                               bool *success_ptr);
+
+  // TODO: Use StringRef
+  static Status ToFormat(const char *s, lldb::Format &format,
+                         size_t *byte_size_ptr); // If non-NULL, then a
+                                                 // byte size can precede
+                                                 // the format character
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_INTERPRETER_OPTIONARGPARSER_H

lldb/trunk/include/lldb/Interpreter/Options.h

 // C Includes
 // C++ Includes
 #include <set>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Interpreter/Args.h"
+#include "lldb/Utility/Status.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
 namespace lldb_private {
 
 struct Option;

lldb/trunk/source/API/SBDebugger.cpp

 #include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/Host/XML.h"
 #include "lldb/Initialization/SystemLifetimeManager.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupPlatform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/TargetList.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm/Support/ManagedStatic.h"
if (arch_name) {
     }
   }
   return false;
 }
 
 ScriptLanguage
 SBDebugger::GetScriptingLanguage(const char *script_language_name) {
   if (!script_language_name) return eScriptLanguageDefault;
-  return Args::StringToScriptLanguage(llvm::StringRef(script_language_name),
-                                      eScriptLanguageDefault, nullptr);
+  return OptionArgParser::ToScriptLanguage(
+      llvm::StringRef(script_language_name), eScriptLanguageDefault, nullptr);
 }
 
 const char *SBDebugger::GetVersionString() {
   return lldb_private::GetVersion();
 }
 
 const char *SBDebugger::StateAsCString(StateType state) {
   return lldb_private::StateAsCString(state);

lldb/trunk/source/Commands/CommandObjectBreakpoint.cpp

 #include "CommandObjectBreakpointCommand.h"
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointIDList.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionValueBoolean.h"
 #include "lldb/Interpreter/OptionValueString.h"
 #include "lldb/Interpreter/OptionValueUInt64.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
     case 'd':
       m_bp_opts.SetEnabled(false);
       break;
     case 'e':
       m_bp_opts.SetEnabled(true);
       break;
     case 'G': {
       bool value, success;
-      value = Args::StringToBoolean(option_arg, false, &success);
+      value = OptionArgParser::ToBoolean(option_arg, false, &success);
       if (success) {
         m_bp_opts.SetAutoContinue(value);
       } else
         error.SetErrorStringWithFormat(
             "invalid boolean value '%s' passed for -G option",
             option_arg.str().c_str());
     }
     break;
     case 'i':
     {
       uint32_t ignore_count;
       if (option_arg.getAsInteger(0, ignore_count))
         error.SetErrorStringWithFormat("invalid ignore count '%s'",
                                        option_arg.str().c_str());
       else
         m_bp_opts.SetIgnoreCount(ignore_count);
     }
     break;
     case 'o': {
       bool value, success;
-      value = Args::StringToBoolean(option_arg, false, &success);
+      value = OptionArgParser::ToBoolean(option_arg, false, &success);
       if (success) {
         m_bp_opts.SetOneShot(value);
       } else
         error.SetErrorStringWithFormat(
             "invalid boolean value '%s' passed for -o option",
             option_arg.str().c_str());
     } break;
     case 't':
public:
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = g_breakpoint_set_options[option_idx].short_option;
 
       switch (short_option) {
       case 'a': {
-        m_load_addr = Args::StringToAddress(execution_context, option_arg,
+        m_load_addr = OptionArgParser::ToAddress(execution_context, option_arg,
                                                  LLDB_INVALID_ADDRESS, &error);
       } break;
 
       case 'A':
         m_all_files = true;
         break;
 
       case 'b':
         m_func_names.push_back(option_arg);
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 
       case 'F':
         m_func_names.push_back(option_arg);
         m_func_name_type_mask |= eFunctionNameTypeFull;
         break;
         
       case 'h': {
         bool success;
-        m_catch_bp = Args::StringToBoolean(option_arg, true, &success);
+        m_catch_bp = OptionArgParser::ToBoolean(option_arg, true, &success);
         if (!success)
           error.SetErrorStringWithFormat(
               "Invalid boolean value for on-catch option: '%s'",
               option_arg.str().c_str());
       } break;
 
       case 'H':
         m_hardware = true;
         break;
 
       case 'K': {
         bool success;
         bool value;
-        value = Args::StringToBoolean(option_arg, true, &success);
+        value = OptionArgParser::ToBoolean(option_arg, true, &success);
         if (value)
           m_skip_prologue = eLazyBoolYes;
         else
           m_skip_prologue = eLazyBoolNo;
 
         if (!success)
           error.SetErrorStringWithFormat(
               "Invalid boolean value for skip prologue option: '%s'",
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
           error.SetErrorStringWithFormat(
               "Unknown language type: '%s' for breakpoint",
               option_arg.str().c_str());
         break;
 
       case 'm': {
         bool success;
         bool value;
-        value = Args::StringToBoolean(option_arg, true, &success);
+        value = OptionArgParser::ToBoolean(option_arg, true, &success);
         if (value)
           m_move_to_nearest_code = eLazyBoolYes;
         else
           m_move_to_nearest_code = eLazyBoolNo;
 
         if (!success)
           error.SetErrorStringWithFormat(
               "Invalid boolean value for move-to-nearest-code option: '%s'",
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         else
           error.SetErrorStringWithFormat("Invalid breakpoint name: %s",
                                          option_arg.str().c_str());
         break;
       }
 
       case 'R': {
         lldb::addr_t tmp_offset_addr;
-        tmp_offset_addr =
-            Args::StringToAddress(execution_context, option_arg, 0, &error);
+        tmp_offset_addr = OptionArgParser::ToAddress(execution_context,
+                                                     option_arg, 0, &error);
         if (error.Success())
           m_offset_addr = tmp_offset_addr;
       } break;
 
       case 'O':
         m_exception_extra_args.AppendArgument("-O");
         m_exception_extra_args.AppendArgument(option_arg);
         break;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 
       case 'S':
         m_func_names.push_back(option_arg);
         m_func_name_type_mask |= eFunctionNameTypeSelector;
         break;
 
       case 'w': {
         bool success;
-        m_throw_bp = Args::StringToBoolean(option_arg, true, &success);
+        m_throw_bp = OptionArgParser::ToBoolean(option_arg, true, &success);
         if (!success)
           error.SetErrorStringWithFormat(
               "Invalid boolean value for on-throw option: '%s'",
               option_arg.str().c_str());
       } break;
 
       case 'X':
         m_source_regex_func_names.insert(option_arg);
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                         ExecutionContext *execution_context) override {
     Status error;
     const int short_option 
         = g_breakpoint_access_options[option_idx].short_option;
 
     switch (short_option) {
       case 'L': {
         bool value, success;
-        value = Args::StringToBoolean(option_arg, false, &success);
+        value = OptionArgParser::ToBoolean(option_arg, false, &success);
         if (success) {
           m_permissions.SetAllowList(value);
         } else
           error.SetErrorStringWithFormat(
               "invalid boolean value '%s' passed for -L option",
               option_arg.str().c_str());
       } break;
       case 'A': {
         bool value, success;
-        value = Args::StringToBoolean(option_arg, false, &success);
+        value = OptionArgParser::ToBoolean(option_arg, false, &success);
         if (success) {
           m_permissions.SetAllowDisable(value);
         } else
           error.SetErrorStringWithFormat(
               "invalid boolean value '%s' passed for -L option",
               option_arg.str().c_str());
       } break;
       case 'D': {
         bool value, success;
-        value = Args::StringToBoolean(option_arg, false, &success);
+        value = OptionArgParser::ToBoolean(option_arg, false, &success);
         if (success) {
           m_permissions.SetAllowDelete(value);
         } else
           error.SetErrorStringWithFormat(
               "invalid boolean value '%s' passed for -L option",
               option_arg.str().c_str());
       } break;
 

lldb/trunk/source/Commands/CommandObjectBreakpointCommand.cpp

 #include "lldb/Breakpoint/BreakpointIDList.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/Core/State.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 
 #include "llvm/ADT/STLExtras.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 
       switch (short_option) {
       case 'o':
         m_use_one_liner = true;
         m_one_liner = option_arg;
         break;
 
       case 's':
-        m_script_language = (lldb::ScriptLanguage)Args::StringToOptionEnum(
+        m_script_language = (lldb::ScriptLanguage)OptionArgParser::ToOptionEnum(
             option_arg, g_breakpoint_add_options[option_idx].enum_values,
             eScriptLanguageNone, error);
 
         if (m_script_language == eScriptLanguagePython ||
             m_script_language == eScriptLanguageDefault) {
           m_use_script_language = true;
         } else {
           m_use_script_language = false;
         }
         break;
 
       case 'e': {
         bool success = false;
-        m_stop_on_error = Args::StringToBoolean(option_arg, false, &success);
+        m_stop_on_error =
+            OptionArgParser::ToBoolean(option_arg, false, &success);
         if (!success)
           error.SetErrorStringWithFormat(
               "invalid value for stop-on-error: \"%s\"",
               option_arg.str().c_str());
       } break;
 
       case 'F':
         m_use_one_liner = false;

lldb/trunk/source/Commands/CommandObjectCommands.cpp

 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandHistory.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObjectRegexCommand.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionValueBoolean.h"
 #include "lldb/Interpreter/OptionValueString.h"
 #include "lldb/Interpreter/OptionValueUInt64.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Utility/StringList.h"
 
 using namespace lldb;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
           m_class_name = option_arg;
         break;
       case 'h':
         if (!option_arg.empty())
           m_short_help = option_arg;
         break;
       case 's':
         m_synchronicity =
-            (ScriptedCommandSynchronicity)Args::StringToOptionEnum(
+            (ScriptedCommandSynchronicity)OptionArgParser::ToOptionEnum(
                 option_arg, GetDefinitions()[option_idx].enum_values, 0, error);
         if (!error.Success())
           error.SetErrorStringWithFormat(
               "unrecognized value for synchronicity '%s'",
               option_arg.str().c_str());
         break;
       default:
         error.SetErrorStringWithFormat("unrecognized option '%c'",

lldb/trunk/source/Commands/CommandObjectDisassemble.cpp

 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/SourceManager.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 
if (option_arg.getAsInteger(0, num_instructions))
           option_arg.str().c_str());
     break;
 
   case 'b':
     show_bytes = true;
     break;
 
   case 's': {
-    start_addr = Args::StringToAddress(execution_context, option_arg,
+    start_addr = OptionArgParser::ToAddress(execution_context, option_arg,
                                             LLDB_INVALID_ADDRESS, &error);
     if (start_addr != LLDB_INVALID_ADDRESS)
       some_location_specified = true;
   } break;
   case 'e': {
-    end_addr = Args::StringToAddress(execution_context, option_arg,
+    end_addr = OptionArgParser::ToAddress(execution_context, option_arg,
                                           LLDB_INVALID_ADDRESS, &error);
     if (end_addr != LLDB_INVALID_ADDRESS)
       some_location_specified = true;
   } break;
 
   case 'n':
     func_name.assign(option_arg);
     some_location_specified = true;
     break;
if (execution_context) {
       auto target_sp =
           execution_context ? execution_context->GetTargetSP() : TargetSP();
       auto platform_sp = target_sp ? target_sp->GetPlatform() : PlatformSP();
       arch = Platform::GetAugmentedArchSpec(platform_sp.get(), option_arg);
     }
     break;
 
   case 'a': {
-    symbol_containing_addr = Args::StringToAddress(
+    symbol_containing_addr = OptionArgParser::ToAddress(
         execution_context, option_arg, LLDB_INVALID_ADDRESS, &error);
     if (symbol_containing_addr != LLDB_INVALID_ADDRESS) {
       some_location_specified = true;
     }
   } break;
 
   default:
     error.SetErrorStringWithFormat("unrecognized short option '%c'",

lldb/trunk/source/Commands/CommandObjectExpression.cpp

 #include "lldb/DataFormatters/ValueObjectPrinter.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Expression/REPL.h"
 #include "lldb/Expression/UserExpression.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 
if (language == eLanguageTypeUnknown)
       error.SetErrorStringWithFormat(
           "unknown language type: '%s' for expression",
           option_arg.str().c_str());
     break;
 
   case 'a': {
     bool success;
     bool result;
-    result = Args::StringToBoolean(option_arg, true, &success);
+    result = OptionArgParser::ToBoolean(option_arg, true, &success);
     if (!success)
       error.SetErrorStringWithFormat(
           "invalid all-threads value setting: \"%s\"",
           option_arg.str().c_str());
     else
       try_all_threads = result;
   } break;
 
   case 'i': {
     bool success;
-    bool tmp_value = Args::StringToBoolean(option_arg, true, &success);
+    bool tmp_value = OptionArgParser::ToBoolean(option_arg, true, &success);
     if (success)
       ignore_breakpoints = tmp_value;
     else
       error.SetErrorStringWithFormat(
           "could not convert \"%s\" to a boolean value.",
           option_arg.str().c_str());
     break;
   }
 
   case 'j': {
     bool success;
-    bool tmp_value = Args::StringToBoolean(option_arg, true, &success);
+    bool tmp_value = OptionArgParser::ToBoolean(option_arg, true, &success);
     if (success)
       allow_jit = tmp_value;
     else
       error.SetErrorStringWithFormat(
           "could not convert \"%s\" to a boolean value.",
           option_arg.str().c_str());
     break;
   }
 
   case 't':
     if (option_arg.getAsInteger(0, timeout)) {
       timeout = 0;
       error.SetErrorStringWithFormat("invalid timeout setting \"%s\"",
                                      option_arg.str().c_str());
     }
     break;
 
   case 'u': {
     bool success;
-    bool tmp_value = Args::StringToBoolean(option_arg, true, &success);
+    bool tmp_value = OptionArgParser::ToBoolean(option_arg, true, &success);
     if (success)
       unwind_on_error = tmp_value;
     else
       error.SetErrorStringWithFormat(
           "could not convert \"%s\" to a boolean value.",
           option_arg.str().c_str());
     break;
   }
 
   case 'v':
     if (option_arg.empty()) {
       m_verbosity = eLanguageRuntimeDescriptionDisplayVerbosityFull;
       break;
     }
-    m_verbosity =
-        (LanguageRuntimeDescriptionDisplayVerbosity)Args::StringToOptionEnum(
+    m_verbosity = (LanguageRuntimeDescriptionDisplayVerbosity)
+        OptionArgParser::ToOptionEnum(
             option_arg, GetDefinitions()[option_idx].enum_values, 0, error);
     if (!error.Success())
       error.SetErrorStringWithFormat(
           "unrecognized value for description-verbosity '%s'",
           option_arg.str().c_str());
     break;
 
   case 'g':
     debug = true;
     unwind_on_error = false;
     ignore_breakpoints = false;
     break;
 
   case 'p':
     top_level = true;
     break;
 
   case 'X': {
     bool success;
-    bool tmp_value = Args::StringToBoolean(option_arg, true, &success);
+    bool tmp_value = OptionArgParser::ToBoolean(option_arg, true, &success);
     if (success)
       auto_apply_fixits = tmp_value ? eLazyBoolYes : eLazyBoolNo;
     else
       error.SetErrorStringWithFormat(
           "could not convert \"%s\" to a boolean value.",
           option_arg.str().c_str());
     break;
   }

lldb/trunk/source/Commands/CommandObjectLog.cpp

 #include "CommandObjectLog.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/FileSpec.h"
if (args.GetArgumentCount() == 1) {
           result.AppendError(
               "Could not convert enable depth to an unsigned integer.");
         } else {
           Timer::SetDisplayDepth(depth);
           result.SetStatus(eReturnStatusSuccessFinishNoResult);
         }
       } else if (sub_command.equals_lower("increment")) {
         bool success;
-        bool increment = Args::StringToBoolean(param, false, &success);
+        bool increment = OptionArgParser::ToBoolean(param, false, &success);
         if (success) {
           Timer::SetQuiet(!increment);
           result.SetStatus(eReturnStatusSuccessFinishNoResult);
         } else
           result.AppendError("Could not convert increment value to boolean.");
       }
     }
 

lldb/trunk/source/Commands/CommandObjectMemory.cpp

 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/DataFormatters/ValueObjectPrinter.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupFormat.h"
 #include "lldb/Interpreter/OptionGroupOutputFile.h"
 #include "lldb/Interpreter/OptionGroupValueObjectDisplay.h"
 #include "lldb/Interpreter/OptionValueString.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeList.h"
#undef ALL_KEYWORDS
 
     if (total_byte_size == 0) {
       total_byte_size = item_count * item_byte_size;
       if (total_byte_size == 0)
         total_byte_size = 32;
     }
 
     if (argc > 0)
-      addr = Args::StringToAddress(&m_exe_ctx, command[0].ref,
+      addr = OptionArgParser::ToAddress(&m_exe_ctx, command[0].ref,
                                         LLDB_INVALID_ADDRESS, &error);
 
     if (addr == LLDB_INVALID_ADDRESS) {
       result.AppendError("invalid start address expression.");
       result.AppendError(error.AsCString());
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     if (argc == 2) {
-      lldb::addr_t end_addr = Args::StringToAddress(
+      lldb::addr_t end_addr = OptionArgParser::ToAddress(
           &m_exe_ctx, command[1].ref, LLDB_INVALID_ADDRESS, nullptr);
       if (end_addr == LLDB_INVALID_ADDRESS) {
         result.AppendError("invalid end address expression.");
         result.AppendError(error.AsCString());
         result.SetStatus(eReturnStatusFailed);
         return false;
       } else if (end_addr <= addr) {
         result.AppendErrorWithFormat(
bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
 
     if (argc != 2) {
       result.AppendError("two addresses needed for memory find");
       return false;
     }
 
     Status error;
-    lldb::addr_t low_addr = Args::StringToAddress(&m_exe_ctx, command[0].ref,
-                                                  LLDB_INVALID_ADDRESS, &error);
+    lldb::addr_t low_addr = OptionArgParser::ToAddress(
+        &m_exe_ctx, command[0].ref, LLDB_INVALID_ADDRESS, &error);
     if (low_addr == LLDB_INVALID_ADDRESS || error.Fail()) {
       result.AppendError("invalid low address");
       return false;
     }
-    lldb::addr_t high_addr = Args::StringToAddress(
+    lldb::addr_t high_addr = OptionArgParser::ToAddress(
         &m_exe_ctx, command[1].ref, LLDB_INVALID_ADDRESS, &error);
     if (high_addr == LLDB_INVALID_ADDRESS || error.Fail()) {
       result.AppendError("invalid high address");
       return false;
     }
 
     if (high_addr <= low_addr) {
       result.AppendError(
StreamString buffer(
         Stream::eBinary,
         process->GetTarget().GetArchitecture().GetAddressByteSize(),
         process->GetTarget().GetArchitecture().GetByteOrder());
 
     OptionValueUInt64 &byte_size_value = m_format_options.GetByteSizeValue();
     size_t item_byte_size = byte_size_value.GetCurrentValue();
 
     Status error;
-    lldb::addr_t addr = Args::StringToAddress(&m_exe_ctx, command[0].ref,
-                                              LLDB_INVALID_ADDRESS, &error);
+    lldb::addr_t addr = OptionArgParser::ToAddress(
+        &m_exe_ctx, command[0].ref, LLDB_INVALID_ADDRESS, &error);
 
     if (addr == LLDB_INVALID_ADDRESS) {
       result.AppendError("invalid address expression\n");
       result.AppendError(error.AsCString());
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
for (auto &entry : command) {
                                        uval64, (uint64_t)item_byte_size);
           result.SetStatus(eReturnStatusFailed);
           return false;
         }
         buffer.PutMaxHex64(uval64, item_byte_size);
         break;
       }
       case eFormatBoolean:
-        uval64 = Args::StringToBoolean(entry.ref, false, &success);
+        uval64 = OptionArgParser::ToBoolean(entry.ref, false, &success);
         if (!success) {
           result.AppendErrorWithFormat(
               "'%s' is not a valid boolean string value.\n", entry.c_str());
           result.SetStatus(eReturnStatusFailed);
           return false;
         }
         buffer.PutMaxHex64(uval64, item_byte_size);
         break;
bool DoExecute(Args &command, CommandReturnObject &result) override {
     if (argc == 0 || argc > 1) {
       result.AppendErrorWithFormat("%s takes an address expression",
                                    m_cmd_name.c_str());
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     Status error;
-    lldb::addr_t addr = Args::StringToAddress(&m_exe_ctx, command[0].ref,
-                                              LLDB_INVALID_ADDRESS, &error);
+    lldb::addr_t addr = OptionArgParser::ToAddress(
+        &m_exe_ctx, command[0].ref, LLDB_INVALID_ADDRESS, &error);
 
     if (addr == LLDB_INVALID_ADDRESS) {
       result.AppendError("invalid address expression");
       result.AppendError(error.AsCString());
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
if (process_sp) {
       const size_t argc = command.GetArgumentCount();
       if (argc > 1 || (argc == 0 && load_addr == LLDB_INVALID_ADDRESS)) {
         result.AppendErrorWithFormat("'%s' takes one argument:\nUsage: %s\n",
                                      m_cmd_name.c_str(), m_cmd_syntax.c_str());
         result.SetStatus(eReturnStatusFailed);
       } else {
         auto load_addr_str = command[0].ref;
         if (command.GetArgumentCount() == 1) {
-          load_addr = Args::StringToAddress(&m_exe_ctx, load_addr_str,
+          load_addr = OptionArgParser::ToAddress(&m_exe_ctx, load_addr_str,
                                                  LLDB_INVALID_ADDRESS, &error);
           if (error.Fail() || load_addr == LLDB_INVALID_ADDRESS) {
             result.AppendErrorWithFormat(
                 "invalid address argument \"%s\": %s\n", command[0].c_str(),
                 error.AsCString());
             result.SetStatus(eReturnStatusFailed);
           }
         }
 

lldb/trunk/source/Commands/CommandObjectProcess.cpp

 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/State.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/UnixSignals.h"
 
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 's':
         bool tmp_result;
         bool success;
-        tmp_result = Args::StringToBoolean(option_arg, false, &success);
+        tmp_result = OptionArgParser::ToBoolean(option_arg, false, &success);
         if (!success)
           error.SetErrorStringWithFormat("invalid boolean option: \"%s\"",
                                          option_arg.str().c_str());
         else {
           if (tmp_result)
             m_keep_stopped = eLazyBoolYes;
           else
             m_keep_stopped = eLazyBoolNo;
public:
 
   ~CommandObjectProcessHandle() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   bool VerifyCommandOptionValue(const std::string &option, int &real_value) {
     bool okay = true;
     bool success = false;
-    bool tmp_value = Args::StringToBoolean(option, false, &success);
+    bool tmp_value = OptionArgParser::ToBoolean(option, false, &success);
 
     if (success && tmp_value)
       real_value = 1;
     else if (success && !tmp_value)
       real_value = 0;
     else {
       // If the value isn't 'true' or 'false', it had better be 0 or 1.
       real_value = StringConvert::ToUInt32(option.c_str(), 3);

lldb/trunk/source/Commands/CommandObjectSource.cpp

 #include "lldb/Core/FileLineResolver.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/SourceManager.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/TargetList.h"
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         file_name = option_arg;
         break;
 
       case 'n':
         symbol_name = option_arg;
         break;
 
       case 'a': {
-        address = Args::StringToAddress(execution_context, option_arg,
+        address = OptionArgParser::ToAddress(execution_context, option_arg,
                                              LLDB_INVALID_ADDRESS, &error);
       } break;
       case 's':
         modules.push_back(std::string(option_arg));
         break;
       default:
         error.SetErrorStringWithFormat("unrecognized short option '%c'",
                                        short_option);
         break;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         file_name = option_arg;
         break;
 
       case 'n':
         symbol_name = option_arg;
         break;
 
       case 'a': {
-        address = Args::StringToAddress(execution_context, option_arg,
+        address = OptionArgParser::ToAddress(execution_context, option_arg,
                                              LLDB_INVALID_ADDRESS, &error);
       } break;
       case 's':
         modules.push_back(std::string(option_arg));
         break;
 
       case 'b':
         show_bp_locs = true;
         break;

lldb/trunk/source/Commands/CommandObjectTarget.cpp

 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/DataFormatters/ValueObjectPrinter.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupArchitecture.h"
 #include "lldb/Interpreter/OptionGroupBoolean.h"
 #include "lldb/Interpreter/OptionGroupFile.h"
 #include "lldb/Interpreter/OptionGroupFormat.h"
 #include "lldb/Interpreter/OptionGroupPlatform.h"
 #include "lldb/Interpreter/OptionGroupString.h"
 #include "lldb/Interpreter/OptionGroupUInt64.h"
 #include "lldb/Interpreter/OptionGroupUUID.h"
public:
 
     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 's':
-        m_sort_order = (SortOrder)Args::StringToOptionEnum(
+        m_sort_order = (SortOrder)OptionArgParser::ToOptionEnum(
             option_arg, GetDefinitions()[option_idx].enum_values,
             eSortOrderNone, error);
         break;
 
       default:
         error.SetErrorStringWithFormat("invalid short option character '%c'",
                                        short_option);
         break;
public:
     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;
       if (short_option == 'g') {
         m_use_global_module_list = true;
       } else if (short_option == 'a') {
-        m_module_addr = Args::StringToAddress(execution_context, option_arg,
-                                              LLDB_INVALID_ADDRESS, &error);
+        m_module_addr = OptionArgParser::ToAddress(
+            execution_context, option_arg, LLDB_INVALID_ADDRESS, &error);
       } else {
         unsigned long width = 0;
         option_arg.getAsInteger(0, width);
         m_format_array.push_back(std::make_pair(short_option, width));
       }
       return error;
     }
 
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       Status error;
 
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'a': {
         m_str = option_arg;
         m_type = eLookupTypeAddress;
-        m_addr = Args::StringToAddress(execution_context, option_arg,
+        m_addr = OptionArgParser::ToAddress(execution_context, option_arg,
                                             LLDB_INVALID_ADDRESS, &error);
         if (m_addr == LLDB_INVALID_ADDRESS)
           error.SetErrorStringWithFormat("invalid address string '%s'",
                                          option_arg.str().c_str());
         break;
       }
 
       case 'n':
         m_str = option_arg;
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 'a': {
         m_type = eLookupTypeAddress;
-        m_addr = Args::StringToAddress(execution_context, option_arg,
+        m_addr = OptionArgParser::ToAddress(execution_context, option_arg,
                                             LLDB_INVALID_ADDRESS, &error);
       } break;
 
       case 'o':
         if (option_arg.getAsInteger(0, m_offset))
           error.SetErrorStringWithFormat("invalid offset string '%s'",
                                          option_arg.str().c_str());
         break;
 

lldb/trunk/source/Commands/CommandObjectThread.cpp

 #include "lldb/Core/SourceManager.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SystemRuntime.h"
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       case 's':
         if (option_arg.getAsInteger(0, m_start))
           error.SetErrorStringWithFormat(
               "invalid integer value for option '%c'", short_option);
         break;
       case 'e': {
         bool success;
         m_extended_backtrace =
-            Args::StringToBoolean(option_arg, false, &success);
+            OptionArgParser::ToBoolean(option_arg, false, &success);
         if (!success)
           error.SetErrorStringWithFormat(
               "invalid boolean value for option '%c'", short_option);
       } break;
       default:
         error.SetErrorStringWithFormat("invalid short option character '%c'",
                                        short_option);
         break;
public:
     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 'a': {
         bool success;
-        bool avoid_no_debug = Args::StringToBoolean(option_arg, true, &success);
+        bool avoid_no_debug =
+            OptionArgParser::ToBoolean(option_arg, true, &success);
         if (!success)
           error.SetErrorStringWithFormat(
               "invalid boolean value for option '%c'", short_option);
         else {
           m_step_in_avoid_no_debug =
               avoid_no_debug ? eLazyBoolYes : eLazyBoolNo;
         }
       } break;
 
       case 'A': {
         bool success;
-        bool avoid_no_debug = Args::StringToBoolean(option_arg, true, &success);
+        bool avoid_no_debug =
+            OptionArgParser::ToBoolean(option_arg, true, &success);
         if (!success)
           error.SetErrorStringWithFormat(
               "invalid boolean value for option '%c'", short_option);
         else {
           m_step_out_avoid_no_debug =
               avoid_no_debug ? eLazyBoolYes : eLazyBoolNo;
         }
       } break;
 
       case 'c':
         if (option_arg.getAsInteger(0, m_step_count))
           error.SetErrorStringWithFormat("invalid step count '%s'",
                                          option_arg.str().c_str());
         break;
 
       case 'C':
         m_class_name.clear();
         m_class_name.assign(option_arg);
         break;
 
       case 'm': {
         OptionEnumValueElement *enum_values =
             GetDefinitions()[option_idx].enum_values;
-        m_run_mode = (lldb::RunMode)Args::StringToOptionEnum(
+        m_run_mode = (lldb::RunMode)OptionArgParser::ToOptionEnum(
             option_arg, enum_values, eOnlyDuringStepping, error);
       } break;
 
       case 'e':
         if (option_arg == "block") {
           m_end_line_is_block_end = 1;
           break;
         }
public:
 
     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 'a': {
-        lldb::addr_t tmp_addr = Args::StringToAddress(
+        lldb::addr_t tmp_addr = OptionArgParser::ToAddress(
             execution_context, option_arg, LLDB_INVALID_ADDRESS, &error);
         if (error.Success())
           m_until_addrs.push_back(tmp_addr);
       } break;
       case 't':
         if (option_arg.getAsInteger(0, m_thread_idx)) {
           m_thread_idx = LLDB_INVALID_INDEX32;
           error.SetErrorStringWithFormat("invalid thread index '%s'",
                                          option_arg.str().c_str());
         }
         break;
       case 'f':
         if (option_arg.getAsInteger(0, m_frame_idx)) {
           m_frame_idx = LLDB_INVALID_FRAME_ID;
           error.SetErrorStringWithFormat("invalid frame index '%s'",
                                          option_arg.str().c_str());
         }
         break;
       case 'm': {
         OptionEnumValueElement *enum_values =
             GetDefinitions()[option_idx].enum_values;
-        lldb::RunMode run_mode = (lldb::RunMode)Args::StringToOptionEnum(
+        lldb::RunMode run_mode = (lldb::RunMode)OptionArgParser::ToOptionEnum(
             option_arg, enum_values, eOnlyDuringStepping, error);
 
         if (error.Success()) {
           if (run_mode == eAllThreads)
             m_stop_others = false;
           else
             m_stop_others = true;
         }
public:
     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 'x': {
         bool success;
-        bool tmp_value = Args::StringToBoolean(option_arg, false, &success);
+        bool tmp_value =
+            OptionArgParser::ToBoolean(option_arg, false, &success);
         if (success)
           m_from_expression = tmp_value;
         else {
           error.SetErrorStringWithFormat(
               "invalid boolean value '%s' for 'x' option",
               option_arg.str().c_str());
         }
       } break;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         if (option_arg.getAsInteger(0, m_line_num))
           return Status("invalid line number: '%s'.", option_arg.str().c_str());
         break;
       case 'b':
         if (option_arg.getAsInteger(0, m_line_offset))
           return Status("invalid line offset: '%s'.", option_arg.str().c_str());
         break;
       case 'a':
-        m_load_addr = Args::StringToAddress(execution_context, option_arg,
+        m_load_addr = OptionArgParser::ToAddress(execution_context, option_arg,
                                                  LLDB_INVALID_ADDRESS, &error);
         break;
       case 'r':
         m_force = true;
         break;
       default:
         return Status("invalid short option character '%c'", short_option);
       }
       return error;

lldb/trunk/source/Commands/CommandObjectType.cpp

 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/Core/State.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupFormat.h"
 #include "lldb/Interpreter/OptionValueBoolean.h"
 #include "lldb/Interpreter/OptionValueLanguage.h"
 #include "lldb/Interpreter/OptionValueString.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Process.h"
public:
     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;
       bool success;
 
       switch (short_option) {
       case 'C':
-        m_cascade = Args::StringToBoolean(option_arg, true, &success);
+        m_cascade = OptionArgParser::ToBoolean(option_arg, true, &success);
         if (!success)
           error.SetErrorStringWithFormat("invalid value for cascade: %s",
                                          option_arg.str().c_str());
         break;
       case 'P':
         handwrite_python = true;
         break;
       case 'l':
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option =
           g_type_format_add_options[option_idx].short_option;
       bool success;
 
       switch (short_option) {
       case 'C':
-        m_cascade = Args::StringToBoolean(option_value, true, &success);
+        m_cascade = OptionArgParser::ToBoolean(option_value, true, &success);
         if (!success)
           error.SetErrorStringWithFormat("invalid value for cascade: %s",
                                          option_value.str().c_str());
         break;
       case 'p':
         m_skip_pointers = true;
         break;
       case 'w':
Status CommandObjectTypeSummaryAdd::CommandOptions::SetOptionValue(
     uint32_t option_idx, llvm::StringRef option_arg,
     ExecutionContext *execution_context) {
   Status error;
   const int short_option = m_getopt_table[option_idx].val;
   bool success;
 
   switch (short_option) {
   case 'C':
-    m_flags.SetCascades(Args::StringToBoolean(option_arg, true, &success));
+    m_flags.SetCascades(OptionArgParser::ToBoolean(option_arg, true, &success));
     if (!success)
       error.SetErrorStringWithFormat("invalid value for cascade: %s",
                                      option_arg.str().c_str());
     break;
   case 'e':
     m_flags.SetDontShowChildren(false);
     break;
   case 'h':
public:
     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;
       bool success;
 
       switch (short_option) {
       case 'C':
-        m_cascade = Args::StringToBoolean(option_arg, true, &success);
+        m_cascade = OptionArgParser::ToBoolean(option_arg, true, &success);
         if (!success)
           error.SetErrorStringWithFormat("invalid value for cascade: %s",
                                          option_arg.str().c_str());
         break;
       case 'c':
         m_expr_paths.push_back(option_arg);
         has_child_list = true;
         break;

lldb/trunk/source/Commands/CommandObjectWatchpointCommand.cpp

 #include "CommandObjectWatchpointCommand.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/Core/State.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //-------------------------------------------------------------------------
 // CommandObjectWatchpointCommandAdd
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 
       switch (short_option) {
       case 'o':
         m_use_one_liner = true;
         m_one_liner = option_arg;
         break;
 
       case 's':
-        m_script_language = (lldb::ScriptLanguage)Args::StringToOptionEnum(
+        m_script_language = (lldb::ScriptLanguage)OptionArgParser::ToOptionEnum(
             option_arg, GetDefinitions()[option_idx].enum_values,
             eScriptLanguageNone, error);
 
         m_use_script_language = (m_script_language == eScriptLanguagePython ||
                                  m_script_language == eScriptLanguageDefault);
         break;
 
       case 'e': {
         bool success = false;
-        m_stop_on_error = Args::StringToBoolean(option_arg, false, &success);
+        m_stop_on_error =
+            OptionArgParser::ToBoolean(option_arg, false, &success);
         if (!success)
           error.SetErrorStringWithFormat(
               "invalid value for stop-on-error: \"%s\"",
               option_arg.str().c_str());
       } break;
 
       case 'F':
         m_use_one_liner = false;

lldb/trunk/source/Interpreter/Args.cpp

 //===-- Args.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 #include <cstdlib>
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
-#include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Interpreter/Args.h"
-#include "lldb/Target/Target.h"
+#include "lldb/Interpreter/Options.h"
+#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Stream.h"
-#include "lldb/Utility/StreamString.h"
+#include "lldb/Utility/StringList.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 
 using namespace lldb;
 using namespace lldb_private;
 

 }
 
 void Args::Clear() {
   m_entries.clear();
   m_argv.clear();
   m_argv.push_back(nullptr);
 }
 
-lldb::addr_t Args::StringToAddress(const ExecutionContext *exe_ctx,
-                                   llvm::StringRef s, lldb::addr_t fail_value,
-                                   Status *error_ptr) {
-  bool error_set = false;
-  if (s.empty()) {
-    if (error_ptr)
-      error_ptr->SetErrorStringWithFormat("invalid address expression \"%s\"",
-                                          s.str().c_str());
-    return fail_value;
-  }
-
-  llvm::StringRef sref = s;
-
-  lldb::addr_t addr = LLDB_INVALID_ADDRESS;
-  if (!s.getAsInteger(0, addr)) {
-    if (error_ptr)
-      error_ptr->Clear();
-    return addr;
-  }
-
-  // Try base 16 with no prefix...
-  if (!s.getAsInteger(16, addr)) {
-    if (error_ptr)
-      error_ptr->Clear();
-    return addr;
-  }
-
-  Target *target = nullptr;
-  if (!exe_ctx || !(target = exe_ctx->GetTargetPtr())) {
-    if (error_ptr)
-      error_ptr->SetErrorStringWithFormat("invalid address expression \"%s\"",
-                                          s.str().c_str());
-    return fail_value;
-  }
-
-  lldb::ValueObjectSP valobj_sp;
-  EvaluateExpressionOptions options;
-  options.SetCoerceToId(false);
-  options.SetUnwindOnError(true);
-  options.SetKeepInMemory(false);
-  options.SetTryAllThreads(true);
-
-  ExpressionResults expr_result =
-      target->EvaluateExpression(s, exe_ctx->GetFramePtr(), valobj_sp, options);
-
-  bool success = false;
-  if (expr_result == eExpressionCompleted) {
-    if (valobj_sp)
-      valobj_sp = valobj_sp->GetQualifiedRepresentationIfAvailable(
-          valobj_sp->GetDynamicValueType(), true);
-    // Get the address to watch.
-    if (valobj_sp)
-      addr = valobj_sp->GetValueAsUnsigned(fail_value, &success);
-    if (success) {
-      if (error_ptr)
-        error_ptr->Clear();
-      return addr;
-    } else {
-      if (error_ptr) {
-        error_set = true;
-        error_ptr->SetErrorStringWithFormat(
-            "address expression \"%s\" resulted in a value whose type "
-            "can't be converted to an address: %s",
-            s.str().c_str(), valobj_sp->GetTypeName().GetCString());
-      }
-    }
-
-  } else {
-    // Since the compiler can't handle things like "main + 12" we should
-    // try to do this for now. The compiler doesn't like adding offsets
-    // to function pointer types.
-    static RegularExpression g_symbol_plus_offset_regex(
-        "^(.*)([-\\+])[[:space:]]*(0x[0-9A-Fa-f]+|[0-9]+)[[:space:]]*$");
-    RegularExpression::Match regex_match(3);
-    if (g_symbol_plus_offset_regex.Execute(sref, &regex_match)) {
-      uint64_t offset = 0;
-      bool add = true;
-      std::string name;
-      std::string str;
-      if (regex_match.GetMatchAtIndex(s, 1, name)) {
-        if (regex_match.GetMatchAtIndex(s, 2, str)) {
-          add = str[0] == '+';
-
-          if (regex_match.GetMatchAtIndex(s, 3, str)) {
-            if (!llvm::StringRef(str).getAsInteger(0, offset)) {
-              Status error;
-              addr = StringToAddress(exe_ctx, name.c_str(),
-                                     LLDB_INVALID_ADDRESS, &error);
-              if (addr != LLDB_INVALID_ADDRESS) {
-                if (add)
-                  return addr + offset;
-                else
-                  return addr - offset;
-              }
-            }
-          }
-        }
-      }
-    }
-
-    if (error_ptr) {
-      error_set = true;
-      error_ptr->SetErrorStringWithFormat(
-          "address expression \"%s\" evaluation failed", s.str().c_str());
-    }
-  }
-
-  if (error_ptr) {
-    if (!error_set)
-      error_ptr->SetErrorStringWithFormat("invalid address expression \"%s\"",
-                                          s.str().c_str());
-  }
-  return fail_value;
-}
-
 const char *Args::StripSpaces(std::string &s, bool leading, bool trailing,
                               bool return_null_if_empty) {
   static const char *k_white_space = " \t\v";
   if (!s.empty()) {
     if (leading) {
       size_t pos = s.find_first_not_of(k_white_space);
       if (pos == std::string::npos)
         s.clear();
       else if (pos > 0)
         s.erase(0, pos);
     }
 
     if (trailing) {
       size_t rpos = s.find_last_not_of(k_white_space);
       if (rpos != std::string::npos && rpos + 1 < s.size())
         s.erase(rpos + 1);
     }
   }
   if (return_null_if_empty && s.empty())
     return nullptr;
   return s.c_str();
 }
 
-bool Args::StringToBoolean(llvm::StringRef ref, bool fail_value,
-                           bool *success_ptr) {
-  if (success_ptr)
-    *success_ptr = true;
-  ref = ref.trim();
-  if (ref.equals_lower("false") || ref.equals_lower("off") ||
-      ref.equals_lower("no") || ref.equals_lower("0")) {
-    return false;
-  } else if (ref.equals_lower("true") || ref.equals_lower("on") ||
-             ref.equals_lower("yes") || ref.equals_lower("1")) {
-    return true;
-  }
-  if (success_ptr)
-    *success_ptr = false;
-  return fail_value;
-}
-
-char Args::StringToChar(llvm::StringRef s, char fail_value, bool *success_ptr) {
-  if (success_ptr)
-    *success_ptr = false;
-  if (s.size() != 1)
-    return fail_value;
-
-  if (success_ptr)
-    *success_ptr = true;
-  return s[0];
-}
-
 bool Args::StringToVersion(llvm::StringRef string, uint32_t &major,
                            uint32_t &minor, uint32_t &update) {
   major = UINT32_MAX;
   minor = UINT32_MAX;
   update = UINT32_MAX;
 
   if (string.empty())
     return false;
if (pos != std::string::npos) {
       safe_arg.insert(pos, 1, '\\');
       prev_pos = pos + 2;
     } else
       break;
   }
   return safe_arg.c_str();
 }
 
-int64_t Args::StringToOptionEnum(llvm::StringRef s,
-                                 OptionEnumValueElement *enum_values,
-                                 int32_t fail_value, Status &error) {
-  error.Clear();
-  if (!enum_values) {
-    error.SetErrorString("invalid enumeration argument");
-    return fail_value;
-  }
-
-  if (s.empty()) {
-    error.SetErrorString("empty enumeration string");
-    return fail_value;
-  }
-
-  for (int i = 0; enum_values[i].string_value != nullptr; i++) {
-    llvm::StringRef this_enum(enum_values[i].string_value);
-    if (this_enum.startswith(s))
-      return enum_values[i].value;
-  }
-
-  StreamString strm;
-  strm.PutCString("invalid enumeration value, valid values are: ");
-  for (int i = 0; enum_values[i].string_value != nullptr; i++) {
-    strm.Printf("%s\"%s\"", i > 0 ? ", " : "", enum_values[i].string_value);
-  }
-  error.SetErrorString(strm.GetString());
-  return fail_value;
-}
-
-lldb::ScriptLanguage
-Args::StringToScriptLanguage(llvm::StringRef s, lldb::ScriptLanguage fail_value,
-                             bool *success_ptr) {
-  if (success_ptr)
-    *success_ptr = true;
-
-  if (s.equals_lower("python"))
-    return eScriptLanguagePython;
-  if (s.equals_lower("default"))
-    return eScriptLanguageDefault;
-  if (s.equals_lower("none"))
-    return eScriptLanguageNone;
-
-  if (success_ptr)
-    *success_ptr = false;
-  return fail_value;
-}
-
-Status Args::StringToFormat(const char *s, lldb::Format &format,
-                            size_t *byte_size_ptr) {
-  format = eFormatInvalid;
-  Status error;
-
-  if (s && s[0]) {
-    if (byte_size_ptr) {
-      if (isdigit(s[0])) {
-        char *format_char = nullptr;
-        unsigned long byte_size = ::strtoul(s, &format_char, 0);
-        if (byte_size != ULONG_MAX)
-          *byte_size_ptr = byte_size;
-        s = format_char;
-      } else
-        *byte_size_ptr = 0;
-    }
-
-    const bool partial_match_ok = true;
-    if (!FormatManager::GetFormatFromCString(s, partial_match_ok, format)) {
-      StreamString error_strm;
-      error_strm.Printf(
-          "Invalid format character or name '%s'. Valid values are:\n", s);
-      for (Format f = eFormatDefault; f < kNumFormats; f = Format(f + 1)) {
-        char format_char = FormatManager::GetFormatAsFormatChar(f);
-        if (format_char)
-          error_strm.Printf("'%c' or ", format_char);
-
-        error_strm.Printf("\"%s\"", FormatManager::GetFormatAsCString(f));
-        error_strm.EOL();
-      }
-
-      if (byte_size_ptr)
-        error_strm.PutCString(
-            "An optional byte size can precede the format character.\n");
-      error.SetErrorString(error_strm.GetString());
-    }
-
-    if (error.Fail())
-      return error;
-  } else {
-    error.SetErrorStringWithFormat("%s option string", s ? "empty" : "invalid");
-  }
-  return error;
-}
-
 lldb::Encoding Args::StringToEncoding(llvm::StringRef s,
                                       lldb::Encoding fail_value) {
   return llvm::StringSwitch<lldb::Encoding>(s)
       .Case("uint", eEncodingUint)
       .Case("sint", eEncodingSint)
       .Case("ieee754", eEncodingIEEE754)
       .Case("vector", eEncodingVector)
       .Default(fail_value);

lldb/trunk/source/Interpreter/CMakeLists.txt

 add_lldb_library(lldbInterpreter
   Args.cpp
   CommandAlias.cpp
   CommandHistory.cpp
   CommandInterpreter.cpp
   CommandObject.cpp
   CommandObjectRegexCommand.cpp
   CommandObjectScript.cpp
   CommandOptionValidators.cpp
   CommandReturnObject.cpp
+  OptionArgParser.cpp
   OptionGroupArchitecture.cpp
   OptionGroupBoolean.cpp
   OptionGroupFile.cpp
   OptionGroupFormat.cpp
   OptionGroupOutputFile.cpp
   OptionGroupPlatform.cpp
   OptionGroupString.cpp
   OptionGroupUInt64.cpp

lldb/trunk/source/Interpreter/OptionArgParser.cpp

+//===-- OptionArgParser.cpp -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Interpreter/OptionArgParser.h"
+#include "lldb/DataFormatters/FormatManager.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Utility/Status.h"
+#include "lldb/Utility/StreamString.h"
+
+using namespace lldb_private;
+using namespace lldb;
+
+bool OptionArgParser::ToBoolean(llvm::StringRef ref, bool fail_value,
+                                bool *success_ptr) {
+  if (success_ptr)
+    *success_ptr = true;
+  ref = ref.trim();
+  if (ref.equals_lower("false") || ref.equals_lower("off") ||
+      ref.equals_lower("no") || ref.equals_lower("0")) {
+    return false;
+  } else if (ref.equals_lower("true") || ref.equals_lower("on") ||
+             ref.equals_lower("yes") || ref.equals_lower("1")) {
+    return true;
+  }
+  if (success_ptr)
+    *success_ptr = false;
+  return fail_value;
+}
+
+char OptionArgParser::ToChar(llvm::StringRef s, char fail_value,
+                             bool *success_ptr) {
+  if (success_ptr)
+    *success_ptr = false;
+  if (s.size() != 1)
+    return fail_value;
+
+  if (success_ptr)
+    *success_ptr = true;
+  return s[0];
+}
+
+int64_t OptionArgParser::ToOptionEnum(llvm::StringRef s,
+                                      OptionEnumValueElement *enum_values,
+                                      int32_t fail_value, Status &error) {
+  error.Clear();
+  if (!enum_values) {
+    error.SetErrorString("invalid enumeration argument");
+    return fail_value;
+  }
+
+  if (s.empty()) {
+    error.SetErrorString("empty enumeration string");
+    return fail_value;
+  }
+
+  for (int i = 0; enum_values[i].string_value != nullptr; i++) {
+    llvm::StringRef this_enum(enum_values[i].string_value);
+    if (this_enum.startswith(s))
+      return enum_values[i].value;
+  }
+
+  StreamString strm;
+  strm.PutCString("invalid enumeration value, valid values are: ");
+  for (int i = 0; enum_values[i].string_value != nullptr; i++) {
+    strm.Printf("%s\"%s\"", i > 0 ? ", " : "", enum_values[i].string_value);
+  }
+  error.SetErrorString(strm.GetString());
+  return fail_value;
+}
+
+Status OptionArgParser::ToFormat(const char *s, lldb::Format &format,
+                                 size_t *byte_size_ptr) {
+  format = eFormatInvalid;
+  Status error;
+
+  if (s && s[0]) {
+    if (byte_size_ptr) {
+      if (isdigit(s[0])) {
+        char *format_char = nullptr;
+        unsigned long byte_size = ::strtoul(s, &format_char, 0);
+        if (byte_size != ULONG_MAX)
+          *byte_size_ptr = byte_size;
+        s = format_char;
+      } else
+        *byte_size_ptr = 0;
+    }
+
+    const bool partial_match_ok = true;
+    if (!FormatManager::GetFormatFromCString(s, partial_match_ok, format)) {
+      StreamString error_strm;
+      error_strm.Printf(
+          "Invalid format character or name '%s'. Valid values are:\n", s);
+      for (Format f = eFormatDefault; f < kNumFormats; f = Format(f + 1)) {
+        char format_char = FormatManager::GetFormatAsFormatChar(f);
+        if (format_char)
+          error_strm.Printf("'%c' or ", format_char);
+
+        error_strm.Printf("\"%s\"", FormatManager::GetFormatAsCString(f));
+        error_strm.EOL();
+      }
+
+      if (byte_size_ptr)
+        error_strm.PutCString(
+            "An optional byte size can precede the format character.\n");
+      error.SetErrorString(error_strm.GetString());
+    }
+
+    if (error.Fail())
+      return error;
+  } else {
+    error.SetErrorStringWithFormat("%s option string", s ? "empty" : "invalid");
+  }
+  return error;
+}
+
+lldb::ScriptLanguage OptionArgParser::ToScriptLanguage(
+    llvm::StringRef s, lldb::ScriptLanguage fail_value, bool *success_ptr) {
+  if (success_ptr)
+    *success_ptr = true;
+
+  if (s.equals_lower("python"))
+    return eScriptLanguagePython;
+  if (s.equals_lower("default"))
+    return eScriptLanguageDefault;
+  if (s.equals_lower("none"))
+    return eScriptLanguageNone;
+
+  if (success_ptr)
+    *success_ptr = false;
+  return fail_value;
+}
+
+lldb::addr_t OptionArgParser::ToAddress(const ExecutionContext *exe_ctx,
+                                        llvm::StringRef s,
+                                        lldb::addr_t fail_value,
+                                        Status *error_ptr) {
+  bool error_set = false;
+  if (s.empty()) {
+    if (error_ptr)
+      error_ptr->SetErrorStringWithFormat("invalid address expression \"%s\"",
+                                          s.str().c_str());
+    return fail_value;
+  }
+
+  llvm::StringRef sref = s;
+
+  lldb::addr_t addr = LLDB_INVALID_ADDRESS;
+  if (!s.getAsInteger(0, addr)) {
+    if (error_ptr)
+      error_ptr->Clear();
+    return addr;
+  }
+
+  // Try base 16 with no prefix...
+  if (!s.getAsInteger(16, addr)) {
+    if (error_ptr)
+      error_ptr->Clear();
+    return addr;
+  }
+
+  Target *target = nullptr;
+  if (!exe_ctx || !(target = exe_ctx->GetTargetPtr())) {
+    if (error_ptr)
+      error_ptr->SetErrorStringWithFormat("invalid address expression \"%s\"",
+                                          s.str().c_str());
+    return fail_value;
+  }
+
+  lldb::ValueObjectSP valobj_sp;
+  EvaluateExpressionOptions options;
+  options.SetCoerceToId(false);
+  options.SetUnwindOnError(true);
+  options.SetKeepInMemory(false);
+  options.SetTryAllThreads(true);
+
+  ExpressionResults expr_result =
+      target->EvaluateExpression(s, exe_ctx->GetFramePtr(), valobj_sp, options);
+
+  bool success = false;
+  if (expr_result == eExpressionCompleted) {
+    if (valobj_sp)
+      valobj_sp = valobj_sp->GetQualifiedRepresentationIfAvailable(
+          valobj_sp->GetDynamicValueType(), true);
+    // Get the address to watch.
+    if (valobj_sp)
+      addr = valobj_sp->GetValueAsUnsigned(fail_value, &success);
+    if (success) {
+      if (error_ptr)
+        error_ptr->Clear();
+      return addr;
+    } else {
+      if (error_ptr) {
+        error_set = true;
+        error_ptr->SetErrorStringWithFormat(
+            "address expression \"%s\" resulted in a value whose type "
+            "can't be converted to an address: %s",
+            s.str().c_str(), valobj_sp->GetTypeName().GetCString());
+      }
+    }
+
+  } else {
+    // Since the compiler can't handle things like "main + 12" we should
+    // try to do this for now. The compiler doesn't like adding offsets
+    // to function pointer types.
+    static RegularExpression g_symbol_plus_offset_regex(
+        "^(.*)([-\\+])[[:space:]]*(0x[0-9A-Fa-f]+|[0-9]+)[[:space:]]*$");
+    RegularExpression::Match regex_match(3);
+    if (g_symbol_plus_offset_regex.Execute(sref, &regex_match)) {
+      uint64_t offset = 0;
+      bool add = true;
+      std::string name;
+      std::string str;
+      if (regex_match.GetMatchAtIndex(s, 1, name)) {
+        if (regex_match.GetMatchAtIndex(s, 2, str)) {
+          add = str[0] == '+';
+
+          if (regex_match.GetMatchAtIndex(s, 3, str)) {
+            if (!llvm::StringRef(str).getAsInteger(0, offset)) {
+              Status error;
+              addr = ToAddress(exe_ctx, name.c_str(), LLDB_INVALID_ADDRESS,
+                               &error);
+              if (addr != LLDB_INVALID_ADDRESS) {
+                if (add)
+                  return addr + offset;
+                else
+                  return addr - offset;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (error_ptr) {
+      error_set = true;
+      error_ptr->SetErrorStringWithFormat(
+          "address expression \"%s\" evaluation failed", s.str().c_str());
+    }
+  }
+
+  if (error_ptr) {
+    if (!error_set)
+      error_ptr->SetErrorStringWithFormat("invalid address expression \"%s\"",
+                                          s.str().c_str());
+  }
+  return fail_value;
+}

lldb/trunk/source/Interpreter/OptionGroupValueObjectDisplay.cpp

 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/DataFormatters/ValueObjectPrinter.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Target/Target.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 OptionGroupValueObjectDisplay::OptionGroupValueObjectDisplay() {}
Status OptionGroupValueObjectDisplay::SetOptionValue(
     ExecutionContext *execution_context) {
   Status error;
   const int short_option = g_option_table[option_idx].short_option;
   bool success = false;
 
   switch (short_option) {
   case 'd': {
     int32_t result;
-    result =
-        Args::StringToOptionEnum(option_arg, g_dynamic_value_types, 2, error);
+    result = OptionArgParser::ToOptionEnum(option_arg, g_dynamic_value_types, 2,
+                                           error);
     if (error.Success())
       use_dynamic = (lldb::DynamicValueType)result;
   } break;
   case 'T':
     show_types = true;
     break;
   case 'L':
     show_location = true;
case 'Y':
     else if (option_arg.getAsInteger(0, no_summary_depth)) {
       no_summary_depth = 0;
       error.SetErrorStringWithFormat("invalid pointer depth '%s'",
                                      option_arg.str().c_str());
     }
     break;
 
   case 'S':
-    use_synth = Args::StringToBoolean(option_arg, true, &success);
+    use_synth = OptionArgParser::ToBoolean(option_arg, true, &success);
     if (!success)
       error.SetErrorStringWithFormat("invalid synthetic-type '%s'",
                                      option_arg.str().c_str());
     break;
 
   case 'V':
-    run_validator = Args::StringToBoolean(option_arg, true, &success);
+    run_validator = OptionArgParser::ToBoolean(option_arg, true, &success);
     if (!success)
       error.SetErrorStringWithFormat("invalid validate '%s'",
                                      option_arg.str().c_str());
     break;
 
   default:
     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
     break;

lldb/trunk/source/Interpreter/OptionGroupWatchpoint.cpp

 //===-- OptionGroupWatchpoint.cpp -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionGroupWatchpoint.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Host/OptionParser.h"
-#include "lldb/Interpreter/Args.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/lldb-enumerations.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static OptionEnumValueElement g_watch_type[] = {
     {OptionGroupWatchpoint::eWatchRead, "read", "Watch for read"},
     {OptionGroupWatchpoint::eWatchWrite, "write", "Watch for write"},

 OptionGroupWatchpoint::SetOptionValue(uint32_t option_idx,
                                       llvm::StringRef option_arg,
                                       ExecutionContext *execution_context) {
   Status error;
   const int short_option = g_option_table[option_idx].short_option;
   switch (short_option) {
   case 'w': {
     WatchType tmp_watch_type;
-    tmp_watch_type = (WatchType)Args::StringToOptionEnum(
+    tmp_watch_type = (WatchType)OptionArgParser::ToOptionEnum(
         option_arg, g_option_table[option_idx].enum_values, 0, error);
     if (error.Success()) {
       watch_type = tmp_watch_type;
       watch_type_specified = true;
     }
     break;
   }
   case 's':
-    watch_size = (uint32_t)Args::StringToOptionEnum(
+    watch_size = (uint32_t)OptionArgParser::ToOptionEnum(
         option_arg, g_option_table[option_idx].enum_values, 0, error);
     break;
 
   default:
     error.SetErrorStringWithFormat("unrecognized short option '%c'",
                                    short_option);
     break;
   }

lldb/trunk/source/Interpreter/OptionValueBoolean.cpp

 //===-- OptionValueBoolean.cpp ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionValueBoolean.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Host/PosixApi.h"
-#include "lldb/Interpreter/Args.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StringList.h"
 #include "llvm/ADT/STLExtras.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void OptionValueBoolean::DumpValue(const ExecutionContext *exe_ctx,
Status OptionValueBoolean::SetValueFromString(llvm::StringRef value_str,
   case eVarSetOperationClear:
     Clear();
     NotifyValueChanged();
     break;
 
   case eVarSetOperationReplace:
   case eVarSetOperationAssign: {
     bool success = false;
-    bool value = Args::StringToBoolean(value_str, false, &success);
+    bool value = OptionArgParser::ToBoolean(value_str, false, &success);
     if (success) {
       m_value_was_set = true;
       m_current_value = value;
       NotifyValueChanged();
     } else {
       if (value_str.size() == 0)
         error.SetErrorString("invalid boolean string value <empty>");
       else

lldb/trunk/source/Interpreter/OptionValueChar.cpp

 //===-- OptionValueChar.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionValueChar.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Interpreter/Args.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StringList.h"
 #include "llvm/ADT/STLExtras.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void OptionValueChar::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
Status OptionValueChar::SetValueFromString(llvm::StringRef value,
   switch (op) {
   case eVarSetOperationClear:
     Clear();
     break;
 
   case eVarSetOperationReplace:
   case eVarSetOperationAssign: {
     bool success = false;
-    char char_value = Args::StringToChar(value, '\0', &success);
+    char char_value = OptionArgParser::ToChar(value, '\0', &success);
     if (success) {
       m_current_value = char_value;
       m_value_was_set = true;
     } else
       error.SetErrorStringWithFormat("'%s' cannot be longer than 1 character",
                                      value.str().c_str());
   } break;
 

lldb/trunk/source/Interpreter/OptionValueFormat.cpp

 //===-- OptionValueFormat.cpp -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionValueFormat.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/DataFormatters/FormatManager.h"
-#include "lldb/Interpreter/Args.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void OptionValueFormat::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                                   uint32_t dump_mask) {
   if (dump_mask & eDumpOptionType)
Status OptionValueFormat::SetValueFromString(llvm::StringRef value,
   case eVarSetOperationClear:
     Clear();
     NotifyValueChanged();
     break;
 
   case eVarSetOperationReplace:
   case eVarSetOperationAssign: {
     Format new_format;
-    error = Args::StringToFormat(value.str().c_str(), new_format, nullptr);
+    error = OptionArgParser::ToFormat(value.str().c_str(), new_format, nullptr);
     if (error.Success()) {
       m_value_was_set = true;
       m_current_value = new_format;
       NotifyValueChanged();
     }
   } break;
 
   case eVarSetOperationInsertBefore:

lldb/trunk/source/Interpreter/Property.cpp

 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionValues.h"
 #include "lldb/Target/Language.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 Property::Property(const PropertyDefinition &definition)
     : m_name(definition.name), m_description(definition.description),
case OptionValue::eTypeArray:
     break;
 
   case OptionValue::eTypeBoolean:
     // "definition.default_uint_value" is the default boolean value if
     // "definition.default_cstr_value" is NULL, otherwise interpret
     // "definition.default_cstr_value" as a string value that represents the
     // default value.
     if (definition.default_cstr_value)
-      m_value_sp.reset(new OptionValueBoolean(Args::StringToBoolean(
+      m_value_sp.reset(new OptionValueBoolean(OptionArgParser::ToBoolean(
           llvm::StringRef(definition.default_cstr_value), false, nullptr)));
     else
       m_value_sp.reset(
           new OptionValueBoolean(definition.default_uint_value != 0));
     break;
 
   case OptionValue::eTypeChar: {
     llvm::StringRef s(definition.default_cstr_value ? definition.default_cstr_value : "");
-    m_value_sp = std::make_shared<OptionValueChar>(Args::StringToChar(s, '\0', nullptr));
+    m_value_sp = std::make_shared<OptionValueChar>(
+        OptionArgParser::ToChar(s, '\0', nullptr));
     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::eTypeFormat:
     // if
     // "definition.default_cstr_value" is NULL, otherwise interpret
     // "definition.default_cstr_value" as a string value that represents the
     // default
     // value.
     {
       Format new_format = eFormatInvalid;
       if (definition.default_cstr_value)
-        Args::StringToFormat(definition.default_cstr_value, new_format,
+        OptionArgParser::ToFormat(definition.default_cstr_value, new_format,
                                   nullptr);
       else
         new_format = (Format)definition.default_uint_value;
       m_value_sp.reset(new OptionValueFormat(new_format));
     }
     break;
 
   case OptionValue::eTypeLanguage:
     // "definition.default_uint_value" is the default language enumeration value

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

 #include "lldb/Core/Section.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Expression/UtilityFunction.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionValueBoolean.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Platform.h"
if (objc_runtime) {
       ObjCLanguageRuntime::TaggedPointerVendor *tagged_ptr_vendor =
           objc_runtime->GetTaggedPointerVendor();
       if (tagged_ptr_vendor) {
         for (size_t i = 0; i < command.GetArgumentCount(); i++) {
           const char *arg_str = command.GetArgumentAtIndex(i);
           if (!arg_str)
             continue;
           Status error;
-          lldb::addr_t arg_addr = Args::StringToAddress(
+          lldb::addr_t arg_addr = OptionArgParser::ToAddress(
               &exe_ctx, arg_str, LLDB_INVALID_ADDRESS, &error);
           if (arg_addr == 0 || arg_addr == LLDB_INVALID_ADDRESS || error.Fail())
             continue;
           auto descriptor_sp = tagged_ptr_vendor->GetClassDescriptor(arg_addr);
           if (!descriptor_sp)
             continue;
           uint64_t info_bits = 0;
           uint64_t value_bits = 0;

lldb/trunk/source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

 //===-- DynamicRegisterInfo.cpp ----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DynamicRegisterInfo.h"
 
 #include "lldb/Core/StreamFile.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Host/StringConvert.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/StringExtractor.h"
 #include "lldb/Utility/StructuredData.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
if (reg_info_dict->GetValueForKeyAsString("dynamic_size_dwarf_expr_bytes",
       for (j = 0; j < reg_info.dynamic_size_dwarf_len; ++j)
         m_dynamic_reg_size_map[i].push_back(dwarf_opcode_bytes[j]);
 
       reg_info.dynamic_size_dwarf_expr_bytes = m_dynamic_reg_size_map[i].data();
     }
 
     llvm::StringRef format_str;
     if (reg_info_dict->GetValueForKeyAsString("format", format_str, nullptr)) {
-      if (Args::StringToFormat(format_str.str().c_str(), reg_info.format, NULL)
+      if (OptionArgParser::ToFormat(format_str.str().c_str(), reg_info.format,
+                                    NULL)
               .Fail()) {
         Clear();
         printf("error: invalid 'format' value in register dictionary\n");
         reg_info_dict->DumpToStdout();
         return 0;
       }
     } else {
       reg_info_dict->GetValueForKeyAsInteger("format", reg_info.format,

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

 
 // Other libraries and framework includes
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/File.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Interpreter/Args.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/JSON.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/SafeMachO.h"
while (packet.GetNameColonValue(key, value)) {
         match_info.GetProcessInfo().SetEffectiveUserID(uid);
       } else if (key.equals("egid")) {
         uint32_t gid = UINT32_MAX;
         if (value.getAsInteger(0, gid))
           return SendErrorResponse(2);
         match_info.GetProcessInfo().SetEffectiveGroupID(gid);
       } else if (key.equals("all_users")) {
         match_info.SetMatchAllUsers(
-            Args::StringToBoolean(value, false, &success));
+            OptionArgParser::ToBoolean(value, false, &success));
       } else if (key.equals("triple")) {
         match_info.GetProcessInfo().GetArchitecture() =
             HostInfo::GetAugmentedArchSpec(value);
       } else {
         success = false;
       }
 
       if (!success)

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

 #include "lldb/Host/Symbols.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Host/XML.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupBoolean.h"
 #include "lldb/Interpreter/OptionGroupUInt64.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/DynamicLoader.h"
if (m_gdb_comm.SendPacketAndWaitForResponse(packet, response, false) ==
             if (value.getAsInteger(0, reg_offset))
               reg_offset = UINT32_MAX;
           } else if (name.equals("encoding")) {
             const Encoding encoding = Args::StringToEncoding(value);
             if (encoding != eEncodingInvalid)
               reg_info.encoding = encoding;
           } else if (name.equals("format")) {
             Format format = eFormatInvalid;
-            if (Args::StringToFormat(value.str().c_str(), format, NULL)
+            if (OptionArgParser::ToFormat(value.str().c_str(), format, NULL)
                     .Success())
               reg_info.format = format;
             else {
               reg_info.format =
                   llvm::StringSwitch<Format>(value)
                       .Case("binary", eFormatBinary)
                       .Case("decimal", eFormatDecimal)
                       .Case("hex", eFormatHex)
feature_node.ForEachChildElementWithName(
           } else if (name == "altname") {
             alt_name.SetString(value);
           } else if (name == "encoding") {
             encoding_set = true;
             reg_info.encoding = Args::StringToEncoding(value, eEncodingUint);
           } else if (name == "format") {
             format_set = true;
             Format format = eFormatInvalid;
-            if (Args::StringToFormat(value.data(), format, NULL).Success())
+            if (OptionArgParser::ToFormat(value.data(), format, NULL).Success())
               reg_info.format = format;
             else if (value == "vector-sint8")
               reg_info.format = eFormatVectorOfSInt8;
             else if (value == "vector-uint8")
               reg_info.format = eFormatVectorOfUInt8;
             else if (value == "vector-sint16")
               reg_info.format = eFormatVectorOfSInt16;
             else if (value == "vector-uint16")

lldb/trunk/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/OptionValueString.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadPlanCallOnFunctionExit.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
     case 'A':
       m_display_timestamp_relative = true;
       m_display_category = true;
       m_display_subsystem = true;
       m_display_activity_chain = true;
       break;
 
     case 'b':
-      m_broadcast_events = Args::StringToBoolean(option_arg, true, nullptr);
+      m_broadcast_events =
+          OptionArgParser::ToBoolean(option_arg, true, nullptr);
       break;
 
     case 'c':
       m_display_category = true;
       break;
 
     case 'C':
       m_display_activity_chain = true;
       break;
 
     case 'd':
       m_include_debug_level = true;
       break;
 
     case 'e':
-      m_echo_to_stderr = Args::StringToBoolean(option_arg, false, nullptr);
+      m_echo_to_stderr = OptionArgParser::ToBoolean(option_arg, false, nullptr);
       break;
 
     case 'f':
       return ParseFilterRule(option_arg);
 
     case 'i':
       m_include_info_level = true;
       break;
 
     case 'l':
-      m_live_stream = Args::StringToBoolean(option_arg, false, nullptr);
+      m_live_stream = OptionArgParser::ToBoolean(option_arg, false, nullptr);
       break;
 
     case 'n':
       m_filter_fall_through_accepts =
-          Args::StringToBoolean(option_arg, true, nullptr);
+          OptionArgParser::ToBoolean(option_arg, true, nullptr);
       break;
 
     case 'r':
       m_display_timestamp_relative = true;
       break;
 
     case 's':
       m_display_subsystem = true;

lldb/trunk/source/Target/Process.cpp

 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Host/Pipe.h"
 #include "lldb/Host/Terminal.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/CPPLanguageRuntime.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/InstrumentationRuntime.h"
 #include "lldb/Target/JITLoader.h"
case 'a': {
     launch_info.GetArchitecture() =
         Platform::GetAugmentedArchSpec(platform_sp.get(), option_arg);
   } break;
 
   case 'A': // Disable ASLR.
   {
     bool success;
     const bool disable_aslr_arg =
-        Args::StringToBoolean(option_arg, true, &success);
+        OptionArgParser::ToBoolean(option_arg, true, &success);
     if (success)
       disable_aslr = disable_aslr_arg ? eLazyBoolYes : eLazyBoolNo;
     else
       error.SetErrorStringWithFormat(
           "Invalid boolean value for disable-aslr option: '%s'",
           option_arg.empty() ? "<null>" : option_arg.str().c_str());
     break;
   }
 
   case 'X': // shell expand args.
   {
     bool success;
-    const bool expand_args = Args::StringToBoolean(option_arg, true, &success);
+    const bool expand_args =
+        OptionArgParser::ToBoolean(option_arg, true, &success);
     if (success)
       launch_info.SetShellExpandArguments(expand_args);
     else
       error.SetErrorStringWithFormat(
           "Invalid boolean value for shell-expand-args option: '%s'",
           option_arg.empty() ? "<null>" : option_arg.str().c_str());
     break;
   }

lldb/trunk/unittests/Interpreter/CMakeLists.txt

 add_lldb_unittest(InterpreterTests
   TestArgs.cpp
   TestCompletion.cpp
+  TestOptionArgParser.cpp
 
   LINK_LIBS
     lldbInterpreter
     lldbUtilityHelpers
   )
 
 target_link_libraries(InterpreterTests
   PRIVATE
   ${PYTHON_LIBRARY}
   )

lldb/trunk/unittests/Interpreter/TestArgs.cpp

 
 TEST(ArgsTest, GetArgumentArrayRef) {
   Args args("foo bar");
   auto ref = args.GetArgumentArrayRef();
   ASSERT_EQ(2u, ref.size());
   EXPECT_STREQ("foo", ref[0]);
   EXPECT_STREQ("bar", ref[1]);
 }
-
-TEST(ArgsTest, StringToBoolean) {
-  bool success = false;
-  EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("true"), false, nullptr));
-  EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("on"), false, nullptr));
-  EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("yes"), false, nullptr));
-  EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("1"), false, nullptr));
-
-  EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("true"), false, &success));
-  EXPECT_TRUE(success);
-  EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("on"), false, &success));
-  EXPECT_TRUE(success);
-  EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("yes"), false, &success));
-  EXPECT_TRUE(success);
-  EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("1"), false, &success));
-  EXPECT_TRUE(success);
-
-  EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("false"), true, nullptr));
-  EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("off"), true, nullptr));
-  EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("no"), true, nullptr));
-  EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("0"), true, nullptr));
-
-  EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("false"), true, &success));
-  EXPECT_TRUE(success);
-  EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("off"), true, &success));
-  EXPECT_TRUE(success);
-  EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("no"), true, &success));
-  EXPECT_TRUE(success);
-  EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("0"), true, &success));
-  EXPECT_TRUE(success);
-
-  EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("10"), false, &success));
-  EXPECT_FALSE(success);
-  EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("10"), true, &success));
-  EXPECT_FALSE(success);
-  EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef(""), true, &success));
-  EXPECT_FALSE(success);
-}
-
-TEST(ArgsTest, StringToChar) {
-  bool success = false;
-
-  EXPECT_EQ('A', Args::StringToChar("A", 'B', nullptr));
-  EXPECT_EQ('B', Args::StringToChar("B", 'A', nullptr));
-
-  EXPECT_EQ('A', Args::StringToChar("A", 'B', &success));
-  EXPECT_TRUE(success);
-  EXPECT_EQ('B', Args::StringToChar("B", 'A', &success));
-  EXPECT_TRUE(success);
-
-  EXPECT_EQ('A', Args::StringToChar("", 'A', &success));
-  EXPECT_FALSE(success);
-  EXPECT_EQ('A', Args::StringToChar("ABC", 'A', &success));
-  EXPECT_FALSE(success);
-}
-
-TEST(ArgsTest, StringToScriptLanguage) {
-  bool success = false;
-
-  EXPECT_EQ(lldb::eScriptLanguageDefault,
-            Args::StringToScriptLanguage(llvm::StringRef("default"),
-                                         lldb::eScriptLanguageNone, nullptr));
-  EXPECT_EQ(lldb::eScriptLanguagePython,
-            Args::StringToScriptLanguage(llvm::StringRef("python"),
-                                         lldb::eScriptLanguageNone, nullptr));
-  EXPECT_EQ(lldb::eScriptLanguageNone,
-            Args::StringToScriptLanguage(llvm::StringRef("none"),
-                                         lldb::eScriptLanguagePython, nullptr));
-
-  EXPECT_EQ(lldb::eScriptLanguageDefault,
-            Args::StringToScriptLanguage(llvm::StringRef("default"),
-                                         lldb::eScriptLanguageNone, &success));
-  EXPECT_TRUE(success);
-  EXPECT_EQ(lldb::eScriptLanguagePython,
-            Args::StringToScriptLanguage(llvm::StringRef("python"),
-                                         lldb::eScriptLanguageNone, &success));
-  EXPECT_TRUE(success);
-  EXPECT_EQ(lldb::eScriptLanguageNone,
-            Args::StringToScriptLanguage(llvm::StringRef("none"),
-                                         lldb::eScriptLanguagePython,
-                                         &success));
-  EXPECT_TRUE(success);
-
-  EXPECT_EQ(lldb::eScriptLanguagePython,
-            Args::StringToScriptLanguage(llvm::StringRef("invalid"),
-                                         lldb::eScriptLanguagePython,
-                                         &success));
-  EXPECT_FALSE(success);
-}

lldb/trunk/unittests/Interpreter/TestOptionArgParser.cpp

+//===-- ArgsTest.cpp --------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+#include "lldb/Interpreter/OptionArgParser.h"
+
+using namespace lldb_private;
+
+TEST(OptionArgParserTest, toBoolean) {
+  bool success = false;
+  EXPECT_TRUE(
+      OptionArgParser::ToBoolean(llvm::StringRef("true"), false, nullptr));
+  EXPECT_TRUE(
+      OptionArgParser::ToBoolean(llvm::StringRef("on"), false, nullptr));
+  EXPECT_TRUE(
+      OptionArgParser::ToBoolean(llvm::StringRef("yes"), false, nullptr));
+  EXPECT_TRUE(OptionArgParser::ToBoolean(llvm::StringRef("1"), false, nullptr));
+
+  EXPECT_TRUE(
+      OptionArgParser::ToBoolean(llvm::StringRef("true"), false, &success));
+  EXPECT_TRUE(success);
+  EXPECT_TRUE(
+      OptionArgParser::ToBoolean(llvm::StringRef("on"), false, &success));
+  EXPECT_TRUE(success);
+  EXPECT_TRUE(
+      OptionArgParser::ToBoolean(llvm::StringRef("yes"), false, &success));
+  EXPECT_TRUE(success);
+  EXPECT_TRUE(
+      OptionArgParser::ToBoolean(llvm::StringRef("1"), false, &success));
+  EXPECT_TRUE(success);
+
+  EXPECT_FALSE(
+      OptionArgParser::ToBoolean(llvm::StringRef("false"), true, nullptr));
+  EXPECT_FALSE(
+      OptionArgParser::ToBoolean(llvm::StringRef("off"), true, nullptr));
+  EXPECT_FALSE(
+      OptionArgParser::ToBoolean(llvm::StringRef("no"), true, nullptr));
+  EXPECT_FALSE(OptionArgParser::ToBoolean(llvm::StringRef("0"), true, nullptr));
+
+  EXPECT_FALSE(
+      OptionArgParser::ToBoolean(llvm::StringRef("false"), true, &success));
+  EXPECT_TRUE(success);
+  EXPECT_FALSE(
+      OptionArgParser::ToBoolean(llvm::StringRef("off"), true, &success));
+  EXPECT_TRUE(success);
+  EXPECT_FALSE(
+      OptionArgParser::ToBoolean(llvm::StringRef("no"), true, &success));
+  EXPECT_TRUE(success);
+  EXPECT_FALSE(
+      OptionArgParser::ToBoolean(llvm::StringRef("0"), true, &success));
+  EXPECT_TRUE(success);
+
+  EXPECT_FALSE(
+      OptionArgParser::ToBoolean(llvm::StringRef("10"), false, &success));
+  EXPECT_FALSE(success);
+  EXPECT_TRUE(
+      OptionArgParser::ToBoolean(llvm::StringRef("10"), true, &success));
+  EXPECT_FALSE(success);
+  EXPECT_TRUE(OptionArgParser::ToBoolean(llvm::StringRef(""), true, &success));
+  EXPECT_FALSE(success);
+}
+
+TEST(OptionArgParserTest, toChar) {
+  bool success = false;
+
+  EXPECT_EQ('A', OptionArgParser::ToChar("A", 'B', nullptr));
+  EXPECT_EQ('B', OptionArgParser::ToChar("B", 'A', nullptr));
+
+  EXPECT_EQ('A', OptionArgParser::ToChar("A", 'B', &success));
+  EXPECT_TRUE(success);
+  EXPECT_EQ('B', OptionArgParser::ToChar("B", 'A', &success));
+  EXPECT_TRUE(success);
+
+  EXPECT_EQ('A', OptionArgParser::ToChar("", 'A', &success));
+  EXPECT_FALSE(success);
+  EXPECT_EQ('A', OptionArgParser::ToChar("ABC", 'A', &success));
+  EXPECT_FALSE(success);
+}
+
+TEST(OptionArgParserTest, toScriptLanguage) {
+  bool success = false;
+
+  EXPECT_EQ(lldb::eScriptLanguageDefault,
+            OptionArgParser::ToScriptLanguage(llvm::StringRef("default"),
+                                              lldb::eScriptLanguageNone,
+                                              nullptr));
+  EXPECT_EQ(lldb::eScriptLanguagePython,
+            OptionArgParser::ToScriptLanguage(
+                llvm::StringRef("python"), lldb::eScriptLanguageNone, nullptr));
+  EXPECT_EQ(lldb::eScriptLanguageNone,
+            OptionArgParser::ToScriptLanguage(
+                llvm::StringRef("none"), lldb::eScriptLanguagePython, nullptr));
+
+  EXPECT_EQ(lldb::eScriptLanguageDefault,
+            OptionArgParser::ToScriptLanguage(llvm::StringRef("default"),
+                                              lldb::eScriptLanguageNone,
+                                              &success));
+  EXPECT_TRUE(success);
+  EXPECT_EQ(lldb::eScriptLanguagePython,
+            OptionArgParser::ToScriptLanguage(llvm::StringRef("python"),
+                                              lldb::eScriptLanguageNone,
+                                              &success));
+  EXPECT_TRUE(success);
+  EXPECT_EQ(lldb::eScriptLanguageNone,
+            OptionArgParser::ToScriptLanguage(llvm::StringRef("none"),
+                                              lldb::eScriptLanguagePython,
+                                              &success));
+  EXPECT_TRUE(success);
+
+  EXPECT_EQ(lldb::eScriptLanguagePython,
+            OptionArgParser::ToScriptLanguage(llvm::StringRef("invalid"),
+                                              lldb::eScriptLanguagePython,
+                                              &success));
+  EXPECT_FALSE(success);
+}