maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Fix typos. 

llvm-svn: 212132
This commit is contained in:
Bruce Mitchener 2014-07-01 21:22:11 +00:00
parent 8e97653528
commit d93c4a3339
135 changed files with 360 additions and 360 deletions
lldb
docs
lldb-gdb-remote.txt
examples/python
delta.pygdbremote.pymach_o.py
include/lldb
API
SBFileSpec.hSBFrame.hSBTarget.hSBThread.hSBValue.h
Breakpoint
Breakpoint.hBreakpointLocationList.hBreakpointSite.hWatchpoint.h
Core
Address.hAddressRange.hCommunication.hConstString.hDataBuffer.hDataEncoder.hIOHandler.hMangled.hModule.hModuleList.hRegularExpression.hSourceManager.hStream.hValueObject.h
Expression
ASTStructExtractor.hClangExpressionParser.hClangExpressionVariable.hClangUserExpression.hIRExecutionUnit.hIRForTarget.h
Host
Condition.hFile.hFileSpec.hHost.hSocketAddress.hSymbols.hTerminal.h
Interpreter
Args.hCommandCompletions.hCommandInterpreter.hCommandObject.h
Symbol
Block.hClangASTImporter.hClangASTType.hClangExternalASTSourceCommon.hCompileUnit.hDeclaration.hFuncUnwinders.hFunction.hLineEntry.hLineTable.hObjectContainer.hObjectFile.hSymbolContext.hSymbolContextScope.hSymbolFile.hVariableList.h
Target
ABI.hCPPLanguageRuntime.hExecutionContext.hExecutionContextScope.hJITLoader.hPlatform.hProcess.hQueueList.hStackFrame.hTarget.hTargetList.hThread.hThreadPlanShouldStopHere.h
Utility
CleanUp.hPseudoTerminal.hSharingPtr.h
scripts
Python/interface
SBFileSpec.iSBFrame.iSBThread.iSBValue.i
checkpoint-llvm.pldisasm-gdb-remote.plsed-sources
source
API
SBFileSpec.cpp
Breakpoint
BreakpointResolverName.cpp
Commands
CommandObjectCommands.cppCommandObjectExpression.cppCommandObjectSettings.cpp
Core
AddressResolverName.cppModule.cppRegularExpression.cppScalar.cppStream.cppValueObjectConstResultImpl.cpp
Host
common
FileSpec.cppHost.cpp
linux
Host.cpp
macosx
Host.mm
Plugins
ABI/MacOSX-arm64
ABIMacOSX_arm64.cpp
DynamicLoader/MacOSX-DYLD
DynamicLoaderMacOSXDYLD.cpp
Show More

4
lldb/docs/lldb-gdb-remote.txt
View File

@ -1083,7 +1083,7 @@ for this region.
// "qsProcessInfo"
//
// BRIEF
// Get the first process info (qfProcessInfo) or subsequent processs
// Get the first process info (qfProcessInfo) or subsequent process
// info (qsProcessInfo) for one or more processes on the remote
// platform. The first call gets the first match and subsequent calls
// to qsProcessInfo gets the subsequent matches. Return an error EXX,
@ -1296,7 +1296,7 @@ for this region.
// sending strings with arbitrary contents in them, including the '#', '$', and '*'
// characters that have special meaning in gdb-remote protocol and cannot occur
// in the middle of the string. The standard solution for this would be to require
// ascii-hex encoding of all strings, or ascii-hex encode the entier JSON payload.
// ascii-hex encoding of all strings, or ascii-hex encode the entire JSON payload.
//
// Instead, the binary escaping convention is used for JSON data. This convention
// (e.g. used for the X packet) says that if '#', '$', '*', or '}' are to occur in

2
lldb/examples/python/delta.py
View File

@ -68,7 +68,7 @@ def parse_log_file(file, options):
generated using:
(lldb) log enable --threadsafe --timestamp --file <FILE> ....
This log file will contain timestamps and this fucntion will then normalize
This log file will contain timestamps and this function will then normalize
those packets to be relative to the first value timestamp that is found and
show delta times between log lines and also keep track of how long it takes
for GDB remote commands to make a send/receive round trip. This can be

12
lldb/examples/python/gdbremote.py
View File

@ -45,7 +45,7 @@ class TerminalColors:
return ''
def bold(self, on = True):
'''Enable or disable bold depending on the "on" paramter.'''
'''Enable or disable bold depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[1m";
@ -54,7 +54,7 @@ class TerminalColors:
return ''
def italics(self, on = True):
'''Enable or disable italics depending on the "on" paramter.'''
'''Enable or disable italics depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[3m";
@ -63,7 +63,7 @@ class TerminalColors:
return ''
def underline(self, on = True):
'''Enable or disable underline depending on the "on" paramter.'''
'''Enable or disable underline depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[4m";
@ -72,7 +72,7 @@ class TerminalColors:
return ''
def inverse(self, on = True):
'''Enable or disable inverse depending on the "on" paramter.'''
'''Enable or disable inverse depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[7m";
@ -81,7 +81,7 @@ class TerminalColors:
return ''
def strike(self, on = True):
'''Enable or disable strike through depending on the "on" paramter.'''
'''Enable or disable strike through depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[9m";
@ -859,7 +859,7 @@ gdb_remote_commands = {
def parse_gdb_log_file(file, options):
'''Parse a GDB log file that was generated by enabling logging with:
(lldb) log enable --threadsafe --timestamp --file <FILE> gdb-remote packets
This log file will contain timestamps and this fucntion will then normalize
This log file will contain timestamps and this function will then normalize
those packets to be relative to the first value timestamp that is found and
show delta times between log lines and also keep track of how long it takes
for GDB remote commands to make a send/receive round trip. This can be

10
lldb/examples/python/mach_o.py
View File

@ -221,7 +221,7 @@ class TerminalColors:
return ''
def bold(self, on = True):
'''Enable or disable bold depending on the "on" paramter.'''
'''Enable or disable bold depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[1m";
@ -230,7 +230,7 @@ class TerminalColors:
return ''
def italics(self, on = True):
'''Enable or disable italics depending on the "on" paramter.'''
'''Enable or disable italics depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[3m";
@ -239,7 +239,7 @@ class TerminalColors:
return ''
def underline(self, on = True):
'''Enable or disable underline depending on the "on" paramter.'''
'''Enable or disable underline depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[4m";
@ -248,7 +248,7 @@ class TerminalColors:
return ''
def inverse(self, on = True):
'''Enable or disable inverse depending on the "on" paramter.'''
'''Enable or disable inverse depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[7m";
@ -257,7 +257,7 @@ class TerminalColors:
return ''
def strike(self, on = True):
'''Enable or disable strike through depending on the "on" paramter.'''
'''Enable or disable strike through depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[9m";

2
lldb/include/lldb/API/SBFileSpec.h
View File

@ -21,7 +21,7 @@ public:
SBFileSpec (const lldb::SBFileSpec &rhs);
SBFileSpec (const char *path);// Deprected, use SBFileSpec (const char *path, bool resolve)
SBFileSpec (const char *path);// Deprecated, use SBFileSpec (const char *path, bool resolve)
SBFileSpec (const char *path, bool resolve);

2
lldb/include/lldb/API/SBFrame.h
View File

@ -75,7 +75,7 @@ public:
/// Get the appropriate function name for this frame. Inlined functions in
/// LLDB are represented by Blocks that have inlined function information, so
/// just looking at the SBFunction or SBSymbol for a frame isn't enough.
/// This function will return the appriopriate function, symbol or inlined
/// This function will return the appropriate function, symbol or inlined
/// function name for the frame.
///
/// This function returns:

6
lldb/include/lldb/API/SBTarget.h
View File

@ -56,7 +56,7 @@ public:
///
/// This only needs to be specified if clients wish to carefully control
/// the exact path will be used to launch a binary. If you create a
/// target with a symlink, that simlink will get resolved in the target
/// target with a symlink, that symlink will get resolved in the target
/// and the resolved path will get used to launch the process. Calling
/// this function can help you still launch your process using the
/// path of your choice.
@ -372,7 +372,7 @@ public:
/// Some launch options specified by logical OR'ing
/// lldb::LaunchFlags enumeration values together.
///
/// @param[in] stop_at_endtry
/// @param[in] stop_at_entry
/// If false do not stop the inferior at the entry point.
///
/// @param[out]
@ -621,7 +621,7 @@ public:
//------------------------------------------------------------------
/// The the section base load addresses for all sections in a module.
/// Clear the section base load addresses for all sections in a module.
///
/// @param[in] module
/// The module to unload.

4
lldb/include/lldb/API/SBThread.h
View File

@ -142,8 +142,8 @@ public:
/// the other threads in a process are allowed to run. So when
/// SBProcess::Continue() is called, any threads that aren't suspended will
/// be allowed to run. If any of the SBThread functions for stepping are
/// called (StepOver, StepInto, StepOut, StepInstruction, RunToAddres), the
/// thread will not be allowed to run and these funtions will simply return.
/// called (StepOver, StepInto, StepOut, StepInstruction, RunToAddress), the
/// thread will not be allowed to run and these functions will simply return.
///
/// Eventually we plan to add support for thread centric debugging where
/// each thread is controlled individually and each thread would broadcast

4
lldb/include/lldb/API/SBValue.h
View File

@ -176,7 +176,7 @@ public:
//------------------------------------------------------------------
/// Get a child value by index from a value.
///
/// Structs, unions, classes, arrays and and pointers have child
/// Structs, unions, classes, arrays and pointers have child
/// values that can be access by index.
///
/// Structs and unions access child members using a zero based index
@ -211,7 +211,7 @@ public:
/// The index of the child value to get
///
/// @param[in] use_dynamic
/// An enumeration that specifies wether to get dynamic values,
/// An enumeration that specifies whether to get dynamic values,
/// and also if the target can be run to figure out the dynamic
/// type of the child value.
///

2
lldb/include/lldb/Breakpoint/Breakpoint.h
View File

@ -431,7 +431,7 @@ public:
/// @param[in] is_synchronous
/// If \b true the callback will be run on the private event thread
/// before the stop event gets reported. If false, the callback will get
/// handled on the public event thead after the stop has been posted.
/// handled on the public event thread after the stop has been posted.
///
/// @return
/// \b true if the process should stop when you hit the breakpoint.

2
lldb/include/lldb/Breakpoint/BreakpointLocationList.h
View File

@ -143,7 +143,7 @@ public:
ClearAllBreakpointSites ();
//------------------------------------------------------------------
/// Tells all the breakopint locations in this list to attempt to
/// Tells all the breakpoint locations in this list to attempt to
/// resolve any possible breakpoint sites.
//------------------------------------------------------------------
void

8
lldb/include/lldb/Breakpoint/BreakpointSite.h
View File

@ -34,7 +34,7 @@ namespace lldb_private {
/// The BreakpointSite class handles the physical breakpoint that is
/// actually inserted in the target program. As such, it is also the
/// one that gets hit, when the program stops. It keeps a list of all
/// BreakpointLocations that share this phsyical site. When the
/// BreakpointLocations that share this physical site. When the
/// breakpoint is hit, all the locations are informed by the breakpoint
/// site. Breakpoint sites are owned by the process.
//----------------------------------------------------------------------
@ -51,7 +51,7 @@ public:
// and m_trap_opcode contain the saved and written opcode.
eHardware, // Breakpoint site is set as a hardware breakpoint
eExternal // Breakpoint site is managed by an external debug nub or
// debug interface where memory reads trasparently will not
// debug interface where memory reads transparently will not
// display any breakpoint opcodes.
};
@ -124,7 +124,7 @@ public:
/// Sets whether the current breakpoint site is enabled or not
///
/// @param[in] enabled
/// \b true if the breakoint is enabled, \b false otherwise.
/// \b true if the breakpoint is enabled, \b false otherwise.
//------------------------------------------------------------------
void
SetEnabled (bool enabled);
@ -173,7 +173,7 @@ public:
GetNumberOfOwners ();
//------------------------------------------------------------------
/// This method returns the the breakpoint location at index \a index
/// This method returns the breakpoint location at index \a index
/// located at this breakpoint site. The owners are listed ordinally
/// from 0 to GetNumberOfOwners() - 1 so you can use this method to iterate
/// over the owners

4
lldb/include/lldb/Breakpoint/Watchpoint.h
View File

@ -134,7 +134,7 @@ public:
/// @param[in] is_synchronous
/// If \b true the callback will be run on the private event thread
/// before the stop event gets reported. If false, the callback will get
/// handled on the public event thead after the stop has been posted.
/// handled on the public event thread after the stop has been posted.
///
/// @return
/// \b true if the process should stop when you hit the watchpoint.
@ -215,7 +215,7 @@ private:
// undergoing a pair of temporary disable/enable actions to avoid recursively
// triggering further watchpoint events.
uint32_t m_disabled_count; // Keep track of the count that the watchpoint is disabled while in ephemeral mode.
// At the end of the ephemeral mode when the watchpoint is to be enabled agian,
// At the end of the ephemeral mode when the watchpoint is to be enabled again,
// we check the count, if it is more than 1, it means the user-supplied actions
// actually want the watchpoint to be disabled!
uint32_t m_watch_read:1, // 1 if we stop when the watched data is read from

6
lldb/include/lldb/Core/Address.h
View File

@ -230,7 +230,7 @@ public:
/// offset based address, and \a style lets the user choose.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
///
/// @param[in] style
/// The display style for the address.
@ -310,7 +310,7 @@ public:
///
/// This function will first resolve its address to a load address.
/// Then, if the address turns out to be in code address, return the
/// load address for a an opcode. This address object might have
/// load address for an opcode. This address object might have
/// extra bits set (bit zero will be set to Thumb functions for an
/// ARM target) that are required for changing the program counter
/// and this function will remove any bits that are intended for
@ -362,7 +362,7 @@ public:
/// offset (for absolute addresses that have no section).
///
/// @return
/// Returns \b true if the the offset is valid, \b false
/// Returns \b true if the offset is valid, \b false
/// otherwise.
//------------------------------------------------------------------
bool

4
lldb/include/lldb/Core/AddressRange.h
View File

@ -189,7 +189,7 @@ public:
/// how the base address gets displayed.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
///
/// @param[in] style
/// The display style for the address.
@ -215,7 +215,7 @@ public:
/// and pointer values, reference counts, etc.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
//------------------------------------------------------------------
void
DumpDebug (Stream *s) const;

4
lldb/include/lldb/Core/Communication.h
View File

@ -59,7 +59,7 @@ namespace lldb_private {
///
/// bool Communication::StartReadThread (Error *);
///
/// If true is returned a read thead has been spawned that will
/// If true is returned a read thread has been spawned that will
/// continually execute a call to the pure virtual DoRead function:
///
/// size_t Communication::ReadFromConnection (void *, size_t, uint32_t);
@ -300,7 +300,7 @@ public:
//------------------------------------------------------------------
/// The static read thread function. This function will call
/// the "DoRead" function continuously and wait for data to become
/// avaialble. When data is received it will append the available
/// available. When data is received it will append the available
/// data to the internal cache and broadcast a
/// \b eBroadcastBitReadThreadGotBytes event.
///

8
lldb/include/lldb/Core/ConstString.h
View File

@ -303,7 +303,7 @@ public:
/// returns an integer result.
///
/// NOTE: only call this function when you want a true string
/// comparision. If you want string equality use the, use the ==
/// comparison. If you want string equality use the, use the ==
/// operator as it is much more efficient. Also if you want string
/// inequality, use the != operator for the same reasons.
///
@ -383,7 +383,7 @@ public:
//------------------------------------------------------------------
/// Set the C string value and its mangled counterpart.
///
/// Object files and debug sybmols often use mangled string to
/// Object files and debug symbols often use mangled string to
/// represent the linkage name for a symbol, function or global.
/// The string pool can efficiently store these values and their
/// counterparts so when we run into another instance of a mangled
@ -406,7 +406,7 @@ public:
/// Retrieve the mangled or demangled counterpart for a mangled
/// or demangled ConstString.
///
/// Object files and debug sybmols often use mangled string to
/// Object files and debug symbols often use mangled string to
/// represent the linkage name for a symbol, function or global.
/// The string pool can efficiently store these values and their
/// counterparts so when we run into another instance of a mangled
@ -478,7 +478,7 @@ public:
//------------------------------------------------------------------
/// Get the size in bytes of the current global string pool.
///
/// Reports the the size in bytes of all shared C string values,
/// Reports the size in bytes of all shared C string values,
/// containers and any other values as a byte size for the
/// entire string pool.
///

2
lldb/include/lldb/Core/DataBuffer.h
View File

@ -20,7 +20,7 @@ namespace lldb_private {
/// @class DataBuffer DataBuffer.h "lldb/Core/DataBuffer.h"
/// @brief A pure virtual protocol class for abstracted data buffers.
///
/// DataBuffer is an abtract class that gets packaged into a shared pointer
/// DataBuffer is an abstract class that gets packaged into a shared pointer
/// that can use to implement various ways to store data (on the heap,
/// memory mapped, cached inferior memory). It gets used by DataExtractor
/// so many DataExtractor objects can share the same data and sub-ranges

6
lldb/include/lldb/Core/DataEncoder.h
View File

@ -173,7 +173,7 @@ public:
}
//------------------------------------------------------------------
/// Get a the data start pointer.
/// Get the data start pointer.
///
/// @return
/// Returns a pointer to the first byte contained in this
@ -234,7 +234,7 @@ public:
/// The size in byte of the integer to encode.
///
/// @param[in] value
/// The integer value to write. The least significate bytes of
/// The integer value to write. The least significant bytes of
/// the integer value will be written if the size is less than
/// 8 bytes.
///
@ -253,7 +253,7 @@ public:
/// start encoding.
///
/// @param[int] src
/// The buffer that contains the the bytes to encode.
/// The buffer that contains the bytes to encode.
///
/// @param[in] src_len
/// The number of bytes to encode.

8
lldb/include/lldb/Core/IOHandler.h
View File

@ -191,7 +191,7 @@ namespace lldb_private {
///
/// This will return true if the input stream is a terminal (tty or
/// pty) and can cause IO handlers to do different things (like
/// for a comfirmation when deleting all breakpoints).
/// for a confirmation when deleting all breakpoints).
//------------------------------------------------------------------
bool
GetIsInteractive ();
@ -200,9 +200,9 @@ namespace lldb_private {
/// Check if the input is coming from a real terminal.
///
/// A real terminal has a valid size with a certain number of rows
/// and colums. If this function returns true, then terminal escape
/// and columns. If this function returns true, then terminal escape
/// sequences are expected to work (cursor movement escape sequences,
/// clearning lines, etc).
/// clearing lines, etc).
//------------------------------------------------------------------
bool
GetIsRealTerminal ();
@ -267,7 +267,7 @@ namespace lldb_private {
//------------------------------------------------------------------
/// Called when a line or lines have been retrieved.
///
/// This funtion can handle the current line and possibly call
/// This function can handle the current line and possibly call
/// IOHandler::SetIsDone(true) when the IO handler is done like when
/// "quit" is entered as a command, of when an empty line is
/// received. It is up to the delegate to determine when a line

6
lldb/include/lldb/Core/Mangled.h
View File

@ -153,7 +153,7 @@ public:
/// demangled name to be computed currently (we don't use the accessor).
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
//----------------------------------------------------------------------
void
Dump (Stream *s) const;
@ -162,7 +162,7 @@ public:
/// Dump a debug description of this object to a Stream \a s.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
//----------------------------------------------------------------------
void
DumpDebug (Stream *s) const;
@ -219,7 +219,7 @@ public:
/// Which name would you prefer to get?
///
/// @return
/// A const reference to the the preferred name string object if this
/// A const reference to the preferred name string object if this
/// object has a valid name of that kind, else a const reference to the
/// other name is returned.
//----------------------------------------------------------------------

18
lldb/include/lldb/Core/Module.h
View File

@ -68,7 +68,7 @@ public:
/// use ModuleList::GetSharedModule().
///
/// @param[in] file_spec
/// The file specification for the on disk repesentation of
/// The file specification for the on disk representation of
/// this executable image.
///
/// @param[in] arch
@ -197,7 +197,7 @@ public:
/// in a module.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
//------------------------------------------------------------------
void
Dump (Stream *s);
@ -419,7 +419,7 @@ public:
VariableList& variable_list);
//------------------------------------------------------------------
/// Find global and static variables by regular exression.
/// Find global and static variables by regular expression.
///
/// @param[in] regex
/// A regular expression to use when matching the name.
@ -472,11 +472,11 @@ public:
///
/// @param[in] type_name
/// The name of the type we are looking for that is a fully
/// or partially qualfieid type name.
/// or partially qualified type name.
///
/// @param[in] exact_match
/// If \b true, \a type_name is fully qualifed and must match
/// exactly. If \b false, \a type_name is a partially qualfied
/// If \b true, \a type_name is fully qualified and must match
/// exactly. If \b false, \a type_name is a partially qualified
/// name where the leading namespaces or classes can be
/// omitted to make finding types that a user may type
/// easier.
@ -773,12 +773,12 @@ public:
/// A debugging function that will cause everything in a module to
/// be parsed.
///
/// All compile units will be pasred, along with all globals and
/// All compile units will be parsed, along with all globals and
/// static variables and all functions for those compile units.
/// All types, scopes, local variables, static variables, global
/// variables, and line tables will be parsed. This can be used
/// prior to dumping a module to see a complete list of the
/// resuling debug information that gets parsed, or as a debug
/// resulting debug information that gets parsed, or as a debug
/// function to ensure that the module can consume all of the
/// debug data the symbol vendor provides.
//------------------------------------------------------------------
@ -966,7 +966,7 @@ public:
//------------------------------------------------------------------
// Return true if the file backing this module has changed since the
// module was originally created since we saved the intial file
// module was originally created since we saved the initial file
// modification time when the module first gets created.
//------------------------------------------------------------------
bool

6
lldb/include/lldb/Core/ModuleList.h
View File

@ -138,7 +138,7 @@ public:
///
/// Clears the list of modules and releases a reference to each
/// module object and if the reference count goes to zero, the
/// module will be deleted. Also relese all memory that might be
/// module will be deleted. Also release all memory that might be
/// held by any collection classes (like std::vector)
//------------------------------------------------------------------
void
@ -150,7 +150,7 @@ public:
/// the supplied stream \a s.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
///
/// @see Module::Dump(Stream *) const
//------------------------------------------------------------------
@ -308,7 +308,7 @@ public:
VariableList& variable_list) const;
//------------------------------------------------------------------
/// Find global and static variables by regular exression.
/// Find global and static variables by regular expression.
///
/// @param[in] regex
/// A regular expression to use when matching the name.

12
lldb/include/lldb/Core/RegularExpression.h
View File

@ -119,7 +119,7 @@ public:
RegularExpression ();
//------------------------------------------------------------------
/// Constructor that takes a regulare expression with flags.
/// Constructor that takes a regular expression with flags.
///
/// Constructor that compiles \a re using \a flags and stores the
/// resulting compiled regular expression into this object.
@ -129,7 +129,7 @@ public:
/// compile.
///
/// @param[in] flags
/// Flags that are passed the the \c regcomp() function.
/// Flags that are passed to the \c regcomp() function.
//------------------------------------------------------------------
explicit
RegularExpression (const char* re, int flags);
@ -141,7 +141,7 @@ public:
//------------------------------------------------------------------
/// Destructor.
///
/// Any previosuly compiled regular expression contained in this
/// Any previously compiled regular expression contained in this
/// object will be freed.
//------------------------------------------------------------------
~RegularExpression ();
@ -154,10 +154,10 @@ public:
/// Compile a regular expression.
///
/// Compile a regular expression using the supplied regular
/// expression text and flags. The compied regular expression lives
/// expression text and flags. The compiled regular expression lives
/// in this object so that it can be readily used for regular
/// expression matches. Execute() can be called after the regular
/// expression is compiled. Any previosuly compiled regular
/// expression is compiled. Any previously compiled regular
/// expression contained in this object will be freed.
///
/// @param[in] re
@ -165,7 +165,7 @@ public:
/// expression to compile.
///
/// @param[in] flags
/// Flags that are passed the the \c regcomp() function.
/// Flags that are passed to the \c regcomp() function.
///
/// @return
/// \b true if the regular expression compiles successfully,

2
lldb/include/lldb/Core/SourceManager.h
View File

@ -85,7 +85,7 @@ public:
CalculateLineOffsets (uint32_t line = UINT32_MAX);
FileSpec m_file_spec_orig; // The original file spec that was used (can be different from m_file_spec)
FileSpec m_file_spec; // The actualy file spec being used (if the target has source mappings, this might be different from m_file_spec_orig)
FileSpec m_file_spec; // The actually file spec being used (if the target has source mappings, this might be different from m_file_spec_orig)
TimeValue m_mod_time; // Keep the modification time that this file data is valid for
uint32_t m_source_map_mod_id; // If the target uses path remappings, be sure to clear our notion of a source file if the path modification ID changes
lldb::DataBufferSP m_data_sp;

2
lldb/include/lldb/Core/Stream.h
View File

@ -472,7 +472,7 @@ public:
/// Indent the current line in the stream.
///
/// Indent the current line using the current indentation level and
/// print an optional string following the idenatation spaces.
/// print an optional string following the indentation spaces.
///
/// @param[in] s
/// A C string to print following the indentation. If NULL, just

10
lldb/include/lldb/Core/ValueObject.h
View File

@ -35,7 +35,7 @@ namespace lldb_private {
/// ValueObject:
///
/// This abstract class provides an interface to a particular value, be it a register, a local or global variable,
/// that is evaluated in some particular scope. The ValueObject also has the capibility of being the "child" of
/// that is evaluated in some particular scope. The ValueObject also has the capability of being the "child" of
/// some other variable object, and in turn of having children.
/// If a ValueObject is a root variable object - having no parent - then it must be constructed with respect to some
/// particular ExecutionContextScope. If it is a child, it inherits the ExecutionContextScope from its parent.
@ -380,7 +380,7 @@ public:
GetTypeImpl ();
//------------------------------------------------------------------
// Sublasses must implement the functions below.
// Subclasses must implement the functions below.
//------------------------------------------------------------------
virtual uint64_t
GetByteSize() = 0;
@ -389,7 +389,7 @@ public:
GetValueType() const = 0;
//------------------------------------------------------------------
// Sublasses can implement the functions below.
// Subclasses can implement the functions below.
//------------------------------------------------------------------
virtual ConstString
GetTypeName();
@ -531,7 +531,7 @@ public:
GetDeclaration (Declaration &decl);
//------------------------------------------------------------------
// The functions below should NOT be modified by sublasses
// The functions below should NOT be modified by subclasses
//------------------------------------------------------------------
const Error &
GetError();
@ -1130,7 +1130,7 @@ protected:
ClearDynamicTypeInformation ();
//------------------------------------------------------------------
// Sublasses must implement the functions below.
// Subclasses must implement the functions below.
//------------------------------------------------------------------
virtual ClangASTType

2
lldb/include/lldb/Expression/ASTStructExtractor.h
View File

@ -30,7 +30,7 @@ namespace lldb_private {
///
/// The definition of this struct is itself in the body of the wrapper function,
/// so Clang does the structure layout itself. ASTStructExtractor reads through
/// the AST for the wrapper funtion and finds the struct.
/// the AST for the wrapper function and finds the struct.
//----------------------------------------------------------------------
class ASTStructExtractor : public clang::SemaConsumer
{

2
lldb/include/lldb/Expression/ClangExpressionParser.h
View File

@ -40,7 +40,7 @@ public:
//------------------------------------------------------------------
/// Constructor
///
/// Initializes class variabes.
/// Initializes class variables.
///
/// @param[in] exe_scope,
/// If non-NULL, an execution context scope that can help to

4
lldb/include/lldb/Expression/ClangExpressionVariable.h
View File

@ -237,8 +237,8 @@ public:
// this function is used to copy the address-of m_live_sp into m_frozen_sp
// this is necessary because the results of certain cast and pointer-arithmetic
// operations (such as those described in bugzilla issues 11588 and 11618) generate
// frozen objcts that do not have a valid address-of, which can be troublesome when
// using synthetic children providers. transferring the address-of the live object
// frozen objects that do not have a valid address-of, which can be troublesome when
// using synthetic children providers. Transferring the address-of the live object
// solves these issues and provides the expected user-level behavior
void
TransferAddress (bool force = false);

4
lldb/include/lldb/Expression/ClangUserExpression.h
View File

@ -167,7 +167,7 @@ public:
///
/// @param[in] function_stack_pointer
/// A pointer to the base of the function's stack frame. This
/// is used to determine whether the expession result resides in
/// is used to determine whether the expression result resides in
/// memory that will still be valid, or whether it needs to be
/// treated as homeless for the purpose of future expressions.
///
@ -309,7 +309,7 @@ public:
static const Error::ValueType kNoResult = 0x1001; ///< ValueObject::GetError() returns this if there is no result from the expression.
private:
//------------------------------------------------------------------
/// Populate m_cplusplus and m_objetivec based on the environment.
/// Populate m_cplusplus and m_objectivec based on the environment.
//------------------------------------------------------------------
void

4
lldb/include/lldb/Expression/IRExecutionUnit.h
View File

@ -456,7 +456,7 @@ private:
//------------------------------------------------------------------
/// Constructor
///
/// Initializes class variabes.
/// Initializes class variables.
///
/// @param[in] name
/// The name of the function.
@ -483,7 +483,7 @@ private:
//----------------------------------------------------------------------
/// @class AllocationRecord IRExecutionUnit.h "lldb/Expression/IRExecutionUnit.h"
/// @brief Enacpsulates a single allocation request made by the JIT.
/// @brief Encapsulates a single allocation request made by the JIT.
///
/// Allocations made by the JIT are first queued up and then applied in
/// bulk to the underlying process.

4
lldb/include/lldb/Expression/IRForTarget.h
View File

@ -188,7 +188,7 @@ private:
//------------------------------------------------------------------
//------------------------------------------------------------------
/// Get the address of a fuction, and a location to put the complete
/// Get the address of a function, and a location to put the complete
/// Value of the function if one is available.
///
/// @param[in] function
@ -579,7 +579,7 @@ private:
ReplaceStrings ();
//------------------------------------------------------------------
/// A basick block-level pass to find all literals that will be
/// A basic block-level pass to find all literals that will be
/// allocated as statics by the JIT (in contrast to the Strings,
/// which already are statics) and synthesize loads for them.
//------------------------------------------------------------------

2
lldb/include/lldb/Host/Condition.h
View File

@ -25,7 +25,7 @@ class TimeValue;
///
/// A class that wraps up a pthread condition (pthread_cond_t). The
/// class will create a pthread condition when an instance is
/// constructed, and detroy it when it is destructed. It also provides
/// constructed, and destroy it when it is destructed. It also provides
/// access to the standard pthread condition calls.
//----------------------------------------------------------------------
class Condition

4
lldb/include/lldb/Host/File.h
View File

@ -331,7 +331,7 @@ public:
///
/// @param[in/out] offset
/// The offset to seek to within the file relative to the
/// end of the file which gets filled in the the resulting
/// end of the file which gets filled in with the resulting
/// absolute file offset.
///
/// @param[in] error_ptr
@ -482,7 +482,7 @@ public:
///
/// Just knowing a file is a interactive isn't enough, we also need
/// to know if the terminal has a width and height so we can do
/// cursor movement and other terminal maninpulations by sending
/// cursor movement and other terminal manipulations by sending
/// escape sequences.
///
/// @return

8
lldb/include/lldb/Host/FileSpec.h
View File

@ -249,7 +249,7 @@ public:
/// by a directory delimiter, and the filename.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
//------------------------------------------------------------------
void
Dump (Stream *s) const;
@ -486,7 +486,7 @@ public:
/// Returns a shared pointer to a data buffer that contains all or
/// part of the contents of a file. The data is memory mapped and
/// will lazily page in data from the file as memory is accessed.
/// The data that is mappped will start \a offset bytes into the
/// The data that is mapped will start \a offset bytes into the
/// file, and \a length bytes will be mapped. If \a length is
/// greater than the number of bytes available in the file starting
/// at \a offset, the number of bytes will be appropriately
@ -504,7 +504,7 @@ public:
/// as many bytes as possible.
///
/// @return
/// A shared pointer to the memeory mapped data. This shared
/// A shared pointer to the memory mapped data. This shared
/// pointer can contain a NULL DataBuffer pointer, so the contained
/// pointer must be checked prior to using it.
//------------------------------------------------------------------
@ -560,7 +560,7 @@ public:
lldb::DataBufferSP
ReadFileContentsAsCString(Error *error_ptr = NULL);
//------------------------------------------------------------------
/// Change the file specificed with a new path.
/// Change the file specified with a new path.
///
/// Update the contents of this object with a new path. The path will
/// be split up into a directory and filename and stored as uniqued

10
lldb/include/lldb/Host/Host.h
View File

@ -48,11 +48,11 @@ public:
/// thread so the callback function must be thread safe.
///
/// When the callback gets called, the return value indicates if
/// minotoring should stop. If \b true is returned from \a callback
/// monitoring should stop. If \b true is returned from \a callback
/// the information will be removed. If \b false is returned then
/// monitoring will continue. If the child process exits, the
/// monitoring will automatically stop after the callback returned
/// ragardless of the callback return value.
/// regardless of the callback return value.
///
/// @param[in] callback
/// A function callback to call when a child receives a signal
@ -259,7 +259,7 @@ public:
///
/// This function call lets the current host OS do any thread
/// specific initialization that it needs, including naming the
/// thread. No cleanup routine is exptected to be called
/// thread. No cleanup routine is expected to be called
///
/// @param[in] name
/// The current thread's name in the current process.
@ -410,7 +410,7 @@ public:
//------------------------------------------------------------------
/// When executable files may live within a directory, where the
/// directory represents an executable bundle (like the MacOSX
/// app bundles), the locate the executable within the containing
/// app bundles), then locate the executable within the containing
/// bundle.
///
/// @param[in,out] file
@ -438,7 +438,7 @@ public:
/// directory member gets filled in.
///
/// @param[in] file_spec
/// A file spec that gets filled in with the appriopriate path.
/// A file spec that gets filled in with the appropriate path.
///
/// @return
/// \b true if \a resource_path was resolved, \a false otherwise.

4
lldb/include/lldb/Host/SocketAddress.h
View File

@ -82,7 +82,7 @@ public:
GetLength () const;
//------------------------------------------------------------------
// Get the mex length for the the largest socket address supported.
// Get the max length for the largest socket address supported.
//------------------------------------------------------------------
static socklen_t
GetMaxLength ();
@ -203,7 +203,7 @@ public:
// Conversion operators to allow getting the contents of this class
// as a pointer to the appropriate structure. This allows an instance
// of this class to be used in calls that take one of the sockaddr
// structure variants without having to manally use the correct
// structure variants without having to manually use the correct
// accessor function.
//------------------------------------------------------------------

2
lldb/include/lldb/Host/Symbols.h
View File

@ -50,7 +50,7 @@ public:
// Locate the object and symbol file given a module specification.
//
// Locating the file can try to download the file from a corporate build
// respository, or using any other means necessary to locate both the
// repository, or using any other means necessary to locate both the
// unstripped object file and the debug symbols.
// The force_lookup argument controls whether the external program is called
// unconditionally to find the symbol file, or if the user's settings are

2
lldb/include/lldb/Host/Terminal.h
View File

@ -101,7 +101,7 @@ public:
///
/// @param[in] save_process_group
/// If \b true, save the process group settings, else do not
/// save the process group setttings for a TTY.
/// save the process group settings for a TTY.
///
/// @return
/// Returns \b true if \a fd describes a TTY and if the state

6
lldb/include/lldb/Interpreter/Args.h
View File

@ -293,7 +293,7 @@ public:
/// A copy \a arg_cstr will be made.
///
/// @param[in] arg_cstr
/// The argument to push on the front the the argument stack.
/// 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.
@ -308,7 +308,7 @@ public:
/// Parse the arguments in the contained arguments.
///
/// The arguments that are consumed by the argument parsing process
/// will be removed from the argument vector. The arguements that
/// will be removed from the argument vector. The arguments that
/// get processed start at the second argument. The first argument
/// is assumed to be the command and will not be touched.
///
@ -430,7 +430,7 @@ public:
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 chracters
// 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

2
lldb/include/lldb/Interpreter/CommandCompletions.h
View File

@ -195,7 +195,7 @@ public:
};
//----------------------------------------------------------------------
// SouceFileCompleter implements the source file completer
// SourceFileCompleter implements the source file completer
//----------------------------------------------------------------------
class SourceFileCompleter : public Completer
{

2
lldb/include/lldb/Interpreter/CommandInterpreter.h
View File

@ -252,7 +252,7 @@ public:
// This version just returns matches, and doesn't compute the substring. It is here so the
// Help command can call it for the first argument.
// word_complete tells whether a the completions are considered a "complete" response (so the
// word_complete tells whether the completions are considered a "complete" response (so the
// completer should complete the quote & put a space after the word.
int

2
lldb/include/lldb/Interpreter/CommandObject.h
View File

@ -269,7 +269,7 @@ public:
//
// Ensures a valid register context (from the selected frame if there
// is a frame in m_exe_ctx, or from the selected thread from m_exe_ctx)
// is availble from m_exe_ctx prior to executing the command. If a
// is available from m_exe_ctx prior to executing the command. If a
// target doesn't exist or is invalid, the command will fail and
// CommandObject::GetInvalidRegContextDescription() will be returned as
// the error. CommandObject subclasses can override the virtual function

12
lldb/include/lldb/Symbol/Block.h
View File

@ -29,13 +29,13 @@ namespace lldb_private {
/// Block objects. The BlockList object contains a section offset
/// address range, and Block objects contain one or more ranges
/// which are offsets into that range. Blocks are can have discontiguous
/// ranges within the BlockList adress range, and each block can
/// ranges within the BlockList address range, and each block can
/// contain child blocks each with their own sets of ranges.
///
/// Each block has a variable list that represents local, argument, and
/// static variables that are scoped to the block.
///
/// Inlined functions are representated by attaching a
/// Inlined functions are represented by attaching a
/// InlineFunctionInfo shared pointer object to a block. Inlined
/// functions are represented as named blocks.
//----------------------------------------------------------------------
@ -169,7 +169,7 @@ public:
/// Dump the block contents.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
///
/// @param[in] base_addr
/// The resolved start address of the Function's address
@ -348,7 +348,7 @@ public:
/// Get const accessor for any inlined function information.
///
/// @return
/// A comst pointer to any inlined function information, or NULL
/// A const pointer to any inlined function information, or NULL
/// if this is a regular block.
//------------------------------------------------------------------
const InlineFunctionInfo*
@ -455,7 +455,7 @@ public:
GetRangeIndexContainingAddress (const Address& addr);
//------------------------------------------------------------------
// Since blocks might have multiple discontiguous addresss ranges,
// Since blocks might have multiple discontiguous address ranges,
// we need to be able to get at any of the address ranges in a block.
//------------------------------------------------------------------
bool
@ -477,7 +477,7 @@ protected:
collection m_children;
RangeList m_ranges;
lldb::InlineFunctionInfoSP m_inlineInfoSP; ///< Inlined function information.
lldb::VariableListSP m_variable_list_sp; ///< The variable list for all local, static and paramter variables scoped to this block.
lldb::VariableListSP m_variable_list_sp; ///< The variable list for all local, static and parameter variables scoped to this block.
bool m_parsed_block_info:1, ///< Set to true if this block and it's children have all been parsed
m_parsed_block_variables:1,
m_parsed_child_blocks:1;

2
lldb/include/lldb/Symbol/ClangASTImporter.h
View File

@ -166,7 +166,7 @@ public:
void BuildNamespaceMap (const clang::NamespaceDecl *decl);
//
// Comleters for maps
// Completers for maps
//
class MapCompleter

2
lldb/include/lldb/Symbol/ClangASTType.h
View File

@ -323,7 +323,7 @@ public:
ClangASTType
GetFullyUnqualifiedType () const;
// Returns -1 if this isn't a function of if the fucntion doesn't have a prototype
// Returns -1 if this isn't a function of if the function doesn't have a prototype
// Returns a value >= 0 if there is a prototype.
int
GetFunctionArgumentCount () const;

2
lldb/include/lldb/Symbol/ClangExternalASTSourceCommon.h
View File

@ -11,7 +11,7 @@
#define liblldb_ClangExternalASTSourceCommon_h
// Clang headers like to use NDEBUG inside of them to enable/disable debug
// releated features using "#ifndef NDEBUG" preprocessor blocks to do one thing
// related features using "#ifndef NDEBUG" preprocessor blocks to do one thing
// or another. This is bad because it means that if clang was built in release
// mode, it assumes that you are building in release mode which is not always
// the case. You can end up with functions that are defined as empty in header

8
lldb/include/lldb/Symbol/CompileUnit.h
View File

@ -115,7 +115,7 @@ public:
/// parse the debug information.
///
/// @param[in] function_sp
/// A shared pointer to the a Function object.
/// A shared pointer to the Function object.
//------------------------------------------------------------------
void
AddFunction(lldb::FunctionSP& function_sp);
@ -178,7 +178,7 @@ public:
/// Dump the compile unit contents to the stream \a s.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
///
/// @param[in] show_context
/// If \b true, variables will dump their symbol context
@ -199,7 +199,7 @@ public:
///
/// Multiple calls to this function can find all entries that match
/// a given file and line by starting with \a start_idx equal to zero,
/// and calling this function back with the return valeu + 1.
/// and calling this function back with the return value + 1.
///
/// @param[in] start_idx
/// The zero based index at which to start looking for matches.
@ -377,7 +377,7 @@ public:
/// using a LineEntry base address will be able to be resolved.
///
/// @param[out] sc_list
/// A SymbolContext list class that willl get any matching
/// A SymbolContext list class that will get any matching
/// entries appended to.
///
/// @return

4
lldb/include/lldb/Symbol/Declaration.h
View File

@ -136,7 +136,7 @@ public:
/// supplied stream \a s.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
//------------------------------------------------------------------
void
Dump (Stream *s, bool show_fullpaths) const;
@ -236,7 +236,7 @@ public:
/// Set accessor for the declaration file specification.
///
/// @param[in] file_spec
/// The new declaration file specifciation.
/// The new declaration file specification.
//------------------------------------------------------------------
void
SetFile (const FileSpec& file_spec)

2
lldb/include/lldb/Symbol/FuncUnwinders.h
View File

@ -21,7 +21,7 @@ public:
// This is often sourced from the eh_frame exception handling info
// 2. Unwinding from a non-call site (any location in the function)
// This is often done by analyzing the function prologue assembly
// langauge instructions
// language instructions
// 3. A fast unwind method for this function which only retrieves a
// limited set of registers necessary to walk the stack
// 4. An architectural default unwind plan when none of the above are

16
lldb/include/lldb/Symbol/Function.h
View File

@ -24,7 +24,7 @@ namespace lldb_private {
/// @class FunctionInfo Function.h "lldb/Symbol/Function.h"
/// @brief A class that contains generic function information.
///
/// This provides generic function information that gets resused between
/// This provides generic function information that gets reused between
/// inline functions and function types.
//----------------------------------------------------------------------
class FunctionInfo
@ -94,7 +94,7 @@ public:
/// supplied stream \a s.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
//------------------------------------------------------------------
void
Dump (Stream *s, bool show_fullpaths) const;
@ -234,7 +234,7 @@ public:
/// supplied stream \a s.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
//------------------------------------------------------------------
void
Dump(Stream *s, bool show_fullpaths) const;
@ -316,14 +316,14 @@ private:
/// (Function::m_type), and contains lexical blocks
/// (Function::m_blocks).
///
/// The function inforation is split into a few pieces:
/// The function information is split into a few pieces:
/// @li The concrete instance information
/// @li The abstract information
///
/// The abstract information is found in the function type (Type) that
/// describes a function information, return type and parameter types.
///
/// The concreate information is the address range information and
/// The concrete information is the address range information and
/// specific locations for an instance of this function.
//----------------------------------------------------------------------
class Function :
@ -547,7 +547,7 @@ public:
//------------------------------------------------------------------
/// Get accessor for the type that describes the function
/// return value type, and paramter types.
/// return value type, and parameter types.
///
/// @return
/// A type object pointer.
@ -557,7 +557,7 @@ public:
//------------------------------------------------------------------
/// Get const accessor for the type that describes the function
/// return value type, and paramter types.
/// return value type, and parameter types.
///
/// @return
/// A const type object pointer.
@ -578,7 +578,7 @@ public:
/// supplied stream \a s.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
///
/// @param[in] show_context
/// If \b true, variables will dump their symbol context

4
lldb/include/lldb/Symbol/LineEntry.h
View File

@ -59,7 +59,7 @@ struct LineEntry
/// supplied stream \a s.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
///
/// @param[in] comp_unit
/// The compile unit object that contains the support file
@ -98,7 +98,7 @@ struct LineEntry
/// line entry to the supplied stream \a s.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
///
/// @param[in] comp_unit
/// The compile unit object that contains the support file

4
lldb/include/lldb/Symbol/LineTable.h
View File

@ -85,7 +85,7 @@ public:
bool is_epilogue_begin,
bool is_terminal_entry);
// Used to instantiate the LineSequence helper classw
// Used to instantiate the LineSequence helper class
LineSequence*
CreateLineSequenceContainer ();
@ -111,7 +111,7 @@ public:
/// Dump all line entries in this line table to the stream \a s.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
///
/// @param[in] style
/// The display style for the address.

4
lldb/include/lldb/Symbol/ObjectContainer.h
View File

@ -85,7 +85,7 @@ public:
/// if it has been parsed.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
//------------------------------------------------------------------
virtual void
Dump (Stream *s) const = 0;
@ -168,7 +168,7 @@ public:
/// and the next plug-in can attempt to parse an object file.
///
/// @return
/// Returns \b true if the header was parsed succesfully, \b
/// Returns \b true if the header was parsed successfully, \b
/// false otherwise.
//------------------------------------------------------------------
virtual bool

4
lldb/include/lldb/Symbol/ObjectFile.h
View File

@ -149,7 +149,7 @@ public:
/// if it has been parsed.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
//------------------------------------------------------------------
virtual void
Dump (Stream *s) = 0;
@ -533,7 +533,7 @@ public:
/// and the next plug-in can attempt to parse an object file.
///
/// @return
/// Returns \b true if the header was parsed succesfully, \b
/// Returns \b true if the header was parsed successfully, \b
/// false otherwise.
//------------------------------------------------------------------
virtual bool

8
lldb/include/lldb/Symbol/SymbolContext.h
View File

@ -140,7 +140,7 @@ public:
/// supplied stream \a s.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
//------------------------------------------------------------------
void
Dump (Stream *s, Target *target) const;
@ -157,7 +157,7 @@ public:
/// was stopped will be displayed.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
///
/// @param[in] so_addr
/// The resolved section offset address.
@ -409,7 +409,7 @@ private:
/// the result of a query that can contain a multiple results. Examples
/// of such queries include:
/// @li Looking up a function by name.
/// @li Finding all addressses for a specified file and line number.
/// @li Finding all addresses for a specified file and line number.
//----------------------------------------------------------------------
class SymbolContextList
{
@ -465,7 +465,7 @@ public:
/// the list to the supplied stream \a s.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
//------------------------------------------------------------------
void
Dump(Stream *s, Target *target) const;

6
lldb/include/lldb/Symbol/SymbolContextScope.h
View File

@ -75,7 +75,7 @@ public:
~SymbolContextScope () {}
//------------------------------------------------------------------
/// Reconstruct the object's symbolc context into \a sc.
/// Reconstruct the object's symbol context into \a sc.
///
/// The object should fill in as much of the SymbolContext as it
/// can so function calls that require a symbol context can be made
@ -119,11 +119,11 @@ public:
}
//------------------------------------------------------------------
/// Dump the object's symbolc context to the stream \a s.
/// Dump the object's symbol context to the stream \a s.
///
/// The object should dump its symbol context to the stream \a s.
/// This function is widely used in the DumpDebug and verbose output
/// for lldb objets.
/// for lldb objects.
///
/// @param[in] s
/// The stream to which to dump the object's symbol context.

2
lldb/include/lldb/Symbol/SymbolFile.h
View File

@ -67,7 +67,7 @@ public:
/// Each symbol file gets to respond with a mask of abilities that
/// it supports for each object file. This happens when we are
/// trying to figure out which symbol file plug-in will get used
/// for a given object file. The plug-in that resoonds with the
/// for a given object file. The plug-in that responds with the
/// best mix of "SymbolFile::Abilities" bits set, will get chosen to
/// be the symbol file parser. This allows each plug-in to check for
/// sections that contain data a symbol file plug-in would need. For

4
lldb/include/lldb/Symbol/VariableList.h
View File

@ -60,10 +60,10 @@ public:
AppendVariablesIfUnique(VariableList &var_list);
// Returns the actual number of unique variables that were added to the
// list. "total_matches" will get updated with the actualy number of
// list. "total_matches" will get updated with the actually number of
// matches that were found regardless of whether they were unique or not
// to allow for error conditions when nothing is found, versus conditions
// where any varaibles that match "regex" were already in "var_list".
// where any variables that match "regex" were already in "var_list".
size_t
AppendVariablesIfUnique (const RegularExpression& regex,
VariableList &var_list,

2
lldb/include/lldb/Target/ABI.h
View File

@ -54,7 +54,7 @@ public:
protected:
// This is the method the ABI will call to actually calculate the return value.
// Don't put it in a persistant value object, that will be done by the ABI::GetReturnValueObject.
// Don't put it in a persistent value object, that will be done by the ABI::GetReturnValueObject.
virtual lldb::ValueObjectSP
GetReturnValueObjectImpl (Thread &thread,
ClangASTType &type) const = 0;

2
lldb/include/lldb/Target/CPPLanguageRuntime.h
View File

@ -136,7 +136,7 @@ public:
static bool
StripNamespacesFromVariableName (const char *name, const char *&base_name_start, const char *&base_name_end);
// in some cases, compilers will output different names for one same type. when tht happens, it might be impossible
// in some cases, compilers will output different names for one same type. when that happens, it might be impossible
// to construct SBType objects for a valid type, because the name that is available is not the same as the name that
// can be used as a search key in FindTypes(). the equivalents map here is meant to return possible alternative names
// for a type through which a search can be conducted. Currently, this is only enabled for C++ but can be extended

38
lldb/include/lldb/Target/ExecutionContext.h
View File

@ -18,10 +18,10 @@
/// variable value from a data section in one of the object files in
/// a target). There are two types of objects that hold onto execution
/// contexts: ExecutionContextRef and ExecutionContext. Both of these
/// objects are deascribed below.
/// objects are described below.
///
/// Not all objects in an ExectionContext objects will be valid. If you want
/// to refer stronly (ExectionContext) or weakly (ExectionContextRef) to
/// to refer strongly (ExectionContext) or weakly (ExectionContextRef) to
/// a process, then only the process and target references will be valid.
/// For threads, only the thread, process and target references will be
/// filled in. For frames, all of the objects will be filled in.
@ -49,7 +49,7 @@ namespace lldb_private {
/// context that might change over time. For example, if an object wants
/// to refer to a stack frame, it should hold onto an ExecutionContextRef
/// to a frame object. The backing object that represents the stack frame
/// might change over time and instaces of this object can track the logical
/// might change over time and instances of this object can track the logical
/// object that refers to a frame even if it does change.
///
/// These objects also don't keep execution objects around longer than they
@ -64,7 +64,7 @@ namespace lldb_private {
/// don't keep these objects around, they are safe to keep around.
///
/// The general rule of thumb is all long lived objects that want to
/// refer to execution contexts should use ExecutionContextRef objcts.
/// refer to execution contexts should use ExecutionContextRef objects.
/// The ExecutionContext class is used to temporarily get shared
/// pointers to any execution context objects that are still around
/// so they are guaranteed to exist during a function that requires the
@ -89,7 +89,7 @@ public:
/// Construct using an ExecutionContext object that might be NULL.
///
/// If \a exe_ctx_ptr is valid, then make weak references to any
/// valid objects in the ExecutionContext, othewise no weak
/// valid objects in the ExecutionContext, otherwise no weak
/// references to any execution context objects will be made.
//------------------------------------------------------------------
ExecutionContextRef (const ExecutionContext *exe_ctx_ptr);
@ -104,7 +104,7 @@ public:
//------------------------------------------------------------------
/// Assignment operator
///
/// Copy all weak refernces in \a rhs.
/// Copy all weak references in \a rhs.
//------------------------------------------------------------------
ExecutionContextRef &
operator =(const ExecutionContextRef &rhs);
@ -112,7 +112,7 @@ public:
//------------------------------------------------------------------
/// Assignment operator from a ExecutionContext
///
/// Make weak refernces to any stringly referenced objects in \a exe_ctx.
/// Make weak references to any strongly referenced objects in \a exe_ctx.
//------------------------------------------------------------------
ExecutionContextRef &
operator =(const ExecutionContext &exe_ctx);
@ -129,13 +129,13 @@ public:
/// Construct using an execution context scope.
///
/// If the ExecutionContextScope object is valid and refers to a frame,
/// make weak refernces too the frame, thread, process and target.
/// make weak references too the frame, thread, process and target.
/// If the ExecutionContextScope object is valid and refers to a thread,
/// make weak refernces too the thread, process and target.
/// make weak references too the thread, process and target.
/// If the ExecutionContextScope object is valid and refers to a process,
/// make weak refernces too the process and target.
/// make weak references too the process and target.
/// If the ExecutionContextScope object is valid and refers to a target,
/// make weak refernces too the target.
/// make weak references too the target.
//------------------------------------------------------------------
ExecutionContextRef (ExecutionContextScope *exe_scope);
@ -143,13 +143,13 @@ public:
/// Construct using an execution context scope.
///
/// If the ExecutionContextScope object refers to a frame,
/// make weak refernces too the frame, thread, process and target.
/// make weak references too the frame, thread, process and target.
/// If the ExecutionContextScope object refers to a thread,
/// make weak refernces too the thread, process and target.
/// make weak references too the thread, process and target.
/// If the ExecutionContextScope object refers to a process,
/// make weak refernces too the process and target.
/// make weak references too the process and target.
/// If the ExecutionContextScope object refers to a target,
/// make weak refernces too the target.
/// make weak references too the target.
//------------------------------------------------------------------
ExecutionContextRef (ExecutionContextScope &exe_scope);
@ -302,8 +302,8 @@ public:
//------------------------------------------------------------------
/// Returns true if this object has a weak reference to a thread.
/// The return value is only an indication of wether this object has
/// a weak reference and does not indicate wether the weak rerference
/// The return value is only an indication of whether this object has
/// a weak reference and does not indicate whether the weak reference
/// is valid or not.
//------------------------------------------------------------------
bool
@ -314,8 +314,8 @@ public:
//------------------------------------------------------------------
/// Returns true if this object has a weak reference to a frame.
/// The return value is only an indication of wether this object has
/// a weak reference and does not indicate wether the weak rerference
/// The return value is only an indication of whether this object has
/// a weak reference and does not indicate whether the weak reference
/// is valid or not.
//------------------------------------------------------------------
bool

2
lldb/include/lldb/Target/ExecutionContextScope.h
View File

@ -29,7 +29,7 @@ namespace lldb_private {
/// ExecutionContext object in the object state. Examples of these
/// objects include: Process, Thread, RegisterContext and StackFrame.
///
/// Bbjects can contain a valid pointer to an instance of this so they
/// Objects can contain a valid pointer to an instance of this so they
/// can reconstruct the execution context.
///
/// Objects that adhere to this protocol can reconstruct enough of a

2
lldb/include/lldb/Target/JITLoader.h
View File

@ -23,7 +23,7 @@ namespace lldb_private {
///
/// Plugins of this kind listen for code generated at runtime in the
/// target. They are very similar to dynamic loader, with the difference
/// that they do not have information about the the target's dyld and
/// that they do not have information about the target's dyld and
/// that there may be multiple JITLoader plugins per process, while
/// there is at most one DynamicLoader.
//----------------------------------------------------------------------

12
lldb/include/lldb/Target/Platform.h
View File

@ -179,13 +179,13 @@ namespace lldb_private {
/// m_arch - The architecture we are looking for when resolving
/// the symbol file.
/// m_uuid - The UUID of the executable and symbol file. This
/// can often be used to match up an exectuable with
/// can often be used to match up an executable with
/// a symbol file, or resolve an symbol file in a
/// symbol file bundle.
///
/// @param[out] sym_file
/// The resolved symbol file spec if the returned error
/// indicates succes.
/// indicates success.
///
/// @return
/// Returns an error that describes success or failure.
@ -220,7 +220,7 @@ namespace lldb_private {
bool
GetOSKernelDescription (std::string &s);
// Returns the the name of the platform
// Returns the name of the platform
ConstString
GetName ();
@ -354,7 +354,7 @@ namespace lldb_private {
/// A zero based architecture index
///
/// @param[out] arch
/// A copy of the archgitecture at index if the return value is
/// A copy of the architecture at index if the return value is
/// \b true.
///
/// @return
@ -418,7 +418,7 @@ namespace lldb_private {
/// attempt to attach to the process with the process ID of \a pid.
/// The platform subclass should return an appropriate ProcessSP
/// subclass that is attached to the process, or an empty shared
/// pointer with an appriopriate error.
/// pointer with an appropriate error.
///
/// @param[in] pid
/// The process ID that we should attempt to attach to.
@ -427,7 +427,7 @@ namespace lldb_private {
/// An appropriate ProcessSP containing a valid shared pointer
/// to the default Process subclass for the platform that is
/// attached to the process, or an empty shared pointer with an
/// appriopriate error fill into the \a error object.
/// appropriate error fill into the \a error object.
//------------------------------------------------------------------
virtual lldb::ProcessSP
Attach (ProcessAttachInfo &attach_info,

10
lldb/include/lldb/Target/Process.h
View File

@ -1220,7 +1220,7 @@ public:
//------------------------------------------------------------------
/// Register for process and thread notifications.
///
/// Clients can register nofication callbacks by filling out a
/// Clients can register notification callbacks by filling out a
/// Process::Notifications structure and calling this function.
///
/// @param[in] callbacks
@ -1236,7 +1236,7 @@ public:
//------------------------------------------------------------------
/// Unregister for process and thread notifications.
///
/// Clients can unregister nofication callbacks by passing a copy of
/// Clients can unregister notification callbacks by passing a copy of
/// the original baton and callbacks in \a callbacks.
///
/// @param[in] callbacks
@ -1744,7 +1744,7 @@ public:
DoSignal (int signal)
{
Error error;
error.SetErrorStringWithFormat("error: %s does not support senging signals to processes", GetPluginName().GetCString());
error.SetErrorStringWithFormat("error: %s does not support sending signals to processes", GetPluginName().GetCString());
return error;
}
@ -2197,7 +2197,7 @@ public:
///
/// The value contained in \a scalar will be swapped to match the
/// byte order of the process that is being debugged. If \a size is
/// less than the size of scalar, the least significate \a size bytes
/// less than the size of scalar, the least significant \a size bytes
/// from scalar will be written. If \a size is larger than the byte
/// size of scalar, then the extra space will be padded with zeros
/// and the scalar value will be placed in the least significant
@ -3050,7 +3050,7 @@ protected:
Broadcaster m_private_state_control_broadcaster; // This is the control broadcaster, used to pause, resume & stop the private state thread.
Listener m_private_state_listener; // This is the listener for the private state thread.
Predicate<bool> m_private_state_control_wait; /// This Predicate is used to signal that a control operation is complete.
lldb::thread_t m_private_state_thread; // Thread ID for the thread that watches interal state events
lldb::thread_t m_private_state_thread; // Thread ID for the thread that watches internal state events
ProcessModID m_mod_id; ///< Tracks the state of the process over stops and other alterations.
uint32_t m_process_unique_id; ///< Each lldb_private::Process class that is created gets a unique integer ID that increments with each new instance
uint32_t m_thread_index_id; ///< Each thread is created with a 1 based index that won't get re-used.

4
lldb/include/lldb/Target/QueueList.h
View File

@ -98,7 +98,7 @@ public:
///
/// @return
/// A QueueSP to the queue requested, if it is present in the QueueList.
/// An empty QueueSP willbe returned if this queue was not found.
/// An empty QueueSP will be returned if this queue was not found.
//------------------------------------------------------------------
lldb::QueueSP
FindQueueByID (lldb::queue_id_t qid);
@ -114,7 +114,7 @@ public:
///
/// @return
/// A QueueSP to the queue requested, if it is present in the QueueList.
/// An empty QueueSP willbe returned if this queue was not found.
/// An empty QueueSP will be returned if this queue was not found.
//------------------------------------------------------------------
lldb::QueueSP
FindQueueByIndexID (uint32_t index_id);

6
lldb/include/lldb/Target/StackFrame.h
View File

@ -177,7 +177,7 @@ public:
///
/// The StackFrame maintains this SymbolContext and adds additional information
/// to it on an as-needed basis. This helps to avoid different functions
/// looking up symbolic information for a given pc value multple times.
/// looking up symbolic information for a given pc value multiple times.
///
/// @params [in] resolve_scope
/// Flags from the SymbolContextItem enumerated type which specify what
@ -261,7 +261,7 @@ public:
///
/// @param[in] get_file_globals
/// Whether to also retrieve compilation-unit scoped variables
/// that are visisble to the entire compilation unit (e.g. file
/// that are visible to the entire compilation unit (e.g. file
/// static in C, globals that are homed in this CU).
///
/// @return
@ -279,7 +279,7 @@ public:
///
/// @param[in] get_file_globals
/// Whether to also retrieve compilation-unit scoped variables
/// that are visisble to the entire compilation unit (e.g. file
/// that are visible to the entire compilation unit (e.g. file
/// static in C, globals that are homed in this CU).
///
/// @return

2
lldb/include/lldb/Target/Target.h
View File

@ -570,7 +570,7 @@ public:
/// in a target.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
/// The stream to which to dump the object description.
//------------------------------------------------------------------
void
Dump (Stream *s, lldb::DescriptionLevel description_level);

2
lldb/include/lldb/Target/TargetList.h
View File

@ -121,7 +121,7 @@ public:
//------------------------------------------------------------------
/// Delete a Target object from the list.
///
/// When clients are done with the Target objets, this function
/// When clients are done with the Target objects, this function
/// should be called to release the memory associated with a target
/// object.
///

2
lldb/include/lldb/Target/Thread.h
View File

@ -1296,7 +1296,7 @@ protected:
int m_resume_signal; ///< The signal that should be used when continuing this thread.
lldb::StateType m_resume_state; ///< This state is used to force a thread to be suspended from outside the ThreadPlan logic.
lldb::StateType m_temporary_resume_state; ///< This state records what the thread was told to do by the thread plan logic for the current resume.
/// It gets set in Thread::ShoudResume.
/// It gets set in Thread::ShouldResume.
std::unique_ptr<lldb_private::Unwind> m_unwinder_ap;
bool m_destroy_called; // This is used internally to make sure derived Thread classes call DestroyThread.
LazyBool m_override_should_notify;

2
lldb/include/lldb/Target/ThreadPlanShouldStopHere.h
View File

@ -21,7 +21,7 @@ namespace lldb_private {
// This is an interface that ThreadPlans can adopt to allow flexible modifications of the behavior
// when a thread plan comes to a place where it would ordinarily stop. If such modification makes
// sense for your plan, inherit from this class, and when you would be about to stop (in your ShouldStop
// method), call InvokeShouldStopHereCallback, passing in the frame comparision between where the step operation
// method), call InvokeShouldStopHereCallback, passing in the frame comparison between where the step operation
// started and where you arrived. If it returns true, then QueueStepOutFromHere will queue the plan
// to execute instead of stopping.
//

2
lldb/include/lldb/Utility/CleanUp.h
View File

@ -27,7 +27,7 @@ namespace lldb_utility {
// file descriptors, opaque handles, pointers, etc). If more complex
// type T objects are desired, we need to probably specialize this class
// to take "const T&" for all input T parameters. Yet if a type T is
// complex already it might be better to build the cleanup funcionality
// complex already it might be better to build the cleanup functionality
// into T.
//
// The cleanup function must take one argument that is of type T.

4
lldb/include/lldb/Utility/PseudoTerminal.h
View File

@ -23,7 +23,7 @@ namespace lldb_utility {
/// @class PseudoTerminal PseudoTerminal.h "lldb/Core/PseudoTerminal.h"
/// @brief A pseudo terminal helper class.
///
/// The pseudo terminal class abtracts the use of pseudo terminals on
/// The pseudo terminal class abstracts the use of pseudo terminals on
/// the host system.
//----------------------------------------------------------------------
class PseudoTerminal
@ -46,7 +46,7 @@ public:
/// Destructor
///
/// The destructor will close the master and slave file descriptors
/// if they are valid and ownwership has not been released using
/// if they are valid and ownership has not been released using
/// one of:
/// @li PseudoTerminal::ReleaseMasterFileDescriptor()
/// @li PseudoTerminal::ReleaseSaveFileDescriptor()

6
lldb/include/lldb/Utility/SharingPtr.h
View File

@ -15,7 +15,7 @@
// Microsoft Visual C++ currently does not enable std::atomic to work
// in CLR mode - as such we need to "hack around it" for MSVC++ builds only
// using Windows specific instrinsics instead of the C++11 atomic support
// using Windows specific intrinsics instead of the C++11 atomic support
#ifdef _MSC_VER
#include <intrin.h>
#else
@ -69,8 +69,8 @@ public:
private:
virtual void on_zero_shared();
// Outlaw copy constructor and assignment operator to keep effictive C++
// warnings down to a minumum
// Outlaw copy constructor and assignment operator to keep effective C++
// warnings down to a minimum
shared_ptr_pointer (const shared_ptr_pointer &);
shared_ptr_pointer & operator=(const shared_ptr_pointer &);
};

6
lldb/scripts/Python/interface/SBFileSpec.i
View File

@ -10,7 +10,7 @@
namespace lldb {
%feature("docstring",
"Represents a file specfication that divides the path into a directory and
"Represents a file specification that divides the path into a directory and
basename. The string values of the paths are put into uniqued string pools
for fast comparisons and efficient memory usage.
@ -28,7 +28,7 @@ For example, the following code
gets the line entry from the symbol context when a thread is stopped.
It gets the file spec corresponding to the line entry and checks that
the filename and the directory matches wat we expect.
the filename and the directory matches what we expect.
") SBFileSpec;
class SBFileSpec
{
@ -37,7 +37,7 @@ public:
SBFileSpec (const lldb::SBFileSpec &rhs);
SBFileSpec (const char *path);// Deprected, use SBFileSpec (const char *path, bool resolve)
SBFileSpec (const char *path);// Deprecated, use SBFileSpec (const char *path, bool resolve)
SBFileSpec (const char *path, bool resolve);

2
lldb/scripts/Python/interface/SBFrame.i
View File

@ -105,7 +105,7 @@ public:
/// Get the appropriate function name for this frame. Inlined functions in
/// LLDB are represented by Blocks that have inlined function information, so
/// just looking at the SBFunction or SBSymbol for a frame isn't enough.
/// This function will return the appriopriate function, symbol or inlined
/// This function will return the appropriate function, symbol or inlined
/// function name for the frame.
///
/// This function returns:

2
lldb/scripts/Python/interface/SBThread.i
View File

@ -230,7 +230,7 @@ public:
/// SBProcess::Continue() is called, any threads that aren't suspended will
/// be allowed to run. If any of the SBThread functions for stepping are
/// called (StepOver, StepInto, StepOut, StepInstruction, RunToAddres), the
/// thread will now be allowed to run and these funtions will simply return.
/// thread will now be allowed to run and these functions will simply return.
///
/// Eventually we plan to add support for thread centric debugging where
/// each thread is controlled individually and each thread would broadcast

6
lldb/scripts/Python/interface/SBValue.i
View File

@ -179,7 +179,7 @@ public:
//------------------------------------------------------------------
/// Get a child value by index from a value.
///
/// Structs, unions, classes, arrays and and pointers have child
/// Structs, unions, classes, arrays and pointers have child
/// values that can be access by index.
///
/// Structs and unions access child members using a zero based index
@ -214,7 +214,7 @@ public:
/// The index of the child value to get
///
/// @param[in] use_dynamic
/// An enumeration that specifies wether to get dynamic values,
/// An enumeration that specifies whether to get dynamic values,
/// and also if the target can be run to figure out the dynamic
/// type of the child value.
///
@ -286,7 +286,7 @@ public:
/// The name of the child value to get
///
/// @param[in] use_dynamic
/// An enumeration that specifies wether to get dynamic values,
/// An enumeration that specifies whether to get dynamic values,
/// and also if the target can be run to figure out the dynamic
/// type of the child value.
///

2
lldb/scripts/checkpoint-llvm.pl
View File

@ -2,7 +2,7 @@
# This script should be pointed to a valid llvm.build folder that
# was created using the "build-llvm.pl" shell script. It will create
# a new llvm.zip file that can be checked into the respository
# a new llvm.zip file that can be checked into the repository
# at lldb/llvm.zip
use strict;

12
lldb/scripts/disasm-gdb-remote.pl
View File

@ -1135,14 +1135,14 @@ sub dump_continue_with_signal_cmd
#----------------------------------------------------------------------
sub dump_A_command
{
my $cmd = get_exptected_char(\@_, 'A') or print "error: incorrect command letter for argument packet, exptected 'A'\n";
my $cmd = get_expected_char(\@_, 'A') or print "error: incorrect command letter for argument packet, expected 'A'\n";
printf("set_program_arguments (\n");
do
{
my $arg_len = get_uint(\@_);
get_exptected_char(\@_, ',') or die "error: missing comma after argument length...?\n";
get_expected_char(\@_, ',') or die "error: missing comma after argument length...?\n";
my $arg_idx = get_uint(\@_);
get_exptected_char(\@_, ',') or die "error: missing comma after argument number...?\n";
get_expected_char(\@_, ',') or die "error: missing comma after argument number...?\n";
my $arg = '';
my $num_hex8_bytes = $arg_len/2;
@ -1153,7 +1153,7 @@ sub dump_A_command
printf(" <%3u> argv[%u] = '%s'\n", $arg_len, $arg_idx, $arg);
if (@_ > 0)
{
get_exptected_char(\@_, ',') or die "error: missing comma after argument argument ASCII hex bytes...?\n";
get_expected_char(\@_, ',') or die "error: missing comma after argument argument ASCII hex bytes...?\n";
}
} while (@_ > 0);
printf(" )\n");
@ -1666,7 +1666,7 @@ sub get256
}
#----------------------------------------------------------------------
# Get a an unsigned integer value by grabbing items off the front of
# Get an unsigned integer value by grabbing items off the front of
# the array stopping when a non-digit char string is encountered.
#
# The argument for this function needs to be a reference to an array
@ -1695,7 +1695,7 @@ sub get_uint
# character doesn't match, it won't touch the array. If the first
# character does match, it will shift it off and return it.
#----------------------------------------------------------------------
sub get_exptected_char
sub get_expected_char
{
my $arrayref = shift;
my $expected_char = shift;

6
lldb/scripts/sed-sources
View File

@ -63,13 +63,13 @@ unexpanding.
=head1 EXAMPLES
# Recursively process all source files in the current working directory
# and and subdirectories and also expand tabs to spaces. All source files
# and subdirectories and also expand tabs to spaces. All source files
# will be overwritten with the newly transformed source files.
% sed-sources -e $cwd
# Recursively process all source files in the current working directory
# and and subdirectories and also unexpand spaces to tabs and preview the
# and subdirectories and also unexpand spaces to tabs and preview the
# results to STDOUT
% sed-sources -p -u $cwd
@ -248,4 +248,4 @@ sub main
# call the main function
main();
main();

2
lldb/source/API/SBFileSpec.cpp
View File

@ -36,7 +36,7 @@ SBFileSpec::SBFileSpec (const lldb_private::FileSpec& fspec) :
{
}
// Deprected!!!
// Deprecated!!!
SBFileSpec::SBFileSpec (const char *path) :
m_opaque_ap(new FileSpec (path, true))
{

4
lldb/source/Breakpoint/BreakpointResolverName.cpp
View File

@ -234,7 +234,7 @@ BreakpointResolverName::SearchCallback
if (context.module_sp)
{
context.module_sp->FindFunctions (m_regex,
!filter_by_cu, // include symbols only if we aren't filterning by CU
!filter_by_cu, // include symbols only if we aren't filtering by CU
include_inlines,
append,
func_list);
@ -264,7 +264,7 @@ BreakpointResolverName::SearchCallback
}
}
// Remove any duplicates between the funcion list and the symbol list
// Remove any duplicates between the function list and the symbol list
SymbolContext sc;
if (func_list.GetSize())
{

2
lldb/source/Commands/CommandObjectCommands.cpp
View File

@ -889,7 +889,7 @@ public:
SetHelpLong(
"This command allows the user to create powerful regular expression commands\n"
"with substitutions. The regular expressions and substitutions are specified\n"
"using the regular exression substitution format of:\n"
"using the regular expression substitution format of:\n"
"\n"
" s/<regex>/<subst>/\n"
"\n"

2
lldb/source/Commands/CommandObjectExpression.cpp
View File

@ -206,7 +206,7 @@ CommandObjectExpression::CommandObjectExpression (CommandInterpreter &interprete
{
SetHelpLong(
"Timeouts:\n\
If the expression can be evaluated statically (without runnning code) then it will be.\n\
If the expression can be evaluated statically (without running code) then it will be.\n\
Otherwise, by default the expression will run on the current thread with a short timeout:\n\
currently .25 seconds. If it doesn't return in that time, the evaluation will be interrupted\n\
and resumed with all threads running. You can use the -a option to disable retrying on all\n\

2
lldb/source/Commands/CommandObjectSettings.cpp
View File

@ -1155,7 +1155,7 @@ protected:
if (argc != 1)
{
result.AppendError ("'setttings clear' takes exactly one argument");
result.AppendError ("'settings clear' takes exactly one argument");
result.SetStatus (eReturnStatusFailed);
return false;
}

2
lldb/source/Core/AddressResolverName.cpp
View File

@ -148,7 +148,7 @@ AddressResolverName::SearchCallback
break;
}
// Remove any duplicates between the funcion list and the symbol list
// Remove any duplicates between the function list and the symbol list
if (func_list.GetSize())
{
for (i = 0; i < func_list.GetSize(); i++)

12
lldb/source/Core/Module.cpp
View File

@ -199,7 +199,7 @@ Module::Module (const ModuleSpec &module_spec) :
else if (module_spec.GetArchitecture().IsValid())
m_arch = module_spec.GetArchitecture();
// Copy the file spec over and use the specfied one (if there was one) so we
// Copy the file spec over and use the specified one (if there was one) so we
// don't use a path that might have gotten resolved a path in 'matching_module_spec'
if (module_spec.GetFileSpec())
m_file = module_spec.GetFileSpec();
@ -1003,7 +1003,7 @@ Module::FindTypes (const SymbolContext& sc,
// Check if "name" starts with "::" which means the qualified type starts
// from the root namespace and implies and exact match. The typenames we
// get back from clang do not start with "::" so we need to strip this off
// in order to get the qualfied names to match
// in order to get the qualified names to match
if (type_scope.size() >= 2 && type_scope[0] == ':' && type_scope[1] == ':')
{
@ -1516,7 +1516,7 @@ Module::LoadScriptingResourceInTarget (Target *target, Error& error, Stream* fee
return false;
}
LoadScriptFromSymFile shoud_load = target->TargetProperties::GetLoadScriptFromSymbolFile();
LoadScriptFromSymFile should_load = target->TargetProperties::GetLoadScriptFromSymbolFile();
Debugger &debugger = target->GetDebugger();
const ScriptLanguage script_language = debugger.GetScriptLanguage();
@ -1546,9 +1546,9 @@ Module::LoadScriptingResourceInTarget (Target *target, Error& error, Stream* fee
FileSpec scripting_fspec (file_specs.GetFileSpecAtIndex(i));
if (scripting_fspec && scripting_fspec.Exists())
{
if (shoud_load == eLoadScriptFromSymFileFalse)
if (should_load == eLoadScriptFromSymFileFalse)
return false;
if (shoud_load == eLoadScriptFromSymFileWarn)
if (should_load == eLoadScriptFromSymFileWarn)
{
if (feedback_stream)
feedback_stream->Printf("warning: '%s' contains a debug script. To run this script in "
@ -1738,7 +1738,7 @@ Module::PrepareForFunctionNameLookup (const ConstString &name,
if (!cpp_method.GetQualifiers().empty())
{
// There is a "const" or other qualifer following the end of the fucntion parens,
// There is a "const" or other qualifier following the end of the function parens,
// this can't be a eFunctionNameTypeBase
lookup_name_type_mask &= ~(eFunctionNameTypeBase);
if (lookup_name_type_mask == eFunctionNameTypeNone)

8
lldb/source/Core/RegularExpression.cpp
View File

@ -71,7 +71,7 @@ RegularExpression::operator= (const RegularExpression &rhs)
//----------------------------------------------------------------------
// Destructor
//
// Any previosuly compiled regular expression contained in this
// Any previously compiled regular expression contained in this
// object will be freed.
//----------------------------------------------------------------------
RegularExpression::~RegularExpression()
@ -81,14 +81,14 @@ RegularExpression::~RegularExpression()
//----------------------------------------------------------------------
// Compile a regular expression using the supplied regular
// expression text and flags. The compied regular expression lives
// expression text and flags. The compiled regular expression lives
// in this object so that it can be readily used for regular
// expression matches. Execute() can be called after the regular
// expression is compiled. Any previosuly compiled regular
// expression is compiled. Any previously compiled regular
// expression contained in this object will be freed.
//
// RETURNS
// True of the refular expression compiles successfully, false
// True if the regular expression compiles successfully, false
// otherwise.
//----------------------------------------------------------------------
bool

2
lldb/source/Core/Scalar.cpp
View File

@ -62,7 +62,7 @@ PromoteToMaxType
promoted_lhs_ptr = &temp_value; // Update the pointer for the promoted left hand side
}
// Make sure our type promotion worked as exptected
// Make sure our type promotion worked as expected
if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType())
return promoted_lhs_ptr->GetType(); // Return the resulting max type

2
lldb/source/Core/Stream.cpp
View File

@ -252,7 +252,7 @@ Stream::EOL()
//------------------------------------------------------------------
// Indent the current line using the current indentation level and
// print an optional string following the idenatation spaces.
// print an optional string following the indentation spaces.
//------------------------------------------------------------------
size_t
Stream::Indent(const char *s)

2
lldb/source/Core/ValueObjectConstResultImpl.cpp
View File

@ -31,7 +31,7 @@ using namespace lldb;
using namespace lldb_private;
// this macro enables a simpler implementation for some method calls in this object that relies only upon
// ValueObject knowning how to set the address type of its children correctly. the alternative implementation
// ValueObject knowing how to set the address type of its children correctly. the alternative implementation
// relies on being able to create a target copy of the frozen object, which makes it less bug-prone but less
// efficient as well. once we are confident the faster implementation is bug-free, this macro (and the slower
// implementations) can go

4
lldb/source/Host/common/FileSpec.cpp
View File

@ -268,7 +268,7 @@ FileSpec::FileSpec(const FileSpec* rhs) :
}
//------------------------------------------------------------------
// Virtual destrcuctor in case anyone inherits from this class.
// Virtual destructor in case anyone inherits from this class.
//------------------------------------------------------------------
FileSpec::~FileSpec()
{
@ -753,7 +753,7 @@ FileSpec::GetFileNameStrippingExtension () const
// Returns a shared pointer to a data buffer that contains all or
// part of the contents of a file. The data is memory mapped and
// will lazily page in data from the file as memory is accessed.
// The data that is mappped will start "file_offset" bytes into the
// The data that is mapped will start "file_offset" bytes into the
// file, and "file_size" bytes will be mapped. If "file_size" is
// greater than the number of bytes available in the file starting
// at "file_offset", the number of bytes will be appropriately

2
lldb/source/Host/common/Host.cpp
View File

@ -1631,7 +1631,7 @@ Host::RunShellCommand (const char *command,
{
error.SetErrorString("timed out waiting for shell command to complete");
// Kill the process since it didn't complete withint the timeout specified
// Kill the process since it didn't complete within the timeout specified
Kill (pid, SIGKILL);
// Wait for the monitor callback to get the message
timeout_time = TimeValue::Now();

4
lldb/source/Host/linux/Host.cpp
View File

@ -352,7 +352,7 @@ GetProcessAndStatInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info, Proce
next_var += strlen(next_var) + 1;
}
// Get the commond line used to start the process.
// Get the command line used to start the process.
buf_sp = ProcFileReader::ReadIntoDataBuffer(pid, "cmdline");
// Grab Arg0 first, if there is one.
@ -532,7 +532,7 @@ Host::GetDistributionId ()
s_distribution_id.SetCString (id_string.c_str ());
if (log)
log->Printf ("distribion id set to \"%s\"",
log->Printf ("distribution id set to \"%s\"",
s_distribution_id.GetCString ());
}
else

10
lldb/source/Host/macosx/Host.mm
View File

@ -565,8 +565,8 @@ LaunchInNewTerminalWithAppleScript (const char *exe_path, ProcessLaunchInfo &lau
if (launch_info.GetFlags().Test (eLaunchFlagDisableASLR))
command.PutCString(" --disable-aslr");
// We are launching on this host in a terminal. So compare the environemnt on the host
// to what is supplied in the launch_info. Any items that aren't in the host environemnt
// We are launching on this host in a terminal. So compare the environment on the host
// to what is supplied in the launch_info. Any items that aren't in the host environment
// need to be sent to darwin-debug. If we send all environment entries, we might blow the
// max command line length, so we only send user modified entries.
const char **envp = launch_info.GetEnvironmentEntries().GetConstArgumentVector ();
@ -660,7 +660,7 @@ LaunchInNewTerminalWithAppleScript (const char *exe_path, ProcessLaunchInfo &lau
{
pid = (intptr_t)accept_thread_result;
// Wait for process to be stopped the the entry point by watching
// Wait for process to be stopped at 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);
@ -1496,7 +1496,7 @@ LaunchProcessXPC (const char *exe_path, ProcessLaunchInfo &launch_info, ::pid_t
return;
} else if (event == XPC_ERROR_CONNECTION_INVALID) {
// The service is invalid. Either the service name supplied to xpc_connection_create() is incorrect
// or we (this process) have canceled the service; we can do any cleanup of appliation state at this point.
// or we (this process) have canceled the service; we can do any cleanup of application state at this point.
// printf("Service disconnected");
return;
} else {
@ -1642,7 +1642,7 @@ Host::LaunchProcess (ProcessLaunchInfo &launch_info)
#if !defined(__arm__) && !defined(__arm64__)
return LaunchInNewTerminalWithAppleScript (exe_path, launch_info);
#else
error.SetErrorString ("launching a processs in a new terminal is not supported on iOS devices");
error.SetErrorString ("launching a process in a new terminal is not supported on iOS devices");
return error;
#endif
}

4
lldb/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp
View File

@ -810,14 +810,14 @@ LoadValueFromConsecutiveGPRRegisters (ExecutionContext &exe_ctx,
const RegisterInfo *reg_info = NULL;
if (is_return_value)
{
// We are assumging we are decoding this immediately after returning
// We are assuming we are decoding this immediately after returning
// from a function call and that the address of the structure is in x8
reg_info = reg_ctx->GetRegisterInfoByName("x8", 0);
}
else
{
// We are assuming we are stopped at the first instruction in a function
// and that the ABI is being respected so all paramters appear where they
// and that the ABI is being respected so all parameters appear where they
// should be (functions with no external linkage can legally violate the ABI).
if (NGRN >= 8)
return false;

6
lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp
View File

@ -263,7 +263,7 @@ DynamicLoaderMacOSXDYLD::DidSetNotificationBreakpoint() const
//----------------------------------------------------------------------
// Try and figure out where dyld is by first asking the Process
// if it knows (which currently calls down in the the lldb::Process
// if it knows (which currently calls down in the lldb::Process
// to get the DYLD info (available on SnowLeopard only). If that fails,
// then check in the default addresses.
//----------------------------------------------------------------------
@ -944,7 +944,7 @@ DynamicLoaderMacOSXDYLD::RemoveModulesUsingImageInfosAddress (lldb::addr_t image
image_infos[idx].PutToLog (log);
}
// Remove this image_infos from the m_all_image_infos. We do the comparision by address
// Remove this image_infos from the m_all_image_infos. We do the comparison by address
// rather than by file spec because we can have many modules with the same "file spec" in the
// case that they are modules loaded from memory.
//
@ -1360,7 +1360,7 @@ DynamicLoaderMacOSXDYLD::UpdateImageInfosHeaderAndLoadCommands(DYLDImageInfo::co
// On Mac OS X libobjc (the Objective-C runtime) has several critical dispatch
// functions written in hand-written assembly, and also have hand-written unwind
// information in the eh_frame section. Normally we prefer analyzing the
// assembly instructions of a curently executing frame to unwind from that frame --
// assembly instructions of a currently executing frame to unwind from that frame --
// but on hand-written functions this profiling can fail. We should use the
// eh_frame instructions for these functions all the time.
//

Some files were not shown because too many files have changed in this diff Show More