Moved Args::StringToXIntYZ to StringConvert::ToXIntYZ

[vharron]

Summary

The refactor was motivated by some comments that Greg made
http://reviews.llvm.org/D6918

[clayborg]

Looks fine.

include/lldb/Host/StringConvert.h

+//===-- StringConvert.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_StringConvert_h_
+#define liblldb_StringConvert_h_
+
+// C Includes
+#include <stdint.h>
+
+// C++ Includes
+
+// Other libraries and framework includes
+// Project includes
+
+namespace lldb_private {
+    
+namespace StringConvert {
+
+//----------------------------------------------------------------------
+/// @namespace StringConvert StringConvert.h "lldb/Host/StringConvert.h"
+/// @brief Utility classes for converting strings into Integers
+//----------------------------------------------------------------------
+
+int32_t
+ToSInt32 (const char *s, int32_t fail_value = 0, int base = 0, bool *success_ptr = nullptr);
+
+uint32_t
+ToUInt32 (const char *s, uint32_t fail_value = 0, int base = 0, bool *success_ptr = nullptr);
+
+int64_t
+ToSInt64 (const char *s, int64_t fail_value = 0, int base = 0, bool *success_ptr = nullptr);
+
+uint64_t
+ToUInt64 (const char *s, uint64_t fail_value = 0, int base = 0, bool *success_ptr = nullptr);
+
+} // namespace StringConvert
+} // namespace lldb_private
+
+#endif

include/lldb/Interpreter/Args.h

public:
     Clear ();
 
     static const char *
     StripSpaces (std::string &s,
                  bool leading = true,
                  bool trailing = true,
                  bool return_null_if_empty = true);
 
-    static int32_t
-    StringToSInt32 (const char *s, int32_t fail_value = 0, int base = 0, bool *success_ptr = NULL);
-
-    static uint32_t
-    StringToUInt32 (const char *s, uint32_t fail_value = 0, int base = 0, bool *success_ptr = NULL);
-
-    static int64_t
-    StringToSInt64 (const char *s, int64_t fail_value = 0, int base = 0, bool *success_ptr = NULL);
-
-    static uint64_t
-    StringToUInt64 (const char *s, uint64_t fail_value = 0, int base = 0, bool *success_ptr = NULL);
-
     static bool
     UInt64ValueIsValidForByteSize (uint64_t uval64, size_t total_byte_size)
     {
         if (total_byte_size > 8)
             return false;
         
         if (total_byte_size == 8)
             return true;

lldb.xcodeproj/project.pbxproj

/* Begin PBXBuildFile section */
     26FFC19914FC072100087D58 /* AuxVector.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26FFC19314FC072100087D58 /* AuxVector.cpp */; };
     26FFC19A14FC072100087D58 /* AuxVector.h in Headers */ = {isa = PBXBuildFile; fileRef = 26FFC19414FC072100087D58 /* AuxVector.h */; };
     26FFC19B14FC072100087D58 /* DYLDRendezvous.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26FFC19514FC072100087D58 /* DYLDRendezvous.cpp */; };
     26FFC19C14FC072100087D58 /* DYLDRendezvous.h in Headers */ = {isa = PBXBuildFile; fileRef = 26FFC19614FC072100087D58 /* DYLDRendezvous.h */; };
     26FFC19D14FC072100087D58 /* DynamicLoaderPOSIXDYLD.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26FFC19714FC072100087D58 /* DynamicLoaderPOSIXDYLD.cpp */; };
     26FFC19E14FC072100087D58 /* DynamicLoaderPOSIXDYLD.h in Headers */ = {isa = PBXBuildFile; fileRef = 26FFC19814FC072100087D58 /* DynamicLoaderPOSIXDYLD.h */; };
     33064C9A1A5C7A330033D415 /* UriParser.cpp in CopyFiles */ = {isa = PBXBuildFile; fileRef = 33064C991A5C7A330033D415 /* UriParser.cpp */; };
     33064C9C1A5C7A490033D415 /* UriParser.h in CopyFiles */ = {isa = PBXBuildFile; fileRef = 33064C9B1A5C7A490033D415 /* UriParser.h */; };
+    33E5E8421A672A240024ED68 /* StringConvert.cpp in CopyFiles */ = {isa = PBXBuildFile; fileRef = 33E5E8411A672A240024ED68 /* StringConvert.cpp */; };
+    33E5E8461A6736D30024ED68 /* StringConvert.h in CopyFiles */ = {isa = PBXBuildFile; fileRef = 33E5E8451A6736D30024ED68 /* StringConvert.h */; };
+    33E5E8471A674FB60024ED68 /* StringConvert.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 33E5E8411A672A240024ED68 /* StringConvert.cpp */; };
     3FDFDDBD199C3A06009756A7 /* FileAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3FDFDDBC199C3A06009756A7 /* FileAction.cpp */; };
     3FDFDDBF199D345E009756A7 /* FileCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3FDFDDBE199D345E009756A7 /* FileCache.cpp */; };
     3FDFDDC6199D37ED009756A7 /* FileSystem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3FDFDDC5199D37ED009756A7 /* FileSystem.cpp */; };
     3FDFE52C19A2917A009756A7 /* HostInfoMacOSX.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3FDFE52B19A2917A009756A7 /* HostInfoMacOSX.mm */; };
     3FDFE53119A292F0009756A7 /* HostInfoPosix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3FDFE53019A292F0009756A7 /* HostInfoPosix.cpp */; };
     3FDFE53319A29304009756A7 /* HostInfoPosix.h in Headers */ = {isa = PBXBuildFile; fileRef = 3FDFE53219A29304009756A7 /* HostInfoPosix.h */; };
     3FDFE53519A29327009756A7 /* HostInfoBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3FDFE53419A29327009756A7 /* HostInfoBase.cpp */; };
     3FDFE56C19AF9C44009756A7 /* HostProcessPosix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3FDFE56A19AF9C44009756A7 /* HostProcessPosix.cpp */; };
/* Begin PBXCopyFilesBuildPhase section */
     };
     AF90106415AB7D2900FF120D /* CopyFiles */ = {
       isa = PBXCopyFilesBuildPhase;
       buildActionMask = 8;
       dstPath = "$(DEVELOPER_DIR)/usr/share/man/man1/";
       dstSubfolderSpec = 0;
       files = (
         AF90106515AB7D3600FF120D /* lldb.1 in CopyFiles */,
+        33E5E8461A6736D30024ED68 /* StringConvert.h in CopyFiles */,
         33064C9C1A5C7A490033D415 /* UriParser.h in CopyFiles */,
+        33E5E8421A672A240024ED68 /* StringConvert.cpp in CopyFiles */,
         33064C9A1A5C7A330033D415 /* UriParser.cpp in CopyFiles */,
       );
       runOnlyForDeploymentPostprocessing = 1;
     };
     AFF87C85150FF5CC000E1742 /* CopyFiles */ = {
       isa = PBXCopyFilesBuildPhase;
       buildActionMask = 8;
       dstPath = /Developer/Library/Lockdown/ServiceAgents/;
/* Begin PBXFileReference section */
     26FFC19314FC072100087D58 /* AuxVector.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AuxVector.cpp; sourceTree = "<group>"; };
     26FFC19414FC072100087D58 /* AuxVector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AuxVector.h; sourceTree = "<group>"; };
     26FFC19514FC072100087D58 /* DYLDRendezvous.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DYLDRendezvous.cpp; sourceTree = "<group>"; };
     26FFC19614FC072100087D58 /* DYLDRendezvous.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DYLDRendezvous.h; sourceTree = "<group>"; };
     26FFC19714FC072100087D58 /* DynamicLoaderPOSIXDYLD.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DynamicLoaderPOSIXDYLD.cpp; sourceTree = "<group>"; };
     26FFC19814FC072100087D58 /* DynamicLoaderPOSIXDYLD.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DynamicLoaderPOSIXDYLD.h; sourceTree = "<group>"; };
     33064C991A5C7A330033D415 /* UriParser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = UriParser.cpp; path = source/Utility/UriParser.cpp; sourceTree = "<group>"; };
     33064C9B1A5C7A490033D415 /* UriParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = UriParser.h; path = source/Utility/UriParser.h; sourceTree = "<group>"; };
+    33E5E8411A672A240024ED68 /* StringConvert.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StringConvert.cpp; sourceTree = "<group>"; };
+    33E5E8451A6736D30024ED68 /* StringConvert.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = StringConvert.h; path = include/lldb/Host/StringConvert.h; sourceTree = SOURCE_ROOT; };
     3F5E8AF31A40D4A500A73232 /* PipeBase.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = PipeBase.h; path = include/lldb/Host/PipeBase.h; sourceTree = "<group>"; };
     3FDFD6C3199C396E009756A7 /* FileAction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FileAction.h; path = include/lldb/Target/FileAction.h; sourceTree = "<group>"; };
     3FDFDDBC199C3A06009756A7 /* FileAction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = FileAction.cpp; path = source/Target/FileAction.cpp; sourceTree = "<group>"; };
     3FDFDDBE199D345E009756A7 /* FileCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = FileCache.cpp; path = source/Host/common/FileCache.cpp; sourceTree = "<group>"; };
     3FDFDDC0199D34E2009756A7 /* FileCache.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = FileCache.h; path = include/lldb/Host/FileCache.h; sourceTree = "<group>"; };
     3FDFDDC1199D34E2009756A7 /* FileSystem.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = FileSystem.h; path = include/lldb/Host/FileSystem.h; sourceTree = "<group>"; };
     3FDFDDC5199D37ED009756A7 /* FileSystem.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FileSystem.cpp; sourceTree = "<group>"; };
     3FDFE52B19A2917A009756A7 /* HostInfoMacOSX.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = HostInfoMacOSX.mm; path = source/Host/macosx/HostInfoMacOSX.mm; sourceTree = "<group>"; };
26BC7DBE10F1B78200F91463 /* Expression */ = {
         49DCF700170E70120092F75E /* Materializer.cpp */,
       );
       name = Expression;
       sourceTree = "<group>";
     };
     26BC7DD010F1B7C100F91463 /* Host */ = {
       isa = PBXGroup;
       children = (
+        33E5E8451A6736D30024ED68 /* StringConvert.h */,
         69A01E1A1236C5D400C660B5 /* common */,
         3FDFE53919A29399009756A7 /* freebsd */,
         233B009C19610D130090E598 /* linux */,
         26BC7EE510F1B88100F91463 /* MacOSX */,
         3FDFDDC4199D37BE009756A7 /* posix */,
         3FDFE53E19A2940E009756A7 /* windows */,
         26BC7DD210F1B7D500F91463 /* Condition.h */,
         266F5CBB12FC846200DFCE33 /* Config.h */,
4CEE62F71145F1C70064CF93 /* GDB Remote */ = {
       );
       name = "GDB Remote";
       path = "gdb-remote";
       sourceTree = "<group>";
     };
     69A01E1A1236C5D400C660B5 /* common */ = {
       isa = PBXGroup;
       children = (
+        33E5E8411A672A240024ED68 /* StringConvert.cpp */,
         25420ED11A649D88009ADBCB /* PipeBase.cpp */,
         26CFDCA2186163A4000E63E5 /* Editline.cpp */,
         260C6EA213011581005E16B0 /* File.cpp */,
         26FA43171301048600E71120 /* FileSpec.cpp */,
         69A01E1B1236C5D400C660B5 /* Condition.cpp */,
         69A01E1C1236C5D400C660B5 /* Host.cpp */,
         3FDFE53419A29327009756A7 /* HostInfoBase.cpp */,
         3FDFED2419BA6D96009756A7 /* HostNativeThreadBase.cpp */,
26680204115FD0ED008E1FE4 /* Sources */ = {
         AF9107EE168570D200DBCD3C /* RegisterContextDarwin_arm64.cpp in Sources */,
       );
       runOnlyForDeploymentPostprocessing = 0;
     };
     2689FFC613353D7A00698AC0 /* Sources */ = {
       isa = PBXSourcesBuildPhase;
       buildActionMask = 2147483647;
       files = (
+        33E5E8471A674FB60024ED68 /* StringConvert.cpp in Sources */,
         26D1804216CEDF0700EDFB5B /* TimeSpecTimeout.cpp in Sources */,
         2689FFDA13353D9D00698AC0 /* lldb.cpp in Sources */,
         2689FFDB13353DA300698AC0 /* lldb-log.cpp in Sources */,
         26474CCD18D0CB5B0073DEBA /* RegisterContextPOSIX_x86.cpp in Sources */,
         2689FFEF13353DB600698AC0 /* Breakpoint.cpp in Sources */,
         2689FFF113353DB600698AC0 /* BreakpointID.cpp in Sources */,
         AF77E0A91A033D740096C0EA /* RegisterContextPOSIXCore_powerpc.cpp in Sources */,
         2689FFF313353DB600698AC0 /* BreakpointIDList.cpp in Sources */,
2689FFD513353D7A00698AC0 /* Debug */ = {
         );
         "OTHER_CPLUSPLUSFLAGS[sdk=iphoneos*]" = (
           "-fno-rtti",
           "-Wglobal-constructors",
           "$(OTHER_CFLAGS)",
           "-DLLDB_USE_BUILTIN_DEMANGLER",
         );
         OTHER_LDFLAGS = "";
+        PATH = /opt/local/bin;
         PRODUCT_NAME = "lib$(TARGET_NAME)";
         SKIP_INSTALL = YES;
         STANDARD_C_PLUS_PLUS_LIBRARY_TYPE = static;
         USER_HEADER_SEARCH_PATHS = "$(SRCROOT)/include $(SRCROOT)/source $(LLVM_SOURCE_DIR)/include $(LLVM_SOURCE_DIR)/tools/clang/include $(LLVM_BUILD_DIR)/$(LLVM_BUILD_DIR_ARCH)/include $(LLVM_BUILD_DIR)/$(LLVM_BUILD_DIR_ARCH)/tools/clang/include";
         VERSIONING_SYSTEM = "apple-generic";
       };
       name = Debug;
     };
2689FFD613353D7A00698AC0 /* Release */ = {
         );
         "OTHER_CPLUSPLUSFLAGS[sdk=iphoneos*]" = (
           "-fno-rtti",
           "-Wglobal-constructors",
           "$(OTHER_CFLAGS)",
           "-DLLDB_USE_BUILTIN_DEMANGLER",
         );
         OTHER_LDFLAGS = "";
+        PATH = /opt/local/bin;
         PRODUCT_NAME = "lib$(TARGET_NAME)";
         SKIP_INSTALL = YES;
         STANDARD_C_PLUS_PLUS_LIBRARY_TYPE = static;
         USER_HEADER_SEARCH_PATHS = "$(SRCROOT)/include $(SRCROOT)/source $(LLVM_SOURCE_DIR)/include $(LLVM_SOURCE_DIR)/tools/clang/include $(LLVM_BUILD_DIR)/$(LLVM_BUILD_DIR_ARCH)/include $(LLVM_BUILD_DIR)/$(LLVM_BUILD_DIR_ARCH)/tools/clang/include";
         VERSIONING_SYSTEM = "apple-generic";
       };
       name = Release;
     };
2689FFD713353D7A00698AC0 /* BuildAndIntegration */ = {
         );
         "OTHER_CPLUSPLUSFLAGS[sdk=iphoneos*]" = (
           "-fno-rtti",
           "-Wglobal-constructors",
           "$(OTHER_CFLAGS)",
           "-DLLDB_USE_BUILTIN_DEMANGLER",
         );
         OTHER_LDFLAGS = "";
+        PATH = /opt/local/bin;
         PRODUCT_NAME = "lib$(TARGET_NAME)";
         SKIP_INSTALL = YES;
         STANDARD_C_PLUS_PLUS_LIBRARY_TYPE = static;
         USER_HEADER_SEARCH_PATHS = "$(SRCROOT)/include $(SRCROOT)/source $(LLVM_SOURCE_DIR)/include $(LLVM_SOURCE_DIR)/tools/clang/include $(LLVM_BUILD_DIR)/$(LLVM_BUILD_DIR_ARCH)/include $(LLVM_BUILD_DIR)/$(LLVM_BUILD_DIR_ARCH)/tools/clang/include";
         VERSIONING_SYSTEM = "apple-generic";
       };
       name = BuildAndIntegration;
     };
49BB8F3B1611172B00BDD462 /* DebugClang */ = {
         );
         "OTHER_CPLUSPLUSFLAGS[sdk=iphoneos*]" = (
           "-fno-rtti",
           "-Wglobal-constructors",
           "$(OTHER_CFLAGS)",
           "-DLLDB_USE_BUILTIN_DEMANGLER",
         );
         OTHER_LDFLAGS = "";
+        PATH = /opt/local/bin;
         PRODUCT_NAME = "lib$(TARGET_NAME)";
         SKIP_INSTALL = YES;
         STANDARD_C_PLUS_PLUS_LIBRARY_TYPE = static;
         USER_HEADER_SEARCH_PATHS = "$(SRCROOT)/include $(SRCROOT)/source $(LLVM_SOURCE_DIR)/include $(LLVM_SOURCE_DIR)/tools/clang/include $(LLVM_BUILD_DIR)/$(LLVM_BUILD_DIR_ARCH)/include $(LLVM_BUILD_DIR)/$(LLVM_BUILD_DIR_ARCH)/tools/clang/include";
         VERSIONING_SYSTEM = "apple-generic";
       };
       name = DebugClang;
     };

source/Commands/CommandObjectBreakpoint.cpp

 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointIDList.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Interpreter/OptionValueString.h"
 #include "lldb/Interpreter/OptionValueUInt64.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Target/Target.h"
public:
                     break;
 
                 case 'b':
                     m_func_names.push_back (option_arg);
                     m_func_name_type_mask |= eFunctionNameTypeBase;
                     break;
 
                 case 'C':
-                    m_column = Args::StringToUInt32 (option_arg, 0);
+                    m_column = StringConvert::ToUInt32 (option_arg, 0);
                     break;
 
                 case 'c':
                     m_condition.assign(option_arg);
                     break;
 
                 case 'D':
                     m_use_dummy = true;
public:
                     break;
 
                 case 'H':
                     m_hardware = true;
                     break;
 
                 case 'i':
                 {
-                    m_ignore_count = Args::StringToUInt32(option_arg, UINT32_MAX, 0);
+                    m_ignore_count = StringConvert::ToUInt32(option_arg, UINT32_MAX, 0);
                     if (m_ignore_count == UINT32_MAX)
                        error.SetErrorStringWithFormat ("invalid ignore count '%s'", option_arg);
                     break;
                 }
 
                 case 'K':
                 {
                     bool success;
                     bool value;
                     value = Args::StringToBoolean (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'", option_arg);
                 }
                 break;
 
                 case 'l':
-                    m_line_num = Args::StringToUInt32 (option_arg, 0);
+                    m_line_num = StringConvert::ToUInt32 (option_arg, 0);
                     break;
 
                 case 'M':
                     m_func_names.push_back (option_arg);
                     m_func_name_type_mask |= eFunctionNameTypeMethod;
                     break;
 
                 case 'n':
public:
                     
                 case 'S':
                     m_func_names.push_back (option_arg);
                     m_func_name_type_mask |= eFunctionNameTypeSelector;
                     break;
 
                 case 't' :
                 {
-                    m_thread_id = Args::StringToUInt64(option_arg, LLDB_INVALID_THREAD_ID, 0);
+                    m_thread_id = StringConvert::ToUInt64(option_arg, LLDB_INVALID_THREAD_ID, 0);
                     if (m_thread_id == LLDB_INVALID_THREAD_ID)
                        error.SetErrorStringWithFormat ("invalid thread id string '%s'", option_arg);
                 }
                 break;
 
                 case 'T':
                     m_thread_name.assign (option_arg);
                     break;
 
                 case 'w':
                 {
                     bool success;
                     m_throw_bp = Args::StringToBoolean (option_arg, true, &success);
                     if (!success)
                         error.SetErrorStringWithFormat ("Invalid boolean value for on-throw option: '%s'", option_arg);
                 }
                 break;
 
                 case 'x':
                 {
-                    m_thread_index = Args::StringToUInt32(option_arg, UINT32_MAX, 0);
+                    m_thread_index = StringConvert::ToUInt32(option_arg, UINT32_MAX, 0);
                     if (m_thread_id == UINT32_MAX)
                        error.SetErrorStringWithFormat ("invalid thread index string '%s'", option_arg);
                     
                 }
                 break;
 
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
public:
                     m_use_dummy = true;
                     break;
                 case 'e':
                     m_enable_passed = true;
                     m_enable_value = true;
                     break;
                 case 'i':
                 {
-                    m_ignore_count = Args::StringToUInt32(option_arg, UINT32_MAX, 0);
+                    m_ignore_count = StringConvert::ToUInt32(option_arg, UINT32_MAX, 0);
                     if (m_ignore_count == UINT32_MAX)
                        error.SetErrorStringWithFormat ("invalid ignore count '%s'", option_arg);
                 }
                 break;
                 case 'o':
                 {
                     bool value, success;
                     value = Args::StringToBoolean(option_arg, false, &success);
public:
                 {
                     if (option_arg[0] == '\0')
                     {
                         m_thread_id = LLDB_INVALID_THREAD_ID;
                         m_thread_id_passed = true;
                     }
                     else
                     {
-                        m_thread_id = Args::StringToUInt64(option_arg, LLDB_INVALID_THREAD_ID, 0);
+                        m_thread_id = StringConvert::ToUInt64(option_arg, LLDB_INVALID_THREAD_ID, 0);
                         if (m_thread_id == LLDB_INVALID_THREAD_ID)
                            error.SetErrorStringWithFormat ("invalid thread id string '%s'", option_arg);
                         else
                             m_thread_id_passed = true;
                     }
                 }
                 break;
                 case 'T':
public:
                 {
                     if (option_arg[0] == '\n')
                     {
                         m_thread_index = UINT32_MAX;
                         m_thread_index_passed = true;
                     }
                     else
                     {
-                        m_thread_index = Args::StringToUInt32 (option_arg, UINT32_MAX, 0);
+                        m_thread_index = StringConvert::ToUInt32 (option_arg, UINT32_MAX, 0);
                         if (m_thread_id == UINT32_MAX)
                            error.SetErrorStringWithFormat ("invalid thread index string '%s'", option_arg);
                         else
                             m_thread_index_passed = true;
                     }
                 }
                 break;
                 default:
public:
 
             switch (short_option)
             {
                 case 'f':
                     m_filename.assign (option_arg);
                     break;
 
                 case 'l':
-                    m_line_num = Args::StringToUInt32 (option_arg, 0);
+                    m_line_num = StringConvert::ToUInt32 (option_arg, 0);
                     break;
 
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;

source/Commands/CommandObjectDisassemble.cpp

 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/SourceManager.h"
-#include "lldb/Interpreter/Args.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.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"
CommandObjectDisassemble::CommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
     
     switch (short_option)
     {
     case 'm':
         show_mixed = true;
         break;
 
     case 'C':
-        num_lines_context = Args::StringToUInt32(option_arg, 0, 0, &success);
+        num_lines_context = StringConvert::ToUInt32(option_arg, 0, 0, &success);
         if (!success)
             error.SetErrorStringWithFormat ("invalid num context lines string: \"%s\"", option_arg);
         break;
 
     case 'c':
-        num_instructions = Args::StringToUInt32(option_arg, 0, 0, &success);
+        num_instructions = StringConvert::ToUInt32(option_arg, 0, 0, &success);
         if (!success)
             error.SetErrorStringWithFormat ("invalid num of instructions string: \"%s\"", option_arg);
         break;
 
     case 'b':
         show_bytes = true;
         break;
 

source/Commands/CommandObjectExpression.cpp

 #include "lldb/lldb-python.h"
 
 #include "CommandObjectExpression.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Interpreter/Args.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/DataFormatters/ValueObjectPrinter.h"
 #include "lldb/Expression/ClangExpressionVariable.h"
 #include "lldb/Expression/ClangUserExpression.h"
 #include "lldb/Expression/ClangFunction.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
case 'i':
             else
                 error.SetErrorStringWithFormat("could not convert \"%s\" to a boolean value.", option_arg);
             break;
         }
     case 't':
         {
             bool success;
             uint32_t result;
-            result = Args::StringToUInt32(option_arg, 0, 0, &success);
+            result = StringConvert::ToUInt32(option_arg, 0, 0, &success);
             if (success)
                 timeout = result;
             else
                 error.SetErrorStringWithFormat ("invalid timeout setting \"%s\"", option_arg);
         }
         break;
         
     case 'u':

source/Commands/CommandObjectFrame.cpp

 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/Timer.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/DataFormatters/ValueObjectPrinter.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Interpreter/OptionGroupFormat.h"
 #include "lldb/Interpreter/OptionGroupValueObjectDisplay.h"
 #include "lldb/Interpreter/OptionGroupVariable.h"
 #include "lldb/Symbol/ClangASTType.h"
public:
         SetOptionValue (uint32_t option_idx, const char *option_arg)
         {
             Error error;
             bool success = false;
             const int short_option = m_getopt_table[option_idx].val;
             switch (short_option)
             {
             case 'r':   
-                relative_frame_offset = Args::StringToSInt32 (option_arg, INT32_MIN, 0, &success);
+                relative_frame_offset = StringConvert::ToSInt32 (option_arg, INT32_MIN, 0, &success);
                 if (!success)
                     error.SetErrorStringWithFormat ("invalid frame offset argument '%s'", option_arg);
                 break;
 
             default:
                 error.SetErrorStringWithFormat ("invalid short option character '%c'", short_option);
                 break;
             }
DoExecute (Args& command, CommandReturnObject &result)
             }
         }
         else 
         {
             if (command.GetArgumentCount() == 1)
             {
                 const char *frame_idx_cstr = command.GetArgumentAtIndex(0);
                 bool success = false;
-                frame_idx = Args::StringToUInt32 (frame_idx_cstr, UINT32_MAX, 0, &success);
+                frame_idx = StringConvert::ToUInt32 (frame_idx_cstr, UINT32_MAX, 0, &success);
                 if (!success)
                 {
                     result.AppendErrorWithFormat ("invalid frame index argument '%s'", frame_idx_cstr);
                     result.SetStatus (eReturnStatusFailed);
                     return false;
                 }
             }
             else if (command.GetArgumentCount() == 0)

source/Commands/CommandObjectLog.cpp

 #include "lldb/Core/Module.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Timer.h"
 
 #include "lldb/Core/Debugger.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 
DoExecute (Args& args,
         }
         else if (argc == 2)
         {
             const char *sub_command = args.GetArgumentAtIndex(0);
 
             if (strcasecmp(sub_command, "enable") == 0)
             {
                 bool success;
-                uint32_t depth = Args::StringToUInt32(args.GetArgumentAtIndex(1), 0, 0, &success);
+                uint32_t depth = StringConvert::ToUInt32(args.GetArgumentAtIndex(1), 0, 0, &success);
                 if (success)
                 {
                     Timer::SetDisplayDepth (depth);
                     result.SetStatus(eReturnStatusSuccessFinishNoResult);
                 }
                 else
                     result.AppendError("Could not convert enable depth to an unsigned integer.");
             }

source/Commands/CommandObjectMemory.cpp

 // Project includes
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/DataFormatters/ValueObjectPrinter.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Interpreter/OptionGroupFormat.h"
 #include "lldb/Interpreter/OptionGroupOutputFile.h"
 #include "lldb/Interpreter/OptionGroupValueObjectDisplay.h"
 #include "lldb/Interpreter/OptionValueString.h"
public:
                         m_infile.Clear();
                         error.SetErrorStringWithFormat("input file does not exist: '%s'", option_arg);
                     }
                     break;
                 
                 case 'o':
                     {
                         bool success;
-                        m_infile_offset = Args::StringToUInt64(option_arg, 0, 0, &success);
+                        m_infile_offset = StringConvert::ToUInt64(option_arg, 0, 0, &success);
                         if (!success)
                         {
                             error.SetErrorStringWithFormat("invalid offset string '%s'", option_arg);
                         }
                     }
                     break;
                     
                 default:
DoExecute (Args& command, CommandReturnObject &result)
 
             case eFormatDefault:
             case eFormatBytes:
             case eFormatHex:
             case eFormatHexUppercase:
             case eFormatPointer:
                 
                 // Decode hex bytes
-                uval64 = Args::StringToUInt64(value_str, UINT64_MAX, 16, &success);
+                uval64 = StringConvert::ToUInt64(value_str, UINT64_MAX, 16, &success);
                 if (!success)
                 {
                     result.AppendErrorWithFormat ("'%s' is not a valid hex string value.\n", value_str);
                     result.SetStatus(eReturnStatusFailed);
                     return false;
                 }
                 else if (!UIntValueIsValidForSize (uval64, item_byte_size))
                 {
DoExecute (Args& command, CommandReturnObject &result)
                     result.AppendErrorWithFormat ("'%s' is not a valid boolean string value.\n", value_str);
                     result.SetStatus(eReturnStatusFailed);
                     return false;
                 }
                 buffer.PutMaxHex64 (uval64, item_byte_size);
                 break;
 
             case eFormatBinary:
-                uval64 = Args::StringToUInt64(value_str, UINT64_MAX, 2, &success);
+                uval64 = StringConvert::ToUInt64(value_str, UINT64_MAX, 2, &success);
                 if (!success)
                 {
                     result.AppendErrorWithFormat ("'%s' is not a valid binary string value.\n", value_str);
                     result.SetStatus(eReturnStatusFailed);
                     return false;
                 }
                 else if (!UIntValueIsValidForSize (uval64, item_byte_size))
                 {
DoExecute (Args& command, CommandReturnObject &result)
                         result.AppendErrorWithFormat ("Memory write to 0x%" PRIx64 " failed: %s.\n", addr, error.AsCString());
                         result.SetStatus(eReturnStatusFailed);
                         return false;
                     }
                 }
                 break;
 
             case eFormatDecimal:
-                sval64 = Args::StringToSInt64(value_str, INT64_MAX, 0, &success);
+                sval64 = StringConvert::ToSInt64(value_str, INT64_MAX, 0, &success);
                 if (!success)
                 {
                     result.AppendErrorWithFormat ("'%s' is not a valid signed decimal value.\n", value_str);
                     result.SetStatus(eReturnStatusFailed);
                     return false;
                 }
                 else if (!SIntValueIsValidForSize (sval64, item_byte_size))
                 {
                     result.AppendErrorWithFormat ("Value %" PRIi64 " is too large or small to fit in a %" PRIu64 " byte signed integer value.\n", sval64, (uint64_t)item_byte_size);
                     result.SetStatus(eReturnStatusFailed);
                     return false;
                 }
                 buffer.PutMaxHex64 (sval64, item_byte_size);
                 break;
 
             case eFormatUnsigned:
-                uval64 = Args::StringToUInt64(value_str, UINT64_MAX, 0, &success);
+                uval64 = StringConvert::ToUInt64(value_str, UINT64_MAX, 0, &success);
                 if (!success)
                 {
                     result.AppendErrorWithFormat ("'%s' is not a valid unsigned decimal string value.\n", value_str);
                     result.SetStatus(eReturnStatusFailed);
                     return false;
                 }
                 else if (!UIntValueIsValidForSize (uval64, item_byte_size))
                 {
                     result.AppendErrorWithFormat ("Value %" PRIu64 " is too large to fit in a %" PRIu64 " byte unsigned integer value.\n", uval64, (uint64_t)item_byte_size);
                     result.SetStatus(eReturnStatusFailed);
                     return false;
                 }
                 buffer.PutMaxHex64 (uval64, item_byte_size);
                 break;
 
             case eFormatOctal:
-                uval64 = Args::StringToUInt64(value_str, UINT64_MAX, 8, &success);
+                uval64 = StringConvert::ToUInt64(value_str, UINT64_MAX, 8, &success);
                 if (!success)
                 {
                     result.AppendErrorWithFormat ("'%s' is not a valid octal string value.\n", value_str);
                     result.SetStatus(eReturnStatusFailed);
                     return false;
                 }
                 else if (!UIntValueIsValidForSize (uval64, item_byte_size))
                 {

source/Commands/CommandObjectPlatform.cpp

 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandOptionValidators.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionGroupFile.h"
 #include "lldb/Interpreter/OptionGroupPlatform.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Platform.h"
public:
     {
         Error error;
         char short_option = (char) GetDefinitions()[option_idx].short_option;
         switch (short_option)
         {
             case 'v':
             {
                 bool ok;
-                uint32_t perms = Args::StringToUInt32(option_arg, 777, 8, &ok);
+                uint32_t perms = StringConvert::ToUInt32(option_arg, 777, 8, &ok);
                 if (!ok)
                     error.SetErrorStringWithFormat("invalid value for permissions: %s", option_arg);
                 else
                     m_permissions = perms;
             }
                 break;
             case 's':
             {
public:
     virtual bool
     DoExecute (Args& args, CommandReturnObject &result)
     {
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
         if (platform_sp)
         {
             std::string cmd_line;
             args.GetCommandString(cmd_line);
-            const lldb::user_id_t fd = Args::StringToUInt64(cmd_line.c_str(), UINT64_MAX);
+            const lldb::user_id_t fd = StringConvert::ToUInt64(cmd_line.c_str(), UINT64_MAX);
             Error error;
             bool success = platform_sp->CloseFile(fd, error);
             if (success)
             {
                 result.AppendMessageWithFormat("file %" PRIu64 " closed.\n", fd);
                 result.SetStatus (eReturnStatusSuccessFinishResult);
             }
             else
public:
     virtual bool
     DoExecute (Args& args, CommandReturnObject &result)
     {
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
         if (platform_sp)
         {
             std::string cmd_line;
             args.GetCommandString(cmd_line);
-            const lldb::user_id_t fd = Args::StringToUInt64(cmd_line.c_str(), UINT64_MAX);
+            const lldb::user_id_t fd = StringConvert::ToUInt64(cmd_line.c_str(), UINT64_MAX);
             std::string buffer(m_options.m_count,0);
             Error error;
             uint32_t retcode = platform_sp->ReadFile(fd, m_options.m_offset, &buffer[0], m_options.m_count, error);
             result.AppendMessageWithFormat("Return = %d\n",retcode);
             result.AppendMessageWithFormat("Data = \"%s\"\n",buffer.c_str());
             result.SetStatus (eReturnStatusSuccessFinishResult);
         }
         else
public:
         {
             Error error;
             char short_option = (char) m_getopt_table[option_idx].val;
             bool success = false;
             
             switch (short_option)
             {
                 case 'o':
-                    m_offset = Args::StringToUInt32(option_arg, 0, 0, &success);
+                    m_offset = StringConvert::ToUInt32(option_arg, 0, 0, &success);
                     if (!success)
                         error.SetErrorStringWithFormat("invalid offset: '%s'", option_arg);
                     break;
                 case 'c':
-                    m_count = Args::StringToUInt32(option_arg, 0, 0, &success);
+                    m_count = StringConvert::ToUInt32(option_arg, 0, 0, &success);
                     if (!success)
                         error.SetErrorStringWithFormat("invalid offset: '%s'", option_arg);
                     break;
 
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
public:
     DoExecute (Args& args, CommandReturnObject &result)
     {
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
         if (platform_sp)
         {
             std::string cmd_line;
             args.GetCommandString(cmd_line);
             Error error;
-            const lldb::user_id_t fd = Args::StringToUInt64(cmd_line.c_str(), UINT64_MAX);
+            const lldb::user_id_t fd = StringConvert::ToUInt64(cmd_line.c_str(), UINT64_MAX);
             uint32_t retcode = platform_sp->WriteFile (fd,
                                                        m_options.m_offset,
                                                        &m_options.m_data[0],
                                                        m_options.m_data.size(),
                                                        error);
             result.AppendMessageWithFormat("Return = %d\n",retcode);
             result.SetStatus (eReturnStatusSuccessFinishResult);
         }
public:
         {
             Error error;
             char short_option = (char) m_getopt_table[option_idx].val;
             bool success = false;
             
             switch (short_option)
             {
                 case 'o':
-                    m_offset = Args::StringToUInt32(option_arg, 0, 0, &success);
+                    m_offset = StringConvert::ToUInt32(option_arg, 0, 0, &success);
                     if (!success)
                         error.SetErrorStringWithFormat("invalid offset: '%s'", option_arg);
                     break;
                 case 'd':
                     m_data.assign(option_arg);
                     break;
                     
                 default:
public:
         {
             Error error;
             const int short_option = m_getopt_table[option_idx].val;
             bool success = false;
 
             switch (short_option)
             {
                 case 'p':
-                    match_info.GetProcessInfo().SetProcessID (Args::StringToUInt32 (option_arg, LLDB_INVALID_PROCESS_ID, 0, &success));
+                    match_info.GetProcessInfo().SetProcessID (StringConvert::ToUInt32 (option_arg, LLDB_INVALID_PROCESS_ID, 0, &success));
                     if (!success)
                         error.SetErrorStringWithFormat("invalid process ID string: '%s'", option_arg);
                     break;
                 
                 case 'P':
-                    match_info.GetProcessInfo().SetParentProcessID (Args::StringToUInt32 (option_arg, LLDB_INVALID_PROCESS_ID, 0, &success));
+                    match_info.GetProcessInfo().SetParentProcessID (StringConvert::ToUInt32 (option_arg, LLDB_INVALID_PROCESS_ID, 0, &success));
                     if (!success)
                         error.SetErrorStringWithFormat("invalid parent process ID string: '%s'", option_arg);
                     break;
 
                 case 'u':
-                    match_info.GetProcessInfo().SetUserID (Args::StringToUInt32 (option_arg, UINT32_MAX, 0, &success));
+                    match_info.GetProcessInfo().SetUserID (StringConvert::ToUInt32 (option_arg, UINT32_MAX, 0, &success));
                     if (!success)
                         error.SetErrorStringWithFormat("invalid user ID string: '%s'", option_arg);
                     break;
 
                 case 'U':
-                    match_info.GetProcessInfo().SetEffectiveUserID (Args::StringToUInt32 (option_arg, UINT32_MAX, 0, &success));
+                    match_info.GetProcessInfo().SetEffectiveUserID (StringConvert::ToUInt32 (option_arg, UINT32_MAX, 0, &success));
                     if (!success)
                         error.SetErrorStringWithFormat("invalid effective user ID string: '%s'", option_arg);
                     break;
 
                 case 'g':
-                    match_info.GetProcessInfo().SetGroupID (Args::StringToUInt32 (option_arg, UINT32_MAX, 0, &success));
+                    match_info.GetProcessInfo().SetGroupID (StringConvert::ToUInt32 (option_arg, UINT32_MAX, 0, &success));
                     if (!success)
                         error.SetErrorStringWithFormat("invalid group ID string: '%s'", option_arg);
                     break;
 
                 case 'G':
-                    match_info.GetProcessInfo().SetEffectiveGroupID (Args::StringToUInt32 (option_arg, UINT32_MAX, 0, &success));
+                    match_info.GetProcessInfo().SetEffectiveGroupID (StringConvert::ToUInt32 (option_arg, UINT32_MAX, 0, &success));
                     if (!success)
                         error.SetErrorStringWithFormat("invalid effective group ID string: '%s'", option_arg);
                     break;
 
                 case 'a':
                     match_info.GetProcessInfo().GetArchitecture().SetTriple (option_arg, m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform().get());
                     break;
 
DoExecute (Args& args, CommandReturnObject &result)
                 
                 if (platform_sp->IsConnected())
                 {
                     Stream &ostrm = result.GetOutputStream();      
                     bool success;
                     for (size_t i=0; i<argc; ++ i)
                     {
                         const char *arg = args.GetArgumentAtIndex(i);
-                        lldb::pid_t pid = Args::StringToUInt32 (arg, LLDB_INVALID_PROCESS_ID, 0, &success);
+                        lldb::pid_t pid = StringConvert::ToUInt32 (arg, LLDB_INVALID_PROCESS_ID, 0, &success);
                         if (success)
                         {
                             ProcessInstanceInfo proc_info;
                             if (platform_sp->GetProcessInfo (pid, proc_info))
                             {
                                 ostrm.Printf ("Process information for process %" PRIu64 ":\n", pid);
                                 proc_info.Dump (ostrm, platform_sp.get());
                             }
public:
         {
             Error error;
             char short_option = (char) m_getopt_table[option_idx].val;
             bool success = false;
             switch (short_option)
             {
                 case 'p':   
                 {
-                    lldb::pid_t pid = Args::StringToUInt32 (option_arg, LLDB_INVALID_PROCESS_ID, 0, &success);
+                    lldb::pid_t pid = StringConvert::ToUInt32 (option_arg, LLDB_INVALID_PROCESS_ID, 0, &success);
                     if (!success || pid == LLDB_INVALID_PROCESS_ID)
                     {
                         error.SetErrorStringWithFormat("invalid process ID '%s'", option_arg);
                     }
                     else
                     {
                         attach_info.SetProcessID (pid);
                     }
public:
             
             const char short_option = (char) g_option_table[option_idx].short_option;
             
             switch (short_option)
             {
                 case 't':
                 {
                     bool success;
-                    timeout = Args::StringToUInt32(option_value, 10, 10, &success);
+                    timeout = StringConvert::ToUInt32(option_value, 10, 10, &success);
                     if (!success)
                         error.SetErrorStringWithFormat("could not convert \"%s\" to a numeric value.", option_value);
                     break;
                 }
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }

source/Commands/CommandObjectProcess.cpp

 // Project includes
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointSite.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
public:
             switch (short_option)
             {
                 case 'c':
                     attach_info.SetContinueOnceAttached(true);
                     break;
 
                 case 'p':   
                     {
-                        lldb::pid_t pid = Args::StringToUInt32 (option_arg, LLDB_INVALID_PROCESS_ID, 0, &success);
+                        lldb::pid_t pid = StringConvert::ToUInt32 (option_arg, LLDB_INVALID_PROCESS_ID, 0, &success);
                         if (!success || pid == LLDB_INVALID_PROCESS_ID)
                         {
                             error.SetErrorStringWithFormat("invalid process ID '%s'", option_arg);
                         }
                         else
                         {
                             attach_info.SetProcessID (pid);
                         }
public:
         SetOptionValue (uint32_t option_idx, const char *option_arg)
         {
             Error error;
             const int short_option = m_getopt_table[option_idx].val;
             bool success = false;
             switch (short_option)
             {
                 case 'i':
-                    m_ignore = Args::StringToUInt32 (option_arg, 0, 0, &success);
+                    m_ignore = StringConvert::ToUInt32 (option_arg, 0, 0, &success);
                     if (!success)
                         error.SetErrorStringWithFormat ("invalid value for ignore option: \"%s\", should be a number.", option_arg);
                     break;
 
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
protected:
     {
         Process *process = m_exe_ctx.GetProcessPtr();
 
         const size_t argc = command.GetArgumentCount();
         
         for (uint32_t i=0; i<argc; ++i)
         {
             const char *image_token_cstr = command.GetArgumentAtIndex(i);
-            uint32_t image_token = Args::StringToUInt32(image_token_cstr, LLDB_INVALID_IMAGE_TOKEN, 0);
+            uint32_t image_token = StringConvert::ToUInt32(image_token_cstr, LLDB_INVALID_IMAGE_TOKEN, 0);
             if (image_token == LLDB_INVALID_IMAGE_TOKEN)
             {
                 result.AppendErrorWithFormat ("invalid image index argument '%s'", image_token_cstr);
                 result.SetStatus (eReturnStatusFailed);
                 break;
             }
             else
             {
DoExecute (Args& command,
         Process *process = m_exe_ctx.GetProcessPtr();
 
         if (command.GetArgumentCount() == 1)
         {
             int signo = LLDB_INVALID_SIGNAL_NUMBER;
             
             const char *signal_name = command.GetArgumentAtIndex(0);
             if (::isxdigit (signal_name[0]))
-                signo = Args::StringToSInt32(signal_name, LLDB_INVALID_SIGNAL_NUMBER, 0);
+                signo = StringConvert::ToSInt32(signal_name, LLDB_INVALID_SIGNAL_NUMBER, 0);
             else
                 signo = process->GetUnixSignals().GetSignalNumberFromName (signal_name);
             
             if (signo == LLDB_INVALID_SIGNAL_NUMBER)
             {
                 result.AppendErrorWithFormat ("Invalid signal argument '%s'.\n", command.GetArgumentAtIndex(0));
                 result.SetStatus (eReturnStatusFailed);
             }
VerifyCommandOptionValue (const std::string &option, int &real_value)
 
         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 = Args::StringToUInt32 (option.c_str(), 3);
+            real_value = StringConvert::ToUInt32 (option.c_str(), 3);
             if (real_value != 0 && real_value != 1)
                 okay = false;
         }
         
         return okay;
     }
 
     void

source/Commands/CommandObjectSource.cpp

 #include "lldb/lldb-python.h"
 
 #include "CommandObjectSource.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Interpreter/Args.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/FileLineResolver.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/SourceManager.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Host/FileSpec.h"
+#include "lldb/Host/StringConvert.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/TargetList.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/Options.h"
public:
         Error
         SetOptionValue (uint32_t option_idx, const char *option_arg)
         {
             Error error;
             const int short_option = g_option_table[option_idx].short_option;
             switch (short_option)
             {
             case 'l':
-                start_line = Args::StringToUInt32 (option_arg, 0);
+                start_line = StringConvert::ToUInt32 (option_arg, 0);
                 if (start_line == 0)
                     error.SetErrorStringWithFormat("invalid line number: '%s'", option_arg);
                 break;
 
              case 'f':
                 file_name = option_arg;
                 break;
 
public:
         Error
         SetOptionValue (uint32_t option_idx, const char *option_arg)
         {
             Error error;
             const int short_option = g_option_table[option_idx].short_option;
             switch (short_option)
             {
             case 'l':
-                start_line = Args::StringToUInt32 (option_arg, 0);
+                start_line = StringConvert::ToUInt32 (option_arg, 0);
                 if (start_line == 0)
                     error.SetErrorStringWithFormat("invalid line number: '%s'", option_arg);
                 break;
 
             case 'c':
-                num_lines = Args::StringToUInt32 (option_arg, 0);
+                num_lines = StringConvert::ToUInt32 (option_arg, 0);
                 if (num_lines == 0)
                     error.SetErrorStringWithFormat("invalid line count: '%s'", option_arg);
                 break;
 
             case 'f':
                 file_name = option_arg;
                 break;
                 

source/Commands/CommandObjectTarget.cpp

 #include "lldb/Core/IOHandler.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/Timer.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/DataFormatters/ValueObjectPrinter.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Interpreter/OptionGroupArchitecture.h"
 #include "lldb/Interpreter/OptionGroupBoolean.h"
 #include "lldb/Interpreter/OptionGroupFile.h"
 #include "lldb/Interpreter/OptionGroupFormat.h"

 protected:
     virtual bool
     DoExecute (Args& args, CommandReturnObject &result)
     {
         if (args.GetArgumentCount() == 1)
         {
             bool success = false;
             const char *target_idx_arg = args.GetArgumentAtIndex(0);
-            uint32_t target_idx = Args::StringToUInt32 (target_idx_arg, UINT32_MAX, 0, &success);
+            uint32_t target_idx = StringConvert::ToUInt32 (target_idx_arg, UINT32_MAX, 0, &success);
             if (success)
             {
                 TargetList &target_list = m_interpreter.GetDebugger().GetTargetList();
                 const uint32_t num_targets = target_list.GetNumTargets();
                 if (target_idx < num_targets)
                 {        
                     TargetSP target_sp (target_list.GetTargetAtIndex (target_idx));
                     if (target_sp)
DoExecute (Args& args, CommandReturnObject &result)
                 result.AppendError("no targets to delete");
                 result.SetStatus(eReturnStatusFailed);
                 success = false;
             }
 
             for (uint32_t arg_idx = 0; success && arg_idx < argc; ++arg_idx)
             {
                 const char *target_idx_arg = args.GetArgumentAtIndex(arg_idx);
-                uint32_t target_idx = Args::StringToUInt32 (target_idx_arg, UINT32_MAX, 0, &success);
+                uint32_t target_idx = StringConvert::ToUInt32 (target_idx_arg, UINT32_MAX, 0, &success);
                 if (success)
                 {
                     if (target_idx < num_targets)
                     {
                         target_sp = target_list.GetTargetAtIndex (target_idx);
                         if (target_sp)
                         {
                             delete_target_list.push_back (target_sp);
DoExecute (Args& command,
         if (target)
         {
             size_t argc = command.GetArgumentCount();
             // check for at least 3 arguments and an odd nubmer of parameters
             if (argc >= 3 && argc & 1)
             {
                 bool success = false;
 
-                uint32_t insert_idx = Args::StringToUInt32(command.GetArgumentAtIndex(0), UINT32_MAX, 0, &success);
+                uint32_t insert_idx = StringConvert::ToUInt32(command.GetArgumentAtIndex(0), UINT32_MAX, 0, &success);
 
                 if (!success)
                 {
                     result.AppendErrorWithFormat("<index> parameter is not an integer: '%s'.\n", command.GetArgumentAtIndex(0));
                     result.SetStatus (eReturnStatusFailed);
                     return result.Succeeded();
                 }
 
DoExecute (Args& args,
                                     for (size_t i=0; i<argc; i += 2)
                                     {
                                         const char *sect_name = args.GetArgumentAtIndex(i);
                                         const char *load_addr_cstr = args.GetArgumentAtIndex(i+1);
                                         if (sect_name && load_addr_cstr)
                                         {
                                             ConstString const_sect_name(sect_name);
                                             bool success = false;
-                                            addr_t load_addr = Args::StringToUInt64(load_addr_cstr, LLDB_INVALID_ADDRESS, 0, &success);
+                                            addr_t load_addr = StringConvert::ToUInt64(load_addr_cstr, LLDB_INVALID_ADDRESS, 0, &success);
                                             if (success)
                                             {
                                                 SectionSP section_sp (section_list->FindSectionByName(const_sect_name));
                                                 if (section_sp)
                                                 {
                                                     if (section_sp->IsThreadSpecific())
                                                     {
                                                         result.AppendErrorWithFormat ("thread specific sections are not yet supported (section '%s')\n", sect_name);
public:
                     {
                         m_type = eLookupTypeAddress;
                         ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
                         m_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
                     }
                     break;
 
                 case 'o':
-                    m_offset = Args::StringToUInt64(option_arg, LLDB_INVALID_ADDRESS);
+                    m_offset = StringConvert::ToUInt64(option_arg, LLDB_INVALID_ADDRESS);
                     if (m_offset == LLDB_INVALID_ADDRESS)
                         error.SetErrorStringWithFormat ("invalid offset string '%s'", option_arg);
                     break;
 
                 case 's':
                     m_str = option_arg;
                     m_type = eLookupTypeSymbol;
                     break;
 
                 case 'f':
                     m_file.SetFile (option_arg, false);
                     m_type = eLookupTypeFileLine;
                     break;
 
                 case 'i':
                     m_include_inlines = false;
                     break;
 
                 case 'l':
-                    m_line_number = Args::StringToUInt32(option_arg, UINT32_MAX);
+                    m_line_number = StringConvert::ToUInt32(option_arg, UINT32_MAX);
                     if (m_line_number == UINT32_MAX)
                         error.SetErrorStringWithFormat ("invalid line number string '%s'", option_arg);
                     else if (m_line_number == 0)
                         error.SetErrorString ("zero is an invalid line number");
                     m_type = eLookupTypeFileLine;
                     break;
 
                 case 'F':
public:
             switch (short_option)
             {
                 case 'c':
                     m_class_name = option_arg;
                     m_sym_ctx_specified = true;
                 break;
 
                 case 'e':
-                    m_line_end = Args::StringToUInt32 (option_arg, UINT_MAX, 0, &success);
+                    m_line_end = StringConvert::ToUInt32 (option_arg, UINT_MAX, 0, &success);
                     if (!success)
                     {
                         error.SetErrorStringWithFormat ("invalid end line number: \"%s\"", option_arg);
                         break;
                     }
                     m_sym_ctx_specified = true;
                 break;
 
                 case 'l':
-                    m_line_start = Args::StringToUInt32 (option_arg, 0, 0, &success);
+                    m_line_start = StringConvert::ToUInt32 (option_arg, 0, 0, &success);
                     if (!success)
                     {
                         error.SetErrorStringWithFormat ("invalid start line number: \"%s\"", option_arg);
                         break;
                     }
                     m_sym_ctx_specified = true;
                 break;
 
public:
                     m_sym_ctx_specified = true;
                 break;
                 case 's':
                     m_module_name = option_arg;
                     m_sym_ctx_specified = true;
                 break;
                 case 't' :
                 {
-                    m_thread_id = Args::StringToUInt64(option_arg, LLDB_INVALID_THREAD_ID, 0);
+                    m_thread_id = StringConvert::ToUInt64(option_arg, LLDB_INVALID_THREAD_ID, 0);
                     if (m_thread_id == LLDB_INVALID_THREAD_ID)
                        error.SetErrorStringWithFormat ("invalid thread id string '%s'", option_arg);
                     m_thread_specified = true;
                 }
                 break;
                 case 'T':
                     m_thread_name = option_arg;
                     m_thread_specified = true;
                 break;
                 case 'q':
                     m_queue_name = option_arg;
                     m_thread_specified = true;
                     break;
                 case 'x':
                 {
-                    m_thread_index = Args::StringToUInt32(option_arg, UINT32_MAX, 0);
+                    m_thread_index = StringConvert::ToUInt32(option_arg, UINT32_MAX, 0);
                     if (m_thread_id == UINT32_MAX)
                        error.SetErrorStringWithFormat ("invalid thread index string '%s'", option_arg);
                     m_thread_specified = true;
                 }
                 break;
                 case 'o':
                     m_use_one_liner = true;
                     m_one_liner = option_arg;
DoExecute (Args& command, CommandReturnObject &result)
                     target->RemoveAllStopHooks();
                 }
             }
             else
             {
                 bool success;
                 for (size_t i = 0; i < num_args; i++)
                 {
-                    lldb::user_id_t user_id = Args::StringToUInt32 (command.GetArgumentAtIndex(i), 0, 0, &success);
+                    lldb::user_id_t user_id = StringConvert::ToUInt32 (command.GetArgumentAtIndex(i), 0, 0, &success);
                     if (!success)
                     {
                         result.AppendErrorWithFormat ("invalid stop hook id: \"%s\".\n", command.GetArgumentAtIndex(i));
                         result.SetStatus(eReturnStatusFailed);
                         return false;
                     }
                     success = target->RemoveStopHookByID (user_id);
                     if (!success)
DoExecute (Args& command, CommandReturnObject &result)
             if (num_args == 0)
             {
                 target->SetAllStopHooksActiveState (m_enable);
             }
             else
             {
                 for (size_t i = 0; i < num_args; i++)
                 {
-                    lldb::user_id_t user_id = Args::StringToUInt32 (command.GetArgumentAtIndex(i), 0, 0, &success);
+                    lldb::user_id_t user_id = StringConvert::ToUInt32 (command.GetArgumentAtIndex(i), 0, 0, &success);
                     if (!success)
                     {
                         result.AppendErrorWithFormat ("invalid stop hook id: \"%s\".\n", command.GetArgumentAtIndex(i));
                         result.SetStatus(eReturnStatusFailed);
                         return false;
                     }
                     success = target->SetStopHookActiveStateByID (user_id, m_enable);
                     if (!success)

source/Commands/CommandObjectThread.cpp

 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/SourceManager.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Target/Process.h"
DoExecute (Args& command, CommandReturnObject &result)
             Process *process = m_exe_ctx.GetProcessPtr();
             Mutex::Locker locker (process->GetThreadList().GetMutex());
             std::vector<ThreadSP> thread_sps;
 
             for (size_t i = 0; i < num_args; i++)
             {
                 bool success;
                 
-                uint32_t thread_idx = Args::StringToUInt32(command.GetArgumentAtIndex(i), 0, 0, &success);
+                uint32_t thread_idx = StringConvert::ToUInt32(command.GetArgumentAtIndex(i), 0, 0, &success);
                 if (!success)
                 {
                     result.AppendErrorWithFormat ("invalid thread specification: \"%s\"\n", command.GetArgumentAtIndex(i));
                     result.SetStatus (eReturnStatusFailed);
                     return false;
                 }
                 
                 thread_sps.push_back(process->GetThreadList().FindThreadByIndexID(thread_idx));
public:
             Error error;
             const int short_option = m_getopt_table[option_idx].val;
 
             switch (short_option)
             {
                 case 'c':
                 {
                     bool success;
-                    int32_t input_count =  Args::StringToSInt32 (option_arg, -1, 0, &success);
+                    int32_t input_count =  StringConvert::ToSInt32 (option_arg, -1, 0, &success);
                     if (!success)
                         error.SetErrorStringWithFormat("invalid integer value for option '%c'", short_option);
                     if (input_count < -1)
                         m_count = UINT32_MAX;
                     else
                         m_count = input_count;
                 }
                 break;
                 case 's':
                 {
                     bool success;
-                    m_start =  Args::StringToUInt32 (option_arg, 0, 0, &success);
+                    m_start =  StringConvert::ToUInt32 (option_arg, 0, 0, &success);
                     if (!success)
                         error.SetErrorStringWithFormat("invalid integer value for option '%c'", short_option);
                 }
                 case 'e':
                 {
                     bool success;
                     m_extended_backtrace =  Args::StringToBoolean (option_arg, false, &success);
                     if (!success)
public:
                     {
                         m_step_out_avoid_no_debug = avoid_no_debug ? eLazyBoolYes : eLazyBoolNo;
                     }
                 }
                 break;
             
             case 'c':
                 {
-                    m_step_count = Args::StringToUInt32(option_arg, UINT32_MAX, 0);
+                    m_step_count = StringConvert::ToUInt32(option_arg, UINT32_MAX, 0);
                     if (m_step_count == UINT32_MAX)
                        error.SetErrorStringWithFormat ("invalid ignore count '%s'", option_arg);
                     break;
                 }
                 break;
             case 'C':
                 {
                     m_class_name.clear();
DoExecute (Args& command, CommandReturnObject &result)
                 result.AppendError ("no selected thread in process");
                 result.SetStatus (eReturnStatusFailed);
                 return false;
             }
         }
         else
         {
             const char *thread_idx_cstr = command.GetArgumentAtIndex(0);
-            uint32_t step_thread_idx = Args::StringToUInt32 (thread_idx_cstr, LLDB_INVALID_INDEX32);
+            uint32_t step_thread_idx = StringConvert::ToUInt32 (thread_idx_cstr, LLDB_INVALID_INDEX32);
             if (step_thread_idx == LLDB_INVALID_INDEX32)
             {
                 result.AppendErrorWithFormat ("invalid thread index '%s'.\n", thread_idx_cstr);
                 result.SetStatus (eReturnStatusFailed);
                 return false;
             }
             thread = process->GetThreadList().FindThreadByIndexID(step_thread_idx).get();
             if (thread == NULL)
DoExecute (Args& command, CommandReturnObject &result)
                 // lock before calling process->Resume below.
                 Mutex::Locker locker (process->GetThreadList().GetMutex());
                 const uint32_t num_threads = process->GetThreadList().GetSize();
                 std::vector<Thread *> resume_threads;
                 for (uint32_t i=0; i<argc; ++i)
                 {
                     bool success;
                     const int base = 0;
-                    uint32_t thread_idx = Args::StringToUInt32 (command.GetArgumentAtIndex(i), LLDB_INVALID_INDEX32, base, &success);
+                    uint32_t thread_idx = StringConvert::ToUInt32 (command.GetArgumentAtIndex(i), LLDB_INVALID_INDEX32, base, &success);
                     if (success)
                     {
                         Thread *thread = process->GetThreadList().FindThreadByIndexID(thread_idx).get();
 
                         if (thread)
                         {
                             resume_threads.push_back(thread);
                         }
public:
         {
             Error error;
             const int short_option = m_getopt_table[option_idx].val;
 
             switch (short_option)
             {
                 case 't':
                 {
-                    m_thread_idx = Args::StringToUInt32 (option_arg, LLDB_INVALID_INDEX32);
+                    m_thread_idx = StringConvert::ToUInt32 (option_arg, LLDB_INVALID_INDEX32);
                     if (m_thread_idx == LLDB_INVALID_INDEX32)
                     {
                         error.SetErrorStringWithFormat ("invalid thread index '%s'", option_arg);
                     }
                 }
                 break;
                 case 'f':
                 {
-                    m_frame_idx = Args::StringToUInt32 (option_arg, LLDB_INVALID_FRAME_ID);
+                    m_frame_idx = StringConvert::ToUInt32 (option_arg, LLDB_INVALID_FRAME_ID);
                     if (m_frame_idx == LLDB_INVALID_FRAME_ID)
                     {
                         error.SetErrorStringWithFormat ("invalid frame index '%s'", option_arg);
                     }
                 }
                 break;
                 case 'm':
                 {
DoExecute (Args& command, CommandReturnObject &result)
 
             if (command.GetArgumentCount() != 1)
             {
                 result.AppendErrorWithFormat ("No line number provided:\n%s", GetSyntax());
                 result.SetStatus (eReturnStatusFailed);
                 return false;
             }
 
-            line_number = Args::StringToUInt32 (command.GetArgumentAtIndex(0), UINT32_MAX);
+            line_number = StringConvert::ToUInt32 (command.GetArgumentAtIndex(0), UINT32_MAX);
             if (line_number == UINT32_MAX)
             {
                 result.AppendErrorWithFormat ("invalid line number: '%s'.\n", command.GetArgumentAtIndex(0));
                 result.SetStatus (eReturnStatusFailed);
                 return false;
             }
 
             if (m_options.m_thread_idx == LLDB_INVALID_THREAD_ID)
DoExecute (Args& command, CommandReturnObject &result)
         }
         else if (command.GetArgumentCount() != 1)
         {
             result.AppendErrorWithFormat("'%s' takes exactly one thread index argument:\nUsage: %s\n", m_cmd_name.c_str(), m_cmd_syntax.c_str());
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
 
-        uint32_t index_id = Args::StringToUInt32(command.GetArgumentAtIndex(0), 0, 0);
+        uint32_t index_id = StringConvert::ToUInt32(command.GetArgumentAtIndex(0), 0, 0);
 
         Thread *new_thread = process->GetThreadList().FindThreadByIndexID(index_id).get();
         if (new_thread == NULL)
         {
             result.AppendErrorWithFormat ("invalid thread #%s.\n", command.GetArgumentAtIndex(0));
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
public:
             switch (short_option)
             {
                 case 'f':
                     m_filenames.AppendIfUnique (FileSpec(option_arg, false));
                     if (m_filenames.GetSize() > 1)
                         return Error("only one source file expected.");
                     break;
                 case 'l':
-                    m_line_num = Args::StringToUInt32 (option_arg, 0, 0, &success);
+                    m_line_num = StringConvert::ToUInt32 (option_arg, 0, 0, &success);
                     if (!success || m_line_num == 0)
                         return Error("invalid line number: '%s'.", option_arg);
                     break;
                 case 'b':
-                    m_line_offset = Args::StringToSInt32 (option_arg, 0, 0, &success);
+                    m_line_offset = StringConvert::ToSInt32 (option_arg, 0, 0, &success);
                     if (!success)
                         return Error("invalid line offset: '%s'.", option_arg);
                     break;
                 case 'a':
                     {
                         ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
                         m_load_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
                     }
DoExecute (Args& args, CommandReturnObject &result)
         {
             result.AppendErrorWithFormat("Too many arguments, expected one - the thread plan index - but got %zu.",
                                          args.GetArgumentCount());
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
 
         bool success;
-        uint32_t thread_plan_idx = Args::StringToUInt32(args.GetArgumentAtIndex(0), 0, 0, &success);
+        uint32_t thread_plan_idx = StringConvert::ToUInt32(args.GetArgumentAtIndex(0), 0, 0, &success);
         if (!success)
         {
             result.AppendErrorWithFormat("Invalid thread index: \"%s\" - should be unsigned int.",
                                          args.GetArgumentAtIndex(0));
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
 

source/Commands/CommandObjectWatchpoint.cpp

 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Breakpoint/WatchpointList.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectVariable.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Target.h"
 
 #include "llvm/ADT/StringRef.h"
public:
         {
             Error error;
             const int short_option = m_getopt_table[option_idx].val;
 
             switch (short_option)
             {
                 case 'i':
                 {
-                    m_ignore_count = Args::StringToUInt32(option_arg, UINT32_MAX, 0);
+                    m_ignore_count = StringConvert::ToUInt32(option_arg, UINT32_MAX, 0);
                     if (m_ignore_count == UINT32_MAX)
                        error.SetErrorStringWithFormat ("invalid ignore count '%s'", option_arg);
                 }
                 break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }

source/Core/RegisterValue.cpp

 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Scalar.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Interpreter/Args.h"
+#include "lldb/Host/StringConvert.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 
 bool
 RegisterValue::Dump (Stream *s, 
                      const RegisterInfo *reg_info, 
RegisterValue::SetValueFromCString (const RegisterInfo *reg_info, const char *value_str)
     {
         case eEncodingInvalid:
             error.SetErrorString ("Invalid encoding.");
             break;
             
         case eEncodingUint:
             if (byte_size <= sizeof (uint64_t))
             {
-                uint64_t uval64 = Args::StringToUInt64(value_str, UINT64_MAX, 0, &success);
+                uint64_t uval64 = StringConvert::ToUInt64(value_str, UINT64_MAX, 0, &success);
                 if (!success)
                     error.SetErrorStringWithFormat ("'%s' is not a valid unsigned integer string value", value_str);
                 else if (!Args::UInt64ValueIsValidForByteSize (uval64, byte_size))
                     error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %u byte unsigned integer value", uval64, byte_size);
                 else
                 {
                     if (!SetUInt (uval64, reg_info->byte_size))
                         error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %u", byte_size);
                 }
             }
             else
             {
                 error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %u", byte_size);
                 return error;
             }
             break;
             
         case eEncodingSint:
             if (byte_size <= sizeof (long long))
             {
-                uint64_t sval64 = Args::StringToSInt64(value_str, INT64_MAX, 0, &success);
+                uint64_t sval64 = StringConvert::ToSInt64(value_str, INT64_MAX, 0, &success);
                 if (!success)
                     error.SetErrorStringWithFormat ("'%s' is not a valid signed integer string value", value_str);
                 else if (!Args::SInt64ValueIsValidForByteSize (sval64, byte_size))
                     error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %u byte signed integer value", sval64, byte_size);
                 else
                 {
                     if (!SetUInt (sval64, reg_info->byte_size))
                         error.SetErrorStringWithFormat ("unsupported signed integer byte size: %u", byte_size);

source/Core/Scalar.cpp

 #include <math.h>
 #include <inttypes.h>
 
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Host/Endian.h"
+#include "lldb/Host/StringConvert.h"
 
 #include "Plugins/Process/Utility/InstructionUtils.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // Promote to max type currently follows the ANSI C rule for type
Scalar::SetValueFromCString (const char *value_str, Encoding encoding, size_t byte_size)
     {
     case eEncodingInvalid:
         error.SetErrorString ("Invalid encoding.");
         break;
 
     case eEncodingUint:
         if (byte_size <= sizeof (unsigned long long))
         {
-            uint64_t uval64 = Args::StringToUInt64(value_str, UINT64_MAX, 0, &success);
+            uint64_t uval64 = StringConvert::ToUInt64(value_str, UINT64_MAX, 0, &success);
             if (!success)
                 error.SetErrorStringWithFormat ("'%s' is not a valid unsigned integer string value", value_str);
             else if (!UIntValueIsValidForSize (uval64, byte_size))
                 error.SetErrorStringWithFormat("value 0x%" PRIx64 " is too large to fit in a %" PRIu64 " byte unsigned integer value", uval64, (uint64_t)byte_size);
             else
             {
                 m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize (byte_size);
                 switch (m_type)
case eEncodingUint:
             error.SetErrorStringWithFormat("unsupported unsigned integer byte size: %" PRIu64 "", (uint64_t)byte_size);
             return error;
         }
         break;
 
     case eEncodingSint:
         if (byte_size <= sizeof (long long))
         {
-            uint64_t sval64 = Args::StringToSInt64(value_str, INT64_MAX, 0, &success);
+            uint64_t sval64 = StringConvert::ToSInt64(value_str, INT64_MAX, 0, &success);
             if (!success)
                 error.SetErrorStringWithFormat ("'%s' is not a valid signed integer string value", value_str);
             else if (!SIntValueIsValidForSize (sval64, byte_size))
                 error.SetErrorStringWithFormat("value 0x%" PRIx64 " is too large to fit in a %" PRIu64 " byte signed integer value", sval64, (uint64_t)byte_size);
             else
             {
                 m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize (byte_size);
                 switch (m_type)

source/Host/CMakeLists.txt

add_host_subdirectory(common
   common/NativeProcessProtocol.cpp
   common/NativeThreadProtocol.cpp
   common/OptionParser.cpp
   common/PipeBase.cpp
   common/ProcessRunLock.cpp
   common/Socket.cpp
   common/SocketAddress.cpp
   common/SoftwareBreakpoint.cpp
+  common/StringConvert.cpp
   common/Symbols.cpp
   common/Terminal.cpp
   common/ThisThread.cpp
   common/ThreadLauncher.cpp
   common/TimeValue.cpp
   )
 
 if (NOT LLDB_DISABLE_LIBEDIT)

source/Host/common/Socket.cpp

 #include "lldb/Host/Socket.h"
 
 #include "lldb/Core/Log.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/SocketAddress.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Host/TimeValue.h"
-#include "lldb/Interpreter/Args.h"
 
 #ifdef __ANDROID_NDK__
 #include <linux/tcp.h>
 #include <bits/error_constants.h>
 #include <asm-generic/errno-base.h>
 #include <errno.h>
 #include <arpa/inet.h>
 #endif

 {
     static RegularExpression g_regex ("([^:]+):([0-9]+)");
     RegularExpression::Match regex_match(2);
     if (g_regex.Execute (host_and_port.data(), &regex_match))
     {
         if (regex_match.GetMatchAtIndex (host_and_port.data(), 1, host_str) &&
             regex_match.GetMatchAtIndex (host_and_port.data(), 2, port_str))
         {
-            port = Args::StringToSInt32 (port_str.c_str(), INT32_MIN);
+            port = StringConvert::ToSInt32 (port_str.c_str(), INT32_MIN);
             if (port != INT32_MIN)
             {
                 if (error_ptr)
                     error_ptr->Clear();
                 return true;
             }
         }
     }
 
     // If this was unsuccessful, then check if it's simply a signed 32-bit integer, representing
     // a port with an empty host.
     host_str.clear();
     port_str.clear();
-    port = Args::StringToSInt32(host_and_port.data(), INT32_MIN);
+    port = StringConvert::ToSInt32(host_and_port.data(), INT32_MIN);
     if (port != INT32_MIN)
     {
         port_str = host_and_port;
         return true;
     }
 
     if (error_ptr)
         error_ptr->SetErrorStringWithFormat("invalid host:port specification: '%s'", host_and_port.data());

source/Host/common/StringConvert.cpp

+//===-- StringConvert.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 <stdlib.h>
+
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/Host/StringConvert.h"
+
+namespace lldb_private {
+
+namespace StringConvert {
+
+int32_t
+ToSInt32 (const char *s, int32_t fail_value, int base, bool *success_ptr)
+{
+    if (s && s[0])
+    {
+        char *end = nullptr;
+        const long sval = ::strtol (s, &end, base);
+        if (*end == '\0')
+        {
+            if (success_ptr)
+                *success_ptr = ((sval <= INT32_MAX) && (sval >= INT32_MIN));
+            return (int32_t)sval; // All characters were used, return the result
+        }
+    }
+    if (success_ptr) *success_ptr = false;
+    return fail_value;
+}
+
+uint32_t
+ToUInt32 (const char *s, uint32_t fail_value, int base, bool *success_ptr)
+{
+    if (s && s[0])
+    {
+        char *end = nullptr;
+        const unsigned long uval = ::strtoul (s, &end, base);
+        if (*end == '\0')
+        {
+            if (success_ptr)
+                *success_ptr = (uval <= UINT32_MAX);
+            return (uint32_t)uval; // All characters were used, return the result
+        }
+    }
+    if (success_ptr) *success_ptr = false;
+    return fail_value;
+}
+
+int64_t
+ToSInt64 (const char *s, int64_t fail_value, int base, bool *success_ptr)
+{
+    if (s && s[0])
+    {
+        char *end = nullptr;
+        int64_t uval = ::strtoll (s, &end, base);
+        if (*end == '\0')
+        {
+            if (success_ptr) *success_ptr = true;
+            return uval; // All characters were used, return the result
+        }
+    }
+    if (success_ptr) *success_ptr = false;
+    return fail_value;
+}
+
+uint64_t
+ToUInt64 (const char *s, uint64_t fail_value, int base, bool *success_ptr)
+{
+    if (s && s[0])
+    {
+        char *end = nullptr;
+        uint64_t uval = ::strtoull (s, &end, base);
+        if (*end == '\0')
+        {
+            if (success_ptr) *success_ptr = true;
+            return uval; // All characters were used, return the result
+        }
+    }
+    if (success_ptr) *success_ptr = false;
+    return fail_value;
+}
+
+}
+}

source/Host/posix/ConnectionFileDescriptorPosix.cpp

 #define _DARWIN_UNLIMITED_SELECT
 #endif
 
 #include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/IOObject.h"
 #include "lldb/Host/SocketAddress.h"
 #include "lldb/Host/Socket.h"
+#include "lldb/Host/StringConvert.h"
 
 // C Includes
 #include <errno.h>
 #include <fcntl.h>
 #include <string.h>
 #include <stdlib.h>
 #include <sys/types.h>
 
if (s && s[0])
         }
 #ifndef LLDB_DISABLE_POSIX
         else if (strstr(s, "fd://") == s)
         {
             // Just passing a native file descriptor within this current process
             // that is already opened (possibly from a service or other source).
             s += strlen("fd://");
             bool success = false;
-            int fd = Args::StringToSInt32(s, -1, 0, &success);
+            int fd = StringConvert::ToSInt32(s, -1, 0, &success);
 
             if (success)
             {
                 // We have what looks to be a valid file descriptor, but we
                 // should make sure it is. We currently are doing this by trying to
                 // get the flags from the file descriptor and making sure it
                 // isn't a bad fd.
                 errno = 0;

source/Interpreter/Args.cpp

 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/DataFormatters/FormatManager.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Target/Process.h"
-//#include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
-//#include "lldb/Target/Thread.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // Args constructor
 //----------------------------------------------------------------------
 Args::Args (const char *command) :

 void
 Args::Clear ()
 {
     m_args.clear ();
     m_argv.clear ();
     m_args_quote_char.clear();
 }
 
-int32_t
-Args::StringToSInt32 (const char *s, int32_t fail_value, int base, bool *success_ptr)
-{
-    if (s && s[0])
-    {
-        char *end = nullptr;
-        const long sval = ::strtol (s, &end, base);
-        if (*end == '\0')
-        {
-            if (success_ptr)
-                *success_ptr = ((sval <= INT32_MAX) && (sval >= INT32_MIN));
-            return (int32_t)sval; // All characters were used, return the result
-        }
-    }
-    if (success_ptr) *success_ptr = false;
-    return fail_value;
-}
-
-uint32_t
-Args::StringToUInt32 (const char *s, uint32_t fail_value, int base, bool *success_ptr)
-{
-    if (s && s[0])
-    {
-        char *end = nullptr;
-        const unsigned long uval = ::strtoul (s, &end, base);
-        if (*end == '\0')
-        {
-            if (success_ptr)
-                *success_ptr = (uval <= UINT32_MAX);
-            return (uint32_t)uval; // All characters were used, return the result
-        }
-    }
-    if (success_ptr) *success_ptr = false;
-    return fail_value;
-}
-
-
-int64_t
-Args::StringToSInt64 (const char *s, int64_t fail_value, int base, bool *success_ptr)
-{
-    if (s && s[0])
-    {
-        char *end = nullptr;
-        int64_t uval = ::strtoll (s, &end, base);
-        if (*end == '\0')
-        {
-            if (success_ptr) *success_ptr = true;
-            return uval; // All characters were used, return the result
-        }
-    }
-    if (success_ptr) *success_ptr = false;
-    return fail_value;
-}
-
-uint64_t
-Args::StringToUInt64 (const char *s, uint64_t fail_value, int base, bool *success_ptr)
-{
-    if (s && s[0])
-    {
-        char *end = nullptr;
-        uint64_t uval = ::strtoull (s, &end, base);
-        if (*end == '\0')
-        {
-            if (success_ptr) *success_ptr = true;
-            return uval; // All characters were used, return the result
-        }
-    }
-    if (success_ptr) *success_ptr = false;
-    return fail_value;
-}
-
 lldb::addr_t
 Args::StringToAddress (const ExecutionContext *exe_ctx, const char *s, lldb::addr_t fail_value, Error *error_ptr)
 {
     bool error_set = false;
     if (s && s[0])
     {
         char *end = nullptr;
         lldb::addr_t addr = ::strtoull (s, &end, 0);
if (s && s[0])
                         if (regex_match.GetMatchAtIndex(s, 1, name))
                         {
                             if (regex_match.GetMatchAtIndex(s, 2, str))
                             {
                                 add = str[0] == '+';
                                 
                                 if (regex_match.GetMatchAtIndex(s, 3, str))
                                 {
-                                    offset = Args::StringToUInt64(str.c_str(), 0, 0, &success);
+                                    offset = StringConvert::ToUInt64(str.c_str(), 0, 0, &success);
                                     
                                     if (success)
                                     {
                                         Error error;
                                         addr = StringToAddress (exe_ctx, name.c_str(), LLDB_INVALID_ADDRESS, &error);
                                         if (addr != LLDB_INVALID_ADDRESS)
                                         {
                                             if (add)

source/Interpreter/CommandHistory.cpp

 //===-- CommandHistory.cpp --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include <inttypes.h>
+
 #include "lldb/Interpreter/CommandHistory.h"
-#include "lldb/Interpreter/Args.h"
+#include "lldb/Host/StringConvert.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 
 CommandHistory::CommandHistory () :
     m_mutex(Mutex::eMutexTypeRecursive),
     m_history()
CommandHistory::FindString (const char* input_str) const
     Mutex::Locker locker(m_mutex);
     if (!input_str)
         return nullptr;
     if (input_str[0] != g_repeat_char)
         return nullptr;
     if (input_str[1] == '-')
     {
         bool success;
-        size_t idx = Args::StringToUInt32 (input_str+2, 0, 0, &success);
+        size_t idx = StringConvert::ToUInt32 (input_str+2, 0, 0, &success);
         if (!success)
             return nullptr;
         if (idx > m_history.size())
             return nullptr;
         idx = m_history.size() - idx;
         return m_history[idx].c_str();
         
     }
     else if (input_str[1] == g_repeat_char)
     {
         if (m_history.empty())
             return nullptr;
         else
             return m_history.back().c_str();
     }
     else
     {
         bool success;
-        uint32_t idx = Args::StringToUInt32 (input_str+1, 0, 0, &success);
+        uint32_t idx = StringConvert::ToUInt32 (input_str+1, 0, 0, &success);
         if (!success)
             return nullptr;
         if (idx >= m_history.size())
             return nullptr;
         return m_history[idx].c_str();
     }
 }
 

source/Interpreter/OptionGroupValueObjectDisplay.cpp

 
 #include "lldb/Interpreter/OptionGroupValueObjectDisplay.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/DataFormatters/ValueObjectPrinter.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Utility/Utils.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 OptionGroupValueObjectDisplay::OptionGroupValueObjectDisplay()
switch (short_option)
         case 'T':   show_types   = true;  break;
         case 'L':   show_location= true;  break;
         case 'F':   flat_output  = true;  break;
         case 'O':   use_objc     = true;  break;
         case 'R':   be_raw       = true;  break;
         case 'A':   ignore_cap   = true;  break;
             
         case 'D':
-            max_depth = Args::StringToUInt32 (option_arg, UINT32_MAX, 0, &success);
+            max_depth = StringConvert::ToUInt32 (option_arg, UINT32_MAX, 0, &success);
             if (!success)
                 error.SetErrorStringWithFormat("invalid max depth '%s'", option_arg);
             break;
             
         case 'P':
-            ptr_depth = Args::StringToUInt32 (option_arg, 0, 0, &success);
+            ptr_depth = StringConvert::ToUInt32 (option_arg, 0, 0, &success);
             if (!success)
                 error.SetErrorStringWithFormat("invalid pointer depth '%s'", option_arg);
             break;
             
         case 'Y':
             if (option_arg)
             {
-                no_summary_depth = Args::StringToUInt32 (option_arg, 0, 0, &success);
+                no_summary_depth = StringConvert::ToUInt32 (option_arg, 0, 0, &success);
                 if (!success)
                     error.SetErrorStringWithFormat("invalid pointer depth '%s'", option_arg);
             }
             else
                 no_summary_depth = 1;
             break;
             
         case 'S':

source/Interpreter/OptionValueArray.cpp

 //===-- OptionValueArray.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/OptionValueArray.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Stream.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/Args.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void
 OptionValueArray::DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask)
 {
if (name && name[0] == '[')
         const char *end_bracket = strchr (name+1, ']');
         if (end_bracket)
         {
             const char *sub_value = nullptr;
             if (end_bracket[1])
                 sub_value = end_bracket + 1;
             std::string index_str (name+1, end_bracket);
             const size_t array_count = m_values.size();
-            int32_t idx = Args::StringToSInt32(index_str.c_str(), INT32_MAX, 0, nullptr);
+            int32_t idx = StringConvert::ToSInt32(index_str.c_str(), INT32_MAX, 0, nullptr);
             if (idx != INT32_MAX)
             {
                 ;
                 uint32_t new_idx = UINT32_MAX;
                 if (idx < 0)
                 {
                     // Access from the end of the array if the index is negative
                     new_idx = array_count - idx;
OptionValueArray::SetArgs (const Args &args, VarSetOperationType op)
     case eVarSetOperationInvalid:
         error.SetErrorString("unsupported operation");
         break;
         
     case eVarSetOperationInsertBefore:
     case eVarSetOperationInsertAfter:
         if (argc > 1)
         {
-            uint32_t idx = Args::StringToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
+            uint32_t idx = StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
             const uint32_t count = GetSize();
             if (idx > count)
             {
                 error.SetErrorStringWithFormat("invalid insert array index %u, index must be 0 through %u", idx, count);
             }
             else
             {
                 if (op == eVarSetOperationInsertAfter)
case eVarSetOperationRemove:
         {
             const uint32_t size = m_values.size();
             std::vector<int> remove_indexes;
             bool all_indexes_valid = true;
             size_t i;
             for (i=0; i<argc; ++i)
             {
                 const size_t idx =
-                  Args::StringToSInt32(args.GetArgumentAtIndex(i), INT32_MAX);
+                  StringConvert::ToSInt32(args.GetArgumentAtIndex(i), INT32_MAX);
                 if (idx >= size)
                 {
                     all_indexes_valid = false;
                     break;
                 }
                 else
                     remove_indexes.push_back(idx);
             }
OptionValueArray::SetArgs (const Args &args, VarSetOperationType op)
         
     case eVarSetOperationClear:
         Clear ();
         break;
         
     case eVarSetOperationReplace:
         if (argc > 1)
         {
-            uint32_t idx = Args::StringToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
+            uint32_t idx = StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
             const uint32_t count = GetSize();
             if (idx > count)
             {
                 error.SetErrorStringWithFormat("invalid replace array index %u, index must be 0 through %u", idx, count);
             }
             else
             {
                 for (size_t i=1; i<argc; ++i, ++idx)

source/Interpreter/OptionValueFileSpecLIst.cpp

 //===-- OptionValueFileSpecList.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/OptionValueFileSpecList.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Stream.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/Args.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void
 OptionValueFileSpecList::DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask)
 {
switch (op)
         case eVarSetOperationClear:
             Clear ();
             NotifyValueChanged();
             break;
             
         case eVarSetOperationReplace:
             if (argc > 1)
             {
-                uint32_t idx = Args::StringToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
+                uint32_t idx = StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
                 const uint32_t count = m_current_value.GetSize();
                 if (idx > count)
                 {
                     error.SetErrorStringWithFormat("invalid file list index %u, index must be 0 through %u", idx, count);
                 }
                 else
                 {
                     for (size_t i=1; i<argc; ++i, ++idx)
switch (op)
                 error.SetErrorString("assign operation takes at least one file path argument");
             }
             break;
             
         case eVarSetOperationInsertBefore:
         case eVarSetOperationInsertAfter:
             if (argc > 1)
             {
-                uint32_t idx = Args::StringToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
+                uint32_t idx = StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
                 const uint32_t count = m_current_value.GetSize();
                 if (idx > count)
                 {
                     error.SetErrorStringWithFormat("invalid insert file list index %u, index must be 0 through %u", idx, count);
                 }
                 else
                 {
                     if (op == eVarSetOperationInsertAfter)
switch (op)
         case eVarSetOperationRemove:
             if (argc > 0)
             {
                 std::vector<int> remove_indexes;
                 bool all_indexes_valid = true;
                 size_t i;
                 for (i=0; all_indexes_valid && i<argc; ++i)
                 {
-                    const int idx = Args::StringToSInt32(args.GetArgumentAtIndex(i), INT32_MAX);
+                    const int idx = StringConvert::ToSInt32(args.GetArgumentAtIndex(i), INT32_MAX);
                     if (idx == INT32_MAX)
                         all_indexes_valid = false;
                     else
                         remove_indexes.push_back(idx);
                 }
                 
                 if (all_indexes_valid)
                 {

source/Interpreter/OptionValuePathMappings.cpp

 //===-- OptionValuePathMappings.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/OptionValuePathMappings.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Stream.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/Args.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void
 OptionValuePathMappings::DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask)
 {
switch (op)
             Clear ();
             NotifyValueChanged();
             break;
             
         case eVarSetOperationReplace:
             // Must be at least one index + 1 pair of paths, and the pair count must be even
             if (argc >= 3 && (((argc - 1) & 1) == 0))
             {
-                uint32_t idx = Args::StringToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
+                uint32_t idx = StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
                 const uint32_t count = m_path_mappings.GetSize();
                 if (idx > count)
                 {
                     error.SetErrorStringWithFormat("invalid file list index %u, index must be 0 through %u", idx, count);
                 }
                 else
                 {
                     for (size_t i=1; i<argc; i += 2, ++idx)
switch (op)
             }
             break;
             
         case eVarSetOperationInsertBefore:
         case eVarSetOperationInsertAfter:
             // Must be at least one index + 1 pair of paths, and the pair count must be even
             if (argc >= 3 && (((argc - 1) & 1) == 0))
             {
-                uint32_t idx = Args::StringToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
+                uint32_t idx = StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
                 const uint32_t count = m_path_mappings.GetSize();
                 if (idx > count)
                 {
                     error.SetErrorStringWithFormat("invalid file list index %u, index must be 0 through %u", idx, count);
                 }
                 else
                 {
                     if (op == eVarSetOperationInsertAfter)
switch (op)
         case eVarSetOperationRemove:
             if (argc > 0)
             {
                 std::vector<int> remove_indexes;
                 bool all_indexes_valid = true;
                 size_t i;
                 for (i=0; all_indexes_valid && i<argc; ++i)
                 {
-                    const int idx = Args::StringToSInt32(args.GetArgumentAtIndex(i), INT32_MAX);
+                    const int idx = StringConvert::ToSInt32(args.GetArgumentAtIndex(i), INT32_MAX);
                     if (idx == INT32_MAX)
                         all_indexes_valid = false;
                     else
                         remove_indexes.push_back(idx);
                 }
                 
                 if (all_indexes_valid)
                 {

source/Interpreter/OptionValueSInt64.cpp

 //===-- OptionValueSInt64.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/OptionValueSInt64.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Stream.h"
-#include "lldb/Interpreter/Args.h"
+#include "lldb/Host/StringConvert.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void
 OptionValueSInt64::DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask)
 {
     //printf ("%p: DumpValue (exe_ctx=%p, strm, mask) m_current_value = %" PRIi64 "\n", this, exe_ctx, m_current_value);
switch (op)
             Clear();
             NotifyValueChanged();
             break;
             
         case eVarSetOperationReplace:
         case eVarSetOperationAssign:
             {
                 bool success = false;
-                int64_t value = Args::StringToSInt64 (value_cstr, 0, 0, &success);
+                int64_t value = StringConvert::ToSInt64 (value_cstr, 0, 0, &success);
                 if (success)
                 {
                     if (value >= m_min_value && value <= m_max_value)
                     {
                         m_value_was_set = true;
                         m_current_value = value;
                         NotifyValueChanged();
                     }

source/Interpreter/OptionValueUInt64.cpp

 //===-- OptionValueUInt64.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/OptionValueUInt64.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Stream.h"
-#include "lldb/Interpreter/Args.h"
+#include "lldb/Host/StringConvert.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 lldb::OptionValueSP
 OptionValueUInt64::Create (const char *value_cstr, Error &error)
 {
     lldb::OptionValueSP value_sp (new OptionValueUInt64());
switch (op)
             Clear ();
             NotifyValueChanged();
             break;
             
         case eVarSetOperationReplace:
         case eVarSetOperationAssign:
         {
             bool success = false;
-            uint64_t value = Args::StringToUInt64 (value_cstr, 0, 0, &success);
+            uint64_t value = StringConvert::ToUInt64 (value_cstr, 0, 0, &success);
             if (success)
             {
                 m_value_was_set = true;
                 m_current_value = value;
                 NotifyValueChanged();
             }
             else
             {

source/Interpreter/Property.cpp

 
 #include "lldb/Interpreter/Property.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/UserSettingsController.h"
-#include "lldb/Interpreter/Args.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionValues.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 Property::Property (const PropertyDefinition &definition) :
     m_name (definition.name),
switch (definition.type)
             m_value_sp.reset (new OptionValueRegex(definition.default_cstr_value, definition.default_uint_value));
             break;
             
         case OptionValue::eTypeSInt64:
             // "definition.default_uint_value" is the default integer value if
             // "definition.default_cstr_value" is NULL, otherwise interpret
             // "definition.default_cstr_value" as a string value that represents the default
             // value.
-            m_value_sp.reset (new OptionValueSInt64(definition.default_cstr_value ? Args::StringToSInt64 (definition.default_cstr_value) : definition.default_uint_value));
+            m_value_sp.reset (new OptionValueSInt64(definition.default_cstr_value ? StringConvert::ToSInt64 (definition.default_cstr_value) : definition.default_uint_value));
             break;
             
         case OptionValue::eTypeUInt64:
             // "definition.default_uint_value" is the default unsigned integer value if
             // "definition.default_cstr_value" is NULL, otherwise interpret
             // "definition.default_cstr_value" as a string value that represents the default
             // value.
-            m_value_sp.reset (new OptionValueUInt64(definition.default_cstr_value ? Args::StringToUInt64 (definition.default_cstr_value) : definition.default_uint_value));
+            m_value_sp.reset (new OptionValueUInt64(definition.default_cstr_value ? StringConvert::ToUInt64 (definition.default_cstr_value) : definition.default_uint_value));
             break;
             
         case OptionValue::eTypeUUID:
             // "definition.default_uint_value" is not used for a OptionValue::eTypeUUID
             // "definition.default_cstr_value" can contain a default UUID value
         {
             UUID uuid;
             if (definition.default_cstr_value)

source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

 #include "lldb/lldb-python.h"
 
 #include "DynamicRegisterInfo.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Interpreter/Args.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/DataFormatters/FormatManager.h"
 
 #ifndef LLDB_DISABLE_PYTHON
 #include "lldb/Interpreter/PythonDataObjects.h"
 #endif
 
//        InvalidateNameMap invalidate_map;
                         {
                             llvm::StringRef reg_name_str;
                             std::string msbit_str;
                             std::string lsbit_str;
                             if (regex_match.GetMatchAtIndex(slice_cstr, 1, reg_name_str) &&
                                 regex_match.GetMatchAtIndex(slice_cstr, 2, msbit_str) &&
                                 regex_match.GetMatchAtIndex(slice_cstr, 3, lsbit_str))
                             {
-                                const uint32_t msbit = Args::StringToUInt32(msbit_str.c_str(), UINT32_MAX);
-                                const uint32_t lsbit = Args::StringToUInt32(lsbit_str.c_str(), UINT32_MAX);
+                                const uint32_t msbit = StringConvert::ToUInt32(msbit_str.c_str(), UINT32_MAX);
+                                const uint32_t lsbit = StringConvert::ToUInt32(lsbit_str.c_str(), UINT32_MAX);
                                 if (msbit != UINT32_MAX && lsbit != UINT32_MAX)
                                 {
                                     if (msbit > lsbit)
                                     {
                                         const uint32_t msbyte = msbit / 8;
                                         const uint32_t lsbyte = lsbit / 8;
 
                                         ConstString containing_reg_name(reg_name_str);

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/Pipe.h"
 #include "lldb/Host/Socket.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Host/TimeValue.h"
 #include "lldb/Target/Process.h"
 
 // Project includes
 #include "ProcessGDBRemoteLog.h"
 
 #if defined(__APPLE__)
if (debugserver_exists)
                     char port_cstr[256];
                     port_cstr[0] = '\0';
                     size_t num_bytes = sizeof(port_cstr);
                     // Read port from pipe with 10 second timeout.
                     error = port_named_pipe.ReadWithTimeout(port_cstr, num_bytes, std::chrono::microseconds(10 * 1000000), num_bytes);
                     if (error.Success())
                     {
                         assert (num_bytes > 0 && port_cstr[num_bytes-1] == '\0');
-                        out_port = Args::StringToUInt32(port_cstr, 0);
+                        out_port = StringConvert::ToUInt32(port_cstr, 0);
                         if (log)
                             log->Printf("GDBRemoteCommunication::%s() debugserver listens %u port", __FUNCTION__, out_port);
                     }
                     else
                     {
                         if (log)
                             log->Printf("GDBRemoteCommunication::%s() failed to read a port value from named pipe %s: %s", __FUNCTION__, named_pipe_path, error.AsCString());
 

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

 #include "lldb/Core/Log.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/StreamGDBRemote.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Host/TimeValue.h"
 #include "lldb/Target/Target.h"
 
 // Project includes
 #include "Utility/StringExtractorGDBRemote.h"
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 #include "lldb/Host/Config.h"
if (m_qGDBServerVersion_is_valid == eLazyBoolCalculate)
                         success = true;
                         m_gdb_server_name.swap(value);
                     }
                     else if (name.compare("version") == 0)
                     {
                         size_t dot_pos = value.find('.');
                         if (dot_pos != std::string::npos)
                             value[dot_pos] = '\0';
-                        const uint32_t version = Args::StringToUInt32(value.c_str(), UINT32_MAX, 0);
+                        const uint32_t version = StringConvert::ToUInt32(value.c_str(), UINT32_MAX, 0);
                         if (version != UINT32_MAX)
                         {
                             success = true;
                             m_gdb_server_version = version;
                         }
                     }
                 }
                 if (success)
if (force || m_qHostInfo_is_valid == eLazyBoolCalculate)
                 StringExtractor extractor;
                 ByteOrder byte_order = eByteOrderInvalid;
                 uint32_t num_keys_decoded = 0;
                 while (response.GetNameColonValue(name, value))
                 {
                     if (name.compare("cputype") == 0)
                     {
                         // exception type in big endian hex
-                        cpu = Args::StringToUInt32 (value.c_str(), LLDB_INVALID_CPUTYPE, 0);
+                        cpu = StringConvert::ToUInt32 (value.c_str(), LLDB_INVALID_CPUTYPE, 0);
                         if (cpu != LLDB_INVALID_CPUTYPE)
                             ++num_keys_decoded;
                     }
                     else if (name.compare("cpusubtype") == 0)
                     {
                         // exception count in big endian hex
-                        sub = Args::StringToUInt32 (value.c_str(), 0, 0);
+                        sub = StringConvert::ToUInt32 (value.c_str(), 0, 0);
                         if (sub != 0)
                             ++num_keys_decoded;
                     }
                     else if (name.compare("arch") == 0)
                     {
                         arch_name.swap (value);
                         ++num_keys_decoded;
                     }
if (force || m_qHostInfo_is_valid == eLazyBoolCalculate)
                             byte_order = eByteOrderBig;
                         else if (value.compare("pdp") == 0)
                             byte_order = eByteOrderPDP;
                         else
                             --num_keys_decoded;
                     }
                     else if (name.compare("ptrsize") == 0)
                     {
-                        pointer_byte_size = Args::StringToUInt32 (value.c_str(), 0, 0);
+                        pointer_byte_size = StringConvert::ToUInt32 (value.c_str(), 0, 0);
                         if (pointer_byte_size != 0)
                             ++num_keys_decoded;
                     }
                     else if (name.compare("os_version") == 0)
                     {
                         Args::StringToVersion (value.c_str(), 
                                                m_os_version_major,
                                                m_os_version_minor,
                                                m_os_version_update);
                         if (m_os_version_major != UINT32_MAX)
                             ++num_keys_decoded;
                     }
                     else if (name.compare("watchpoint_exceptions_received") == 0)
                     {
                         ++num_keys_decoded;
                         if (strcmp(value.c_str(),"before") == 0)
                             m_watchpoints_trigger_after_instruction = eLazyBoolNo;
                         else if (strcmp(value.c_str(),"after") == 0)
                             m_watchpoints_trigger_after_instruction = eLazyBoolYes;
                         else
                             --num_keys_decoded;
                     }
                     else if (name.compare("default_packet_timeout") == 0)
                     {
-                        m_default_packet_timeout = Args::StringToUInt32(value.c_str(), 0);
+                        m_default_packet_timeout = StringConvert::ToUInt32(value.c_str(), 0);
                         if (m_default_packet_timeout > 0)
                         {
                             SetPacketTimeout(m_default_packet_timeout);
                             ++num_keys_decoded;
                         }
                     }
 
                 }
if (m_supports_memory_region_info != eLazyBoolNo)
             std::string value;
             addr_t addr_value;
             bool success = true;
             bool saw_permissions = false;
             while (success && response.GetNameColonValue(name, value))
             {
                 if (name.compare ("start") == 0)
                 {
-                    addr_value = Args::StringToUInt64(value.c_str(), LLDB_INVALID_ADDRESS, 16, &success);
+                    addr_value = StringConvert::ToUInt64(value.c_str(), LLDB_INVALID_ADDRESS, 16, &success);
                     if (success)
                         region_info.GetRange().SetRangeBase(addr_value);
                 }
                 else if (name.compare ("size") == 0)
                 {
-                    addr_value = Args::StringToUInt64(value.c_str(), 0, 16, &success);
+                    addr_value = StringConvert::ToUInt64(value.c_str(), 0, 16, &success);
                     if (success)
                         region_info.GetRange().SetByteSize (addr_value);
                 }
                 else if (name.compare ("permissions") == 0 && region_info.GetRange().IsValid())
                 {
                     saw_permissions = true;
                     if (region_info.GetRange().Contains (addr))
                     {
if (m_supports_watchpoint_support_info != eLazyBoolNo)
         {
             m_supports_watchpoint_support_info = eLazyBoolYes;        
             std::string name;
             std::string value;
             while (response.GetNameColonValue(name, value))
             {
                 if (name.compare ("num") == 0)
                 {
-                    num = Args::StringToUInt32(value.c_str(), 0, 0);
+                    num = StringConvert::ToUInt32(value.c_str(), 0, 0);
                     m_num_supported_hardware_watchpoints = num;
                 }
             }
         }
         else
         {
             m_supports_watchpoint_support_info = eLazyBoolNo;
         }
if (response.IsNormalResponse())
         uint32_t sub = 0;
         std::string vendor;
         std::string os_type;
         
         while (response.GetNameColonValue(name, value))
         {
             if (name.compare("pid") == 0)
             {
-                process_info.SetProcessID (Args::StringToUInt32 (value.c_str(), LLDB_INVALID_PROCESS_ID, 0));
+                process_info.SetProcessID (StringConvert::ToUInt32 (value.c_str(), LLDB_INVALID_PROCESS_ID, 0));
             }
             else if (name.compare("ppid") == 0)
             {
-                process_info.SetParentProcessID (Args::StringToUInt32 (value.c_str(), LLDB_INVALID_PROCESS_ID, 0));
+                process_info.SetParentProcessID (StringConvert::ToUInt32 (value.c_str(), LLDB_INVALID_PROCESS_ID, 0));
             }
             else if (name.compare("uid") == 0)
             {
-                process_info.SetUserID (Args::StringToUInt32 (value.c_str(), UINT32_MAX, 0));
+                process_info.SetUserID (StringConvert::ToUInt32 (value.c_str(), UINT32_MAX, 0));
             }
             else if (name.compare("euid") == 0)
             {
-                process_info.SetEffectiveUserID (Args::StringToUInt32 (value.c_str(), UINT32_MAX, 0));
+                process_info.SetEffectiveUserID (StringConvert::ToUInt32 (value.c_str(), UINT32_MAX, 0));
             }
             else if (name.compare("gid") == 0)
             {
-                process_info.SetGroupID (Args::StringToUInt32 (value.c_str(), UINT32_MAX, 0));
+                process_info.SetGroupID (StringConvert::ToUInt32 (value.c_str(), UINT32_MAX, 0));
             }
             else if (name.compare("egid") == 0)
             {
-                process_info.SetEffectiveGroupID (Args::StringToUInt32 (value.c_str(), UINT32_MAX, 0));
+                process_info.SetEffectiveGroupID (StringConvert::ToUInt32 (value.c_str(), UINT32_MAX, 0));
             }
             else if (name.compare("triple") == 0)
             {
                 StringExtractor extractor;
                 extractor.GetStringRef().swap(value);
                 extractor.SetFilePos(0);
                 extractor.GetHexByteString (value);
                 process_info.GetArchitecture ().SetTriple (value.c_str());
             }
             else if (name.compare("name") == 0)
             {
                 StringExtractor extractor;
                 // The process name from ASCII hex bytes since we can't 
                 // control the characters in a process name
                 extractor.GetStringRef().swap(value);
                 extractor.SetFilePos(0);
                 extractor.GetHexByteString (value);
                 process_info.GetExecutableFile().SetFile (value.c_str(), false);
             }
             else if (name.compare("cputype") == 0)
             {
-                cpu = Args::StringToUInt32 (value.c_str(), LLDB_INVALID_CPUTYPE, 16);
+                cpu = StringConvert::ToUInt32 (value.c_str(), LLDB_INVALID_CPUTYPE, 16);
             }
             else if (name.compare("cpusubtype") == 0)
             {
-                sub = Args::StringToUInt32 (value.c_str(), 0, 16);
+                sub = StringConvert::ToUInt32 (value.c_str(), 0, 16);
             }
             else if (name.compare("vendor") == 0)
             {
                 vendor = value;
             }
             else if (name.compare("ostype") == 0)
             {
                 os_type = value;
if (SendPacketAndWaitForResponse ("qProcessInfo", response, false) == PacketResult::Success)
             StringExtractor extractor;
             ByteOrder byte_order = eByteOrderInvalid;
             uint32_t num_keys_decoded = 0;
             lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
             while (response.GetNameColonValue(name, value))
             {
                 if (name.compare("cputype") == 0)
                 {
-                    cpu = Args::StringToUInt32 (value.c_str(), LLDB_INVALID_CPUTYPE, 16);
+                    cpu = StringConvert::ToUInt32 (value.c_str(), LLDB_INVALID_CPUTYPE, 16);
                     if (cpu != LLDB_INVALID_CPUTYPE)
                         ++num_keys_decoded;
                 }
                 else if (name.compare("cpusubtype") == 0)
                 {
-                    sub = Args::StringToUInt32 (value.c_str(), 0, 16);
+                    sub = StringConvert::ToUInt32 (value.c_str(), 0, 16);
                     if (sub != 0)
                         ++num_keys_decoded;
                 }
                 else if (name.compare("triple") == 0)
                 {
                     StringExtractor extractor;
                     extractor.GetStringRef().swap(value);
                     extractor.SetFilePos(0);
if (SendPacketAndWaitForResponse ("qProcessInfo", response, false) == PacketResult::Success)
                         byte_order = eByteOrderBig;
                     else if (value.compare("pdp") == 0)
                         byte_order = eByteOrderPDP;
                     else
                         --num_keys_decoded;
                 }
                 else if (name.compare("ptrsize") == 0)
                 {
-                    pointer_byte_size = Args::StringToUInt32 (value.c_str(), 0, 16);
+                    pointer_byte_size = StringConvert::ToUInt32 (value.c_str(), 0, 16);
                     if (pointer_byte_size != 0)
                         ++num_keys_decoded;
                 }
                 else if (name.compare("pid") == 0)
                 {
-                    pid = Args::StringToUInt64(value.c_str(), 0, 16);
+                    pid = StringConvert::ToUInt64(value.c_str(), 0, 16);
                     if (pid != LLDB_INVALID_PROCESS_ID)
                         ++num_keys_decoded;
                 }
             }
             if (num_keys_decoded > 0)
                 m_qProcessInfo_is_valid = eLazyBoolYes;
             if (pid != LLDB_INVALID_PROCESS_ID)
             {
GDBRemoteCommunicationClient::LaunchGDBserverAndGetPort (lldb::pid_t &pid, const char *remote_accept_hostname)
     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
     {
         std::string name;
         std::string value;
         uint16_t port = 0;
         while (response.GetNameColonValue(name, value))
         {
             if (name.compare("port") == 0)
-                port = Args::StringToUInt32(value.c_str(), 0, 0);
+                port = StringConvert::ToUInt32(value.c_str(), 0, 0);
             else if (name.compare("pid") == 0)
-                pid = Args::StringToUInt64(value.c_str(), LLDB_INVALID_PROCESS_ID, 0);
+                pid = StringConvert::ToUInt64(value.c_str(), LLDB_INVALID_PROCESS_ID, 0);
         }
         return port;
     }
     return 0;
 }
 
 bool
 GDBRemoteCommunicationClient::KillSpawnedProcess (lldb::pid_t pid)

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.cpp

 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Debug.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Host/File.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Host/TimeValue.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/NativeRegisterContext.h"
 #include "Host/common/NativeProcessProtocol.h"
 #include "Host/common/NativeThreadProtocol.h"
 
if (packet.GetChar() == ':')
                 }
                 else
                 {
                     success = false;
                 }
             }
             else if (key.compare("pid") == 0)
             {
-                match_info.GetProcessInfo().SetProcessID (Args::StringToUInt32(value.c_str(), LLDB_INVALID_PROCESS_ID, 0, &success));
+                match_info.GetProcessInfo().SetProcessID (StringConvert::ToUInt32(value.c_str(), LLDB_INVALID_PROCESS_ID, 0, &success));
             }
             else if (key.compare("parent_pid") == 0)
             {
-                match_info.GetProcessInfo().SetParentProcessID (Args::StringToUInt32(value.c_str(), LLDB_INVALID_PROCESS_ID, 0, &success));
+                match_info.GetProcessInfo().SetParentProcessID (StringConvert::ToUInt32(value.c_str(), LLDB_INVALID_PROCESS_ID, 0, &success));
             }
             else if (key.compare("uid") == 0)
             {
-                match_info.GetProcessInfo().SetUserID (Args::StringToUInt32(value.c_str(), UINT32_MAX, 0, &success));
+                match_info.GetProcessInfo().SetUserID (StringConvert::ToUInt32(value.c_str(), UINT32_MAX, 0, &success));
             }
             else if (key.compare("gid") == 0)
             {
-                match_info.GetProcessInfo().SetGroupID (Args::StringToUInt32(value.c_str(), UINT32_MAX, 0, &success));
+                match_info.GetProcessInfo().SetGroupID (StringConvert::ToUInt32(value.c_str(), UINT32_MAX, 0, &success));
             }
             else if (key.compare("euid") == 0)
             {
-                match_info.GetProcessInfo().SetEffectiveUserID (Args::StringToUInt32(value.c_str(), UINT32_MAX, 0, &success));
+                match_info.GetProcessInfo().SetEffectiveUserID (StringConvert::ToUInt32(value.c_str(), UINT32_MAX, 0, &success));
             }
             else if (key.compare("egid") == 0)
             {
-                match_info.GetProcessInfo().SetEffectiveGroupID (Args::StringToUInt32(value.c_str(), UINT32_MAX, 0, &success));
+                match_info.GetProcessInfo().SetEffectiveGroupID (StringConvert::ToUInt32(value.c_str(), UINT32_MAX, 0, &success));
             }
             else if (key.compare("all_users") == 0)
             {
                 match_info.SetMatchAllUsers(Args::StringToBoolean(value.c_str(), false, &success));
             }
             else if (key.compare("triple") == 0)
             {
                 match_info.GetProcessInfo().GetArchitecture().SetTriple (value.c_str(), NULL);

 {
     packet.SetFilePos(::strlen ("qSpeedTest:"));
 
     std::string key;
     std::string value;
     bool success = packet.GetNameColonValue(key, value);
     if (success && key.compare("response_size") == 0)
     {
-        uint32_t response_size = Args::StringToUInt32(value.c_str(), 0, 0, &success);
+        uint32_t response_size = StringConvert::ToUInt32(value.c_str(), 0, 0, &success);
         if (success)
         {
             if (response_size == 0)
                 return SendOKResponse();
             StreamString response;
             uint32_t bytes_left = response_size;
             response.PutCString("data:");
             while (bytes_left > 0)
if (m_is_platform)
         std::string name;
         std::string value;
         uint16_t port = UINT16_MAX;
         while (packet.GetNameColonValue(name, value))
         {
             if (name.compare ("host") == 0)
                 hostname.swap(value);
             else if (name.compare ("port") == 0)
-                port = Args::StringToUInt32(value.c_str(), 0, 0);
+                port = StringConvert::ToUInt32(value.c_str(), 0, 0);
         }
         if (port == UINT16_MAX)
             port = GetNextAvailablePort();
 
         // Spawn a new thread to accept the port that gets bound after
         // binding to port 0 (zero).
 
         // Spawn a debugserver and try to get the port it listens to.

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

 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/Timer.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Host/HostThread.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Host/TimeValue.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #ifndef LLDB_DISABLE_PYTHON
for (StringExtractorGDBRemote::ResponseType response_type = StringExtractorGDBRemote::eResponse;
                         reg_name.SetCString(value.c_str());
                     }
                     else if (name.compare("alt-name") == 0)
                     {
                         alt_name.SetCString(value.c_str());
                     }
                     else if (name.compare("bitsize") == 0)
                     {
-                        reg_info.byte_size = Args::StringToUInt32(value.c_str(), 0, 0) / CHAR_BIT;
+                        reg_info.byte_size = StringConvert::ToUInt32(value.c_str(), 0, 0) / CHAR_BIT;
                     }
                     else if (name.compare("offset") == 0)
                     {
-                        uint32_t offset = Args::StringToUInt32(value.c_str(), UINT32_MAX, 0);
+                        uint32_t offset = StringConvert::ToUInt32(value.c_str(), UINT32_MAX, 0);
                         if (reg_offset != offset)
                         {
                             reg_offset = offset;
                         }
                     }
                     else if (name.compare("encoding") == 0)
                     {
                         const Encoding encoding = Args::StringToEncoding (value.c_str());
for (StringExtractorGDBRemote::ResponseType response_type = StringExtractorGDBRemote::eResponse;
                             reg_info.format = eFormatVectorOfUInt128;
                     }
                     else if (name.compare("set") == 0)
                     {
                         set_name.SetCString(value.c_str());
                     }
                     else if (name.compare("gcc") == 0)
                     {
-                        reg_info.kinds[eRegisterKindGCC] = Args::StringToUInt32(value.c_str(), LLDB_INVALID_REGNUM, 0);
+                        reg_info.kinds[eRegisterKindGCC] = StringConvert::ToUInt32(value.c_str(), LLDB_INVALID_REGNUM, 0);
                     }
                     else if (name.compare("dwarf") == 0)
                     {
-                        reg_info.kinds[eRegisterKindDWARF] = Args::StringToUInt32(value.c_str(), LLDB_INVALID_REGNUM, 0);
+                        reg_info.kinds[eRegisterKindDWARF] = StringConvert::ToUInt32(value.c_str(), LLDB_INVALID_REGNUM, 0);
                     }
                     else if (name.compare("generic") == 0)
                     {
                         reg_info.kinds[eRegisterKindGeneric] = Args::StringToGenericRegister (value.c_str());
                     }
                     else if (name.compare("container-regs") == 0)
                     {
                         std::pair<llvm::StringRef, llvm::StringRef> value_pair;
                         value_pair.second = value;
                         do
                         {
                             value_pair = value_pair.second.split(',');
                             if (!value_pair.first.empty())
                             {
-                                uint32_t reg = Args::StringToUInt32 (value_pair.first.str().c_str(), LLDB_INVALID_REGNUM, 16);
+                                uint32_t reg = StringConvert::ToUInt32 (value_pair.first.str().c_str(), LLDB_INVALID_REGNUM, 16);
                                 if (reg != LLDB_INVALID_REGNUM)
                                     value_regs.push_back (reg);
                             }
                         } while (!value_pair.second.empty());
                     }
                     else if (name.compare("invalidate-regs") == 0)
                     {
                         std::pair<llvm::StringRef, llvm::StringRef> value_pair;
                         value_pair.second = value;
                         do
                         {
                             value_pair = value_pair.second.split(',');
                             if (!value_pair.first.empty())
                             {
-                                uint32_t reg = Args::StringToUInt32 (value_pair.first.str().c_str(), LLDB_INVALID_REGNUM, 16);
+                                uint32_t reg = StringConvert::ToUInt32 (value_pair.first.str().c_str(), LLDB_INVALID_REGNUM, 16);
                                 if (reg != LLDB_INVALID_REGNUM)
                                     invalidate_regs.push_back (reg);
                             }
                         } while (!value_pair.second.empty());
                     }
                 }
 
                 reg_info.byte_offset = reg_offset;
case 'S':
             ThreadSP thread_sp;
             ThreadGDBRemote *gdb_thread = NULL;
 
             while (stop_packet.GetNameColonValue(name, value))
             {
                 if (name.compare("metype") == 0)
                 {
                     // exception type in big endian hex
-                    exc_type = Args::StringToUInt32 (value.c_str(), 0, 16);
+                    exc_type = StringConvert::ToUInt32 (value.c_str(), 0, 16);
                 }
                 else if (name.compare("medata") == 0)
                 {
                     // exception data in big endian hex
-                    exc_data.push_back(Args::StringToUInt64 (value.c_str(), 0, 16));
+                    exc_data.push_back(StringConvert::ToUInt64 (value.c_str(), 0, 16));
                 }
                 else if (name.compare("thread") == 0)
                 {
                     // thread in big endian hex
-                    lldb::tid_t tid = Args::StringToUInt64 (value.c_str(), LLDB_INVALID_THREAD_ID, 16);
+                    lldb::tid_t tid = StringConvert::ToUInt64 (value.c_str(), LLDB_INVALID_THREAD_ID, 16);
                     // m_thread_list_real does have its own mutex, but we need to
                     // hold onto the mutex between the call to m_thread_list_real.FindThreadByID(...)
                     // and the m_thread_list_real.AddThread(...) so it doesn't change on us
                     Mutex::Locker locker (m_thread_list_real.GetMutex ());
                     thread_sp = m_thread_list_real.FindThreadByProtocolID(tid, false);
 
                     if (!thread_sp)
                     {
case 'S':
                     // process that includes the thread for this stop reply
                     // packet
                     size_t comma_pos;
                     lldb::tid_t tid;
                     while ((comma_pos = value.find(',')) != std::string::npos)
                     {
                         value[comma_pos] = '\0';
                         // thread in big endian hex
-                        tid = Args::StringToUInt64 (value.c_str(), LLDB_INVALID_THREAD_ID, 16);
+                        tid = StringConvert::ToUInt64 (value.c_str(), LLDB_INVALID_THREAD_ID, 16);
                         if (tid != LLDB_INVALID_THREAD_ID)
                             m_thread_ids.push_back (tid);
                         value.erase(0, comma_pos + 1);
                     }
-                    tid = Args::StringToUInt64 (value.c_str(), LLDB_INVALID_THREAD_ID, 16);
+                    tid = StringConvert::ToUInt64 (value.c_str(), LLDB_INVALID_THREAD_ID, 16);
                     if (tid != LLDB_INVALID_THREAD_ID)
                         m_thread_ids.push_back (tid);
                 }
                 else if (name.compare("hexname") == 0)
                 {
                     StringExtractor name_extractor;
                     // Swap "value" over into "name_extractor"
                     name_extractor.GetStringRef().swap(value);
                     // Now convert the HEX bytes into a string value
                     name_extractor.GetHexByteString (value);
                     thread_name.swap (value);
                 }
                 else if (name.compare("name") == 0)
                 {
                     thread_name.swap (value);
                 }
                 else if (name.compare("qaddr") == 0)
                 {
-                    thread_dispatch_qaddr = Args::StringToUInt64 (value.c_str(), 0, 16);
+                    thread_dispatch_qaddr = StringConvert::ToUInt64 (value.c_str(), 0, 16);
                 }
                 else if (name.compare("reason") == 0)
                 {
                     reason.swap(value);
                 }
                 else if (name.compare("description") == 0)
                 {
                     StringExtractor desc_extractor;
                     // Swap "value" over into "name_extractor"
                     desc_extractor.GetStringRef().swap(value);
                     // Now convert the HEX bytes into a string value
                     desc_extractor.GetHexByteString (thread_name);
                 }
                 else if (name.size() == 2 && ::isxdigit(name[0]) && ::isxdigit(name[1]))
                 {
                     // We have a register number that contains an expedited
                     // register value. Lets supply this register to our thread
                     // so it won't have to go and read it.
                     if (gdb_thread)
                     {
-                        uint32_t reg = Args::StringToUInt32 (name.c_str(), UINT32_MAX, 16);
+                        uint32_t reg = StringConvert::ToUInt32 (name.c_str(), UINT32_MAX, 16);
 
                         if (reg != UINT32_MAX)
                         {
                             StringExtractor reg_value_extractor;
                             // Swap "value" over into "reg_value_extractor"
                             reg_value_extractor.GetStringRef().swap(value);
                             if (!gdb_thread->PrivateSetRegisterValue (reg, reg_value_extractor))
                             {

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

 //===-- DWARFCompileUnit.cpp ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFCompileUnit.h"
 
 #include "lldb/Core/Mangled.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/Timer.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
if (die)
             else if (strstr(producer_cstr, "clang"))
             {
                 static RegularExpression g_clang_version_regex("clang-([0-9]+)\\.([0-9]+)\\.([0-9]+)");
                 RegularExpression::Match regex_match(3);
                 if (g_clang_version_regex.Execute (producer_cstr, &regex_match))
                 {
                     std::string str;
                     if (regex_match.GetMatchAtIndex (producer_cstr, 1, str))
-                        m_producer_version_major = Args::StringToUInt32(str.c_str(), UINT32_MAX, 10);
+                        m_producer_version_major = StringConvert::ToUInt32(str.c_str(), UINT32_MAX, 10);
                     if (regex_match.GetMatchAtIndex (producer_cstr, 2, str))
-                        m_producer_version_minor = Args::StringToUInt32(str.c_str(), UINT32_MAX, 10);
+                        m_producer_version_minor = StringConvert::ToUInt32(str.c_str(), UINT32_MAX, 10);
                     if (regex_match.GetMatchAtIndex (producer_cstr, 3, str))
-                        m_producer_version_update = Args::StringToUInt32(str.c_str(), UINT32_MAX, 10);
+                        m_producer_version_update = StringConvert::ToUInt32(str.c_str(), UINT32_MAX, 10);
                 }
                 m_producer = eProducerClang;
             }
             else if (strstr(producer_cstr, "GNU"))
                 m_producer = eProducerGCC;
         }
     }
     if (m_producer == eProducerInvalid)

source/Symbol/SymbolContext.cpp

 //===-- SymbolContext.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/Symbol/SymbolContext.h"
 
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/Host.h"
-#include "lldb/Interpreter/Args.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/Target.h"
case eModuleSpecified:
         break;
     case eFileSpecified:
         // CompUnits can't necessarily be resolved here, since an inlined function might show up in 
         // a number of CompUnits.  Instead we just convert to a FileSpec and store it away.
         m_file_spec_ap.reset (new FileSpec (spec_string, false));
         m_type |= eFileSpecified;
         break;
     case eLineStartSpecified:
-        m_start_line = Args::StringToSInt32(spec_string, 0, 0, &return_value);
+        m_start_line = StringConvert::ToSInt32(spec_string, 0, 0, &return_value);
         if (return_value)
             m_type |= eLineStartSpecified;
         break;
     case eLineEndSpecified:
-        m_end_line = Args::StringToSInt32(spec_string, 0, 0, &return_value);
+        m_end_line = StringConvert::ToSInt32(spec_string, 0, 0, &return_value);
         if (return_value)
             m_type |= eLineEndSpecified;
         break;
     case eFunctionSpecified:
         m_function_spec.assign(spec_string);
         m_type |= eFunctionSpecified;
         break;
     case eClassOrNamespaceSpecified:

source/Target/UnixSignals.cpp

 //===-- UnixSignals.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/Target/UnixSignals.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Interpreter/Args.h"
+#include "lldb/Host/StringConvert.h"
 
 using namespace lldb_private;
 
 UnixSignals::Signal::Signal 
 (
     const char *name, 
     const char *short_name, 
     bool default_suppress, 
UnixSignals::GetSignalNumberFromName (const char *name) const
 
     collection::const_iterator pos, end = m_signals.end ();
     for (pos = m_signals.begin (); pos != end; pos++)
     {
         if ((const_name == pos->second.m_name) || (const_name == pos->second.m_short_name))
             return pos->first;
     }
     
-    const int32_t signo = Args::StringToSInt32(name, LLDB_INVALID_SIGNAL_NUMBER, 0);
+    const int32_t signo = StringConvert::ToSInt32(name, LLDB_INVALID_SIGNAL_NUMBER, 0);
     if (signo != LLDB_INVALID_SIGNAL_NUMBER)
         return signo;
     return LLDB_INVALID_SIGNAL_NUMBER;
 }
 
 int32_t
 UnixSignals::GetFirstSignalNumber () const
 {

tools/lldb-gdbserver/lldb-gdbserver.cpp

if (host_and_port && host_and_port[0])
             final_host_and_port.append ("localhost");
         final_host_and_port.append (host_and_port);
 
         const std::string::size_type colon_pos = final_host_and_port.find (':');
         if (colon_pos != std::string::npos)
         {
             connection_host = final_host_and_port.substr (0, colon_pos);
             connection_port = final_host_and_port.substr (colon_pos + 1);
-            connection_portno = Args::StringToUInt32 (connection_port.c_str (), 0);
+            connection_portno = StringConvert::ToUInt32 (connection_port.c_str (), 0);
         }
         else
         {
             fprintf (stderr, "failed to parse host and port from connection string '%s'\n", final_host_and_port.c_str ());
             display_usage (progname);
             exit (1);
         }