Diff 73418

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

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
/// command line is copied into an internal buffer and then split up		/// command line is copied into an internal buffer and then split up
/// into arguments. Arguments are space delimited if there are no quotes		/// into arguments. Arguments are space delimited if there are no quotes
/// (single, double, or backtick quotes) surrounding the argument. Spaces		/// (single, double, or backtick quotes) surrounding the argument. Spaces
/// can be escaped using a \ character to avoid having to surround an		/// can be escaped using a \ character to avoid having to surround an
/// argument that contains a space with quotes.		/// argument that contains a space with quotes.
//----------------------------------------------------------------------		//----------------------------------------------------------------------
class Args {		class Args {
public:		public:
		struct ArgEntry {
		private:
		friend class Args;
		std::unique_ptr<char[]> ptr;

		char *data() { return ptr.get(); }

		public:
		ArgEntry() = default;
		ArgEntry(llvm::StringRef str, char quote);

		llvm::StringRef ref;
		char quote;
		const char *c_str() const { return ptr.get(); }
		};

//------------------------------------------------------------------		//------------------------------------------------------------------
/// 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(llvm::StringRef)		/// @see Args::SetCommandString(llvm::StringRef)
//------------------------------------------------------------------		//------------------------------------------------------------------
Args(llvm::StringRef command = llvm::StringRef());		Args(llvm::StringRef command = llvm::StringRef());

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

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

//------------------------------------------------------------------		//------------------------------------------------------------------
/// Destructor.		/// Destructor.
//------------------------------------------------------------------		//------------------------------------------------------------------
~Args();		~Args();

//------------------------------------------------------------------		//------------------------------------------------------------------
/// Dump all entries to the stream \a s using label \a label_name.		/// Dump all entries to the stream \a s using label \a label_name.
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Lines	public:
//------------------------------------------------------------------		//------------------------------------------------------------------
llvm::StringRef AppendArgument(llvm::StringRef arg_str,		llvm::StringRef AppendArgument(llvm::StringRef arg_str,
char quote_char = '\0');		char quote_char = '\0');

void AppendArguments(const Args &rhs);		void AppendArguments(const Args &rhs);

void AppendArguments(const char **argv);		void AppendArguments(const char **argv);

// Delete const char* versions of StringRef functions. Normally this would
// not be necessary, as const char * is implicitly convertible to StringRef.
// However, since the use of const char* is so pervasive, and since StringRef
// will assert if you try to construct one from nullptr, this allows the
// compiler to catch instances of the function being invoked with a
// const char *, allowing us to replace them with explicit conversions at each
// call-site. This ensures that no callsites slip through the cracks where
// we would be trying to implicitly convert from nullptr, since it will force
// us to evaluate and explicitly convert each one.
//
// Once StringRef use becomes more pervasive, there will be fewer
// implicit conversions because we will be using StringRefs across the whole
// pipeline, so we won't have to have this "glue" that converts between the
// two, and at that point it becomes easy to just make sure you don't pass
// nullptr into the function on the odd occasion that you do pass a
// const char *.
// Call-site fixing methodology:
// 1. If you know the string cannot be null (e.g. it's a const char[], or
// it's been checked for null), use llvm::StringRef(ptr).
// 2. If you don't know if it can be null (e.g. it's returned from a
// function whose semantics are unclear), use
// llvm::StringRef::withNullAsEmpty(ptr).
// 3. If it's .c_str() of a std::string, just pass the std::string directly.
// 4. If it's .str().c_str() of a StringRef, just pass the StringRef
// directly.
void ReplaceArgumentAtIndex(size_t, const char *, char = '\0') = delete;
void AppendArgument(const char *arg_str, char quote_char = '\0') = delete;
void InsertArgumentAtIndex(size_t, const char *, char = '\0') = delete;
static bool StringToBoolean(const char , bool, bool ) = delete;
static lldb::ScriptLanguage
StringToScriptLanguage(const char , lldb::ScriptLanguage, bool ) = delete;
static lldb::Encoding
StringToEncoding(const char *,
lldb::Encoding = lldb::eEncodingInvalid) = delete;
static uint32_t StringToGenericRegister(const char *) = delete;
static bool StringToVersion(const char *, uint32_t &, uint32_t &,
uint32_t &) = delete;
const char Unshift(const char , char = '\0') = delete;
void AddOrReplaceEnvironmentVariable(const char , const char ) = delete;
bool ContainsEnvironmentVariable(const char *,
size_t * = nullptr) const = delete;
static int64_t StringToOptionEnum(const char , OptionEnumValueElement ,
int32_t, Error &) = delete;

//------------------------------------------------------------------		//------------------------------------------------------------------
/// Insert the argument value at index \a idx to \a arg_cstr.		/// Insert the argument value at index \a idx to \a arg_cstr.
///		///
/// @param[in] idx		/// @param[in] idx
/// The index of where to insert the argument.		/// The index of where to insert the argument.
///		///
/// @param[in] arg_cstr		/// @param[in] arg_cstr
/// The new argument as a NULL terminated C string.		/// The new argument as a NULL terminated C string.
▲ Show 20 Lines • Show All 210 Lines • ▼ Show 20 Lines	public:
// printable and isn't one of the common in escape sequences listed in the		// printable and isn't one of the common in escape sequences listed in the
// help for EncodeEscapeSequences, then it will be encoded as octal. Printable		// help for EncodeEscapeSequences, then it will be encoded as octal. Printable
// characters are left alone.		// characters are left alone.
static void ExpandEscapedCharacters(const char *src, std::string &dst);		static void ExpandEscapedCharacters(const char *src, std::string &dst);

static std::string EscapeLLDBCommandArgument(const std::string &arg,		static std::string EscapeLLDBCommandArgument(const std::string &arg,
char quote_char);		char quote_char);

// This one isn't really relevant to Arguments per se, but we're using the
// Args as a
// general strings container, so...
void LongestCommonPrefix(std::string &common_prefix);

//------------------------------------------------------------------		//------------------------------------------------------------------
/// Add or replace an environment variable with the given value.		/// Add or replace an environment variable with the given value.
///		///
/// This command adds the environment variable if it is not already		/// This command adds the environment variable if it is not already
/// present using the given value. If the environment variable is		/// present using the given value. If the environment variable is
/// already in the list, it replaces the first such occurrence		/// already in the list, it replaces the first such occurrence
/// with the new value.		/// with the new value.
//------------------------------------------------------------------		//------------------------------------------------------------------
Show All 16 Lines	public:
///		///
/// @return		/// @return
/// true if the specified env var name exists in the list in		/// true if the specified env var name exists in the list in
/// either of the above-mentioned formats; otherwise, false.		/// either of the above-mentioned formats; otherwise, false.
//------------------------------------------------------------------		//------------------------------------------------------------------
bool ContainsEnvironmentVariable(llvm::StringRef env_var_name,		bool ContainsEnvironmentVariable(llvm::StringRef env_var_name,
size_t *argument_index = nullptr) const;		size_t *argument_index = nullptr) const;

protected:		private:
//------------------------------------------------------------------		std::vector<ArgEntry> m_entries;
// Classes that inherit from Args can see and modify these		std::vector<char *> m_argv;
//------------------------------------------------------------------
typedef std::list<std::string> arg_sstr_collection;
typedef std::vector<const char *> arg_cstr_collection;
typedef std::vector<char> arg_quote_char_collection;
arg_sstr_collection m_args;
arg_cstr_collection m_argv; ///< The current argument vector.
arg_quote_char_collection m_args_quote_char;

void UpdateArgsAfterOptionParsing();		void UpdateArgsAfterOptionParsing();

void UpdateArgvFromArgs();

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

} // namespace lldb_private		} // namespace lldb_private

#endif // liblldb_Command_h_		#endif // liblldb_Command_h_

lldb/trunk/source/Core/Logging.cpp

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Lines	Log *lldb_private::GetLogIfAnyCategoriesSet(uint32_t mask) {
return nullptr;		return nullptr;
}		}

void lldb_private::DisableLog(const char *categories, Stream feedback_strm) {		void lldb_private::DisableLog(const char *categories, Stream feedback_strm) {
Log *log(GetLog());		Log *log(GetLog());

if (log != nullptr) {		if (log != nullptr) {
uint32_t flag_bits = 0;		uint32_t flag_bits = 0;
if (categories[0] != nullptr) {		if (categories && categories[0]) {
flag_bits = log->GetMask().Get();		flag_bits = log->GetMask().Get();
for (size_t i = 0; categories[i] != nullptr; ++i) {		for (size_t i = 0; categories[i] != nullptr; ++i) {
const char *arg = categories[i];		const char *arg = categories[i];

if (0 == ::strcasecmp(arg, "all"))		if (0 == ::strcasecmp(arg, "all"))
flag_bits &= ~LIBLLDB_LOG_ALL;		flag_bits &= ~LIBLLDB_LOG_ALL;
else if (0 == ::strcasecmp(arg, "api"))		else if (0 == ::strcasecmp(arg, "api"))
flag_bits &= ~LIBLLDB_LOG_API;		flag_bits &= ~LIBLLDB_LOG_API;
▲ Show 20 Lines • Show All 218 Lines • Show Last 20 Lines

lldb/trunk/source/Core/StringList.cpp

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines	if (i > 0)
strm.PutCString(separator);		strm.PutCString(separator);
strm.PutCString(GetStringAtIndex(i));		strm.PutCString(GetStringAtIndex(i));
}		}
}		}

void StringList::Clear() { m_strings.clear(); }		void StringList::Clear() { m_strings.clear(); }

void StringList::LongestCommonPrefix(std::string &common_prefix) {		void StringList::LongestCommonPrefix(std::string &common_prefix) {
const size_t num_strings = m_strings.size();

if (num_strings == 0) {
common_prefix.clear();		common_prefix.clear();
} else {		if (m_strings.empty())
common_prefix = m_strings.front();		return;

for (size_t idx = 1; idx < num_strings; ++idx) {
std::string &curr_string = m_strings[idx];
size_t new_size = curr_string.size();

// First trim common_prefix if it is longer than the current element:
if (common_prefix.size() > new_size)
common_prefix.erase(new_size);

// Then trim it at the first disparity:
for (size_t i = 0; i < common_prefix.size(); i++) {
if (curr_string[i] != common_prefix[i]) {
common_prefix.erase(i);
break;
}
}

// If we've emptied the common prefix, we're done.		auto args = llvm::makeArrayRef(m_strings);
if (common_prefix.empty())		llvm::StringRef prefix = args.front();
		for (auto arg : args.drop_front()) {
		size_t count = 0;
		for (count = 0; count < std::min(prefix.size(), arg.size()); ++count) {
		if (prefix[count] != arg[count])
break;		break;
}		}
		prefix = prefix.take_front(count);
}		}
		common_prefix = prefix;
}		}

void StringList::InsertStringAtIndex(size_t idx, const char *str) {		void StringList::InsertStringAtIndex(size_t idx, const char *str) {
if (str) {		if (str) {
if (idx < m_strings.size())		if (idx < m_strings.size())
m_strings.insert(m_strings.begin() + idx, str);		m_strings.insert(m_strings.begin() + idx, str);
else		else
m_strings.push_back(str);		m_strings.push_back(str);
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/Args.cpp

Show All 19 Lines
#include "lldb/Interpreter/Args.h"		#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandInterpreter.h"		#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandReturnObject.h"		#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/Options.h"		#include "lldb/Interpreter/Options.h"
#include "lldb/Target/Process.h"		#include "lldb/Target/Process.h"
#include "lldb/Target/StackFrame.h"		#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"		#include "lldb/Target/Target.h"

		#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringSwitch.h"		#include "llvm/ADT/StringSwitch.h"

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

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

//----------------------------------------------------------------------
// 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
// 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
// own m_argv appropriately.
//----------------------------------------------------------------------
Args::Args(const Args &rhs)
: m_args(rhs.m_args), m_argv(), m_args_quote_char(rhs.m_args_quote_char) {
UpdateArgvFromArgs();
}

//----------------------------------------------------------------------
// 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
// 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
// own m_argv appropriately.
//----------------------------------------------------------------------
const Args &Args::operator=(const Args &rhs) {
// Make sure we aren't assigning to self
if (this != &rhs) {
m_args = rhs.m_args;
m_args_quote_char = rhs.m_args_quote_char;
UpdateArgvFromArgs();
}
return *this;
}

//----------------------------------------------------------------------
// Destructor
//----------------------------------------------------------------------
Args::~Args() {}

void Args::Dump(Stream &s, const char *label_name) const {
if (!label_name)
return;

const size_t argc = m_argv.size();
for (size_t i = 0; i < argc; ++i) {
s.Indent();
const char *arg_cstr = m_argv[i];
if (arg_cstr)
s.Printf("%s[%zi]=\"%s\"\n", label_name, i, arg_cstr);
else
s.Printf("%s[%zi]=NULL\n", label_name, i);
}
s.EOL();
}

bool Args::GetCommandString(std::string &command) const {
command.clear();
const size_t argc = GetArgumentCount();
for (size_t i = 0; i < argc; ++i) {
if (i > 0)
command += ' ';
command += m_argv[i];
}
return argc > 0;
}

bool Args::GetQuotedCommandString(std::string &command) const {
command.clear();
const size_t argc = GetArgumentCount();
for (size_t i = 0; i < argc; ++i) {
if (i > 0)
command.append(1, ' ');
char quote_char = GetArgumentQuoteCharAtIndex(i);
if (quote_char) {
command.append(1, quote_char);
command.append(m_argv[i]);
command.append(1, quote_char);
} else
command.append(m_argv[i]);
}
return argc > 0;
}

// A helper function for argument parsing.		// A helper function for argument parsing.
// Parses the initial part of the first argument using normal double quote		// Parses the initial part of the first argument using normal double quote
// rules:		// rules:
// backslash escapes the double quote and itself. The parsed string is appended		// backslash escapes the double quote and itself. The parsed string is appended
// to the second		// to the second
// argument. The function returns the unparsed portion of the string, starting		// argument. The function returns the unparsed portion of the string, starting
// at the closing		// at the closing
Show All 29 Lines	while (true) {

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

return quoted;		return quoted;
}		}

// A helper function for SetCommandString.		static size_t ArgvToArgc(const char **argv) {
// Parses a single argument from the command string, processing quotes and		if (!argv)
// backslashes in a		return 0;
// shell-like manner. The parsed argument is appended to the m_args array. The		size_t count = 0;
// function returns		while (*argv++)
// the unparsed portion of the string, starting at the first unqouted, unescaped		++count;
// whitespace		return count;
// character.		}
llvm::StringRef Args::ParseSingleArgument(llvm::StringRef command) {
// Argument can be split into multiple discontiguous pieces,
// for example:
// "Hello ""World"
// this would result in a single argument "Hello World" (without/
// the quotes) since the quotes would be removed and there is
// not space between the strings.

		// A helper function for SetCommandString. Parses a single argument from the
		// command string, processing quotes and backslashes in a shell-like manner.
		// The function returns a tuple consisting of the parsed argument, the quote
		// char used, and the unparsed portion of the string starting at the first
		// unqouted, unescaped whitespace character.
		static std::tuple<std::string, char, llvm::StringRef>
		ParseSingleArgument(llvm::StringRef command) {
		// Argument can be split into multiple discontiguous pieces, for example:
		// "Hello ""World"
		// this would result in a single argument "Hello World" (without the quotes)
		// since the quotes would be removed and there is not space between the
		// strings.
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';

▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines	case '`':
// If we found a closing quote, skip it.		// If we found a closing quote, skip it.
if (!command.empty())		if (!command.empty())
command = command.drop_front();		command = command.drop_front();

break;		break;
}		}
} while (!arg_complete);		} while (!arg_complete);

m_args.push_back(arg);		return std::make_tuple(arg, first_quote_char, command);
m_args_quote_char.push_back(first_quote_char);
return command;
}		}

void Args::SetCommandString(llvm::StringRef command) {		Args::ArgEntry::ArgEntry(llvm::StringRef str, char quote) : quote(quote) {
m_args.clear();		size_t size = str.size();
m_argv.clear();		ptr.reset(new char[size + 1]);
m_args_quote_char.clear();

static const char *k_space_separators = " \t";		::memcpy(data(), str.data() ? str.data() : "", size);
command = command.ltrim(k_space_separators);		ptr[size] = 0;
while (!command.empty()) {		ref = llvm::StringRef(c_str(), size);
command = ParseSingleArgument(command);
command = command.ltrim(k_space_separators);
}		}

UpdateArgvFromArgs();		//----------------------------------------------------------------------
		// Args constructor
		//----------------------------------------------------------------------
		Args::Args(llvm::StringRef command) { SetCommandString(command); }

		Args::Args(const Args &rhs) { *this = rhs; }

		Args &Args::operator=(const Args &rhs) {
		Clear();

		m_argv.clear();
		m_entries.clear();
		for (auto &entry : rhs.m_entries) {
		m_entries.emplace_back(entry.ref, entry.quote);
		m_argv.push_back(m_entries.back().data());
		}
		m_argv.push_back(nullptr);
		return *this;
}		}

void Args::UpdateArgsAfterOptionParsing() {		//----------------------------------------------------------------------
// Now m_argv might be out of date with m_args, so we need to fix that		// Destructor
arg_cstr_collection::const_iterator argv_pos, argv_end = m_argv.end();		//----------------------------------------------------------------------
arg_sstr_collection::iterator args_pos;		Args::~Args() {}
arg_quote_char_collection::iterator quotes_pos;
		void Args::Dump(Stream &s, const char *label_name) const {
for (argv_pos = m_argv.begin(), args_pos = m_args.begin(),		if (!label_name)
quotes_pos = m_args_quote_char.begin();		return;
argv_pos != argv_end && args_pos != m_args.end(); ++argv_pos) {
const char argv_cstr = argv_pos;		int i = 0;
if (argv_cstr == nullptr)		for (auto &entry : m_entries) {
break;		s.Indent();
		s.Printf("%s[%zi]=\"%*s\"\n", label_name, i++, entry.ref.size(),
while (args_pos != m_args.end()) {		entry.ref.data());
const char *args_cstr = args_pos->c_str();
if (args_cstr == argv_cstr) {
// We found the argument that matches the C string in the
// vector, so we can now look for the next one
++args_pos;
++quotes_pos;
break;
} else {
quotes_pos = m_args_quote_char.erase(quotes_pos);
args_pos = m_args.erase(args_pos);
}		}
		s.Printf("%s[%zi]=NULL\n", label_name, i);
		s.EOL();
}		}

		bool Args::GetCommandString(std::string &command) const {
		command.clear();

		for (size_t i = 0; i < m_entries.size(); ++i) {
		if (i > 0)
		command += ' ';
		command += m_entries[i].ref;
}		}

if (args_pos != m_args.end())		return !m_entries.empty();
m_args.erase(args_pos, m_args.end());		}

		bool Args::GetQuotedCommandString(std::string &command) const {
		command.clear();

		for (size_t i = 0; i < m_entries.size(); ++i) {
		if (i > 0)
		command += ' ';

		if (m_entries[i].quote) {
		command += m_entries[i].quote;
		command += m_entries[i].ref;
		command += m_entries[i].quote;
		} else {
		command += m_entries[i].ref;
		}
		}

if (quotes_pos != m_args_quote_char.end())		return !m_entries.empty();
m_args_quote_char.erase(quotes_pos, m_args_quote_char.end());
}		}

void Args::UpdateArgvFromArgs() {		void Args::SetCommandString(llvm::StringRef command) {
		Clear();
m_argv.clear();		m_argv.clear();
arg_sstr_collection::const_iterator pos, end = m_args.end();
for (pos = m_args.begin(); pos != end; ++pos)		static const char *k_space_separators = " \t";
m_argv.push_back(pos->c_str());		command = command.ltrim(k_space_separators);
		std::string arg;
		char quote;
		while (!command.empty()) {
		std::tie(arg, quote, command) = ParseSingleArgument(command);
		m_entries.emplace_back(arg, quote);
		m_argv.push_back(m_entries.back().data());
		command = command.ltrim(k_space_separators);
		}
m_argv.push_back(nullptr);		m_argv.push_back(nullptr);
// Make sure we have enough arg quote chars in the array
if (m_args_quote_char.size() < m_args.size())
m_args_quote_char.resize(m_argv.size());
}		}

size_t Args::GetArgumentCount() const {		void Args::UpdateArgsAfterOptionParsing() {
if (m_argv.empty())		assert(!m_argv.empty());
return 0;		assert(m_argv.back() == nullptr);
return m_argv.size() - 1;
		// Now m_argv might be out of date with m_entries, so we need to fix that.
		// This happens because getopt_long_only may permute the order of the
		// arguments in argv, so we need to re-order the quotes and the refs array
		// to match.
		for (int i = 0; i < m_argv.size() - 1; ++i) {
		const char *argv = m_argv[i];
		auto pos =
		std::find_if(m_entries.begin() + i, m_entries.end(),
		[argv](const ArgEntry &D) { return D.c_str() == argv; });
		assert(pos != m_entries.end());
		size_t distance = std::distance(m_entries.begin(), pos);
		if (i == distance)
		continue;

		assert(distance > i);

		std::swap(m_entries[i], m_entries[distance]);
		assert(m_entries[i].ref.data() == m_argv[i]);
}		}
		m_entries.resize(m_argv.size() - 1);
		}

		size_t Args::GetArgumentCount() const { return m_entries.size(); }

const char *Args::GetArgumentAtIndex(size_t idx) const {		const char *Args::GetArgumentAtIndex(size_t idx) const {
if (idx < m_argv.size())		if (idx < m_argv.size())
return m_argv[idx];		return m_argv[idx];
return nullptr;		return nullptr;
}		}

char Args::GetArgumentQuoteCharAtIndex(size_t idx) const {		char Args::GetArgumentQuoteCharAtIndex(size_t idx) const {
if (idx < m_args_quote_char.size())		if (idx < m_entries.size())
return m_args_quote_char[idx];		return m_entries[idx].quote;
return '\0';		return '\0';
}		}

char **Args::GetArgumentVector() {		char **Args::GetArgumentVector() {
if (!m_argv.empty())		assert(!m_argv.empty());
return const_cast<char **>(&m_argv[0]);		// TODO: functions like execve and posix_spawnp exhibit undefined behavior
return nullptr;		// when argv or envp is null. So the code below is actually wrong. However,
		// other code in LLDB depends on it being null. The code has been acting this
		// way for some time, so it makes sense to leave it this way until someone
		// has the time to come along and fix it.
		return (m_argv.size() > 1) ? m_argv.data() : nullptr;
}		}

const char **Args::GetConstArgumentVector() const {		const char **Args::GetConstArgumentVector() const {
if (!m_argv.empty())		assert(!m_argv.empty());
return const_cast<const char **>(&m_argv[0]);		return (m_argv.size() > 1) ? const_cast<const char **>(m_argv.data())
return nullptr;		: nullptr;
}		}

void Args::Shift() {		void Args::Shift() {
// Don't pop the last NULL terminator from the argv array		// Don't pop the last NULL terminator from the argv array
if (m_argv.size() > 1) {		if (m_entries.empty())
		return;
m_argv.erase(m_argv.begin());		m_argv.erase(m_argv.begin());
m_args.pop_front();		m_entries.erase(m_entries.begin());
if (!m_args_quote_char.empty())
m_args_quote_char.erase(m_args_quote_char.begin());
}
}		}

llvm::StringRef Args::Unshift(llvm::StringRef arg_str, char quote_char) {		llvm::StringRef Args::Unshift(llvm::StringRef arg_str, char quote_char) {
m_args.push_front(arg_str);		return InsertArgumentAtIndex(0, arg_str, quote_char);
m_argv.insert(m_argv.begin(), m_args.front().c_str());
m_args_quote_char.insert(m_args_quote_char.begin(), quote_char);
return llvm::StringRef::withNullAsEmpty(GetArgumentAtIndex(0));
}		}

void Args::AppendArguments(const Args &rhs) {		void Args::AppendArguments(const Args &rhs) {
const size_t rhs_argc = rhs.GetArgumentCount();		assert(m_argv.size() == m_entries.size() + 1);
for (size_t i = 0; i < rhs_argc; ++i)		assert(m_argv.back() == nullptr);
AppendArgument(llvm::StringRef(rhs.GetArgumentAtIndex(i)),		m_argv.pop_back();
rhs.GetArgumentQuoteCharAtIndex(i));		for (auto &entry : rhs.m_entries) {
		m_entries.emplace_back(entry.ref, entry.quote);
		m_argv.push_back(m_entries.back().data());
		}
		m_argv.push_back(nullptr);
}		}

void Args::AppendArguments(const char **argv) {		void Args::AppendArguments(const char **argv) {
if (argv) {		size_t argc = ArgvToArgc(argv);
for (uint32_t i = 0; argv[i]; ++i)
AppendArgument(llvm::StringRef::withNullAsEmpty(argv[i]));		assert(m_argv.size() == m_entries.size() + 1);
		assert(m_argv.back() == nullptr);
		m_argv.pop_back();
		for (int i = 0; i < argc; ++i) {
		m_entries.emplace_back(argv[i], '\0');
		m_argv.push_back(m_entries.back().data());
}		}

		m_argv.push_back(nullptr);
}		}

llvm::StringRef Args::AppendArgument(llvm::StringRef arg_str, char quote_char) {		llvm::StringRef Args::AppendArgument(llvm::StringRef arg_str, char quote_char) {
return InsertArgumentAtIndex(GetArgumentCount(), arg_str, quote_char);		return InsertArgumentAtIndex(GetArgumentCount(), arg_str, quote_char);
}		}

llvm::StringRef Args::InsertArgumentAtIndex(size_t idx, llvm::StringRef arg_str,		llvm::StringRef Args::InsertArgumentAtIndex(size_t idx, llvm::StringRef arg_str,
char quote_char) {		char quote_char) {
// Since we are using a std::list to hold onto the copied C string and		assert(m_argv.size() == m_entries.size() + 1);
// we don't have direct access to the elements, we have to iterate to		assert(m_argv.back() == nullptr);
// find the value.
arg_sstr_collection::iterator pos, end = m_args.end();
size_t i = idx;
for (pos = m_args.begin(); i > 0 && pos != end; ++pos)
--i;

pos = m_args.insert(pos, arg_str);

if (idx >= m_args_quote_char.size()) {
m_args_quote_char.resize(idx + 1);
m_args_quote_char[idx] = quote_char;
} else
m_args_quote_char.insert(m_args_quote_char.begin() + idx, quote_char);

UpdateArgvFromArgs();		if (idx > m_entries.size())
return GetArgumentAtIndex(idx);		return llvm::StringRef();
		m_entries.emplace(m_entries.begin() + idx, arg_str, quote_char);
		m_argv.insert(m_argv.begin() + idx, m_entries[idx].data());
		return m_entries[idx].ref;
}		}

llvm::StringRef Args::ReplaceArgumentAtIndex(size_t idx,		llvm::StringRef Args::ReplaceArgumentAtIndex(size_t idx,
llvm::StringRef arg_str,		llvm::StringRef arg_str,
char quote_char) {		char quote_char) {
// Since we are using a std::list to hold onto the copied C string and		assert(m_argv.size() == m_entries.size() + 1);
// we don't have direct access to the elements, we have to iterate to		assert(m_argv.back() == nullptr);
// find the value.
arg_sstr_collection::iterator pos, end = m_args.end();		if (idx >= m_entries.size())
size_t i = idx;
for (pos = m_args.begin(); i > 0 && pos != end; ++pos)
--i;

if (pos != end) {
pos->assign(arg_str);
assert(idx < m_argv.size() - 1);
m_argv[idx] = pos->c_str();
if (idx >= m_args_quote_char.size())
m_args_quote_char.resize(idx + 1);
m_args_quote_char[idx] = quote_char;
return GetArgumentAtIndex(idx);
}
return llvm::StringRef();		return llvm::StringRef();

		if (arg_str.size() > m_entries[idx].ref.size()) {
		m_entries[idx] = ArgEntry(arg_str, quote_char);
		m_argv[idx] = m_entries[idx].data();
		} else {
		const char *src_data = arg_str.data() ? arg_str.data() : "";
		::memcpy(m_entries[idx].data(), src_data, arg_str.size());
		m_entries[idx].ptr[arg_str.size()] = 0;
		m_entries[idx].ref = m_entries[idx].ref.take_front(arg_str.size());
		}

		return m_entries[idx].ref;
}		}

void Args::DeleteArgumentAtIndex(size_t idx) {		void Args::DeleteArgumentAtIndex(size_t idx) {
// Since we are using a std::list to hold onto the copied C string and		if (idx >= m_entries.size())
// we don't have direct access to the elements, we have to iterate to		return;
// find the value.
arg_sstr_collection::iterator pos, end = m_args.end();
size_t i = idx;
for (pos = m_args.begin(); i > 0 && pos != end; ++pos)
--i;

if (pos != end) {
m_args.erase(pos);
assert(idx < m_argv.size() - 1);
m_argv.erase(m_argv.begin() + idx);		m_argv.erase(m_argv.begin() + idx);
if (idx < m_args_quote_char.size())		m_entries.erase(m_entries.begin() + idx);
m_args_quote_char.erase(m_args_quote_char.begin() + idx);
}
}		}

void Args::SetArguments(size_t argc, const char **argv) {		void Args::SetArguments(size_t argc, const char **argv) {
// m_argv will be rebuilt in UpdateArgvFromArgs() below, so there is		Clear();
// no need to clear it here.
m_args.clear();
m_args_quote_char.clear();

// First copy each string
for (size_t i = 0; i < argc; ++i) {
m_args.push_back(argv[i]);
if ((argv[i][0] == '\'') \|\| (argv[i][0] == '"') \|\| (argv[i][0] == '`'))
m_args_quote_char.push_back(argv[i][0]);
else
m_args_quote_char.push_back('\0');
}

UpdateArgvFromArgs();		auto args = llvm::makeArrayRef(argv, argc);
}		m_entries.resize(argc);
		m_argv.resize(argc + 1);
		for (int i = 0; i < args.size(); ++i) {
		char quote =
		((args[i][0] == '\'') \|\| (args[i][0] == '"') \|\| (args[i][0] == '`'))
		? args[i][0]
		: '\0';

void Args::SetArguments(const char **argv) {		m_entries[i] = ArgEntry(args[i], quote);
// m_argv will be rebuilt in UpdateArgvFromArgs() below, so there is		m_argv[i] = m_entries[i].data();
// no need to clear it here.
m_args.clear();
m_args_quote_char.clear();

if (argv) {
// First copy each string
for (size_t i = 0; argv[i]; ++i) {
m_args.push_back(argv[i]);
if ((argv[i][0] == '\'') \|\| (argv[i][0] == '"') \|\| (argv[i][0] == '`'))
m_args_quote_char.push_back(argv[i][0]);
else
m_args_quote_char.push_back('\0');
}		}
}		}

UpdateArgvFromArgs();		void Args::SetArguments(const char **argv) {
		SetArguments(ArgvToArgc(argv), argv);
}		}

Error Args::ParseOptions(Options &options, ExecutionContext *execution_context,		Error Args::ParseOptions(Options &options, ExecutionContext *execution_context,
PlatformSP platform_sp, bool require_validation) {		PlatformSP platform_sp, bool require_validation) {
StreamString sstr;		StreamString sstr;
Error error;		Error error;
Option *long_options = options.GetLongOptions();		Option *long_options = options.GetLongOptions();
if (long_options == nullptr) {		if (long_options == nullptr) {
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Lines	Error Args::ParseOptions(Options &options, ExecutionContext *execution_context,

// Update our ARGV now that get options has consumed all the options		// Update our ARGV now that get options has consumed all the options
m_argv.erase(m_argv.begin(), m_argv.begin() + OptionParser::GetOptionIndex());		m_argv.erase(m_argv.begin(), m_argv.begin() + OptionParser::GetOptionIndex());
UpdateArgsAfterOptionParsing();		UpdateArgsAfterOptionParsing();
return error;		return error;
}		}

void Args::Clear() {		void Args::Clear() {
m_args.clear();		m_entries.clear();
m_argv.clear();		m_argv.clear();
m_args_quote_char.clear();		m_argv.push_back(nullptr);
}		}

lldb::addr_t Args::StringToAddress(const ExecutionContext *exe_ctx,		lldb::addr_t Args::StringToAddress(const ExecutionContext *exe_ctx,
const char *s, lldb::addr_t fail_value,		const char *s, lldb::addr_t fail_value,
Error *error_ptr) {		Error *error_ptr) {
bool error_set = false;		bool error_set = false;
if (s && s[0]) {		if (s && s[0]) {
llvm::StringRef sref = s;		llvm::StringRef sref = s;
▲ Show 20 Lines • Show All 330 Lines • ▼ Show 20 Lines	uint32_t result = llvm::StringSwitch<uint32_t>(s)
.Case("arg5", LLDB_REGNUM_GENERIC_ARG5)		.Case("arg5", LLDB_REGNUM_GENERIC_ARG5)
.Case("arg6", LLDB_REGNUM_GENERIC_ARG6)		.Case("arg6", LLDB_REGNUM_GENERIC_ARG6)
.Case("arg7", LLDB_REGNUM_GENERIC_ARG7)		.Case("arg7", LLDB_REGNUM_GENERIC_ARG7)
.Case("arg8", LLDB_REGNUM_GENERIC_ARG8)		.Case("arg8", LLDB_REGNUM_GENERIC_ARG8)
.Default(LLDB_INVALID_REGNUM);		.Default(LLDB_INVALID_REGNUM);
return result;		return result;
}		}

void Args::LongestCommonPrefix(std::string &common_prefix) {
arg_sstr_collection::iterator pos, end = m_args.end();
pos = m_args.begin();
if (pos == end)
common_prefix.clear();
else
common_prefix = (*pos);

for (++pos; pos != end; ++pos) {
size_t new_size = (*pos).size();

// First trim common_prefix if it is longer than the current element:
if (common_prefix.size() > new_size)
common_prefix.erase(new_size);

// Then trim it at the first disparity:

for (size_t i = 0; i < common_prefix.size(); i++) {
if ((*pos)[i] != common_prefix[i]) {
common_prefix.erase(i);
break;
}
}

// If we've emptied the common prefix, we're done.
if (common_prefix.empty())
break;
}
}

void Args::AddOrReplaceEnvironmentVariable(llvm::StringRef env_var_name,		void Args::AddOrReplaceEnvironmentVariable(llvm::StringRef env_var_name,
llvm::StringRef new_value) {		llvm::StringRef new_value) {
if (env_var_name.empty())		if (env_var_name.empty())
return;		return;

// Build the new entry.		// Build the new entry.
std::string var_string(env_var_name);		std::string var_string(env_var_name);
if (!new_value.empty()) {		if (!new_value.empty()) {
▲ Show 20 Lines • Show All 422 Lines • ▼ Show 20 Lines	void Args::ParseArgsForCompletion(Options &options,
// Finally we have to handle the case where the cursor index points at a		// Finally we have to handle the case where the cursor index points at a
// single "-". We want to mark that in		// single "-". We want to mark that in
// the option_element_vector, but only if it is not after the "--". But it		// the option_element_vector, but only if it is not after the "--". But it
// turns out that OptionParser::Parse just ignores		// turns out that OptionParser::Parse just ignores
// an isolated "-". So we have to look it up by hand here. We only care if		// an isolated "-". So we have to look it up by hand here. We only care if
// it is AT the cursor position.		// it is AT the cursor position.
// Note, a single quoted dash is not the same as a single dash...		// Note, a single quoted dash is not the same as a single dash...

		const ArgEntry &cursor = m_entries[cursor_index];
if ((static_cast<int32_t>(dash_dash_pos) == -1 \|\|		if ((static_cast<int32_t>(dash_dash_pos) == -1 \|\|
cursor_index < dash_dash_pos) &&		cursor_index < dash_dash_pos) &&
m_args_quote_char[cursor_index] == '\0' &&		cursor.quote == '\0' && cursor.ref == "-") {
strcmp(GetArgumentAtIndex(cursor_index), "-") == 0) {
option_element_vector.push_back(		option_element_vector.push_back(
OptionArgElement(OptionArgElement::eBareDash, cursor_index,		OptionArgElement(OptionArgElement::eBareDash, cursor_index,
OptionArgElement::eBareDash));		OptionArgElement::eBareDash));
}		}
}		}

void Args::EncodeEscapeSequences(const char *src, std::string &dst) {		void Args::EncodeEscapeSequences(const char *src, std::string &dst) {
dst.clear();		dst.clear();
▲ Show 20 Lines • Show All 174 Lines • Show Last 20 Lines

lldb/trunk/unittests/Interpreter/TestArgs.cpp

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Lines	TEST(ArgsTest, TestAppendArg) {
args.SetCommandString("first_arg");		args.SetCommandString("first_arg");
EXPECT_EQ(1u, args.GetArgumentCount());		EXPECT_EQ(1u, args.GetArgumentCount());
args.AppendArgument(llvm::StringRef("second_arg"));		args.AppendArgument(llvm::StringRef("second_arg"));
EXPECT_EQ(2u, args.GetArgumentCount());		EXPECT_EQ(2u, args.GetArgumentCount());
EXPECT_STREQ(args.GetArgumentAtIndex(0), "first_arg");		EXPECT_STREQ(args.GetArgumentAtIndex(0), "first_arg");
EXPECT_STREQ(args.GetArgumentAtIndex(1), "second_arg");		EXPECT_STREQ(args.GetArgumentAtIndex(1), "second_arg");
}		}

		TEST(ArgsTest, TestInsertArg) {
		Args args;
		args.AppendArgument("1");
		args.AppendArgument("2");
		args.AppendArgument("3");
		args.InsertArgumentAtIndex(1, "1.5");
		args.InsertArgumentAtIndex(4, "3.5");

		ASSERT_EQ(5u, args.GetArgumentCount());
		EXPECT_STREQ("1", args.GetArgumentAtIndex(0));
		EXPECT_STREQ("1.5", args.GetArgumentAtIndex(1));
		EXPECT_STREQ("2", args.GetArgumentAtIndex(2));
		EXPECT_STREQ("3", args.GetArgumentAtIndex(3));
		EXPECT_STREQ("3.5", args.GetArgumentAtIndex(4));
		}

		TEST(ArgsTest, TestArgv) {
		Args args;
		EXPECT_EQ(nullptr, args.GetArgumentVector());

		args.AppendArgument("1");
		EXPECT_NE(nullptr, args.GetArgumentVector()[0]);
		EXPECT_EQ(nullptr, args.GetArgumentVector()[1]);

		args.AppendArgument("2");
		EXPECT_NE(nullptr, args.GetArgumentVector()[0]);
		EXPECT_NE(nullptr, args.GetArgumentVector()[1]);
		EXPECT_EQ(nullptr, args.GetArgumentVector()[2]);

		args.AppendArgument("3");
		EXPECT_NE(nullptr, args.GetArgumentVector()[0]);
		EXPECT_NE(nullptr, args.GetArgumentVector()[1]);
		EXPECT_NE(nullptr, args.GetArgumentVector()[2]);
		EXPECT_EQ(nullptr, args.GetArgumentVector()[3]);

		args.InsertArgumentAtIndex(1, "1.5");
		EXPECT_NE(nullptr, args.GetArgumentVector()[0]);
		EXPECT_NE(nullptr, args.GetArgumentVector()[1]);
		EXPECT_NE(nullptr, args.GetArgumentVector()[2]);
		EXPECT_NE(nullptr, args.GetArgumentVector()[3]);
		EXPECT_EQ(nullptr, args.GetArgumentVector()[4]);

		args.InsertArgumentAtIndex(4, "3.5");
		EXPECT_NE(nullptr, args.GetArgumentVector()[0]);
		EXPECT_NE(nullptr, args.GetArgumentVector()[1]);
		EXPECT_NE(nullptr, args.GetArgumentVector()[2]);
		EXPECT_NE(nullptr, args.GetArgumentVector()[3]);
		EXPECT_NE(nullptr, args.GetArgumentVector()[4]);
		EXPECT_EQ(nullptr, args.GetArgumentVector()[5]);
		}

		TEST(ArgsTest, GetQuotedCommandString) {
		Args args;
		const char *str = "process launch -o stdout.txt -- \"a b c\"";
		args.SetCommandString(str);

		std::string stdstr;
		ASSERT_TRUE(args.GetQuotedCommandString(stdstr));
		EXPECT_EQ(str, stdstr);
		}

		TEST(ArgsTest, BareSingleQuote) {
		Args args;
		args.SetCommandString("a\\'b");
		EXPECT_EQ(1u, args.GetArgumentCount());

		EXPECT_STREQ("a'b", args.GetArgumentAtIndex(0));
		}

		TEST(ArgsTest, DoubleQuotedItem) {
		Args args;
		args.SetCommandString("\"a b c\"");
		EXPECT_EQ(1u, args.GetArgumentCount());

		EXPECT_STREQ("a b c", args.GetArgumentAtIndex(0));
		}

		TEST(ArgsTest, AppendArguments) {
		Args args;
		const char *argv[] = {"1", "2", nullptr};
		const char *argv2[] = {"3", "4", nullptr};

		args.AppendArguments(argv);
		ASSERT_EQ(2u, args.GetArgumentCount());
		EXPECT_STREQ("1", args.GetArgumentVector()[0]);
		EXPECT_STREQ("2", args.GetArgumentVector()[1]);
		EXPECT_EQ(nullptr, args.GetArgumentVector()[2]);
		EXPECT_STREQ("1", args.GetArgumentAtIndex(0));
		EXPECT_STREQ("2", args.GetArgumentAtIndex(1));

		args.AppendArguments(argv2);
		ASSERT_EQ(4u, args.GetArgumentCount());
		EXPECT_STREQ("1", args.GetArgumentVector()[0]);
		EXPECT_STREQ("2", args.GetArgumentVector()[1]);
		EXPECT_STREQ("3", args.GetArgumentVector()[2]);
		EXPECT_STREQ("4", args.GetArgumentVector()[3]);
		EXPECT_EQ(nullptr, args.GetArgumentVector()[4]);
		EXPECT_STREQ("1", args.GetArgumentAtIndex(0));
		EXPECT_STREQ("2", args.GetArgumentAtIndex(1));
		EXPECT_STREQ("3", args.GetArgumentAtIndex(2));
		EXPECT_STREQ("4", args.GetArgumentAtIndex(3));
		}

TEST(ArgsTest, StringToBoolean) {		TEST(ArgsTest, StringToBoolean) {
bool success = false;		bool success = false;
EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("true"), false, nullptr));		EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("true"), false, nullptr));
EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("on"), false, nullptr));		EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("on"), false, nullptr));
EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("yes"), false, nullptr));		EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("yes"), false, nullptr));
EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("1"), false, nullptr));		EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("1"), false, nullptr));

EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("true"), false, &success));		EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("true"), false, &success));
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines

This is an archive of the discontinued LLVM Phabricator instance.

Refactor Args a different way
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 73418

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

lldb/trunk/source/Core/Logging.cpp

lldb/trunk/source/Core/StringList.cpp

lldb/trunk/source/Interpreter/Args.cpp

lldb/trunk/unittests/Interpreter/TestArgs.cpp

This is an archive of the discontinued LLVM Phabricator instance.

Refactor Args a different wayClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 73418

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

lldb/trunk/source/Core/Logging.cpp

lldb/trunk/source/Core/StringList.cpp

lldb/trunk/source/Interpreter/Args.cpp

lldb/trunk/unittests/Interpreter/TestArgs.cpp

Refactor Args a different way
ClosedPublic