No functional change.
llvm-svn: 239995
endian: is one of "little", "big", or "pdp"
ptrsize: an unsigned number that represents how big pointers are in bytes on the debug target
hostname: the hostname of the host that is running the GDB server if available
-os_build: a string for the the OS build for the remote host as a string value
+os_build: a string for the OS build for the remote host as a string value
os_kernel: a string describing the kernel version
os_version: a version string that represents the current OS version (10.8.2)
watchpoint_exceptions_received: one of "before" or "after" to specify if a watchpoint is triggered before or after the pc when it stops
-//===-- head_find.c ---------------------------------------------*- C++ -*-===//
+//===-- heap_find.c ---------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
{
g_matches.clear();
// Setup "info" to look for a malloc block that contains data
- // that is the a pointer
+ // that is the pointer
if (addr)
{
range_contains_data_callback_info_t data_info;
{
g_matches.clear();
// Setup "info" to look for a malloc block that contains data
- // that is the a pointer
+ // that is the pointer
range_contains_data_callback_info_t data_info;
data_info.type = eDataTypeContainsData; // Check each block for data
data_info.data.buffer = (uint8_t *)&addr; // What data? The pointer value passed in
if (g_objc_classes.Update())
{
// Setup "info" to look for a malloc block that contains data
- // that is the a pointer
+ // that is the pointer
range_contains_data_callback_info_t data_info;
data_info.type = eDataTypeObjC; // Check each block for data
data_info.objc.match_isa = isa;
// Reset all stats
g_objc_class_snapshot.Reset ();
// Setup "info" to look for a malloc block that contains data
- // that is the a pointer
+ // that is the pointer
range_contains_data_callback_info_t data_info;
data_info.type = eDataTypeHeapInfo; // Check each block for data
data_info.match_count = 0; // Initialize the match count to zero
uint8_t *m_end; ///< A pointer to the byte that is past the end of the data.
lldb::ByteOrder m_byte_order; ///< The byte order of the data we are extracting from.
uint8_t m_addr_size; ///< The address size to use when extracting pointers or addresses
- mutable lldb::DataBufferSP m_data_sp; ///< The shared pointer to data that can be shared among multilple instances
+ mutable lldb::DataBufferSP m_data_sp; ///< The shared pointer to data that can be shared among multiple instances
private:
DISALLOW_COPY_AND_ASSIGN (DataEncoder);
/// bytes into the contained data, into the stream \a s. \a
/// num_per_line objects will be dumped on each line before a new
/// line will be output. If \a base_addr is a valid address, then
- /// each new line of output will be prededed by the address value
+ /// each new line of output will be preceded by the address value
/// plus appropriate offset, and a colon and space. Bitfield values
/// can be dumped by calling this function multiple times with the
/// same start offset, format and size, yet differing \a
GetSharedDataOffset () const;
//------------------------------------------------------------------
- /// Get a the data start pointer.
+ /// Get the data start pointer.
///
/// @return
/// Returns a pointer to the first byte contained in this
///
/// @return
/// \a dst if all values were properly extracted and copied,
- /// NULL otherise.
+ /// NULL otherwise.
//------------------------------------------------------------------
void *
GetU8 (lldb::offset_t *offset_ptr, void *dst, uint32_t count) const;
///
/// @return
/// \a dst if all values were properly extracted and copied,
- /// NULL otherise.
+ /// NULL otherwise.
//------------------------------------------------------------------
void *
GetU16 (lldb::offset_t *offset_ptr, void *dst, uint32_t count) const;
///
/// @return
/// \a dst if all values were properly extracted and copied,
- /// NULL otherise.
+ /// NULL otherwise.
//------------------------------------------------------------------
void *
GetU32 (lldb::offset_t *offset_ptr, void *dst, uint32_t count) const;
///
/// @return
/// \a dst if all values were properly extracted and copied,
- /// NULL otherise.
+ /// NULL otherwise.
//------------------------------------------------------------------
void *
GetU64 ( lldb::offset_t *offset_ptr, void *dst, uint32_t count) const;
const uint8_t * m_end; ///< A pointer to the byte that is past the end of the data.
lldb::ByteOrder m_byte_order; ///< The byte order of the data we are extracting from.
uint32_t m_addr_size; ///< The address size to use when extracting pointers or addresses
- mutable lldb::DataBufferSP m_data_sp; ///< The shared pointer to data that can be shared among multilple instances
+ mutable lldb::DataBufferSP m_data_sp; ///< The shared pointer to data that can be shared among multiple instances
const uint32_t m_target_byte_size;
};
}
//------------------------------------------------------------------
- /// Called when a new line is created or one of an identifed set of
+ /// Called when a new line is created or one of an identified set of
/// indentation characters is typed.
///
/// This function determines how much indentation should be added
/// following the line containing the cursor are not included.
///
/// @param[in] cursor_position
- /// The number of characters preceeding the cursor on the final
+ /// The number of characters preceding the cursor on the final
/// line at the time.
///
/// @return
//------------------------------------------------------------------
// Note: the parser needs to be destructed before the execution unit, so
- // declare the the execution unit first.
+ // declare the execution unit first.
std::shared_ptr<IRExecutionUnit> m_execution_unit_sp;
std::unique_ptr<ClangExpressionParser> m_parser; ///< The parser responsible for compiling the function.
lldb::ModuleWP m_jit_module_wp;
/// occur. This can be NULL if no error status is desired.
///
/// @return
- /// @li \b true when the a master files descriptor is
+ /// @li \b true when the master files descriptor is
/// successfully opened.
/// @li \b false if anything goes wrong.
///
/// occur. This can be NULL if no error status is desired.
///
/// @return
- /// @li \b true when the a master files descriptor is
+ /// @li \b true when the master files descriptor is
/// successfully opened.
/// @li \b false if anything goes wrong.
///
};
%feature("docstring",
-"A class that represents the a platform that can represent the current host or a remote host debug platform.
+"A class that represents a platform that can represent the current host or a remote host debug platform.
The SBPlatform class represents the current host, or a remote host.
It can be connected to a remote platform in order to provide ways
o SBSymbolContext: A container that stores various debugger related info.
o SBValue: Represents the value of a variable, a register, or an expression.
o SBModule: Represents an executable image and its associated object and symbol
- files. SBTarget conatins SBModule(s).
+ files. SBTarget contains SBModule(s).
o SBBreakpoint: Represents a logical breakpoint and its associated settings.
- SBTarget conatins SBBreakpoint(s).
+ SBTarget contains SBBreakpoint(s).
o SBSymbol: Represents the symbol possibly associated with a stack frame.
o SBCompileUnit: Represents a compilation unit, or compiled source file.
o SBFunction: Represents a generic function, which can be inlined or not.
if (module_sp)
{
// We are going to return a "const char *" value through the public
- // API, so we need to constify it so it gets added permanently the the
+ // API, so we need to constify it so it gets added permanently the
// string pool and then we don't need to worry about the lifetime of the
// string as it will never go away once it has been put into the ConstString
// string pool
if (dump_variable)
{
// Use the variable object code to make sure we are
- // using the same APIs as the the public API will be
+ // using the same APIs as the public API will be
// using...
valobj_sp = frame->GetValueObjectForFrameVariable (var_sp,
m_varobj_options.use_dynamic);
}
else
{
- result.AppendMessageWithFormat("Eroor getting file size of %s (remote)\n", remote_file_path.c_str());
+ result.AppendMessageWithFormat("Error getting file size of %s (remote)\n", remote_file_path.c_str());
result.SetStatus (eReturnStatusFailed);
}
}
{ LLDB_OPT_SET_ALL, false, "plugin", 'P' , OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePlugin, "Name of the process plugin you want to use."},
{ LLDB_OPT_SET_1, false, "pid", 'p' , OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePid, "The process ID of an existing process to attach to."},
{ LLDB_OPT_SET_2, false, "name", 'n' , OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeProcessName, "The name of the process to attach to."},
- { LLDB_OPT_SET_2, false, "waitfor", 'w' , OptionParser::eNoArgument , NULL, NULL, 0, eArgTypeNone, "Wait for the
the process with <process-name> to launch."},
+ { LLDB_OPT_SET_2, false, "waitfor", 'w' , OptionParser::eNoArgument , NULL, NULL, 0, eArgTypeNone, "Wait for the process with <process-name> to launch."},
{ 0, false, NULL , 0 , 0 , NULL, NULL, 0, eArgTypeNone, NULL }
};
CommandObjectPlatformShell (CommandInterpreter &interpreter) :
CommandObjectRaw (interpreter,
"platform shell",
- "Run a shell command on a the selected platform.",
+ "Run a shell command on the selected platform.",
"platform shell <shell-command>",
0),
m_options(interpreter)
// Save the actual mmap'ed size
m_mmap_size = length + page_offset;
- // Our data is at an offset into the the mapped data
+ // Our data is at an offset into the mapped data
m_data = m_mmap_addr + page_offset;
- // Our pretend size is the size that was requestd
+ // Our pretend size is the size that was requested
m_size = length;
}
}
//----------------------------------------------------------------------
-// Compare the the string values.
+// Compare the string values.
//----------------------------------------------------------------------
int
Mangled::Compare (const Mangled& a, const Mangled& b)
{
// This branch will get hit if we are executing code in the context of a function that
// claims to have an object pointer (through DW_AT_object_pointer?) but is not formally a
- // method of the class. In that case, just look up the "this" variable in the the current
+ // method of the class. In that case, just look up the "this" variable in the current
// scope and use its type.
// FIXME: This code is formally correct, but clang doesn't currently emit DW_AT_object_pointer
// for C++ so it hasn't actually been tested.
{
// This branch will get hit if we are executing code in the context of a function that
// claims to have an object pointer (through DW_AT_object_pointer?) but is not formally a
- // method of the class. In that case, just look up the "self" variable in the the current
+ // method of the class. In that case, just look up the "self" variable in the current
// scope and use its type.
VariableList *vars = frame->GetVariableList(false);
if (name[0] == '$')
{
- // The $__lldb_expr_result name indicates the the return value has allocated as
+ // The $__lldb_expr_result name indicates the return value has allocated as
// a static variable. Per the comment at ASTResultSynthesizer::SynthesizeBodyResult,
// accesses to this static variable need to be redirected to the result of dereferencing
// a pointer that is passed in as one of the arguments.
if (error.Success ())
{
bool verify = false;
- // Make sure we have the a breakpoint opcode exists at this address
+ // Make sure the breakpoint opcode exists at this address
if (::memcmp (curr_break_op, m_trap_opcodes, m_opcode_size) == 0)
{
break_op_found = true;
// {
// pid = (intptr_t)accept_thread_result;
//
-// // Wait for process to be stopped the the entry point by watching
+// // Wait for process to be stopped the entry point by watching
// // for the process status to be set to SSTOP which indicates it it
// // SIGSTOP'ed at the entry point
// WaitForProcessToSIGSTOP (pid, 5);
CommandObject *sub_cmd_obj = cmd_obj->GetSubcommandObject (cmd_word.c_str());
if (sub_cmd_obj)
cmd_obj = sub_cmd_obj;
- else // cmd_word was not a valid sub-command word, so we are donee
+ else // cmd_word was not a valid sub-command word, so we are done
done = true;
}
else
{
if (start_backtick > 0 && command[start_backtick-1] == '\\')
{
- // The backtick was preceeded by a '\' character, remove the slash
+ // The backtick was preceded by a '\' character, remove the slash
// and don't treat the backtick as the start of an expression
command.erase(start_backtick-1, 1);
// No need to add one to start_backtick since we just deleted a char
bool spawn_thread,
CommandInterpreterRunOptions &options)
{
- // Always re-create the command intepreter when we run it in case
+ // Always re-create the command interpreter when we run it in case
// any file handles have changed.
bool force_create = true;
m_debugger.PushIOHandler(GetIOHandler(force_create, &options));
{ LLDB_OPT_SET_1 , false, "outfile", 'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFilename , "Specify a path for capturing command output."},
{ LLDB_OPT_SET_1 , false, "append-outfile" , SHORT_OPTION_APND,
OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone ,
- "Append to the
the file specified with '--outfile <path>'."},
+ "Append to the file specified with '--outfile <path>'."},
};
uint32_t
{
if (key.front() == '[')
{
- // Key name starts with '[', so the the key value must be in single or double quotes like:
+ // Key name starts with '[', so the key value must be in single or double quotes like:
// ['<key>']
// ["<key>"]
if ((key.size() > 2) && (key.back() == ']'))
}
if (!value_sp && error.AsCString() == nullptr)
{
- error.SetErrorStringWithFormat ("invalid value path '%s', %s values only support '[<key>]' subvalues where <key> a string value optionally delimitted by single or double quotes",
+ error.SetErrorStringWithFormat ("invalid value path '%s', %s values only support '[<key>]' subvalues where <key> a string value optionally delimited by single or double quotes",
name,
GetTypeAsCString());
}
Type *base_class_type = ResolveTypeUID(encoding_uid);
if (base_class_type == NULL)
{
- GetObjectFile()->GetModule()->ReportError("0x%8.8x: DW_TAG_inheritance failed to resolve a the base class at 0x%8.8" PRIx64 " from enclosing type 0x%8.8x. \nPlease file a bug and attach the file at the start of this error message",
+ GetObjectFile()->GetModule()->ReportError("0x%8.8x: DW_TAG_inheritance failed to resolve the base class at 0x%8.8" PRIx64 " from enclosing type 0x%8.8x. \nPlease file a bug and attach the file at the start of this error message",
die->GetOffset(),
encoding_uid,
parent_die->GetOffset());
{
// Check the number of operator parameters. Sometimes we have
// seen bad DWARF that doesn't correctly describe operators and
- // if we try to create a methed and add it to the class, clang
+ // if we try to create a method and add it to the class, clang
// will assert and crash, so we need to make sure things are
// acceptable.
if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount (op_kind, num_params))
for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx)
{
// Print the starting squiggly bracket (if this is the
- // first member) or comman (for member 2 and beyong) for
+ // first member) or comma (for member 2 and beyond) for
// the struct/union/class member.
if (child_idx == 0)
s->PutChar('{');
for (element_idx = 0; element_idx < element_count; ++element_idx)
{
// Print the starting squiggly bracket (if this is the
- // first member) or comman (for member 2 and beyong) for
+ // first member) or comma (for member 2 and beyond) for
// the struct/union/class member.
if (element_idx == 0)
s->PutChar('{');
break;
default:
- // We are down the a scalar type that we just need to display.
+ // We are down to a scalar type that we just need to display.
data.Dump(s,
data_byte_offset,
format,
// format was not enum, just fall through and dump the value as requested....
default:
- // We are down the a scalar type that we just need to display.
+ // We are down to a scalar type that we just need to display.
{
uint32_t item_count = 1;
// A few formats, we might need to modify our size and count for depending
}
//----------------------------------------------------------------------
-// Find functions using the a Mangled::Tokens token list. This
-// function currently implements an interative approach designed to find
-// all instances of certain functions. It isn't designed to the the
+// Find functions using the Mangled::Tokens token list. This
+// function currently implements an interactive approach designed to find
+// all instances of certain functions. It isn't designed to the
// quickest way to lookup functions as it will need to iterate through
// all functions and see if they match, though it does provide a powerful
// and context sensitive way to search for all functions with a certain
else
{
// All the line table entries actually point to the version of the Compile
- // Unit that is in the support files (the one at 0 was artifically added.)
+ // Unit that is in the support files (the one at 0 was artificially added.)
// So prefer the one further on in the support files if it exists...
FileSpecList &support_files = GetSupportFiles();
const bool full = true;
const size_t aug_str_len = strlen(cie_sp->augmentation);
// A 'z' may be present as the first character of the string.
// If present, the Augmentation Data field shall be present.
- // The contents of the Augmentation Data shall be intepreted
+ // The contents of the Augmentation Data shall be interpreted
// according to other characters in the Augmentation String.
if (cie_sp->augmentation[0] == 'z')
{
if (DoReadMemory (bp_addr, curr_break_op, break_op_size, error) == break_op_size)
{
bool verify = false;
- // Make sure we have the a breakpoint opcode exists at this address
+ // Make sure the breakpoint opcode exists at this address
if (::memcmp (curr_break_op, break_op, break_op_size) == 0)
{
break_op_found = true;
&& sc.comp_unit == m_addr_context.comp_unit
&& sc.function == m_addr_context.function)
{
- // Okay, find the next occurance of this file in the line table:
+ // Okay, find the next occurrence of this file in the line table:
LineTable *line_table = m_addr_context.comp_unit->GetLineTable();
if (line_table)
{
bool step_past_remaining_inline = false;
if (entry_idx > 0)
{
- // We require the the previous line entry and the current line entry come
+ // We require the previous line entry and the current line entry come
// from the same file.
// The other requirement is that the previous line table entry be part of an
// inlined block, we don't want to step past cases where people have inlined
child.expect_exact(prompt)
child.sendline('target stop-hook list')
- # Now run the program, expect to stop at the the first breakpoint which is within the stop-hook range.
+ # Now run the program, expect to stop at the first breakpoint which is within the stop-hook range.
child.expect_exact(prompt)
child.sendline('run')
# Make sure we see the stop hook text from the stop of the process from the run hitting the first breakpoint
child.sendline('breakpoint set -f main.cpp -l %d' % self.thread_function)
child.expect_exact(prompt)
- # Now run the program, expect to stop at the the first breakpoint which is within the stop-hook range.
+ # Now run the program, expect to stop at the first breakpoint which is within the stop-hook range.
child.sendline('run')
child.expect_exact("Process") # 'Process 2415 launched', 'Process 2415 stopped'
child.expect_exact(prompt)
//===----------------------------------------------------------------------===//
// This test is intended to create a situation in which one thread will be
-// created while a the debugger is stepping in another thread.
+// created while the debugger is stepping in another thread.
#include <pthread.h>
#include <atomic>
//===----------------------------------------------------------------------===//
// This test is intended to create a situation in which one thread will exit
-// while a the debugger is stepping in another thread.
+// while the debugger is stepping in another thread.
#include <pthread.h>
#include <unistd.h>
// SBFunction, SBSymbol, and SBAddress.
//
// When stopped on breakppint 1, we can get the line entry using SBFrame API
-// SBFrame.GetLineEntry(). We'll get the start address for the the line entry
+// SBFrame.GetLineEntry(). We'll get the start address for the line entry
// with the SBAddress type, resolve the symbol context using the SBTarget API
// SBTarget.ResolveSymbolContextForAddress() in order to get the SBSymbol.
//
-// We then stop at breakpoint 2, get the SBFrame, and the the SBFunction object.
+// We then stop at breakpoint 2, get the SBFrame, and the SBFunction object.
//
// The address from calling GetStartAddress() on the symbol and the function
// should point to the same address, and we also verify that.
print"""\
Usage: redo.py [-F filename_component] [-n] [session_dir] [-d]
where options:
--F : only consider the test for re-run if the session filename conatins the filename component
+-F : only consider the test for re-run if the session filename contains the filename component
for example: -F x86_64
-n : when running the tests, do not turn on trace mode, i.e, no '-t' option
is passed to the test driver (this will run the tests faster)
gl.append((var, val))
#print "golden list:", gl
- # This test uses a #include of a the "basic_type.cpp" so we need to enable
+ # This test uses a #include of "basic_type.cpp" so we need to enable
# always setting inlined breakpoints.
self.runCmd('settings set target.inline-breakpoint-strategy always')
# And add hooks to restore the settings during tearDown().
output = self.res.GetOutput()
# The input type is in a canonical form as a set of named atoms.
- # The display type string must conatin each and every element.
+ # The display type string must contain each and every element.
#
# Example:
# runCmd: frame variable --show-types a_array_bounded[0]
gl.append((var, val))
#print "golden list:", gl
- # This test uses a #include of a the "basic_type.cpp" so we need to enable
+ # This test uses a #include of "basic_type.cpp" so we need to enable
# always setting inlined breakpoints.
self.runCmd('settings set target.inline-breakpoint-strategy always')
# And add hooks to restore the settings during tearDown().
output = self.res.GetOutput()
# The input type is in a canonical form as a set of named atoms.
- # The display type string must conatin each and every element.
+ # The display type string must contain each and every element.
#
# Example:
# runCmd: expr a
// UNWIND_SECOND_LEVEL_REGULAR entries have a funcOffset which includes the
// functionOffset from the containing index table already. UNWIND_SECOND_LEVEL_COMPRESSED
// entries only have the offset from the containing index table functionOffset.
- // So strip off the contianing index table functionOffset value here so they can
+ // So strip off the containing index table functionOffset value here so they can
// be treated the same at the lower layers.
print_function_encoding (baton, idx, encoding, (uint32_t) -1, func_offset - baton.first_level_index_entry.functionOffset);
char name[PATH_MAX]; // Name of the executable image (usually a full path)
uint32_t state; // State of the executable image (see enum DNBSharedLibraryState)
nub_addr_t header_addr; // Executable header address
- uuid_t uuid; // Unique indentifier for matching with symbols
+ uuid_t uuid; // Unique identifier for matching with symbols
uint32_t num_segments; // Number of contiguous memory segments to in SEGMENTS array
DNBSegment *segments; // Array of contiguous memory segments in executable
};
if (nPos == (MIint)(vrTxt.length() - 1))
return false;
- // Quote must be the first character in the string or be preceeded by a space
+ // Quote must be the first character in the string or be preceded by a space
// Also check for embedded string formating quote
const MIchar cBckSlash = '\\';
const MIchar cSpace = ' ';
if (nPos == (MIint)std::string::npos)
return false;
- // Slash must be the first character in the string or be preceeded by a space
+ // Slash must be the first character in the string or be preceded by a space
const MIchar cSpace = ' ';
if ((nPos > 0) && (vrTxt[nPos - 1] != cSpace))
return false;
// Throws: None.
//--
CMICmdCmdInterpreterExec::CMICmdCmdInterpreterExec(void)
- : m_constStrArgNamedInterpreter("intepreter")
+ : m_constStrArgNamedInterpreter("interpreter")
, m_constStrArgNamedCommand("command")
{
// Command factory matches this name with that received from the stdin stream
m_miCmdData.Clear();
m_miCmdData.strMiCmd = vTextLine;
- // The following change m_miCmdData as valid parts are indentified
- vwbYesValid = (MiHasCmdTokenEndingHypthen(vTextLine) || MiHasCmdTokenEndingAlpha(vTextLine));
+ // The following change m_miCmdData as valid parts are identified
+ vwbYesValid = (MiHasCmdTokenEndingHyphen(vTextLine) || MiHasCmdTokenEndingAlpha(vTextLine));
vwbYesValid = vwbYesValid && MiHasCmd(vTextLine);
if (vwbYesValid)
{
// Throws: None.
//--
bool
-CMICmdInterpreter::MiHasCmdTokenEndingHypthen(const CMIUtilString &vTextLine)
+CMICmdInterpreter::MiHasCmdTokenEndingHyphen(const CMIUtilString &vTextLine)
{
- // The hythen is mandatory
+ // The hyphen is mandatory
const MIint nPos = vTextLine.find("-", 0);
if ((nPos == (MIint)std::string::npos))
return false;
//++ ------------------------------------------------------------------------------------
// Details: Does the command entered match the criteria for a MI command format.
-// Is the command token present before the hypen?
+// Is the command token present before the hyphen?
// Type: Method.
// Args: vTextLine - (R) Text data to interpret.
// Return: bool - True = yes command token present, false = token not present.
//++ ------------------------------------------------------------------------------------
// Details: Does the command name entered match the criteria for a MI command format.
-// Is a recogised command present? The command name is entered into the
+// Is a recognised command present? The command name is entered into the
// command meta data structure whether correct or not for reporting or later
// command execution purposes. Command options is present are also put into the
// command meta data structure.
void operator=(const CMICmdInterpreter &);
bool HasCmdFactoryGotMiCmd(const SMICmdData &vCmdData) const;
- bool MiHasCmdTokenEndingHypthen(const CMIUtilString &vTextLine);
+ bool MiHasCmdTokenEndingHyphen(const CMIUtilString &vTextLine);
bool MiHasCmdTokenEndingAlpha(const CMIUtilString &vTextLine);
bool MiHasCmd(const CMIUtilString &vTextLine);
bool MiHasCmdTokenPresent(const CMIUtilString &vTextLine);
}
//++ ------------------------------------------------------------------------------------
-// Details: Set up the events from the SBDebugger's we would to listent to.
+// Details: Set up the events from the SBDebugger's we would like to listen to.
// Type: Method.
// Args: None.
// Return: MIstatus::success - Functionality succeeded.
vwEventMask = (*it).second;
}
- SetErrorDescription(CMIUtilString::Format(MIRSRC(IDS_LLDBDEBUGGER_ERR_CLIENTNOTREGISTERD), vClientName.c_str()));
+ SetErrorDescription(CMIUtilString::Format(MIRSRC(IDS_LLDBDEBUGGER_ERR_CLIENTNOTREGISTERED), vClientName.c_str()));
return MIstatus::failure;
}
// Details: Momentarily wait for an events being broadcast and inspect those that do
// come this way. Check if the target should exit event if so start shutting
// down this thread and the application. Any other events pass on to the
-// Out-of-band handler to futher determine what kind of event arrived.
+// Out-of-band handler to further determine what kind of event arrived.
// This function runs in the thread "MI debugger event".
// Type: Method.
// Args: vrbIsAlive - (W) False = yes exit event monitoring thread, true = continue.
{IDS_LLDBDEBUGGER_ERR_THREAD_DELETE, "LLDB Debugger. Thread failed to delete '%s'"},
{IDS_LLDBDEBUGGER_ERR_INVALIDBROADCASTER, "LLDB Debugger. Invalid SB broadcaster class name '%s' "},
{IDS_LLDBDEBUGGER_ERR_INVALIDCLIENTNAME, "LLDB Debugger. Invalid client name '%s' "},
- {IDS_LLDBDEBUGGER_ERR_CLIENTNOTREGISTERD, "LLDB Debugger. Client name '%s' not registered for listening events"},
+ {IDS_LLDBDEBUGGER_ERR_CLIENTNOTREGISTERED, "LLDB Debugger. Client name '%s' not registered for listening events"},
{IDS_LLDBDEBUGGER_ERR_STOPLISTENER, "LLDB Debugger. Failure occurred stopping event for client '%s' SBBroadcaster '%s'"},
{IDS_LLDBDEBUGGER_ERR_BROARDCASTER_NAME, "LLDB Debugger. Broardcaster's name '%s' is not valid"},
{IDS_LLDBDEBUGGER_WRN_UNKNOWN_EVENT, "LLDB Debugger. Unhandled event '%s'"},
{IDS_CMD_ERR_LLDB_ERR_WRITE_MEM_BYTES, "Command '%s'. Unable to write memory block of %u bytes at address 0x%016" PRIx64 ": %s "},
{IDS_CMD_ERR_LLDB_ERR_NOT_WRITE_WHOLEBLK, "Command '%s'. LLDB unable to write entire memory block of %u bytes at address 0x%016" PRIX64},
{IDS_CMD_ERR_SET_NEW_DRIVER_STATE, "Command '%s'. Command tried to set new MI Driver running state and failed. %s"},
- {IDS_CMD_ERR_INFO_PRINTFN_NOT_FOUND, "The request '%s' was not recogised, not implemented"},
+ {IDS_CMD_ERR_INFO_PRINTFN_NOT_FOUND, "The request '%s' was not recognised, not implemented"},
{IDS_CMD_ERR_INFO_PRINTFN_FAILED, "The request '%s' failed."},
{IDS_CMD_ERR_GDBSET_OPT_TARGETASYNC, "'target-async' expects \"on\" or \"off\""},
{IDS_CMD_ERR_GDBSET_OPT_SOLIBSEARCHPATH, "'solib-search-path' requires at least one argument"},
}
//++ ------------------------------------------------------------------------------------
-// Details: Retrieve the resource text data for the given resource ID. If a resourse ID
+// Details: Retrieve the resource text data for the given resource ID. If a resource ID
// cannot be found and error is given returning the ID of the resource that
// cannot be located.
// Type: Method.
IDS_LLDBDEBUGGER_ERR_THREAD_DELETE,
IDS_LLDBDEBUGGER_ERR_INVALIDBROADCASTER,
IDS_LLDBDEBUGGER_ERR_INVALIDCLIENTNAME,
- IDS_LLDBDEBUGGER_ERR_CLIENTNOTREGISTERD,
+ IDS_LLDBDEBUGGER_ERR_CLIENTNOTREGISTERED,
IDS_LLDBDEBUGGER_ERR_STOPLISTENER,
IDS_LLDBDEBUGGER_ERR_BROARDCASTER_NAME,
IDS_LLDBDEBUGGER_WRN_UNKNOWN_EVENT,
//++ ------------------------------------------------------------------------------------
// Details: Set whether *this driver (the parent) is enabled to pass a command to its
// fall through (child) driver to interpret the command and do work instead
-// (if *this driver decides it can't hanled the command).
+// (if *this driver decides it can't handle the command).
// Type: Method.
// Args: vbYes - (R) True = yes fall through, false = do not pass on command.
// Return: MIstatus::success - Functional succeeded.
//++ ------------------------------------------------------------------------------------
// Details: Get whether *this driver (the parent) is enabled to pass a command to its
// fall through (child) driver to interpret the command and do work instead
-// (if *this driver decides it can't hanled the command).
+// (if *this driver decides it can't handle the command).
// Type: Method.
// Args: None.
// Return: bool - True = yes fall through, false = do not pass on command.
// --interpreter and also passes additional arguments which can be interpreted as an
// executable if called from the command line. Using --executable tells the MI Driver
// it is being called from the command line and to prepare to launch the executable
-// argument for a debug session. Using --interpreter on the commnd line does not
+// argument for a debug session. Using --interpreter on the command line does not
// issue additional commands to initialise a debug session.
// Type: Overridden.
// Args: argc - (R) An integer that contains the count of arguments that follow in
// Check for escape character, may be cursor control characters
// This code is not necessary for application operation, just want to keep tabs on what
- // is been given to the driver to try and intepret.
+ // has been given to the driver to try and interpret.
if (vMITextLine.at(0) == 27)
{
CMIUtilString logInput(MIRSRC(IDS_STDIN_INPUT_CTRL_CHARS));
// executable if called from the command line. Using --executable tells the MI
// Driver is being called the command line and that the executable argument is indeed
// a specified executable an so actions commands to set up the executable for a
-// debug session. Using --interpreter on the commnd line does not action additional
+// debug session. Using --interpreter on the command line does not action additional
// commands to initialise a debug session and so be able to launch the process. The directory
// where the log file is created is specified using --log-dir.
// Type: Method.
bOk = bOk && CMICmnLogMediumFile::Instance().SetDirectory(strLogDir);
}
- // Todo: Remove this output when MI is finished. It is temporary to persuade Ecllipse plugin to work.
+ // Todo: Remove this output when MI is finished. It is temporary to persuade Eclipse plugin to work.
// Eclipse reads this literally and will not work unless it gets this exact version text.
// Handle --version option (ignore the --interpreter option if present)
if (bHaveArgVersion)
return bOk;
}
- // Todo: Make this the --version when the the above --version version is removed
+ // Todo: Make this the --version when the above --version version is removed
// Handle --versionlong option (ignore the --interpreter option if present)
if (bHaveArgVersionLong)
{
return bOk;
}
- // Both '--help' and '--intepreter' means give help for MI only. Without
+ // Both '--help' and '--interpreter' means give help for MI only. Without
// '--interpreter' help the LLDB driver is working and so help is for that.
if (bHaveArgHelp && bHaveArgInterpret)
{
}
// This makes the assumption that there is at least one MI compatible
- // driver registered and one LLDB driver registerd and the CMIDriver
+ // driver registered and one LLDB driver registered and the CMIDriver
// is the first one found.
// ToDo: Implement a better solution that handle any order, any number
// of drivers. Or this 'feature' may be removed if deemed not required.
}
//++ ------------------------------------------------------------------------------------
-// Details: CMIUtilString assigment operator.
+// Details: CMIUtilString assignment operator.
// Type: Method.
// Args: vpRhs - Pointer to UTF8 text data.
// Return: CMIUtilString & - *this string.
}
//++ ------------------------------------------------------------------------------------
-// Details: CMIUtilString assigment operator.
+// Details: CMIUtilString assignment operator.
// Type: Method.
// Args: vrRhs - The other string to copy from.
// Return: CMIUtilString & - *this string.
// Details: Splits string into array of strings using delimiter. However the string is
// also considered for text surrounded by quotes. Text with quotes including the
// delimiter is treated as a whole. If multiple delimiter are found in sequence
-// then they are not added to the list of splits. Quotes that are embedded in the
+// then they are not added to the list of splits. Quotes that are embedded in
// the string as string formatted quotes are ignored (proceeded by a '\\') i.e.
// "\"MI GDB local C++.cpp\":88".
// Type: Method.
// Details: Extract the number from the string. The number can be either a hexadecimal or
// natural number. It cannot contain other non-numeric characters.
// Type: Method.
-// Args: vwrNumber - (W) Number exracted from the string.
+// Args: vwrNumber - (W) Number extracted from the string.
// Return: bool - True = yes number, false not a number.
// Throws: None.
//--
//++ ------------------------------------------------------------------------------------
// Details: Extract the number from the hexadecimal string..
// Type: Method.
-// Args: vwrNumber - (W) Number exracted from the string.
+// Args: vwrNumber - (W) Number extracted from the string.
// Return: bool - True = yes number, false not a number.
// Throws: None.
//--
}
//++ ------------------------------------------------------------------------------------
-// Details: Find first occurence in *this string which maches the pattern.
+// Details: Find first occurrence in *this string which matches the pattern.
// Type: Method.
// Args: vrPattern - (R) The pattern to search for.
// vnPos - (R) The starting position at which to start searching. (Dflt = 0)
}
//++ ------------------------------------------------------------------------------------
-// Details: Find first occurence in *this string which maches the pattern and isn't surrounded by quotes.
+// Details: Find first occurrence in *this string which matches the pattern and isn't surrounded by quotes.
// Type: Method.
// Args: vrPattern - (R) The pattern to search for.
// vbSkipQuotedText - (R) True = don't look at quoted text, false = otherwise.
}
//++ ------------------------------------------------------------------------------------
-// Details: Find first occurence in *this string which doesn't mach to the pattern.
+// Details: Find first occurrence in *this string which doesn't match the pattern.
// Type: Method.
// Args: vrPattern - (R) The pattern to search for.
// vnPos - (R) Position of the first character in the string to be considered in the search. (Dflt = 0)
}
//++ ------------------------------------------------------------------------------------
-// Details: Find first occurence of not escaped quotation mark in *this string.
+// Details: Find first occurrence of not escaped quotation mark in *this string.
// Type: Method.
// Args: vnPos - (R) Position of the first character in the string to be considered in the search.
// Return: MIuint - The position of the quotation mark.
{
assert (!attach_target.empty () && "attach_target cannot be empty");
- // First check if the attach_target is convertable to a long. If so, we'll use it as a pid.
+ // First check if the attach_target is convertible to a long. If so, we'll use it as a pid.
char *end_p = nullptr;
const long int pid = strtol (attach_target.c_str (), &end_p, 10);
argc -= 1;
argv += 1;
- // Any arguments left over are for the the program that we need to launch. If there
+ // Any arguments left over are for the program that we need to launch. If there
// are no arguments, then the GDB server will start up and wait for an 'A' packet
// to launch a program, or a vAttach packet to attach to an existing process, unless
// explicitly asked to attach with the --attach={pid|program_name} form.
<code>
<font color=blue>class</font> CommandObjectType:<br/>
<font color=blue>def</font> __init__(self, debugger, session_dict):<br/>
- <i>this call should initialize the command with respect to the command interpeter for the passed-in debugger</i> <br/>
+ <i>this call should initialize the command with respect to the command interpreter for the passed-in debugger</i> <br/>
<font color=blue>def</font> __call__(self, debugger, command, exe_ctx, result): <br/>
<i>this is the actual bulk of the command, akin to Python command functions</i> <br/>
<font color=blue>def</font> get_short_help(self): <br/>
<p>where <b>debugger</b> and <b>internal_dict</b> are as above, that function will get run when the module is loaded
allowing you to add whatever commands you want into the current debugger. Note that
- this function will only be run when using the LLDB comand <b>command script import</b>,
+ this function will only be run when using the LLDB command <b>command script import</b>,
it will not get run if anyone imports your module from another module.
If you want to always run code when your module is loaded from LLDB
<u>or</u> when loaded via an <b>import</b> statement in python code
o SBSymbolContext: A container that stores various debugger related info.
o SBValue: Represents the value of a variable, a register, or an expression.
o SBModule: Represents an executable image and its associated object and symbol
- files. SBTarget conatins SBModule(s).
+ files. SBTarget contains SBModule(s).
o SBBreakpoint: Represents a logical breakpoint and its associated settings.
- SBTarget conatins SBBreakpoint(s).
+ SBTarget contains SBBreakpoint(s).
o SBSymbol: Represents the symbol possibly associated with a stack frame.
o SBCompileUnit: Represents a compilation unit, or compiled source file.
o SBFunction: Represents a generic function, which can be inlined or not.
<a name="L18"></a><tt class="py-lineno"> 18</tt> <tt class="py-line"><tt class="py-docstring">o SBSymbolContext: A container that stores various debugger related info.</tt> </tt>
<a name="L19"></a><tt class="py-lineno"> 19</tt> <tt class="py-line"><tt class="py-docstring">o SBValue: Represents the value of a variable, a register, or an expression.</tt> </tt>
<a name="L20"></a><tt class="py-lineno"> 20</tt> <tt class="py-line"><tt class="py-docstring">o SBModule: Represents an executable image and its associated object and symbol</tt> </tt>
-<a name="L21"></a><tt class="py-lineno"> 21</tt> <tt class="py-line"><tt class="py-docstring"> files. SBTarget conatins SBModule(s).</tt> </tt>
+<a name="L21"></a><tt class="py-lineno"> 21</tt> <tt class="py-line"><tt class="py-docstring"> files. SBTarget contains SBModule(s).</tt> </tt>
<a name="L22"></a><tt class="py-lineno"> 22</tt> <tt class="py-line"><tt class="py-docstring">o SBBreakpoint: Represents a logical breakpoint and its associated settings.</tt> </tt>
-<a name="L23"></a><tt class="py-lineno"> 23</tt> <tt class="py-line"><tt class="py-docstring"> SBTarget conatins SBBreakpoint(s).</tt> </tt>
+<a name="L23"></a><tt class="py-lineno"> 23</tt> <tt class="py-line"><tt class="py-docstring"> SBTarget contains SBBreakpoint(s).</tt> </tt>
<a name="L24"></a><tt class="py-lineno"> 24</tt> <tt class="py-line"><tt class="py-docstring">o SBSymbol: Represents the symbol possibly associated with a stack frame.</tt> </tt>
<a name="L25"></a><tt class="py-lineno"> 25</tt> <tt class="py-line"><tt class="py-docstring">o SBCompileUnit: Represents a compilation unit, or compiled source file.</tt> </tt>
<a name="L26"></a><tt class="py-lineno"> 26</tt> <tt class="py-line"><tt class="py-docstring">o SBFunction: Represents a generic function, which can be inlined or not.</tt> </tt>
<p>
On Linux and Android, all required remote functionality is contained in the
<code>lldb-server</code> binary. This binary combines the functionality of the
- platform and gdb-remote stub. A single binary fascilitates deployment and reduces
+ platform and gdb-remote stub. A single binary facilitates deployment and reduces
code size, since the two functions share a lot of code. The
<code>lldb-server</code> binary is also statically linked with the rest of LLDB
(unlike <code>lldb</code>, which dynamically links to <code>liblldb.so</code> by
projects / platform / upstream / llvm.git / commitdiff