This is an archive of the discontinued LLVM Phabricator instance.

Differential D45480

Move Args.cpp from Interpreter to Utility
ClosedPublic

Authored by labath on Apr 10 2018, 3:16 AM.

Details

Reviewers
zturner
jingham
davide
Commits
rG145d95c96479: Move Args.cpp from Interpreter to Utility
rLLDB330200: Move Args.cpp from Interpreter to Utility
rL330200: Move Args.cpp from Interpreter to Utility
Summary

The Args class is used in plenty of places besides the command
interpreter (e.g., anything requiring an argc+argv combo, such as when
launching a process), so it needs to be in a lower layer. Now that the
class has no external dependencies, it can be moved down to the Utility
module.

This removes the last (direct) dependency from the Host module to
Interpreter, so I remove the Interpreter module from Host's dependency
list.

Diff Detail

Repository
rL LLVM

Event Timeline

labath created this revision.Apr 10 2018, 3:16 AM
Herald added a subscriber: mgorny. · View Herald TranscriptApr 10 2018, 3:16 AM
Harbormaster completed remote builds in B16929: Diff 141816.Apr 10 2018, 3:19 AM
zturner added a comment.Apr 10 2018, 9:58 AM

This removes the last (direct) dependency from the Host module to Interpreter, so I remove the Interpreter module from Host's dependency list.

Big milestone! Kudos

labath added a comment.Apr 12 2018, 2:53 AM
In D45480#1063268, @zturner wrote:

This removes the last (direct) dependency from the Host module to Interpreter, so I remove the Interpreter module from Host's dependency list.

Big milestone! Kudos

Thanks. Host is still a member of a lot of cycles with other modules, but I think I have a plan on how to solve these as well.

I take it that everyone is ok with checking this in then.

davide accepted this revision.Apr 12 2018, 8:06 AM

No objections from me.

This revision is now accepted and ready to land.Apr 12 2018, 8:06 AM
Closed by commit rL330200: Move Args.cpp from Interpreter to Utility (authored by labath). · Explain WhyApr 17 2018, 11:58 AM
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: llvm-commits. · View Herald TranscriptApr 17 2018, 11:58 AM

Revision Contents

PathSize
lldb/
trunk/
include/
lldb/
Interpreter/
368 lines
2 lines
2 lines
2 lines
2 lines
Target/
2 lines
Utility/
363 lines
source/
API/
2 lines
2 lines
2 lines
2 lines
Breakpoint/
2 lines
Commands/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Core/
2 lines
Host/
1 line
macosx/
2 lines
Interpreter/
694 lines
1 line
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Plugins/
LanguageRuntime/
RenderScript/
RenderScriptRuntime/
2 lines
2 lines
Platform/
MacOSX/
2 lines
Process/
gdb-remote/
2 lines
2 lines
2 lines
2 lines
Utility/
685 lines
1 line
tools/
lldb-server/
2 lines
unittests/
Interpreter/
1 line
189 lines
Utility/
191 lines
1 line
tools/
lldb-server/
tests/
2 lines
2 lines

Diff 142812

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

//===-- Args.h --------------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_Command_h_
#define liblldb_Command_h_
// C Includes
// C++ Includes
#include <string>
#include <utility>
#include <vector>
// Other libraries and framework includes
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringRef.h"
// Project includes
#include "lldb/Utility/Environment.h"
#include "lldb/lldb-private-types.h"
#include "lldb/lldb-types.h"
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Args Args.h "lldb/Interpreter/Args.h"
/// @brief A command line argument class.
///
/// The Args class is designed to be fed a command line. The
/// command line is copied into an internal buffer and then split up
/// into arguments. Arguments are space delimited if there are no quotes
/// (single, double, or backtick quotes) surrounding the argument. Spaces
/// can be escaped using a \ character to avoid having to surround an
/// argument that contains a space with quotes.
//----------------------------------------------------------------------
class Args {
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.
///
/// @param[in] command
/// A NULL terminated command that will be copied and split up
/// into arguments.
///
/// @see Args::SetCommandString(llvm::StringRef)
//------------------------------------------------------------------
Args(llvm::StringRef command = llvm::StringRef());
Args(const Args &rhs);
explicit Args(const StringList &list);
Args &operator=(const Args &rhs);
//------------------------------------------------------------------
/// Destructor.
//------------------------------------------------------------------
~Args();
explicit Args(const Environment &env) : Args() {
SetArguments(const_cast<const char **>(env.getEnvp().get()));
}
explicit operator Environment() const { return GetConstArgumentVector(); }
//------------------------------------------------------------------
/// Dump all entries to the stream \a s using label \a label_name.
///
/// If label_name is nullptr, the dump operation is skipped.
///
/// @param[in] s
/// The stream to which to dump all arguments in the argument
/// vector.
/// @param[in] label_name
/// The label_name to use as the label printed for each
/// entry of the args like so:
/// {label_name}[{index}]={value}
//------------------------------------------------------------------
void Dump(Stream &s, const char *label_name = "argv") const;
//------------------------------------------------------------------
/// Sets the command string contained by this object.
///
/// The command string will be copied and split up into arguments
/// that can be accessed via the accessor functions.
///
/// @param[in] command
/// A command StringRef that will be copied and split up
/// into arguments.
///
/// @see Args::GetArgumentCount() const
/// @see Args::GetArgumentAtIndex (size_t) const
/// @see Args::GetArgumentVector ()
/// @see Args::Shift ()
/// @see Args::Unshift (const char *)
//------------------------------------------------------------------
void SetCommandString(llvm::StringRef command);
bool GetCommandString(std::string &command) const;
bool GetQuotedCommandString(std::string &command) const;
//------------------------------------------------------------------
/// Gets the number of arguments left in this command object.
///
/// @return
/// The number or arguments in this object.
//------------------------------------------------------------------
size_t GetArgumentCount() const;
bool empty() const { return GetArgumentCount() == 0; }
//------------------------------------------------------------------
/// Gets the NULL terminated C string argument pointer for the
/// argument at index \a idx.
///
/// @return
/// The NULL terminated C string argument pointer if \a idx is a
/// valid argument index, NULL otherwise.
//------------------------------------------------------------------
const char *GetArgumentAtIndex(size_t idx) const;
llvm::ArrayRef<ArgEntry> entries() const { return m_entries; }
char GetArgumentQuoteCharAtIndex(size_t idx) const;
using const_iterator = std::vector<ArgEntry>::const_iterator;
const_iterator begin() const { return m_entries.begin(); }
const_iterator end() const { return m_entries.end(); }
size_t size() const { return GetArgumentCount(); }
const ArgEntry &operator[](size_t n) const { return m_entries[n]; }
//------------------------------------------------------------------
/// Gets the argument vector.
///
/// The value returned by this function can be used by any function
/// that takes and vector. The return value is just like \a argv
/// in the standard C entry point function:
/// \code
/// int main (int argc, const char **argv);
/// \endcode
///
/// @return
/// An array of NULL terminated C string argument pointers that
/// also has a terminating NULL C string pointer
//------------------------------------------------------------------
char **GetArgumentVector();
//------------------------------------------------------------------
/// Gets the argument vector.
///
/// The value returned by this function can be used by any function
/// that takes and vector. The return value is just like \a argv
/// in the standard C entry point function:
/// \code
/// int main (int argc, const char **argv);
/// \endcode
///
/// @return
/// An array of NULL terminate C string argument pointers that
/// also has a terminating NULL C string pointer
//------------------------------------------------------------------
const char **GetConstArgumentVector() const;
//------------------------------------------------------------------
/// Gets the argument as an ArrayRef. Note that the return value does *not*
/// have a nullptr const char * at the end, as the size of the list is
/// embedded in the ArrayRef object.
//------------------------------------------------------------------
llvm::ArrayRef<const char *> GetArgumentArrayRef() const {
return llvm::makeArrayRef(m_argv).drop_back();
}
//------------------------------------------------------------------
/// Appends a new argument to the end of the list argument list.
///
/// @param[in] arg_cstr
/// The new argument as a NULL terminated C string.
///
/// @param[in] quote_char
/// If the argument was originally quoted, put in the quote char here.
//------------------------------------------------------------------
void AppendArgument(llvm::StringRef arg_str, char quote_char = '\0');
void AppendArguments(const Args &rhs);
void AppendArguments(const char **argv);
//------------------------------------------------------------------
/// Insert the argument value at index \a idx to \a arg_cstr.
///
/// @param[in] idx
/// The index of where to insert the argument.
///
/// @param[in] arg_cstr
/// The new argument as a NULL terminated C string.
///
/// @param[in] quote_char
/// If the argument was originally quoted, put in the quote char here.
///
/// @return
/// The NULL terminated C string of the copy of \a arg_cstr.
//------------------------------------------------------------------
void InsertArgumentAtIndex(size_t idx, llvm::StringRef arg_str,
char quote_char = '\0');
//------------------------------------------------------------------
/// Replaces the argument value at index \a idx to \a arg_cstr
/// if \a idx is a valid argument index.
///
/// @param[in] idx
/// The index of the argument that will have its value replaced.
///
/// @param[in] arg_cstr
/// The new argument as a NULL terminated C string.
///
/// @param[in] quote_char
/// If the argument was originally quoted, put in the quote char here.
//------------------------------------------------------------------
void ReplaceArgumentAtIndex(size_t idx, llvm::StringRef arg_str,
char quote_char = '\0');
//------------------------------------------------------------------
/// Deletes the argument value at index
/// if \a idx is a valid argument index.
///
/// @param[in] idx
/// The index of the argument that will have its value replaced.
///
//------------------------------------------------------------------
void DeleteArgumentAtIndex(size_t idx);
//------------------------------------------------------------------
/// Sets the argument vector value, optionally copying all
/// arguments into an internal buffer.
///
/// Sets the arguments to match those found in \a argv. All argument
/// strings will be copied into an internal buffers.
//
// FIXME: Handle the quote character somehow.
//------------------------------------------------------------------
void SetArguments(size_t argc, const char **argv);
void SetArguments(const char **argv);
//------------------------------------------------------------------
/// Shifts the first argument C string value of the array off the
/// argument array.
///
/// The string value will be freed, so a copy of the string should
/// be made by calling Args::GetArgumentAtIndex (size_t) const
/// first and copying the returned value before calling
/// Args::Shift().
///
/// @see Args::GetArgumentAtIndex (size_t) const
//------------------------------------------------------------------
void Shift();
//------------------------------------------------------------------
/// Inserts a class owned copy of \a arg_cstr at the beginning of
/// the argument vector.
///
/// A copy \a arg_cstr will be made.
///
/// @param[in] arg_cstr
/// The argument to push on the front of the argument stack.
///
/// @param[in] quote_char
/// If the argument was originally quoted, put in the quote char here.
//------------------------------------------------------------------
void Unshift(llvm::StringRef arg_str, char quote_char = '\0');
//------------------------------------------------------------------
// Clear the arguments.
//
// For re-setting or blanking out the list of arguments.
//------------------------------------------------------------------
void Clear();
static const char *StripSpaces(std::string &s, bool leading = true,
bool trailing = true,
bool return_null_if_empty = true);
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;
const uint64_t max = ((uint64_t)1 << (uint64_t)(total_byte_size * 8)) - 1;
return uval64 <= max;
}
static bool SInt64ValueIsValidForByteSize(int64_t sval64,
size_t total_byte_size) {
if (total_byte_size > 8)
return false;
if (total_byte_size == 8)
return true;
const int64_t max = ((int64_t)1 << (uint64_t)(total_byte_size * 8 - 1)) - 1;
const int64_t min = ~(max);
return min <= sval64 && sval64 <= max;
}
static lldb::Encoding
StringToEncoding(llvm::StringRef s,
lldb::Encoding fail_value = lldb::eEncodingInvalid);
static uint32_t StringToGenericRegister(llvm::StringRef s);
static bool StringToVersion(llvm::StringRef string, uint32_t &major,
uint32_t &minor, uint32_t &update);
static const char *GetShellSafeArgument(const FileSpec &shell,
const char *unsafe_arg,
std::string &safe_arg);
// EncodeEscapeSequences will change the textual representation of common
// escape sequences like "\n" (two characters) into a single '\n'. It does
// this for all of the supported escaped sequences and for the \0ooo (octal)
// and \xXX (hex). The resulting "dst" string will contain the character
// versions of all supported escape sequences. The common supported escape
// sequences are: "\a", "\b", "\f", "\n", "\r", "\t", "\v", "\'", "\"", "\\".
static void EncodeEscapeSequences(const char *src, std::string &dst);
// ExpandEscapeSequences will change a string of possibly non-printable
// characters and expand them into text. So '\n' will turn into two characters
// like "\n" which is suitable for human reading. When a character is not
// 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
// characters are left alone.
static void ExpandEscapedCharacters(const char *src, std::string &dst);
static std::string EscapeLLDBCommandArgument(const std::string &arg,
char quote_char);
private:
std::vector<ArgEntry> m_entries;
std::vector<char *> m_argv;
};
} // namespace lldb_private
#endif // liblldb_Command_h_

lldb/trunk/include/lldb/Interpreter/CommandAlias.h

Show All 10 Lines
#define liblldb_CommandAlias_h_ #define liblldb_CommandAlias_h_
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <memory> #include <memory>
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandObject.h" #include "lldb/Interpreter/CommandObject.h"
#include "lldb/Utility/Args.h"
#include "lldb/lldb-forward.h" #include "lldb/lldb-forward.h"
namespace lldb_private { namespace lldb_private {
class CommandAlias : public CommandObject { class CommandAlias : public CommandObject {
public: public:
typedef std::unique_ptr<CommandAlias> UniquePointer; typedef std::unique_ptr<CommandAlias> UniquePointer;
CommandAlias(CommandInterpreter &interpreter, lldb::CommandObjectSP cmd_sp, CommandAlias(CommandInterpreter &interpreter, lldb::CommandObjectSP cmd_sp,
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Interpreter/CommandInterpreter.h

Show All 13 Lines
// C++ Includes // C++ Includes
#include <mutex> #include <mutex>
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Broadcaster.h" #include "lldb/Core/Broadcaster.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Event.h" #include "lldb/Core/Event.h"
#include "lldb/Core/IOHandler.h" #include "lldb/Core/IOHandler.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandAlias.h" #include "lldb/Interpreter/CommandAlias.h"
#include "lldb/Interpreter/CommandHistory.h" #include "lldb/Interpreter/CommandHistory.h"
#include "lldb/Interpreter/CommandObject.h" #include "lldb/Interpreter/CommandObject.h"
#include "lldb/Interpreter/ScriptInterpreter.h" #include "lldb/Interpreter/ScriptInterpreter.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/StringList.h" #include "lldb/Utility/StringList.h"
#include "lldb/lldb-forward.h" #include "lldb/lldb-forward.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
class CommandInterpreterRunOptions { class CommandInterpreterRunOptions {
▲ Show 20 Lines • Show All 545 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Interpreter/CommandObject.h

Show All 14 Lines
#include <map> #include <map>
#include <string> #include <string>
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Utility/Flags.h" #include "lldb/Utility/Flags.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandCompletions.h" #include "lldb/Interpreter/CommandCompletions.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/StringList.h" #include "lldb/Utility/StringList.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
// This function really deals with CommandObjectLists, but we didn't make a // This function really deals with CommandObjectLists, but we didn't make a
// CommandObjectList class, so I'm sticking it here. But we really should have // CommandObjectList class, so I'm sticking it here. But we really should have
// such a class. Anyway, it looks up the commands in the map that match the // such a class. Anyway, it looks up the commands in the map that match the
▲ Show 20 Lines • Show All 469 Lines • Show Last 20 Lines

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

Show All 11 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <set> #include <set>
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Interpreter/Args.h" #include "lldb/Utility/Args.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
namespace lldb_private { namespace lldb_private {
▲ Show 20 Lines • Show All 383 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/ProcessInfo.h

//===-- ProcessInfo.h -------------------------------------------*- C++ -*-===// //===-- ProcessInfo.h -------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_ProcessInfo_h_ #ifndef liblldb_ProcessInfo_h_
#define liblldb_ProcessInfo_h_ #define liblldb_ProcessInfo_h_
// LLDB headers // LLDB headers
#include "lldb/Interpreter/Args.h"
#include "lldb/Utility/ArchSpec.h" #include "lldb/Utility/ArchSpec.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/Environment.h" #include "lldb/Utility/Environment.h"
#include "lldb/Utility/FileSpec.h" #include "lldb/Utility/FileSpec.h"
namespace lldb_private { namespace lldb_private {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// ProcessInfo // ProcessInfo
// //
// A base class for information for a process. This can be used to fill // A base class for information for a process. This can be used to fill
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Utility/Args.h

//===-- Args.h --------------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_UTILITY_ARGS_H
#define LLDB_UTILITY_ARGS_H
#include "lldb/Utility/Environment.h"
#include "lldb/lldb-private-types.h"
#include "lldb/lldb-types.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringRef.h"
#include <string>
#include <utility>
#include <vector>
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Args Args.h "lldb/Utility/Args.h"
/// @brief A command line argument class.
///
/// The Args class is designed to be fed a command line. The
/// command line is copied into an internal buffer and then split up
/// into arguments. Arguments are space delimited if there are no quotes
/// (single, double, or backtick quotes) surrounding the argument. Spaces
/// can be escaped using a \ character to avoid having to surround an
/// argument that contains a space with quotes.
//----------------------------------------------------------------------
class Args {
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.
///
/// @param[in] command
/// A NULL terminated command that will be copied and split up
/// into arguments.
///
/// @see Args::SetCommandString(llvm::StringRef)
//------------------------------------------------------------------
Args(llvm::StringRef command = llvm::StringRef());
Args(const Args &rhs);
explicit Args(const StringList &list);
Args &operator=(const Args &rhs);
//------------------------------------------------------------------
/// Destructor.
//------------------------------------------------------------------
~Args();
explicit Args(const Environment &env) : Args() {
SetArguments(const_cast<const char **>(env.getEnvp().get()));
}
explicit operator Environment() const { return GetConstArgumentVector(); }
//------------------------------------------------------------------
/// Dump all entries to the stream \a s using label \a label_name.
///
/// If label_name is nullptr, the dump operation is skipped.
///
/// @param[in] s
/// The stream to which to dump all arguments in the argument
/// vector.
/// @param[in] label_name
/// The label_name to use as the label printed for each
/// entry of the args like so:
/// {label_name}[{index}]={value}
//------------------------------------------------------------------
void Dump(Stream &s, const char *label_name = "argv") const;
//------------------------------------------------------------------
/// Sets the command string contained by this object.
///
/// The command string will be copied and split up into arguments
/// that can be accessed via the accessor functions.
///
/// @param[in] command
/// A command StringRef that will be copied and split up
/// into arguments.
///
/// @see Args::GetArgumentCount() const
/// @see Args::GetArgumentAtIndex (size_t) const
/// @see Args::GetArgumentVector ()
/// @see Args::Shift ()
/// @see Args::Unshift (const char *)
//------------------------------------------------------------------
void SetCommandString(llvm::StringRef command);
bool GetCommandString(std::string &command) const;
bool GetQuotedCommandString(std::string &command) const;
//------------------------------------------------------------------
/// Gets the number of arguments left in this command object.
///
/// @return
/// The number or arguments in this object.
//------------------------------------------------------------------
size_t GetArgumentCount() const;
bool empty() const { return GetArgumentCount() == 0; }
//------------------------------------------------------------------
/// Gets the NULL terminated C string argument pointer for the
/// argument at index \a idx.
///
/// @return
/// The NULL terminated C string argument pointer if \a idx is a
/// valid argument index, NULL otherwise.
//------------------------------------------------------------------
const char *GetArgumentAtIndex(size_t idx) const;
llvm::ArrayRef<ArgEntry> entries() const { return m_entries; }
char GetArgumentQuoteCharAtIndex(size_t idx) const;
using const_iterator = std::vector<ArgEntry>::const_iterator;
const_iterator begin() const { return m_entries.begin(); }
const_iterator end() const { return m_entries.end(); }
size_t size() const { return GetArgumentCount(); }
const ArgEntry &operator[](size_t n) const { return m_entries[n]; }
//------------------------------------------------------------------
/// Gets the argument vector.
///
/// The value returned by this function can be used by any function
/// that takes and vector. The return value is just like \a argv
/// in the standard C entry point function:
/// \code
/// int main (int argc, const char **argv);
/// \endcode
///
/// @return
/// An array of NULL terminated C string argument pointers that
/// also has a terminating NULL C string pointer
//------------------------------------------------------------------
char **GetArgumentVector();
//------------------------------------------------------------------
/// Gets the argument vector.
///
/// The value returned by this function can be used by any function
/// that takes and vector. The return value is just like \a argv
/// in the standard C entry point function:
/// \code
/// int main (int argc, const char **argv);
/// \endcode
///
/// @return
/// An array of NULL terminate C string argument pointers that
/// also has a terminating NULL C string pointer
//------------------------------------------------------------------
const char **GetConstArgumentVector() const;
//------------------------------------------------------------------
/// Gets the argument as an ArrayRef. Note that the return value does *not*
/// have a nullptr const char * at the end, as the size of the list is
/// embedded in the ArrayRef object.
//------------------------------------------------------------------
llvm::ArrayRef<const char *> GetArgumentArrayRef() const {
return llvm::makeArrayRef(m_argv).drop_back();
}
//------------------------------------------------------------------
/// Appends a new argument to the end of the list argument list.
///
/// @param[in] arg_cstr
/// The new argument as a NULL terminated C string.
///
/// @param[in] quote_char
/// If the argument was originally quoted, put in the quote char here.
//------------------------------------------------------------------
void AppendArgument(llvm::StringRef arg_str, char quote_char = '\0');
void AppendArguments(const Args &rhs);
void AppendArguments(const char **argv);
//------------------------------------------------------------------
/// Insert the argument value at index \a idx to \a arg_cstr.
///
/// @param[in] idx
/// The index of where to insert the argument.
///
/// @param[in] arg_cstr
/// The new argument as a NULL terminated C string.
///
/// @param[in] quote_char
/// If the argument was originally quoted, put in the quote char here.
///
/// @return
/// The NULL terminated C string of the copy of \a arg_cstr.
//------------------------------------------------------------------
void InsertArgumentAtIndex(size_t idx, llvm::StringRef arg_str,
char quote_char = '\0');
//------------------------------------------------------------------
/// Replaces the argument value at index \a idx to \a arg_cstr
/// if \a idx is a valid argument index.
///
/// @param[in] idx
/// The index of the argument that will have its value replaced.
///
/// @param[in] arg_cstr
/// The new argument as a NULL terminated C string.
///
/// @param[in] quote_char
/// If the argument was originally quoted, put in the quote char here.
//------------------------------------------------------------------
void ReplaceArgumentAtIndex(size_t idx, llvm::StringRef arg_str,
char quote_char = '\0');
//------------------------------------------------------------------
/// Deletes the argument value at index
/// if \a idx is a valid argument index.
///
/// @param[in] idx
/// The index of the argument that will have its value replaced.
///
//------------------------------------------------------------------
void DeleteArgumentAtIndex(size_t idx);
//------------------------------------------------------------------
/// Sets the argument vector value, optionally copying all
/// arguments into an internal buffer.
///
/// Sets the arguments to match those found in \a argv. All argument
/// strings will be copied into an internal buffers.
//
// FIXME: Handle the quote character somehow.
//------------------------------------------------------------------
void SetArguments(size_t argc, const char **argv);
void SetArguments(const char **argv);
//------------------------------------------------------------------
/// Shifts the first argument C string value of the array off the
/// argument array.
///
/// The string value will be freed, so a copy of the string should
/// be made by calling Args::GetArgumentAtIndex (size_t) const
/// first and copying the returned value before calling
/// Args::Shift().
///
/// @see Args::GetArgumentAtIndex (size_t) const
//------------------------------------------------------------------
void Shift();
//------------------------------------------------------------------
/// Inserts a class owned copy of \a arg_cstr at the beginning of
/// the argument vector.
///
/// A copy \a arg_cstr will be made.
///
/// @param[in] arg_cstr
/// The argument to push on the front of the argument stack.
///
/// @param[in] quote_char
/// If the argument was originally quoted, put in the quote char here.
//------------------------------------------------------------------
void Unshift(llvm::StringRef arg_str, char quote_char = '\0');
//------------------------------------------------------------------
// Clear the arguments.
//
// For re-setting or blanking out the list of arguments.
//------------------------------------------------------------------
void Clear();
static const char *StripSpaces(std::string &s, bool leading = true,
bool trailing = true,
bool return_null_if_empty = true);
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;
const uint64_t max = ((uint64_t)1 << (uint64_t)(total_byte_size * 8)) - 1;
return uval64 <= max;
}
static bool SInt64ValueIsValidForByteSize(int64_t sval64,
size_t total_byte_size) {
if (total_byte_size > 8)
return false;
if (total_byte_size == 8)
return true;
const int64_t max = ((int64_t)1 << (uint64_t)(total_byte_size * 8 - 1)) - 1;
const int64_t min = ~(max);
return min <= sval64 && sval64 <= max;
}
static lldb::Encoding
StringToEncoding(llvm::StringRef s,
lldb::Encoding fail_value = lldb::eEncodingInvalid);
static uint32_t StringToGenericRegister(llvm::StringRef s);
static bool StringToVersion(llvm::StringRef string, uint32_t &major,
uint32_t &minor, uint32_t &update);
static const char *GetShellSafeArgument(const FileSpec &shell,
const char *unsafe_arg,
std::string &safe_arg);
// EncodeEscapeSequences will change the textual representation of common
// escape sequences like "\n" (two characters) into a single '\n'. It does
// this for all of the supported escaped sequences and for the \0ooo (octal)
// and \xXX (hex). The resulting "dst" string will contain the character
// versions of all supported escape sequences. The common supported escape
// sequences are: "\a", "\b", "\f", "\n", "\r", "\t", "\v", "\'", "\"", "\\".
static void EncodeEscapeSequences(const char *src, std::string &dst);
// ExpandEscapeSequences will change a string of possibly non-printable
// characters and expand them into text. So '\n' will turn into two characters
// like "\n" which is suitable for human reading. When a character is not
// 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
// characters are left alone.
static void ExpandEscapedCharacters(const char *src, std::string &dst);
static std::string EscapeLLDBCommandArgument(const std::string &arg,
char quote_char);
private:
std::vector<ArgEntry> m_entries;
std::vector<char *> m_argv;
};
} // namespace lldb_private
#endif // LLDB_UTILITY_ARGS_H

lldb/trunk/source/API/SBDebugger.cpp

Show All 39 Lines
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StructuredDataImpl.h" #include "lldb/Core/StructuredDataImpl.h"
#include "lldb/DataFormatters/DataVisualization.h" #include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/Host/XML.h" #include "lldb/Host/XML.h"
#include "lldb/Initialization/SystemLifetimeManager.h" #include "lldb/Initialization/SystemLifetimeManager.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/OptionArgParser.h" #include "lldb/Interpreter/OptionArgParser.h"
#include "lldb/Interpreter/OptionGroupPlatform.h" #include "lldb/Interpreter/OptionGroupPlatform.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/TargetList.h" #include "lldb/Target/TargetList.h"
#include "lldb/Utility/Args.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Support/DynamicLibrary.h" #include "llvm/Support/DynamicLibrary.h"
#include "llvm/Support/ManagedStatic.h" #include "llvm/Support/ManagedStatic.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 1,188 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBPlatform.cpp

//===-- SBPlatform.cpp ------------------------------------------*- C++ -*-===// //===-- SBPlatform.cpp ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/API/SBPlatform.h" #include "lldb/API/SBPlatform.h"
#include "lldb/API/SBError.h" #include "lldb/API/SBError.h"
#include "lldb/API/SBFileSpec.h" #include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBLaunchInfo.h" #include "lldb/API/SBLaunchInfo.h"
#include "lldb/API/SBUnixSignals.h" #include "lldb/API/SBUnixSignals.h"
#include "lldb/Host/File.h" #include "lldb/Host/File.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Target/Platform.h" #include "lldb/Target/Platform.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/ArchSpec.h" #include "lldb/Utility/ArchSpec.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
#include <functional> #include <functional>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 460 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBProcess.cpp

Show All 14 Lines
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Target/MemoryRegionInfo.h" #include "lldb/Target/MemoryRegionInfo.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/SystemRuntime.h" #include "lldb/Target/SystemRuntime.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/Stream.h" #include "lldb/Utility/Stream.h"
// Project includes // Project includes
#include "lldb/API/SBBroadcaster.h" #include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBCommandReturnObject.h" #include "lldb/API/SBCommandReturnObject.h"
#include "lldb/API/SBDebugger.h" #include "lldb/API/SBDebugger.h"
▲ Show 20 Lines • Show All 1,344 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBTarget.cpp

Show All 38 Lines
#include "lldb/Core/STLUtils.h" #include "lldb/Core/STLUtils.h"
#include "lldb/Core/SearchFilter.h" #include "lldb/Core/SearchFilter.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/StructuredDataImpl.h" #include "lldb/Core/StructuredDataImpl.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Core/ValueObjectList.h" #include "lldb/Core/ValueObjectList.h"
#include "lldb/Core/ValueObjectVariable.h" #include "lldb/Core/ValueObjectVariable.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/DeclVendor.h" #include "lldb/Symbol/DeclVendor.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ABI.h" #include "lldb/Target/ABI.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Target/LanguageRuntime.h" #include "lldb/Target/LanguageRuntime.h"
#include "lldb/Target/ObjCLanguageRuntime.h" #include "lldb/Target/ObjCLanguageRuntime.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 "lldb/Target/TargetList.h" #include "lldb/Target/TargetList.h"
#include "lldb/Utility/ArchSpec.h" #include "lldb/Utility/ArchSpec.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/FileSpec.h" #include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/RegularExpression.h" #include "lldb/Utility/RegularExpression.h"
#include "../source/Commands/CommandObjectBreakpoint.h" #include "../source/Commands/CommandObjectBreakpoint.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "llvm/Support/PrettyStackTrace.h" #include "llvm/Support/PrettyStackTrace.h"
#include "llvm/Support/Regex.h" #include "llvm/Support/Regex.h"
▲ Show 20 Lines • Show All 2,158 Lines • Show Last 20 Lines

lldb/trunk/source/Breakpoint/BreakpointIDList.cpp

Show All 10 Lines
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
#include "lldb/Breakpoint/BreakpointIDList.h" #include "lldb/Breakpoint/BreakpointIDList.h"
#include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Args.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// class BreakpointIDList // class BreakpointIDList
//---------------------------------------------------------------------- //----------------------------------------------------------------------
▲ Show 20 Lines • Show All 327 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandCompletions.cpp

Show All 17 Lines
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringSet.h" #include "llvm/ADT/StringSet.h"
// Project includes // Project includes
#include "lldb/Core/FileSpecList.h" #include "lldb/Core/FileSpecList.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandCompletions.h" #include "lldb/Interpreter/CommandCompletions.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/OptionValueProperties.h" #include "lldb/Interpreter/OptionValueProperties.h"
#include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/Variable.h" #include "lldb/Symbol/Variable.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/FileSpec.h" #include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StreamString.h"
#include "lldb/Utility/TildeExpressionResolver.h" #include "lldb/Utility/TildeExpressionResolver.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
▲ Show 20 Lines • Show All 528 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectApropos.cpp

//===-- CommandObjectApropos.cpp ---------------------------------*- C++ //===-- CommandObjectApropos.cpp ---------------------------------*- C++
//-*-===// //-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "CommandObjectApropos.h" #include "CommandObjectApropos.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/Interpreter/Property.h" #include "lldb/Interpreter/Property.h"
#include "lldb/Utility/Args.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
// CommandObjectApropos // CommandObjectApropos
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectCommands.cpp

Show All 12 Lines
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
// Project includes // Project includes
#include "CommandObjectCommands.h" #include "CommandObjectCommands.h"
#include "CommandObjectHelp.h" #include "CommandObjectHelp.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/IOHandler.h" #include "lldb/Core/IOHandler.h"
#include "lldb/Host/OptionParser.h" #include "lldb/Host/OptionParser.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandHistory.h" #include "lldb/Interpreter/CommandHistory.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandObjectRegexCommand.h" #include "lldb/Interpreter/CommandObjectRegexCommand.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/OptionArgParser.h" #include "lldb/Interpreter/OptionArgParser.h"
#include "lldb/Interpreter/OptionValueBoolean.h" #include "lldb/Interpreter/OptionValueBoolean.h"
#include "lldb/Interpreter/OptionValueString.h" #include "lldb/Interpreter/OptionValueString.h"
#include "lldb/Interpreter/OptionValueUInt64.h" #include "lldb/Interpreter/OptionValueUInt64.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Interpreter/ScriptInterpreter.h" #include "lldb/Interpreter/ScriptInterpreter.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/StringList.h" #include "lldb/Utility/StringList.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
// CommandObjectCommandsSource // CommandObjectCommandsSource
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
▲ Show 20 Lines • Show All 1,924 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectFrame.cpp

Show All 18 Lines
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/Value.h" #include "lldb/Core/Value.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectVariable.h" #include "lldb/Core/ValueObjectVariable.h"
#include "lldb/DataFormatters/DataVisualization.h" #include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/DataFormatters/ValueObjectPrinter.h" #include "lldb/DataFormatters/ValueObjectPrinter.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/OptionParser.h" #include "lldb/Host/OptionParser.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/OptionGroupFormat.h" #include "lldb/Interpreter/OptionGroupFormat.h"
#include "lldb/Interpreter/OptionGroupValueObjectDisplay.h" #include "lldb/Interpreter/OptionGroupValueObjectDisplay.h"
#include "lldb/Interpreter/OptionGroupVariable.h" #include "lldb/Interpreter/OptionGroupVariable.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/Type.h" #include "lldb/Symbol/Type.h"
#include "lldb/Symbol/Variable.h" #include "lldb/Symbol/Variable.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/StopInfo.h" #include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StreamString.h"
#include "lldb/Utility/Timer.h" #include "lldb/Utility/Timer.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
#pragma mark CommandObjectFrameDiagnose #pragma mark CommandObjectFrameDiagnose
▲ Show 20 Lines • Show All 708 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectLog.cpp

Show All 10 Lines
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "CommandObjectLog.h" #include "CommandObjectLog.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Host/OptionParser.h" #include "lldb/Host/OptionParser.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/OptionArgParser.h" #include "lldb/Interpreter/OptionArgParser.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Symbol/LineTable.h" #include "lldb/Symbol/LineTable.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/FileSpec.h" #include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/RegularExpression.h" #include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Stream.h" #include "lldb/Utility/Stream.h"
#include "lldb/Utility/Timer.h" #include "lldb/Utility/Timer.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 343 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectMemory.cpp

Show All 18 Lines
#include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h" #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/DumpDataExtractor.h" #include "lldb/Core/DumpDataExtractor.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/ValueObjectMemory.h" #include "lldb/Core/ValueObjectMemory.h"
#include "lldb/DataFormatters/ValueObjectPrinter.h" #include "lldb/DataFormatters/ValueObjectPrinter.h"
#include "lldb/Host/OptionParser.h" #include "lldb/Host/OptionParser.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/OptionArgParser.h" #include "lldb/Interpreter/OptionArgParser.h"
#include "lldb/Interpreter/OptionGroupFormat.h" #include "lldb/Interpreter/OptionGroupFormat.h"
#include "lldb/Interpreter/OptionGroupOutputFile.h" #include "lldb/Interpreter/OptionGroupOutputFile.h"
#include "lldb/Interpreter/OptionGroupValueObjectDisplay.h" #include "lldb/Interpreter/OptionGroupValueObjectDisplay.h"
#include "lldb/Interpreter/OptionValueString.h" #include "lldb/Interpreter/OptionValueString.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/TypeList.h" #include "lldb/Symbol/TypeList.h"
#include "lldb/Target/MemoryHistory.h" #include "lldb/Target/MemoryHistory.h"
#include "lldb/Target/MemoryRegionInfo.h" #include "lldb/Target/MemoryRegionInfo.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/DataBufferHeap.h" #include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/DataBufferLLVM.h" #include "lldb/Utility/DataBufferLLVM.h"
#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StreamString.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 1,742 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectPlatform.cpp

Show All 12 Lines
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "CommandObjectPlatform.h" #include "CommandObjectPlatform.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Host/OptionParser.h" #include "lldb/Host/OptionParser.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandOptionValidators.h" #include "lldb/Interpreter/CommandOptionValidators.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/OptionGroupFile.h" #include "lldb/Interpreter/OptionGroupFile.h"
#include "lldb/Interpreter/OptionGroupPlatform.h" #include "lldb/Interpreter/OptionGroupPlatform.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Platform.h" #include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/DataExtractor.h" #include "lldb/Utility/DataExtractor.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
#include "llvm/Support/Threading.h" #include "llvm/Support/Threading.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 1,875 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectProcess.cpp

Show All 15 Lines
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Breakpoint/BreakpointSite.h" #include "lldb/Breakpoint/BreakpointSite.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/OptionParser.h" #include "lldb/Host/OptionParser.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.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/OptionArgParser.h" #include "lldb/Interpreter/OptionArgParser.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Target/Platform.h" #include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/StopInfo.h" #include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/UnixSignals.h" #include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/Args.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
class CommandObjectProcessLaunchOrAttach : public CommandObjectParsed { class CommandObjectProcessLaunchOrAttach : public CommandObjectParsed {
public: public:
CommandObjectProcessLaunchOrAttach(CommandInterpreter &interpreter, CommandObjectProcessLaunchOrAttach(CommandInterpreter &interpreter,
const char *name, const char *help, const char *name, const char *help,
▲ Show 20 Lines • Show All 1,613 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectRegister.cpp

//===-- CommandObjectRegister.cpp -------------------------------*- C++ -*-===// //===-- CommandObjectRegister.cpp -------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CommandObjectRegister.h" #include "CommandObjectRegister.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Host/OptionParser.h" #include "lldb/Host/OptionParser.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/OptionGroupFormat.h" #include "lldb/Interpreter/OptionGroupFormat.h"
#include "lldb/Interpreter/OptionValueArray.h" #include "lldb/Interpreter/OptionValueArray.h"
#include "lldb/Interpreter/OptionValueBoolean.h" #include "lldb/Interpreter/OptionValueBoolean.h"
#include "lldb/Interpreter/OptionValueUInt64.h" #include "lldb/Interpreter/OptionValueUInt64.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/DataExtractor.h" #include "lldb/Utility/DataExtractor.h"
#include "llvm/Support/Errno.h" #include "llvm/Support/Errno.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// "register read" // "register read"
▲ Show 20 Lines • Show All 375 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectTarget.cpp

Show All 15 Lines
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/ValueObjectVariable.h" #include "lldb/Core/ValueObjectVariable.h"
#include "lldb/DataFormatters/ValueObjectPrinter.h" #include "lldb/DataFormatters/ValueObjectPrinter.h"
#include "lldb/Host/OptionParser.h" #include "lldb/Host/OptionParser.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Host/Symbols.h" #include "lldb/Host/Symbols.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/OptionArgParser.h" #include "lldb/Interpreter/OptionArgParser.h"
#include "lldb/Interpreter/OptionGroupArchitecture.h" #include "lldb/Interpreter/OptionGroupArchitecture.h"
#include "lldb/Interpreter/OptionGroupBoolean.h" #include "lldb/Interpreter/OptionGroupBoolean.h"
#include "lldb/Interpreter/OptionGroupFile.h" #include "lldb/Interpreter/OptionGroupFile.h"
#include "lldb/Interpreter/OptionGroupFormat.h" #include "lldb/Interpreter/OptionGroupFormat.h"
#include "lldb/Interpreter/OptionGroupPlatform.h" #include "lldb/Interpreter/OptionGroupPlatform.h"
Show All 13 Lines
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ABI.h" #include "lldb/Target/ABI.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadSpec.h" #include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/Timer.h" #include "lldb/Utility/Timer.h"
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
#include "llvm/Support/FormatAdapters.h" #include "llvm/Support/FormatAdapters.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <cerrno> #include <cerrno>
▲ Show 20 Lines • Show All 4,879 Lines • Show Last 20 Lines

lldb/trunk/source/Core/RegisterValue.cpp

//===-- RegisterValue.cpp ---------------------------------------*- C++ -*-===// //===-- RegisterValue.cpp ---------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/DumpDataExtractor.h" #include "lldb/Core/DumpDataExtractor.h"
#include "lldb/Core/Scalar.h" #include "lldb/Core/Scalar.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Utility/Args.h"
#include "lldb/Utility/DataExtractor.h" #include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#include "lldb/Utility/Stream.h" #include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StreamString.h"
#include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS #include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS
#include "lldb/lldb-private-types.h" // for RegisterInfo, type128 #include "lldb/lldb-private-types.h" // for RegisterInfo, type128
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
▲ Show 20 Lines • Show All 946 Lines • Show Last 20 Lines

lldb/trunk/source/Host/CMakeLists.txt

Show First 20 Lines • Show All 174 Lines • ▼ Show 20 Linesif (NOT LLDB_DISABLE_LIBEDIT)
list(APPEND EXTRA_LIBS edit) list(APPEND EXTRA_LIBS edit)
endif() endif()
add_lldb_library(lldbHost add_lldb_library(lldbHost
${HOST_SOURCES} ${HOST_SOURCES}
LINK_LIBS LINK_LIBS
lldbCore lldbCore
lldbInterpreter
lldbSymbol lldbSymbol
lldbTarget lldbTarget
lldbUtility lldbUtility
${LLDB_PLUGINS} ${LLDB_PLUGINS}
${EXTRA_LIBS} ${EXTRA_LIBS}
LINK_COMPONENTS LINK_COMPONENTS
Object Object
Support Support
) )

lldb/trunk/source/Host/macosx/HostInfoMacOSX.mm

//===-- HostInfoMacOSX.mm ---------------------------------------*- C++ -*-===// //===-- HostInfoMacOSX.mm ---------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#if !defined(LLDB_DISABLE_PYTHON) #if !defined(LLDB_DISABLE_PYTHON)
#include "Plugins/ScriptInterpreter/Python/lldb-python.h" #include "Plugins/ScriptInterpreter/Python/lldb-python.h"
#endif #endif
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Host/macosx/HostInfoMacOSX.h" #include "lldb/Host/macosx/HostInfoMacOSX.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Utility/Args.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/SafeMachO.h" #include "lldb/Utility/SafeMachO.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
// C++ Includes // C++ Includes
▲ Show 20 Lines • Show All 313 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/Args.cpp

//===-- Args.cpp ------------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// C Includes
#include <cstdlib>
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Interpreter/Args.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StringList.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringSwitch.h"
using namespace lldb;
using namespace lldb_private;
// A helper function for argument parsing.
// 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) {
// Inside double quotes, '\' and '"' are special.
static const char *k_escapable_characters = "\"\\";
while (true) {
// Skip over over regular characters and append them.
size_t regular = quoted.find_first_of(k_escapable_characters);
result += quoted.substr(0, regular);
quoted = quoted.substr(regular);
// 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()) {
// A lone backslash at the end of string, let's just append it.
result += '\\';
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();
}
return quoted;
}
static size_t ArgvToArgc(const char **argv) {
if (!argv)
return 0;
size_t count = 0;
while (*argv++)
++count;
return count;
}
// 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;
// Since we can have multiple quotes that form a single command
// in a command like: "Hello "world'!' (which will make a single
// argument "Hello world!") we remember the first quote character
// we encounter and use that for the quote character.
char first_quote_char = '\0';
bool arg_complete = false;
do {
// 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);
if (command.empty())
break;
char special = command.front();
command = command.drop_front();
switch (special) {
case '\\':
if (command.empty()) {
arg += '\\';
break;
}
// If the character after the backslash is not a whitelisted escapable
// character, we
// leave the character sequence untouched.
if (strchr(" \t\\'\"`", command.front()) == nullptr)
arg += '\\';
arg += command.front();
command = command.drop_front();
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;
case '"':
case '\'':
case '`':
// We found the start of a quote scope.
if (first_quote_char == '\0')
first_quote_char = special;
if (special == '"')
command = ParseDoubleQuotes(command, arg);
else {
// For single quotes, we simply skip ahead to the matching quote
// character
// (or the end of the string).
size_t quoted = command.find(special);
arg += command.substr(0, quoted);
command = command.substr(quoted);
}
// If we found a closing quote, skip it.
if (!command.empty())
command = command.drop_front();
break;
}
} while (!arg_complete);
return std::make_tuple(arg, first_quote_char, command);
}
Args::ArgEntry::ArgEntry(llvm::StringRef str, char quote) : quote(quote) {
size_t size = str.size();
ptr.reset(new char[size + 1]);
::memcpy(data(), str.data() ? str.data() : "", size);
ptr[size] = 0;
ref = llvm::StringRef(c_str(), size);
}
//----------------------------------------------------------------------
// Args constructor
//----------------------------------------------------------------------
Args::Args(llvm::StringRef command) { SetCommandString(command); }
Args::Args(const Args &rhs) { *this = rhs; }
Args::Args(const StringList &list) : Args() {
for(size_t i = 0; i < list.GetSize(); ++i)
AppendArgument(list[i]);
}
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;
}
//----------------------------------------------------------------------
// Destructor
//----------------------------------------------------------------------
Args::~Args() {}
void Args::Dump(Stream &s, const char *label_name) const {
if (!label_name)
return;
int i = 0;
for (auto &entry : m_entries) {
s.Indent();
s.Format("{0}[{1}]=\"{2}\"\n", label_name, i++, entry.ref);
}
s.Format("{0}[{1}]=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;
}
return !m_entries.empty();
}
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;
}
}
return !m_entries.empty();
}
void Args::SetCommandString(llvm::StringRef command) {
Clear();
m_argv.clear();
static const char *k_space_separators = " \t";
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);
}
size_t Args::GetArgumentCount() const { return m_entries.size(); }
const char *Args::GetArgumentAtIndex(size_t idx) const {
if (idx < m_argv.size())
return m_argv[idx];
return nullptr;
}
char Args::GetArgumentQuoteCharAtIndex(size_t idx) const {
if (idx < m_entries.size())
return m_entries[idx].quote;
return '\0';
}
char **Args::GetArgumentVector() {
assert(!m_argv.empty());
// TODO: functions like execve and posix_spawnp exhibit undefined behavior
// 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 {
assert(!m_argv.empty());
return (m_argv.size() > 1) ? const_cast<const char **>(m_argv.data())
: nullptr;
}
void Args::Shift() {
// Don't pop the last NULL terminator from the argv array
if (m_entries.empty())
return;
m_argv.erase(m_argv.begin());
m_entries.erase(m_entries.begin());
}
void Args::Unshift(llvm::StringRef arg_str, char quote_char) {
InsertArgumentAtIndex(0, arg_str, quote_char);
}
void Args::AppendArguments(const Args &rhs) {
assert(m_argv.size() == m_entries.size() + 1);
assert(m_argv.back() == nullptr);
m_argv.pop_back();
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) {
size_t argc = ArgvToArgc(argv);
assert(m_argv.size() == m_entries.size() + 1);
assert(m_argv.back() == nullptr);
m_argv.pop_back();
for (auto arg : llvm::makeArrayRef(argv, argc)) {
m_entries.emplace_back(arg, '\0');
m_argv.push_back(m_entries.back().data());
}
m_argv.push_back(nullptr);
}
void Args::AppendArgument(llvm::StringRef arg_str, char quote_char) {
InsertArgumentAtIndex(GetArgumentCount(), arg_str, quote_char);
}
void Args::InsertArgumentAtIndex(size_t idx, llvm::StringRef arg_str,
char quote_char) {
assert(m_argv.size() == m_entries.size() + 1);
assert(m_argv.back() == nullptr);
if (idx > m_entries.size())
return;
m_entries.emplace(m_entries.begin() + idx, arg_str, quote_char);
m_argv.insert(m_argv.begin() + idx, m_entries[idx].data());
}
void Args::ReplaceArgumentAtIndex(size_t idx, llvm::StringRef arg_str,
char quote_char) {
assert(m_argv.size() == m_entries.size() + 1);
assert(m_argv.back() == nullptr);
if (idx >= m_entries.size())
return;
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());
}
}
void Args::DeleteArgumentAtIndex(size_t idx) {
if (idx >= m_entries.size())
return;
m_argv.erase(m_argv.begin() + idx);
m_entries.erase(m_entries.begin() + idx);
}
void Args::SetArguments(size_t argc, const char **argv) {
Clear();
auto args = llvm::makeArrayRef(argv, argc);
m_entries.resize(argc);
m_argv.resize(argc + 1);
for (size_t i = 0; i < args.size(); ++i) {
char quote =
((args[i][0] == '\'') || (args[i][0] == '"') || (args[i][0] == '`'))
? args[i][0]
: '\0';
m_entries[i] = ArgEntry(args[i], quote);
m_argv[i] = m_entries[i].data();
}
}
void Args::SetArguments(const char **argv) {
SetArguments(ArgvToArgc(argv), argv);
}
void Args::Clear() {
m_entries.clear();
m_argv.clear();
m_argv.push_back(nullptr);
}
const char *Args::StripSpaces(std::string &s, bool leading, bool trailing,
bool return_null_if_empty) {
static const char *k_white_space = " \t\v";
if (!s.empty()) {
if (leading) {
size_t pos = s.find_first_not_of(k_white_space);
if (pos == std::string::npos)
s.clear();
else if (pos > 0)
s.erase(0, pos);
}
if (trailing) {
size_t rpos = s.find_last_not_of(k_white_space);
if (rpos != std::string::npos && rpos + 1 < s.size())
s.erase(rpos + 1);
}
}
if (return_null_if_empty && s.empty())
return nullptr;
return s.c_str();
}
bool Args::StringToVersion(llvm::StringRef string, uint32_t &major,
uint32_t &minor, uint32_t &update) {
major = UINT32_MAX;
minor = UINT32_MAX;
update = UINT32_MAX;
if (string.empty())
return false;
llvm::StringRef major_str, minor_str, update_str;
std::tie(major_str, minor_str) = string.split('.');
std::tie(minor_str, update_str) = minor_str.split('.');
if (major_str.getAsInteger(10, major))
return false;
if (!minor_str.empty() && minor_str.getAsInteger(10, minor))
return false;
if (!update_str.empty() && update_str.getAsInteger(10, update))
return false;
return true;
}
const char *Args::GetShellSafeArgument(const FileSpec &shell,
const char *unsafe_arg,
std::string &safe_arg) {
struct ShellDescriptor {
ConstString m_basename;
const char *m_escapables;
};
static ShellDescriptor g_Shells[] = {{ConstString("bash"), " '\"<>()&"},
{ConstString("tcsh"), " '\"<>()&$"},
{ConstString("sh"), " '\"<>()&"}};
// safe minimal set
const char *escapables = " '\"";
if (auto basename = shell.GetFilename()) {
for (const auto &Shell : g_Shells) {
if (Shell.m_basename == basename) {
escapables = Shell.m_escapables;
break;
}
}
}
safe_arg.assign(unsafe_arg);
size_t prev_pos = 0;
while (prev_pos < safe_arg.size()) {
// Escape spaces and quotes
size_t pos = safe_arg.find_first_of(escapables, prev_pos);
if (pos != std::string::npos) {
safe_arg.insert(pos, 1, '\\');
prev_pos = pos + 2;
} else
break;
}
return safe_arg.c_str();
}
lldb::Encoding Args::StringToEncoding(llvm::StringRef s,
lldb::Encoding fail_value) {
return llvm::StringSwitch<lldb::Encoding>(s)
.Case("uint", eEncodingUint)
.Case("sint", eEncodingSint)
.Case("ieee754", eEncodingIEEE754)
.Case("vector", eEncodingVector)
.Default(fail_value);
}
uint32_t Args::StringToGenericRegister(llvm::StringRef s) {
if (s.empty())
return LLDB_INVALID_REGNUM;
uint32_t result = llvm::StringSwitch<uint32_t>(s)
.Case("pc", LLDB_REGNUM_GENERIC_PC)
.Case("sp", LLDB_REGNUM_GENERIC_SP)
.Case("fp", LLDB_REGNUM_GENERIC_FP)
.Cases("ra", "lr", LLDB_REGNUM_GENERIC_RA)
.Case("flags", LLDB_REGNUM_GENERIC_FLAGS)
.Case("arg1", LLDB_REGNUM_GENERIC_ARG1)
.Case("arg2", LLDB_REGNUM_GENERIC_ARG2)
.Case("arg3", LLDB_REGNUM_GENERIC_ARG3)
.Case("arg4", LLDB_REGNUM_GENERIC_ARG4)
.Case("arg5", LLDB_REGNUM_GENERIC_ARG5)
.Case("arg6", LLDB_REGNUM_GENERIC_ARG6)
.Case("arg7", LLDB_REGNUM_GENERIC_ARG7)
.Case("arg8", LLDB_REGNUM_GENERIC_ARG8)
.Default(LLDB_INVALID_REGNUM);
return result;
}
void Args::EncodeEscapeSequences(const char *src, std::string &dst) {
dst.clear();
if (src) {
for (const char *p = src; *p != '\0'; ++p) {
size_t non_special_chars = ::strcspn(p, "\\");
if (non_special_chars > 0) {
dst.append(p, non_special_chars);
p += non_special_chars;
if (*p == '\0')
break;
}
if (*p == '\\') {
++p; // skip the slash
switch (*p) {
case 'a':
dst.append(1, '\a');
break;
case 'b':
dst.append(1, '\b');
break;
case 'f':
dst.append(1, '\f');
break;
case 'n':
dst.append(1, '\n');
break;
case 'r':
dst.append(1, '\r');
break;
case 't':
dst.append(1, '\t');
break;
case 'v':
dst.append(1, '\v');
break;
case '\\':
dst.append(1, '\\');
break;
case '\'':
dst.append(1, '\'');
break;
case '"':
dst.append(1, '"');
break;
case '0':
// 1 to 3 octal chars
{
// Make a string that can hold onto the initial zero char,
// up to 3 octal digits, and a terminating NULL.
char oct_str[5] = {'\0', '\0', '\0', '\0', '\0'};
int i;
for (i = 0; (p[i] >= '0' && p[i] <= '7') && i < 4; ++i)
oct_str[i] = p[i];
// We don't want to consume the last octal character since
// the main for loop will do this for us, so we advance p by
// one less than i (even if i is zero)
p += i - 1;
unsigned long octal_value = ::strtoul(oct_str, nullptr, 8);
if (octal_value <= UINT8_MAX) {
dst.append(1, (char)octal_value);
}
}
break;
case 'x':
// hex number in the format
if (isxdigit(p[1])) {
++p; // Skip the 'x'
// Make a string that can hold onto two hex chars plus a
// NULL terminator
char hex_str[3] = {*p, '\0', '\0'};
if (isxdigit(p[1])) {
++p; // Skip the first of the two hex chars
hex_str[1] = *p;
}
unsigned long hex_value = strtoul(hex_str, nullptr, 16);
if (hex_value <= UINT8_MAX)
dst.append(1, (char)hex_value);
} else {
dst.append(1, 'x');
}
break;
default:
// Just desensitize any other character by just printing what
// came after the '\'
dst.append(1, *p);
break;
}
}
}
}
}
void Args::ExpandEscapedCharacters(const char *src, std::string &dst) {
dst.clear();
if (src) {
for (const char *p = src; *p != '\0'; ++p) {
if (isprint(*p))
dst.append(1, *p);
else {
switch (*p) {
case '\a':
dst.append("\\a");
break;
case '\b':
dst.append("\\b");
break;
case '\f':
dst.append("\\f");
break;
case '\n':
dst.append("\\n");
break;
case '\r':
dst.append("\\r");
break;
case '\t':
dst.append("\\t");
break;
case '\v':
dst.append("\\v");
break;
case '\'':
dst.append("\\'");
break;
case '"':
dst.append("\\\"");
break;
case '\\':
dst.append("\\\\");
break;
default: {
// Just encode as octal
dst.append("\\0");
char octal_str[32];
snprintf(octal_str, sizeof(octal_str), "%o", *p);
dst.append(octal_str);
} break;
}
}
}
}
}
std::string Args::EscapeLLDBCommandArgument(const std::string &arg,
char quote_char) {
const char *chars_to_escape = nullptr;
switch (quote_char) {
case '\0':
chars_to_escape = " \t\\'\"`";
break;
case '\'':
chars_to_escape = "";
break;
case '"':
chars_to_escape = "$\"`\\";
break;
default:
assert(false && "Unhandled quote character");
}
std::string res;
res.reserve(arg.size());
for (char c : arg) {
if (::strchr(chars_to_escape, c))
res.push_back('\\');
res.push_back(c);
}
return res;
}

lldb/trunk/source/Interpreter/CMakeLists.txt

add_lldb_library(lldbInterpreter add_lldb_library(lldbInterpreter
Args.cpp
CommandAlias.cpp CommandAlias.cpp
CommandHistory.cpp CommandHistory.cpp
CommandInterpreter.cpp CommandInterpreter.cpp
CommandObject.cpp CommandObject.cpp
CommandObjectRegexCommand.cpp CommandObjectRegexCommand.cpp
CommandObjectScript.cpp CommandObjectScript.cpp
CommandOptionValidators.cpp CommandOptionValidators.cpp
CommandReturnObject.cpp CommandReturnObject.cpp
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/CommandInterpreter.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
#include "lldb/Utility/Timer.h" #include "lldb/Utility/Timer.h"
#ifndef LLDB_DISABLE_LIBEDIT #ifndef LLDB_DISABLE_LIBEDIT
#include "lldb/Host/Editline.h" #include "lldb/Host/Editline.h"
#endif #endif
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandCompletions.h" #include "lldb/Interpreter/CommandCompletions.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/OptionValueProperties.h" #include "lldb/Interpreter/OptionValueProperties.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Interpreter/Property.h" #include "lldb/Interpreter/Property.h"
#include "lldb/Utility/Args.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/TargetList.h" #include "lldb/Target/TargetList.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
▲ Show 20 Lines • Show All 3,075 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/CommandObjectScript.cpp

Show All 12 Lines
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/DataFormatters/DataVisualization.h" #include "lldb/DataFormatters/DataVisualization.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/ScriptInterpreter.h" #include "lldb/Interpreter/ScriptInterpreter.h"
#include "lldb/Utility/Args.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
// CommandObjectScript // CommandObjectScript
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueArch.cpp

Show All 9 Lines
#include "lldb/Interpreter/OptionValueArch.h" #include "lldb/Interpreter/OptionValueArch.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/DataFormatters/FormatManager.h" #include "lldb/DataFormatters/FormatManager.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandCompletions.h" #include "lldb/Interpreter/CommandCompletions.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Utility/Args.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
void OptionValueArch::DumpValue(const ExecutionContext *exe_ctx, Stream &strm, void OptionValueArch::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
uint32_t dump_mask) { uint32_t dump_mask) {
if (dump_mask & eDumpOptionType) if (dump_mask & eDumpOptionType)
strm.Printf("(%s)", GetTypeAsCString()); strm.Printf("(%s)", GetTypeAsCString());
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueArgs.cpp

//===-- OptionValueArgs.cpp -------------------------------------*- C++ -*-===// //===-- OptionValueArgs.cpp -------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValueArgs.h" #include "lldb/Interpreter/OptionValueArgs.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Interpreter/Args.h" #include "lldb/Utility/Args.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
size_t OptionValueArgs::GetArgs(Args &args) { size_t OptionValueArgs::GetArgs(Args &args) {
args.Clear(); args.Clear();
for (auto value : m_values) { for (auto value : m_values) {
llvm::StringRef string_value = value->GetStringValue(); llvm::StringRef string_value = value->GetStringValue();
if (!string_value.empty()) if (!string_value.empty())
args.AppendArgument(string_value); args.AppendArgument(string_value);
} }
return args.GetArgumentCount(); return args.GetArgumentCount();
} }

lldb/trunk/source/Interpreter/OptionValueArray.cpp

//===-- OptionValueArray.cpp ------------------------------------*- C++ -*-===// //===-- OptionValueArray.cpp ------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValueArray.h" #include "lldb/Interpreter/OptionValueArray.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Utility/Args.h"
#include "lldb/Utility/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
void OptionValueArray::DumpValue(const ExecutionContext *exe_ctx, Stream &strm, void OptionValueArray::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
uint32_t dump_mask) { uint32_t dump_mask) {
const Type array_element_type = ConvertTypeMaskToType(m_type_mask); const Type array_element_type = ConvertTypeMaskToType(m_type_mask);
▲ Show 20 Lines • Show All 286 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueDictionary.cpp

Show All 10 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
// Project includes // Project includes
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/DataFormatters/FormatManager.h" #include "lldb/DataFormatters/FormatManager.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/OptionValueString.h" #include "lldb/Interpreter/OptionValueString.h"
#include "lldb/Utility/Args.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
void OptionValueDictionary::DumpValue(const ExecutionContext *exe_ctx, void OptionValueDictionary::DumpValue(const ExecutionContext *exe_ctx,
Stream &strm, uint32_t dump_mask) { Stream &strm, uint32_t dump_mask) {
const Type dict_type = ConvertTypeMaskToType(m_type_mask); const Type dict_type = ConvertTypeMaskToType(m_type_mask);
if (dump_mask & eDumpOptionType) { if (dump_mask & eDumpOptionType) {
▲ Show 20 Lines • Show All 295 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueFileSpec.cpp

//===-- OptionValueFileSpec.cpp ---------------------------------*- C++ -*-===// //===-- OptionValueFileSpec.cpp ---------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValueFileSpec.h" #include "lldb/Interpreter/OptionValueFileSpec.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/DataFormatters/FormatManager.h" #include "lldb/DataFormatters/FormatManager.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandCompletions.h" #include "lldb/Interpreter/CommandCompletions.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/DataBufferLLVM.h" #include "lldb/Utility/DataBufferLLVM.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
OptionValueFileSpec::OptionValueFileSpec(bool resolve) OptionValueFileSpec::OptionValueFileSpec(bool resolve)
: OptionValue(), m_current_value(), m_default_value(), m_data_sp(), : OptionValue(), m_current_value(), m_default_value(), m_data_sp(),
m_data_mod_time(), m_data_mod_time(),
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueFileSpecLIst.cpp

//===-- OptionValueFileSpecLIst.cpp -----------------------------*- C++ -*-===// //===-- OptionValueFileSpecLIst.cpp -----------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValueFileSpecList.h" #include "lldb/Interpreter/OptionValueFileSpecList.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Utility/Args.h"
#include "lldb/Utility/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
void OptionValueFileSpecList::DumpValue(const ExecutionContext *exe_ctx, void OptionValueFileSpecList::DumpValue(const ExecutionContext *exe_ctx,
Stream &strm, uint32_t dump_mask) { Stream &strm, uint32_t dump_mask) {
if (dump_mask & eDumpOptionType) if (dump_mask & eDumpOptionType)
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueLanguage.cpp

//===-- OptionValueLanguage.cpp ---------------------------------*- C++ -*-===// //===-- OptionValueLanguage.cpp ---------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValueLanguage.h" #include "lldb/Interpreter/OptionValueLanguage.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/DataFormatters/FormatManager.h" #include "lldb/DataFormatters/FormatManager.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
void OptionValueLanguage::DumpValue(const ExecutionContext *exe_ctx, void OptionValueLanguage::DumpValue(const ExecutionContext *exe_ctx,
Stream &strm, uint32_t dump_mask) { Stream &strm, uint32_t dump_mask) {
if (dump_mask & eDumpOptionType) if (dump_mask & eDumpOptionType)
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValuePathMappings.cpp

//===-- OptionValuePathMappings.cpp -----------------------------*- C++ -*-===// //===-- OptionValuePathMappings.cpp -----------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Interpreter/OptionValuePathMappings.h" #include "lldb/Interpreter/OptionValuePathMappings.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Utility/Args.h"
#include "lldb/Utility/FileSpec.h" #include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
namespace { namespace {
static bool VerifyPathExists(const char *path) { static bool VerifyPathExists(const char *path) {
if (path && path[0]) if (path && path[0])
▲ Show 20 Lines • Show All 183 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueProperties.cpp

Show All 10 Lines
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Utility/Flags.h" #include "lldb/Utility/Flags.h"
#include "lldb/Core/UserSettingsController.h" #include "lldb/Core/UserSettingsController.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/OptionValues.h" #include "lldb/Interpreter/OptionValues.h"
#include "lldb/Interpreter/Property.h" #include "lldb/Interpreter/Property.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/Stream.h" #include "lldb/Utility/Stream.h"
#include "lldb/Utility/StringList.h" #include "lldb/Utility/StringList.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
OptionValueProperties::OptionValueProperties(const ConstString &name) OptionValueProperties::OptionValueProperties(const ConstString &name)
: OptionValue(), m_name(name), m_properties(), m_name_to_index() {} : OptionValue(), m_name(name), m_properties(), m_name_to_index() {}
▲ Show 20 Lines • Show All 648 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueString.cpp

Show All 9 Lines
#include "lldb/Interpreter/OptionValueString.h" #include "lldb/Interpreter/OptionValueString.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Host/OptionParser.h" #include "lldb/Host/OptionParser.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Utility/Args.h"
#include "lldb/Utility/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
void OptionValueString::DumpValue(const ExecutionContext *exe_ctx, Stream &strm, void OptionValueString::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
uint32_t dump_mask) { uint32_t dump_mask) {
if (dump_mask & eDumpOptionType) if (dump_mask & eDumpOptionType)
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

Show All 20 Lines
#include "lldb/Core/DumpDataExtractor.h" #include "lldb/Core/DumpDataExtractor.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
#include "lldb/Core/ValueObjectVariable.h" #include "lldb/Core/ValueObjectVariable.h"
#include "lldb/DataFormatters/DumpValueObjectOptions.h" #include "lldb/DataFormatters/DumpValueObjectOptions.h"
#include "lldb/Expression/UserExpression.h" #include "lldb/Expression/UserExpression.h"
#include "lldb/Host/OptionParser.h" #include "lldb/Host/OptionParser.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandObjectMultiword.h" #include "lldb/Interpreter/CommandObjectMultiword.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/Type.h" #include "lldb/Symbol/Type.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/Utility/DataBufferLLVM.h" #include "lldb/Utility/DataBufferLLVM.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/RegularExpression.h" #include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 5,019 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptScriptGroup.cpp

//===-- RenderScriptScriptGroup.cpp -----------------------------*- C++ -*-===// //===-- RenderScriptScriptGroup.cpp -----------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandObjectMultiword.h" #include "lldb/Interpreter/CommandObjectMultiword.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/Type.h" #include "lldb/Symbol/Type.h"
#include "lldb/Symbol/VariableList.h" #include "lldb/Symbol/VariableList.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#include "RenderScriptRuntime.h" #include "RenderScriptRuntime.h"
#include "RenderScriptScriptGroup.h" #include "RenderScriptScriptGroup.h"
using namespace lldb; using namespace lldb;
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformiOSSimulatorCoreSimulatorSupport.h

Show All 18 Lines
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
#ifdef __APPLE__ #ifdef __APPLE__
#include <objc/objc.h> #include <objc/objc.h>
#else #else
typedef void *id; typedef void *id;
#endif #endif
// Project includes // Project includes
#include "lldb/Interpreter/Args.h"
#include "lldb/Target/ProcessLaunchInfo.h" #include "lldb/Target/ProcessLaunchInfo.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#include "llvm/ADT/Optional.h" #include "llvm/ADT/Optional.h"
// And now the actual magic // And now the actual magic
namespace CoreSimulatorSupport { namespace CoreSimulatorSupport {
class Process { class Process {
▲ Show 20 Lines • Show All 189 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h

Show All 18 Lines
#include <vector> #include <vector>
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/Communication.h" #include "lldb/Core/Communication.h"
#include "lldb/Core/Listener.h" #include "lldb/Core/Listener.h"
#include "lldb/Host/HostThread.h" #include "lldb/Host/HostThread.h"
#include "lldb/Host/Predicate.h" #include "lldb/Host/Predicate.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Utility/Args.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
#include "lldb/Utility/StringExtractorGDBRemote.h" #include "lldb/Utility/StringExtractorGDBRemote.h"
namespace lldb_private { namespace lldb_private {
namespace process_gdb_remote { namespace process_gdb_remote {
typedef enum { typedef enum {
▲ Show 20 Lines • Show All 273 Lines • Show Last 20 Lines

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

Show All 16 Lines
#include <numeric> #include <numeric>
#include <sstream> #include <sstream>
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Host/XML.h" #include "lldb/Host/XML.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Target/MemoryRegionInfo.h" #include "lldb/Target/MemoryRegionInfo.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/UnixSignals.h" #include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/DataBufferHeap.h" #include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/JSON.h" #include "lldb/Utility/JSON.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StreamString.h"
// Project includes // Project includes
#include "ProcessGDBRemote.h" #include "ProcessGDBRemote.h"
▲ Show 20 Lines • Show All 4,000 Lines • Show Last 20 Lines

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

Show All 27 Lines
#include "lldb/Host/File.h" #include "lldb/Host/File.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Host/PosixApi.h" #include "lldb/Host/PosixApi.h"
#include "lldb/Host/common/NativeProcessProtocol.h" #include "lldb/Host/common/NativeProcessProtocol.h"
#include "lldb/Host/common/NativeRegisterContext.h" #include "lldb/Host/common/NativeRegisterContext.h"
#include "lldb/Host/common/NativeThreadProtocol.h" #include "lldb/Host/common/NativeThreadProtocol.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Target/FileAction.h" #include "lldb/Target/FileAction.h"
#include "lldb/Target/MemoryRegionInfo.h" #include "lldb/Target/MemoryRegionInfo.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/DataBuffer.h" #include "lldb/Utility/DataBuffer.h"
#include "lldb/Utility/Endian.h" #include "lldb/Utility/Endian.h"
#include "lldb/Utility/JSON.h" #include "lldb/Utility/JSON.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StreamString.h"
#include "lldb/Utility/UriParser.h" #include "lldb/Utility/UriParser.h"
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
▲ Show 20 Lines • Show All 3,195 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Host/HostThread.h" #include "lldb/Host/HostThread.h"
#include "lldb/Host/PosixApi.h" #include "lldb/Host/PosixApi.h"
#include "lldb/Host/PseudoTerminal.h" #include "lldb/Host/PseudoTerminal.h"
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Host/Symbols.h" #include "lldb/Host/Symbols.h"
#include "lldb/Host/ThreadLauncher.h" #include "lldb/Host/ThreadLauncher.h"
#include "lldb/Host/XML.h" #include "lldb/Host/XML.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandObject.h" #include "lldb/Interpreter/CommandObject.h"
#include "lldb/Interpreter/CommandObjectMultiword.h" #include "lldb/Interpreter/CommandObjectMultiword.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/OptionArgParser.h" #include "lldb/Interpreter/OptionArgParser.h"
#include "lldb/Interpreter/OptionGroupBoolean.h" #include "lldb/Interpreter/OptionGroupBoolean.h"
#include "lldb/Interpreter/OptionGroupUInt64.h" #include "lldb/Interpreter/OptionGroupUInt64.h"
#include "lldb/Interpreter/OptionValueProperties.h" #include "lldb/Interpreter/OptionValueProperties.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Interpreter/Property.h" #include "lldb/Interpreter/Property.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/ABI.h" #include "lldb/Target/ABI.h"
#include "lldb/Target/DynamicLoader.h" #include "lldb/Target/DynamicLoader.h"
#include "lldb/Target/MemoryRegionInfo.h" #include "lldb/Target/MemoryRegionInfo.h"
#include "lldb/Target/SystemRuntime.h" #include "lldb/Target/SystemRuntime.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/TargetList.h" #include "lldb/Target/TargetList.h"
#include "lldb/Target/ThreadPlanCallFunction.h" #include "lldb/Target/ThreadPlanCallFunction.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/CleanUp.h" #include "lldb/Utility/CleanUp.h"
#include "lldb/Utility/FileSpec.h" #include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StreamString.h"
#include "lldb/Utility/Timer.h" #include "lldb/Utility/Timer.h"
// Project includes // Project includes
#include "GDBRemoteRegisterContext.h" #include "GDBRemoteRegisterContext.h"
#include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h" #include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h"
▲ Show 20 Lines • Show All 5,312 Lines • Show Last 20 Lines

lldb/trunk/source/Utility/Args.cpp

//===-- Args.cpp ------------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Utility/Args.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StringList.h"
#include "llvm/ADT/StringSwitch.h"
using namespace lldb;
using namespace lldb_private;
// A helper function for argument parsing.
// 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) {
// Inside double quotes, '\' and '"' are special.
static const char *k_escapable_characters = "\"\\";
while (true) {
// Skip over over regular characters and append them.
size_t regular = quoted.find_first_of(k_escapable_characters);
result += quoted.substr(0, regular);
quoted = quoted.substr(regular);
// 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()) {
// A lone backslash at the end of string, let's just append it.
result += '\\';
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();
}
return quoted;
}
static size_t ArgvToArgc(const char **argv) {
if (!argv)
return 0;
size_t count = 0;
while (*argv++)
++count;
return count;
}
// 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;
// Since we can have multiple quotes that form a single command
// in a command like: "Hello "world'!' (which will make a single
// argument "Hello world!") we remember the first quote character
// we encounter and use that for the quote character.
char first_quote_char = '\0';
bool arg_complete = false;
do {
// 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);
if (command.empty())
break;
char special = command.front();
command = command.drop_front();
switch (special) {
case '\\':
if (command.empty()) {
arg += '\\';
break;
}
// If the character after the backslash is not a whitelisted escapable
// character, we
// leave the character sequence untouched.
if (strchr(" \t\\'\"`", command.front()) == nullptr)
arg += '\\';
arg += command.front();
command = command.drop_front();
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;
case '"':
case '\'':
case '`':
// We found the start of a quote scope.
if (first_quote_char == '\0')
first_quote_char = special;
if (special == '"')
command = ParseDoubleQuotes(command, arg);
else {
// For single quotes, we simply skip ahead to the matching quote
// character
// (or the end of the string).
size_t quoted = command.find(special);
arg += command.substr(0, quoted);
command = command.substr(quoted);
}
// If we found a closing quote, skip it.
if (!command.empty())
command = command.drop_front();
break;
}
} while (!arg_complete);
return std::make_tuple(arg, first_quote_char, command);
}
Args::ArgEntry::ArgEntry(llvm::StringRef str, char quote) : quote(quote) {
size_t size = str.size();
ptr.reset(new char[size + 1]);
::memcpy(data(), str.data() ? str.data() : "", size);
ptr[size] = 0;
ref = llvm::StringRef(c_str(), size);
}
//----------------------------------------------------------------------
// Args constructor
//----------------------------------------------------------------------
Args::Args(llvm::StringRef command) { SetCommandString(command); }
Args::Args(const Args &rhs) { *this = rhs; }
Args::Args(const StringList &list) : Args() {
for (size_t i = 0; i < list.GetSize(); ++i)
AppendArgument(list[i]);
}
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;
}
//----------------------------------------------------------------------
// Destructor
//----------------------------------------------------------------------
Args::~Args() {}
void Args::Dump(Stream &s, const char *label_name) const {
if (!label_name)
return;
int i = 0;
for (auto &entry : m_entries) {
s.Indent();
s.Format("{0}[{1}]=\"{2}\"\n", label_name, i++, entry.ref);
}
s.Format("{0}[{1}]=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;
}
return !m_entries.empty();
}
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;
}
}
return !m_entries.empty();
}
void Args::SetCommandString(llvm::StringRef command) {
Clear();
m_argv.clear();
static const char *k_space_separators = " \t";
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);
}
size_t Args::GetArgumentCount() const { return m_entries.size(); }
const char *Args::GetArgumentAtIndex(size_t idx) const {
if (idx < m_argv.size())
return m_argv[idx];
return nullptr;
}
char Args::GetArgumentQuoteCharAtIndex(size_t idx) const {
if (idx < m_entries.size())
return m_entries[idx].quote;
return '\0';
}
char **Args::GetArgumentVector() {
assert(!m_argv.empty());
// TODO: functions like execve and posix_spawnp exhibit undefined behavior
// 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 {
assert(!m_argv.empty());
return (m_argv.size() > 1) ? const_cast<const char **>(m_argv.data())
: nullptr;
}
void Args::Shift() {
// Don't pop the last NULL terminator from the argv array
if (m_entries.empty())
return;
m_argv.erase(m_argv.begin());
m_entries.erase(m_entries.begin());
}
void Args::Unshift(llvm::StringRef arg_str, char quote_char) {
InsertArgumentAtIndex(0, arg_str, quote_char);
}
void Args::AppendArguments(const Args &rhs) {
assert(m_argv.size() == m_entries.size() + 1);
assert(m_argv.back() == nullptr);
m_argv.pop_back();
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) {
size_t argc = ArgvToArgc(argv);
assert(m_argv.size() == m_entries.size() + 1);
assert(m_argv.back() == nullptr);
m_argv.pop_back();
for (auto arg : llvm::makeArrayRef(argv, argc)) {
m_entries.emplace_back(arg, '\0');
m_argv.push_back(m_entries.back().data());
}
m_argv.push_back(nullptr);
}
void Args::AppendArgument(llvm::StringRef arg_str, char quote_char) {
InsertArgumentAtIndex(GetArgumentCount(), arg_str, quote_char);
}
void Args::InsertArgumentAtIndex(size_t idx, llvm::StringRef arg_str,
char quote_char) {
assert(m_argv.size() == m_entries.size() + 1);
assert(m_argv.back() == nullptr);
if (idx > m_entries.size())
return;
m_entries.emplace(m_entries.begin() + idx, arg_str, quote_char);
m_argv.insert(m_argv.begin() + idx, m_entries[idx].data());
}
void Args::ReplaceArgumentAtIndex(size_t idx, llvm::StringRef arg_str,
char quote_char) {
assert(m_argv.size() == m_entries.size() + 1);
assert(m_argv.back() == nullptr);
if (idx >= m_entries.size())
return;
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());
}
}
void Args::DeleteArgumentAtIndex(size_t idx) {
if (idx >= m_entries.size())
return;
m_argv.erase(m_argv.begin() + idx);
m_entries.erase(m_entries.begin() + idx);
}
void Args::SetArguments(size_t argc, const char **argv) {
Clear();
auto args = llvm::makeArrayRef(argv, argc);
m_entries.resize(argc);
m_argv.resize(argc + 1);
for (size_t i = 0; i < args.size(); ++i) {
char quote =
((args[i][0] == '\'') || (args[i][0] == '"') || (args[i][0] == '`'))
? args[i][0]
: '\0';
m_entries[i] = ArgEntry(args[i], quote);
m_argv[i] = m_entries[i].data();
}
}
void Args::SetArguments(const char **argv) {
SetArguments(ArgvToArgc(argv), argv);
}
void Args::Clear() {
m_entries.clear();
m_argv.clear();
m_argv.push_back(nullptr);
}
const char *Args::StripSpaces(std::string &s, bool leading, bool trailing,
bool return_null_if_empty) {
static const char *k_white_space = " \t\v";
if (!s.empty()) {
if (leading) {
size_t pos = s.find_first_not_of(k_white_space);
if (pos == std::string::npos)
s.clear();
else if (pos > 0)
s.erase(0, pos);
}
if (trailing) {
size_t rpos = s.find_last_not_of(k_white_space);
if (rpos != std::string::npos && rpos + 1 < s.size())
s.erase(rpos + 1);
}
}
if (return_null_if_empty && s.empty())
return nullptr;
return s.c_str();
}
bool Args::StringToVersion(llvm::StringRef string, uint32_t &major,
uint32_t &minor, uint32_t &update) {
major = UINT32_MAX;
minor = UINT32_MAX;
update = UINT32_MAX;
if (string.empty())
return false;
llvm::StringRef major_str, minor_str, update_str;
std::tie(major_str, minor_str) = string.split('.');
std::tie(minor_str, update_str) = minor_str.split('.');
if (major_str.getAsInteger(10, major))
return false;
if (!minor_str.empty() && minor_str.getAsInteger(10, minor))
return false;
if (!update_str.empty() && update_str.getAsInteger(10, update))
return false;
return true;
}
const char *Args::GetShellSafeArgument(const FileSpec &shell,
const char *unsafe_arg,
std::string &safe_arg) {
struct ShellDescriptor {
ConstString m_basename;
const char *m_escapables;
};
static ShellDescriptor g_Shells[] = {{ConstString("bash"), " '\"<>()&"},
{ConstString("tcsh"), " '\"<>()&$"},
{ConstString("sh"), " '\"<>()&"}};
// safe minimal set
const char *escapables = " '\"";
if (auto basename = shell.GetFilename()) {
for (const auto &Shell : g_Shells) {
if (Shell.m_basename == basename) {
escapables = Shell.m_escapables;
break;
}
}
}
safe_arg.assign(unsafe_arg);
size_t prev_pos = 0;
while (prev_pos < safe_arg.size()) {
// Escape spaces and quotes
size_t pos = safe_arg.find_first_of(escapables, prev_pos);
if (pos != std::string::npos) {
safe_arg.insert(pos, 1, '\\');
prev_pos = pos + 2;
} else
break;
}
return safe_arg.c_str();
}
lldb::Encoding Args::StringToEncoding(llvm::StringRef s,
lldb::Encoding fail_value) {
return llvm::StringSwitch<lldb::Encoding>(s)
.Case("uint", eEncodingUint)
.Case("sint", eEncodingSint)
.Case("ieee754", eEncodingIEEE754)
.Case("vector", eEncodingVector)
.Default(fail_value);
}
uint32_t Args::StringToGenericRegister(llvm::StringRef s) {
if (s.empty())
return LLDB_INVALID_REGNUM;
uint32_t result = llvm::StringSwitch<uint32_t>(s)
.Case("pc", LLDB_REGNUM_GENERIC_PC)
.Case("sp", LLDB_REGNUM_GENERIC_SP)
.Case("fp", LLDB_REGNUM_GENERIC_FP)
.Cases("ra", "lr", LLDB_REGNUM_GENERIC_RA)
.Case("flags", LLDB_REGNUM_GENERIC_FLAGS)
.Case("arg1", LLDB_REGNUM_GENERIC_ARG1)
.Case("arg2", LLDB_REGNUM_GENERIC_ARG2)
.Case("arg3", LLDB_REGNUM_GENERIC_ARG3)
.Case("arg4", LLDB_REGNUM_GENERIC_ARG4)
.Case("arg5", LLDB_REGNUM_GENERIC_ARG5)
.Case("arg6", LLDB_REGNUM_GENERIC_ARG6)
.Case("arg7", LLDB_REGNUM_GENERIC_ARG7)
.Case("arg8", LLDB_REGNUM_GENERIC_ARG8)
.Default(LLDB_INVALID_REGNUM);
return result;
}
void Args::EncodeEscapeSequences(const char *src, std::string &dst) {
dst.clear();
if (src) {
for (const char *p = src; *p != '\0'; ++p) {
size_t non_special_chars = ::strcspn(p, "\\");
if (non_special_chars > 0) {
dst.append(p, non_special_chars);
p += non_special_chars;
if (*p == '\0')
break;
}
if (*p == '\\') {
++p; // skip the slash
switch (*p) {
case 'a':
dst.append(1, '\a');
break;
case 'b':
dst.append(1, '\b');
break;
case 'f':
dst.append(1, '\f');
break;
case 'n':
dst.append(1, '\n');
break;
case 'r':
dst.append(1, '\r');
break;
case 't':
dst.append(1, '\t');
break;
case 'v':
dst.append(1, '\v');
break;
case '\\':
dst.append(1, '\\');
break;
case '\'':
dst.append(1, '\'');
break;
case '"':
dst.append(1, '"');
break;
case '0':
// 1 to 3 octal chars
{
// Make a string that can hold onto the initial zero char,
// up to 3 octal digits, and a terminating NULL.
char oct_str[5] = {'\0', '\0', '\0', '\0', '\0'};
int i;
for (i = 0; (p[i] >= '0' && p[i] <= '7') && i < 4; ++i)
oct_str[i] = p[i];
// We don't want to consume the last octal character since
// the main for loop will do this for us, so we advance p by
// one less than i (even if i is zero)
p += i - 1;
unsigned long octal_value = ::strtoul(oct_str, nullptr, 8);
if (octal_value <= UINT8_MAX) {
dst.append(1, (char)octal_value);
}
}
break;
case 'x':
// hex number in the format
if (isxdigit(p[1])) {
++p; // Skip the 'x'
// Make a string that can hold onto two hex chars plus a
// NULL terminator
char hex_str[3] = {*p, '\0', '\0'};
if (isxdigit(p[1])) {
++p; // Skip the first of the two hex chars
hex_str[1] = *p;
}
unsigned long hex_value = strtoul(hex_str, nullptr, 16);
if (hex_value <= UINT8_MAX)
dst.append(1, (char)hex_value);
} else {
dst.append(1, 'x');
}
break;
default:
// Just desensitize any other character by just printing what
// came after the '\'
dst.append(1, *p);
break;
}
}
}
}
}
void Args::ExpandEscapedCharacters(const char *src, std::string &dst) {
dst.clear();
if (src) {
for (const char *p = src; *p != '\0'; ++p) {
if (isprint(*p))
dst.append(1, *p);
else {
switch (*p) {
case '\a':
dst.append("\\a");
break;
case '\b':
dst.append("\\b");
break;
case '\f':
dst.append("\\f");
break;
case '\n':
dst.append("\\n");
break;
case '\r':
dst.append("\\r");
break;
case '\t':
dst.append("\\t");
break;
case '\v':
dst.append("\\v");
break;
case '\'':
dst.append("\\'");
break;
case '"':
dst.append("\\\"");
break;
case '\\':
dst.append("\\\\");
break;
default: {
// Just encode as octal
dst.append("\\0");
char octal_str[32];
snprintf(octal_str, sizeof(octal_str), "%o", *p);
dst.append(octal_str);
} break;
}
}
}
}
}
std::string Args::EscapeLLDBCommandArgument(const std::string &arg,
char quote_char) {
const char *chars_to_escape = nullptr;
switch (quote_char) {
case '\0':
chars_to_escape = " \t\\'\"`";
break;
case '\'':
chars_to_escape = "";
break;
case '"':
chars_to_escape = "$\"`\\";
break;
default:
assert(false && "Unhandled quote character");
}
std::string res;
res.reserve(arg.size());
for (char c : arg) {
if (::strchr(chars_to_escape, c))
res.push_back('\\');
res.push_back(c);
}
return res;
}

lldb/trunk/source/Utility/CMakeLists.txt

Show All 35 Linesif (LLVM_BUILD_STATIC)
endif() endif()
if (NOT LLDB_DISABLE_CURSES) if (NOT LLDB_DISABLE_CURSES)
list(APPEND LLDB_SYSTEM_LIBS gpm) list(APPEND LLDB_SYSTEM_LIBS gpm)
endif() endif()
endif() endif()
add_lldb_library(lldbUtility add_lldb_library(lldbUtility
ArchSpec.cpp ArchSpec.cpp
Args.cpp
Baton.cpp Baton.cpp
Connection.cpp Connection.cpp
ConstString.cpp ConstString.cpp
DataBufferHeap.cpp DataBufferHeap.cpp
DataBufferLLVM.cpp DataBufferLLVM.cpp
DataEncoder.cpp DataEncoder.cpp
DataExtractor.cpp DataExtractor.cpp
Environment.cpp Environment.cpp
Show All 39 Lines

lldb/trunk/tools/lldb-server/LLDBServerUtilities.cpp

//===-- LLDBServerUtilities.cpp ---------------------------------*- C++ -*-===// //===-- LLDBServerUtilities.cpp ---------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "LLDBServerUtilities.h" #include "LLDBServerUtilities.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Utility/Args.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StreamString.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
using namespace lldb; using namespace lldb;
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

lldb/trunk/unittests/Interpreter/CMakeLists.txt

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

lldb/trunk/unittests/Interpreter/TestArgs.cpp

//===-- ArgsTest.cpp --------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "gtest/gtest.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Utility/StringList.h"
#include <limits>
#include <sstream>
using namespace lldb_private;
TEST(ArgsTest, TestSingleArg) {
Args args;
args.SetCommandString("arg");
EXPECT_EQ(1u, args.GetArgumentCount());
EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg");
}
TEST(ArgsTest, TestSingleQuotedArgWithSpace) {
Args args;
args.SetCommandString("\"arg with space\"");
EXPECT_EQ(1u, args.GetArgumentCount());
EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg with space");
}
TEST(ArgsTest, TestSingleArgWithQuotedSpace) {
Args args;
args.SetCommandString("arg\\ with\\ space");
EXPECT_EQ(1u, args.GetArgumentCount());
EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg with space");
}
TEST(ArgsTest, TestMultipleArgs) {
Args args;
args.SetCommandString("this has multiple args");
EXPECT_EQ(4u, args.GetArgumentCount());
EXPECT_STREQ(args.GetArgumentAtIndex(0), "this");
EXPECT_STREQ(args.GetArgumentAtIndex(1), "has");
EXPECT_STREQ(args.GetArgumentAtIndex(2), "multiple");
EXPECT_STREQ(args.GetArgumentAtIndex(3), "args");
}
TEST(ArgsTest, TestOverwriteArgs) {
Args args;
args.SetCommandString("this has multiple args");
EXPECT_EQ(4u, args.GetArgumentCount());
args.SetCommandString("arg");
EXPECT_EQ(1u, args.GetArgumentCount());
EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg");
}
TEST(ArgsTest, TestAppendArg) {
Args args;
args.SetCommandString("first_arg");
EXPECT_EQ(1u, args.GetArgumentCount());
args.AppendArgument(llvm::StringRef("second_arg"));
EXPECT_EQ(2u, args.GetArgumentCount());
EXPECT_STREQ(args.GetArgumentAtIndex(0), "first_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, StringListConstructor) {
StringList list;
list << "foo" << "bar" << "baz";
Args args(list);
ASSERT_EQ(3u, args.GetArgumentCount());
EXPECT_EQ("foo", args[0].ref);
EXPECT_EQ("bar", args[1].ref);
EXPECT_EQ("baz", args[2].ref);
}
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, GetArgumentArrayRef) {
Args args("foo bar");
auto ref = args.GetArgumentArrayRef();
ASSERT_EQ(2u, ref.size());
EXPECT_STREQ("foo", ref[0]);
EXPECT_STREQ("bar", ref[1]);
}

lldb/trunk/unittests/Utility/ArgsTest.cpp

//===-- ArgsTest.cpp --------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "gtest/gtest.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/StringList.h"
#include <limits>
#include <sstream>
using namespace lldb_private;
TEST(ArgsTest, TestSingleArg) {
Args args;
args.SetCommandString("arg");
EXPECT_EQ(1u, args.GetArgumentCount());
EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg");
}
TEST(ArgsTest, TestSingleQuotedArgWithSpace) {
Args args;
args.SetCommandString("\"arg with space\"");
EXPECT_EQ(1u, args.GetArgumentCount());
EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg with space");
}
TEST(ArgsTest, TestSingleArgWithQuotedSpace) {
Args args;
args.SetCommandString("arg\\ with\\ space");
EXPECT_EQ(1u, args.GetArgumentCount());
EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg with space");
}
TEST(ArgsTest, TestMultipleArgs) {
Args args;
args.SetCommandString("this has multiple args");
EXPECT_EQ(4u, args.GetArgumentCount());
EXPECT_STREQ(args.GetArgumentAtIndex(0), "this");
EXPECT_STREQ(args.GetArgumentAtIndex(1), "has");
EXPECT_STREQ(args.GetArgumentAtIndex(2), "multiple");
EXPECT_STREQ(args.GetArgumentAtIndex(3), "args");
}
TEST(ArgsTest, TestOverwriteArgs) {
Args args;
args.SetCommandString("this has multiple args");
EXPECT_EQ(4u, args.GetArgumentCount());
args.SetCommandString("arg");
EXPECT_EQ(1u, args.GetArgumentCount());
EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg");
}
TEST(ArgsTest, TestAppendArg) {
Args args;
args.SetCommandString("first_arg");
EXPECT_EQ(1u, args.GetArgumentCount());
args.AppendArgument(llvm::StringRef("second_arg"));
EXPECT_EQ(2u, args.GetArgumentCount());
EXPECT_STREQ(args.GetArgumentAtIndex(0), "first_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, StringListConstructor) {
StringList list;
list << "foo"
<< "bar"
<< "baz";
Args args(list);
ASSERT_EQ(3u, args.GetArgumentCount());
EXPECT_EQ("foo", args[0].ref);
EXPECT_EQ("bar", args[1].ref);
EXPECT_EQ("baz", args[2].ref);
}
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, GetArgumentArrayRef) {
Args args("foo bar");
auto ref = args.GetArgumentArrayRef();
ASSERT_EQ(2u, ref.size());
EXPECT_STREQ("foo", ref[0]);
EXPECT_STREQ("bar", ref[1]);
}

lldb/trunk/unittests/Utility/CMakeLists.txt

add_lldb_unittest(UtilityTests add_lldb_unittest(UtilityTests
ArgsTest.cpp
ArchSpecTest.cpp ArchSpecTest.cpp
CleanUpTest.cpp CleanUpTest.cpp
ConstStringTest.cpp ConstStringTest.cpp
EnvironmentTest.cpp EnvironmentTest.cpp
JSONTest.cpp JSONTest.cpp
LogTest.cpp LogTest.cpp
NameMatchesTest.cpp NameMatchesTest.cpp
StatusTest.cpp StatusTest.cpp
Show All 18 Lines

lldb/trunk/unittests/tools/lldb-server/tests/MessageObjects.cpp

//===-- MessageObjects.cpp --------------------------------------*- C++ -*-===// //===-- MessageObjects.cpp --------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MessageObjects.h" #include "MessageObjects.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Utility/Args.h"
#include "lldb/Utility/StringExtractor.h" #include "lldb/Utility/StringExtractor.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
using namespace lldb_private; using namespace lldb_private;
using namespace lldb; using namespace lldb;
using namespace llvm; using namespace llvm;
namespace llgs_tests { namespace llgs_tests {
▲ Show 20 Lines • Show All 356 Lines • Show Last 20 Lines

lldb/trunk/unittests/tools/lldb-server/tests/TestClient.cpp

//===-- TestClient.cpp ------------------------------------------*- C++ -*-===// //===-- TestClient.cpp ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "TestClient.h" #include "TestClient.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Host/common/TCPSocket.h" #include "lldb/Host/common/TCPSocket.h"
#include "lldb/Host/posix/ConnectionFileDescriptorPosix.h" #include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Target/ProcessLaunchInfo.h" #include "lldb/Target/ProcessLaunchInfo.h"
#include "lldb/Utility/Args.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
#include "llvm/Testing/Support/Error.h" #include "llvm/Testing/Support/Error.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include <cstdlib> #include <cstdlib>
#include <future> #include <future>
#include <sstream> #include <sstream>
#include <string> #include <string>
▲ Show 20 Lines • Show All 225 Lines • Show Last 20 Lines
lldb/trunk/tools/lldb-server/LLDBServerUtilities.cpp