Diff 20999

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

Show All 12 Lines
// C Includes		// C Includes
// C++ Includes		// C++ Includes
#include <list>		#include <list>
#include <string>		#include <string>
#include <vector>		#include <vector>
#include <utility>		#include <utility>

// Other libraries and framework includes		// Other libraries and framework includes
		#include "llvm/ADT/StringRef.h"
// Project includes		// Project includes
#include "lldb/lldb-private-types.h"		#include "lldb/lldb-private-types.h"
#include "lldb/lldb-types.h"		#include "lldb/lldb-types.h"
#include "lldb/Core/Error.h"		#include "lldb/Core/Error.h"
#include "lldb/Host/OptionParser.h"		#include "lldb/Host/OptionParser.h"

namespace lldb_private {		namespace lldb_private {

▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines	public:

//------------------------------------------------------------------		//------------------------------------------------------------------
/// Construct with an option command string.		/// Construct with an option command string.
///		///
/// @param[in] command		/// @param[in] command
/// A NULL terminated command that will be copied and split up		/// A NULL terminated command that will be copied and split up
/// into arguments.		/// into arguments.
///		///
/// @see Args::SetCommandString(const char *)		/// @see Args::SetCommandString(llvm::StringRef)
//------------------------------------------------------------------		//------------------------------------------------------------------
Args (const char *command = NULL);		Args (llvm::StringRef command = llvm::StringRef());

Args (const char *command, size_t len);

Args (const Args &rhs);		Args (const Args &rhs);

const Args &		const Args &
operator= (const Args &rhs);		operator= (const Args &rhs);

//------------------------------------------------------------------		//------------------------------------------------------------------
/// Destructor.		/// Destructor.
Show All 12 Lines	public:

//------------------------------------------------------------------		//------------------------------------------------------------------
/// Sets the command string contained by this object.		/// Sets the command string contained by this object.
///		///
/// The command string will be copied and split up into arguments		/// The command string will be copied and split up into arguments
/// that can be accessed via the accessor functions.		/// that can be accessed via the accessor functions.
///		///
/// @param[in] command		/// @param[in] command
/// A NULL terminated command that will be copied and split up		/// A command StringRef that will be copied and split up
/// into arguments.		/// into arguments.
///		///
/// @see Args::GetArgumentCount() const		/// @see Args::GetArgumentCount() const
/// @see Args::GetArgumentAtIndex (size_t) const		/// @see Args::GetArgumentAtIndex (size_t) const
/// @see Args::GetArgumentVector ()		/// @see Args::GetArgumentVector ()
/// @see Args::Shift ()		/// @see Args::Shift ()
/// @see Args::Unshift (const char *)		/// @see Args::Unshift (const char *)
//------------------------------------------------------------------		//------------------------------------------------------------------
void		void
SetCommandString (const char *command);		SetCommandString (llvm::StringRef command);

void
SetCommandString (const char *command, size_t len);

bool		bool
GetCommandString (std::string &command) const;		GetCommandString (std::string &command) const;

bool		bool
GetQuotedCommandString (std::string &command) const;		GetQuotedCommandString (std::string &command) const;

//------------------------------------------------------------------		//------------------------------------------------------------------
▲ Show 20 Lines • Show All 311 Lines • ▼ Show 20 Lines	protected:
arg_cstr_collection m_argv; ///< The current argument vector.		arg_cstr_collection m_argv; ///< The current argument vector.
arg_quote_char_collection m_args_quote_char;		arg_quote_char_collection m_args_quote_char;

void		void
UpdateArgsAfterOptionParsing ();		UpdateArgsAfterOptionParsing ();

void		void
UpdateArgvFromArgs ();		UpdateArgvFromArgs ();

		llvm::StringRef
		ParseSingleArgument (llvm::StringRef command);
};		};

} // namespace lldb_private		} // namespace lldb_private

#endif // liblldb_Command_h_		#endif // liblldb_Command_h_

lldb/trunk/source/Commands/CommandObjectExpression.cpp

Show First 20 Lines • Show All 481 Lines • ▼ Show 20 Lines	if (command[0] == '-')
break;		break;
}		}
}		}
s = end_options;		s = end_options;
}		}

if (end_options)		if (end_options)
{		{
Args args (command, end_options - command);		Args args (llvm::StringRef(command, end_options - command));
if (!ParseOptions (args, result))		if (!ParseOptions (args, result))
return false;		return false;

Error error (m_option_group.NotifyOptionParsingFinished());		Error error (m_option_group.NotifyOptionParsingFinished());
if (error.Fail())		if (error.Fail())
{		{
result.AppendError (error.AsCString());		result.AppendError (error.AsCString());
result.SetStatus (eReturnStatusFailed);		result.SetStatus (eReturnStatusFailed);
Show All 22 Lines

lldb/trunk/source/Commands/CommandObjectPlatform.cpp

Show First 20 Lines • Show All 2,136 Lines • ▼ Show 20 Lines	DoExecute (const char *raw_command_line, CommandReturnObject &result)
break;		break;
}		}
}		}
s = end_options;		s = end_options;
}		}

if (end_options)		if (end_options)
{		{
Args args (raw_command_line, end_options - raw_command_line);		Args args (llvm::StringRef(raw_command_line, end_options - raw_command_line));
if (!ParseOptions (args, result))		if (!ParseOptions (args, result))
return false;		return false;
}		}
}		}

if (expr == NULL)		if (expr == NULL)
expr = raw_command_line;		expr = raw_command_line;

▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectWatchpoint.cpp

Show First 20 Lines • Show All 1,205 Lines • ▼ Show 20 Lines	DoExecute (const char *raw_command, CommandReturnObject &result)
break;		break;
}		}
}		}
s = end_options;		s = end_options;
}		}

if (end_options)		if (end_options)
{		{
Args args (raw_command, end_options - raw_command);		Args args (llvm::StringRef(raw_command, end_options - raw_command));
if (!ParseOptions (args, result))		if (!ParseOptions (args, result))
return false;		return false;

Error error (m_option_group.NotifyOptionParsingFinished());		Error error (m_option_group.NotifyOptionParsingFinished());
if (error.Fail())		if (error.Fail())
{		{
result.AppendError (error.AsCString());		result.AppendError (error.AsCString());
result.SetStatus (eReturnStatusFailed);		result.SetStatus (eReturnStatusFailed);
▲ Show 20 Lines • Show All 167 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/Args.cpp

Show All 27 Lines
#include "lldb/Target/Target.h"		#include "lldb/Target/Target.h"

using namespace lldb;		using namespace lldb;
using namespace lldb_private;		using namespace lldb_private;

//----------------------------------------------------------------------		//----------------------------------------------------------------------
// Args constructor		// Args constructor
//----------------------------------------------------------------------		//----------------------------------------------------------------------
Args::Args (const char *command) :		Args::Args (llvm::StringRef command) :
m_args(),		m_args(),
m_argv(),		m_argv(),
m_args_quote_char()		m_args_quote_char()
{		{
if (command)
SetCommandString (command);		SetCommandString (command);
}		}


Args::Args (const char *command, size_t len) :
m_args(),
m_argv(),
m_args_quote_char()
{
if (command && len)
SetCommandString (command, len);
}

//----------------------------------------------------------------------		//----------------------------------------------------------------------
// We have to be very careful on the copy constructor of this class		// We have to be very careful on the copy constructor of this class
// to make sure we copy all of the string values, but we can't copy the		// to make sure we copy all of the string values, but we can't copy the
// rhs.m_argv into m_argv since it will point to the "const char *" c		// rhs.m_argv into m_argv since it will point to the "const char *" c
// strings in rhs.m_args. We need to copy the string list and update our		// strings in rhs.m_args. We need to copy the string list and update our
// own m_argv appropriately.		// own m_argv appropriately.
//----------------------------------------------------------------------		//----------------------------------------------------------------------
Args::Args (const Args &rhs) :		Args::Args (const Args &rhs) :
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines	for (size_t i = 0; i < argc; ++i)
command.append (1, quote_char);		command.append (1, quote_char);
}		}
else		else
command.append (m_argv[i]);		command.append (m_argv[i]);
}		}
return argc > 0;		return argc > 0;
}		}

void		// A helper function for argument parsing.
Args::SetCommandString (const char *command, size_t len)		// Parses the initial part of the first argument using normal double quote rules:
		// backslash escapes the double quote and itself. The parsed string is appended to the second
		// argument. The function returns the unparsed portion of the string, starting at the closing
		// quote.
		static llvm::StringRef
		ParseDoubleQuotes(llvm::StringRef quoted, std::string &result)
{		{
// Use std::string to make sure we get a NULL terminated string we can use		// Inside double quotes, '\' and '"' are special.
// as "command" could point to a string within a large string....		static const char *k_escapable_characters = "\"\\";
std::string null_terminated_command(command, len);		while (true)
SetCommandString(null_terminated_command.c_str());
}

void
Args::SetCommandString (const char *command)
{		{
m_args.clear();		// Skip over over regular characters and append them.
m_argv.clear();		size_t regular = quoted.find_first_of(k_escapable_characters);
m_args_quote_char.clear();		result += quoted.substr(0, regular);
		quoted = quoted.substr(regular);

if (command && command[0])		// If we have reached the end of string or the closing quote, we're done.
		if (quoted.empty() \|\| quoted.front() == '"')
		break;

		// We have found a backslash.
		quoted = quoted.drop_front();

		if (quoted.empty())
{		{
static const char *k_space_separators = " \t";		// A lone backslash at the end of string, let's just append it.
static const char *k_escapable_characters = " \t\\'\"";		result += '\\';
const char *arg_end = nullptr;
const char *arg_pos;
for (arg_pos = command;
arg_pos && arg_pos[0];
arg_pos = arg_end)
{
// Skip any leading space separators
const char *arg_start = ::strspn (arg_pos, k_space_separators) + arg_pos;

// If there were only space separators to the end of the line, then
// we're done.
if (*arg_start == '\0')
break;		break;
		}

		// If the character after the backslash is not a whitelisted escapable character, we
		// leave the character sequence untouched.
		if (strchr(k_escapable_characters, quoted.front()) == nullptr)
		result += '\\';

		result += quoted.front();
		quoted = quoted.drop_front();
		}

// Arguments can be split into multiple discontiguous pieces,		return quoted;
		}

		// A helper function for SetCommandString.
		// Parses a single argument from the command string, processing quotes and backslashes in a
		// shell-like manner. The parsed argument is appended to the m_args array. The function returns
		// the unparsed portion of the string, starting at the first unqouted, unescaped whitespace
		// character.
		llvm::StringRef
		Args::ParseSingleArgument(llvm::StringRef command)
		{
		// Argument can be split into multiple discontiguous pieces,
// for example:		// for example:
// "Hello ""World"		// "Hello ""World"
// this would result in a single argument "Hello World" (without/		// this would result in a single argument "Hello World" (without/
// the quotes) since the quotes would be removed and there is		// the quotes) since the quotes would be removed and there is
// not space between the strings. So we need to keep track of the		// not space between the strings.
// current start of each argument piece in "arg_piece_start"
const char *arg_piece_start = arg_start;
arg_pos = arg_piece_start;

std::string arg;		std::string arg;

// Since we can have multiple quotes that form a single command		// Since we can have multiple quotes that form a single command
// in a command like: "Hello "world'!' (which will make a single		// in a command like: "Hello "world'!' (which will make a single
// argument "Hello world!") we remember the first quote character		// argument "Hello world!") we remember the first quote character
// we encounter and use that for the quote character.		// we encounter and use that for the quote character.
char first_quote_char = '\0';		char first_quote_char = '\0';
char quote_char = '\0';
bool arg_complete = false;

		bool arg_complete = false;
do		do
{		{
arg_end = ::strcspn (arg_pos, k_escapable_characters) + arg_pos;		// Skip over over regular characters and append them.
		size_t regular = command.find_first_of(" \t\"'`\\");
		arg += command.substr(0, regular);
		command = command.substr(regular);

switch (arg_end[0])		if (command.empty())
{
default:
assert (!"Unhandled case statement, we must handle this...");
break;		break;

case '\0':		char special = command.front();
// End of C string		command = command.drop_front();
if (arg_piece_start && arg_piece_start[0])		switch (special)
arg.append (arg_piece_start);		{
arg_complete = true;
break;
case '\\':		case '\\':
// Backslash character		if (command.empty())
switch (arg_end[1])
{		{
case '\0':		arg += '\\';
arg.append (arg_piece_start);
++arg_end;
arg_complete = true;
break;		break;
		}

default:		// If the character after the backslash is not a whitelisted escapable character, we
// Only consider this two-character sequence an escape sequence if we're unquoted and
// the character after the backslash is a whitelisted escapable character. Otherwise
// leave the character sequence untouched.		// leave the character sequence untouched.
if (quote_char == '\0' && (nullptr != strchr(k_escapable_characters, arg_end[1])))		static const char *k_escapable_characters = " \t\\'\"`";
{		if (strchr(k_escapable_characters, command.front()) == nullptr)
arg.append (arg_piece_start, arg_end - arg_piece_start);		arg += '\\';
arg.append (arg_end + 1, 1);
arg_pos = arg_end + 2;		arg += command.front();
arg_piece_start = arg_pos;		command.drop_front();
}
else
arg_pos = arg_end + 2;
break;		break;
}
		case ' ':
		case '\t':
		// We are not inside any quotes, we just found a space after an
		// argument. We are done.
		arg_complete = true;
break;		break;

case '"':		case '"':
case '\'':		case '\'':
case '`':		case '`':
// Quote characters
if (quote_char)
{
// We found a quote character while inside a quoted
// character argument. If it matches our current quote
// character, this ends the effect of the quotes. If it
// doesn't we ignore it.
if (quote_char == arg_end[0])
{
arg.append (arg_piece_start, arg_end - arg_piece_start);
// Clear the quote character and let parsing
// continue (we need to watch for things like:
// "Hello ""World"
// "Hello "World
// "Hello "'World'
// All of which will result in a single argument "Hello World"
quote_char = '\0'; // Note that we are no longer inside quotes
arg_pos = arg_end + 1; // Skip the quote character
arg_piece_start = arg_pos; // Note we are starting from later in the string
}
else
{
// different quote, skip it and keep going
arg_pos = arg_end + 1;
}
}
else
{
// We found the start of a quote scope.		// We found the start of a quote scope.
// Make sure there isn't a string that precedes
// the start of a quote scope like:
// Hello" World"
// If so, then add the "Hello" to the arg
if (arg_end > arg_piece_start)
arg.append (arg_piece_start, arg_end - arg_piece_start);

// Enter into a quote scope
quote_char = arg_end[0];

if (first_quote_char == '\0')		if (first_quote_char == '\0')
first_quote_char = quote_char;		first_quote_char = special;

arg_pos = arg_end;		if (special == '"')
++arg_pos; // Skip the quote character		command = ParseDoubleQuotes(command, arg);
arg_piece_start = arg_pos; // Note we are starting from later in the string

// Skip till the next quote character
const char *end_quote = ::strchr (arg_piece_start, quote_char);
while (end_quote && end_quote[-1] == '\\')
{
// Don't skip the quote character if it is
// preceded by a '\' character
end_quote = ::strchr (end_quote + 1, quote_char);
}

if (end_quote)
{
if (end_quote > arg_piece_start)
arg.append (arg_piece_start, end_quote - arg_piece_start);

// If the next character is a space or the end of
// string, this argument is complete...
if (end_quote[1] == ' ' \|\| end_quote[1] == '\t' \|\| end_quote[1] == '\0')
{
arg_complete = true;
arg_end = end_quote + 1;
}
else		else
{		{
arg_pos = end_quote + 1;		// For single quotes, we simply skip ahead to the matching quote character
arg_piece_start = arg_pos;		// (or the end of the string).
}		size_t quoted = command.find(special);
quote_char = '\0';		arg += command.substr(0, quoted);
}		command = command.substr(quoted);
else
{
// Consume the rest of the string as there was no terminating quote
arg.append(arg_piece_start);
arg_end = arg_piece_start + strlen(arg_piece_start);
arg_complete = true;
}
}		}
break;

case ' ':		// If we found a closing quote, skip it.
case '\t':		if (! command.empty())
if (quote_char)		command = command.drop_front();
{
// We are currently processing a quoted character and found
// a space character, skip any spaces and keep trying to find
// the end of the argument.
arg_pos = ::strspn (arg_end, k_space_separators) + arg_end;
}
else
{
// We are not inside any quotes, we just found a space after an
// argument
if (arg_end > arg_piece_start)
arg.append (arg_piece_start, arg_end - arg_piece_start);
arg_complete = true;
}
break;		break;
}		}
} while (!arg_complete);		} while (!arg_complete);

m_args.push_back(arg);		m_args.push_back(arg);
m_args_quote_char.push_back (first_quote_char);		m_args_quote_char.push_back (first_quote_char);
		return command;
}		}
UpdateArgvFromArgs();
		void
		Args::SetCommandString (llvm::StringRef command)
		{
		m_args.clear();
		m_argv.clear();
		m_args_quote_char.clear();

		static const char *k_space_separators = " \t";
		command = command.ltrim(k_space_separators);
		while (!command.empty())
		{
		command = ParseSingleArgument(command);
		command = command.ltrim(k_space_separators);
}		}

		UpdateArgvFromArgs();
}		}

void		void
Args::UpdateArgsAfterOptionParsing()		Args::UpdateArgsAfterOptionParsing()
{		{
// Now m_argv might be out of date with m_args, so we need to fix that		// Now m_argv might be out of date with m_args, so we need to fix that
arg_cstr_collection::const_iterator argv_pos, argv_end = m_argv.end();		arg_cstr_collection::const_iterator argv_pos, argv_end = m_argv.end();
arg_sstr_collection::iterator args_pos;		arg_sstr_collection::iterator args_pos;
▲ Show 20 Lines • Show All 1,373 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/CommandInterpreter.cpp

Show First 20 Lines • Show All 1,406 Lines • ▼ Show 20 Lines

CommandObject *		CommandObject *
CommandInterpreter::BuildAliasResult (const char *alias_name,		CommandInterpreter::BuildAliasResult (const char *alias_name,
std::string &raw_input_string,		std::string &raw_input_string,
std::string &alias_result,		std::string &alias_result,
CommandReturnObject &result)		CommandReturnObject &result)
{		{
CommandObject *alias_cmd_obj = nullptr;		CommandObject *alias_cmd_obj = nullptr;
Args cmd_args (raw_input_string.c_str());		Args cmd_args (raw_input_string);
alias_cmd_obj = GetCommandObject (alias_name);		alias_cmd_obj = GetCommandObject (alias_name);
StreamString result_str;		StreamString result_str;

if (alias_cmd_obj)		if (alias_cmd_obj)
{		{
std::string alias_name_str = alias_name;		std::string alias_name_str = alias_name;
if ((cmd_args.GetArgumentCount() == 0)		if ((cmd_args.GetArgumentCount() == 0)
\|\| (alias_name_str.compare (cmd_args.GetArgumentAtIndex(0)) != 0))		\|\| (alias_name_str.compare (cmd_args.GetArgumentAtIndex(0)) != 0))
▲ Show 20 Lines • Show All 653 Lines • ▼ Show 20 Lines	CommandInterpreter::HandleCompletion (const char *current_line,
const char *last_char,		const char *last_char,
int match_start_point,		int match_start_point,
int max_return_elements,		int max_return_elements,
StringList &matches)		StringList &matches)
{		{
// We parse the argument up to the cursor, so the last argument in parsed_line is		// We parse the argument up to the cursor, so the last argument in parsed_line is
// the one containing the cursor, and the cursor is after the last character.		// the one containing the cursor, and the cursor is after the last character.

Args parsed_line(current_line, last_char - current_line);		Args parsed_line(llvm::StringRef(current_line, last_char - current_line));
Args partial_parsed_line(current_line, cursor - current_line);		Args partial_parsed_line(llvm::StringRef(current_line, cursor - current_line));

// Don't complete comments, and if the line we are completing is just the history repeat character,		// Don't complete comments, and if the line we are completing is just the history repeat character,
// substitute the appropriate history line.		// substitute the appropriate history line.
const char *first_arg = parsed_line.GetArgumentAtIndex(0);		const char *first_arg = parsed_line.GetArgumentAtIndex(0);
if (first_arg)		if (first_arg)
{		{
if (first_arg[0] == m_comment_char)		if (first_arg[0] == m_comment_char)
return 0;		return 0;
▲ Show 20 Lines • Show All 1,286 Lines • Show Last 20 Lines

lldb/trunk/test/settings/quoting/Makefile

				LEVEL = ../../make

				C_SOURCES := main.c

				include $(LEVEL)/Makefile.rules

lldb/trunk/test/settings/quoting/TestQuoting.py

				"""
				Test quoting of arguments to lldb commands
				"""

				import os, time, re
				import unittest2
				import lldb
				from lldbtest import *

				class SettingsCommandTestCase(TestBase):

				mydir = TestBase.compute_mydir(__file__)

				@classmethod
				def classCleanup(cls):
				"""Cleanup the test byproducts."""
				cls.RemoveTempFile("stdout.txt")

				def test_no_quote(self):
				self.do_test_args("a b c", "a\0b\0c\0")

				def test_single_quote(self):
				self.do_test_args("'a b c'", "a b c\0")

				def test_double_quote(self):
				self.do_test_args('"a b c"', "a b c\0")

				def test_double_quote(self):
				self.do_test_args('"a b c"', 'a b c\0')

				def test_single_quote_escape(self):
				self.do_test_args("'a b\\' c", "a b\\\0c\0")

				def test_double_quote_escape(self):
				self.do_test_args('"a b\\" c"', 'a b" c\0')

				def test_double_quote_escape(self):
				self.do_test_args('"a b\\" c"', 'a b" c\0')

				def test_double_quote_escape2(self):
				self.do_test_args('"a b\\\\" c', 'a b\\\0c\0')

				def test_double_quote_escape2(self):
				self.do_test_args('"a b\\\\" c', 'a b\\\0c\0')

				def test_single_in_double(self):
				self.do_test_args('"a\'b"', "a'b\0")

				def test_double_in_single(self):
				self.do_test_args("'a\"b'", 'a"b\0')

				def test_combined(self):
				self.do_test_args('"a b"c\'d e\'', 'a bcd e\0')

				def test_bare_single(self):
				self.do_test_args("a\\'b", "a'b\0")

				def test_bare_double(self):
				self.do_test_args('a\\"b', 'a"b\0')

				def do_test_args(self, args_in, args_out):
				"""Test argument parsing. Run the program with args_in. The program dumps its arguments
				to stdout. Compare the stdout with args_out."""
				self.buildDefault()

				exe = os.path.join(os.getcwd(), "a.out")
				self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)

				self.runCmd("process launch -o stdout.txt -- " + args_in)

				with open('stdout.txt', 'r') as f:
				output = f.read()

				self.RemoveTempFile("stdout.txt")

				self.assertEqual(output, args_out)

				if __name__ == '__main__':
				import atexit
				lldb.SBDebugger.Initialize()
				atexit.register(lambda: lldb.SBDebugger.Terminate())
				unittest2.main()

lldb/trunk/test/settings/quoting/main.c

				#include <stdio.h>
				#include <string.h>

				/* This program writes its arguments (separated by '\0') to stdout. */
				int
				main(int argc, char const *argv[])
				{
				int i;
				for (i = 1; i < argc; ++i)
				fwrite(argv[i], strlen(argv[i])+1, 1, stdout);

				return 0;
				}

This is an archive of the discontinued LLVM Phabricator instance.

Fix handling of backslashes in Args parsing
ClosedPublic

Details

Diff Detail

Event Timeline

Arguments

Revision Contents

Diff 20999

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

lldb/trunk/source/Commands/CommandObjectExpression.cpp

lldb/trunk/source/Commands/CommandObjectPlatform.cpp

lldb/trunk/source/Commands/CommandObjectWatchpoint.cpp

lldb/trunk/source/Interpreter/Args.cpp

lldb/trunk/source/Interpreter/CommandInterpreter.cpp

lldb/trunk/test/settings/quoting/Makefile

lldb/trunk/test/settings/quoting/TestQuoting.py

lldb/trunk/test/settings/quoting/main.c

This is an archive of the discontinued LLVM Phabricator instance.

Fix handling of backslashes in Args parsingClosedPublic

Details

Diff Detail

Event Timeline

Arguments

Revision Contents

Diff 20999

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

lldb/trunk/source/Commands/CommandObjectExpression.cpp

lldb/trunk/source/Commands/CommandObjectPlatform.cpp

lldb/trunk/source/Commands/CommandObjectWatchpoint.cpp

lldb/trunk/source/Interpreter/Args.cpp

lldb/trunk/source/Interpreter/CommandInterpreter.cpp

lldb/trunk/test/settings/quoting/Makefile

lldb/trunk/test/settings/quoting/TestQuoting.py

lldb/trunk/test/settings/quoting/main.c

Fix handling of backslashes in Args parsing
ClosedPublic