Fix typos.

[brucem]

Summary

Fix a bunch of typos.

[clayborg]

Looks good.

examples/darwin/heap_find/heap/heap_find.cpp

 static void
 range_info_callback (task_t task, 
                      void *baton, 
                      unsigned type, 
                      uint64_t ptr_addr, 
                      uint64_t ptr_size);
 
 //----------------------------------------------------------------------
-// Redefine private gloval variables prototypes from 
+// Redefine private global variables prototypes from
 // "/usr/local/include/stack_logging.h"
 //----------------------------------------------------------------------
 
 extern "C" int stack_logging_enable_logging;
 
 //----------------------------------------------------------------------
 // Local defines
 //----------------------------------------------------------------------
struct Entry
         uint32_t idx;   // Index into the m_objc_class_ptrs[] array
         uint32_t count; // Number of object instances that were found
         uint64_t bytes; // Total number of bytes for each objc class
     };
     
     static int
     compare_bytes (const Entry *a, const Entry *b)
     {
-        // Reverse the comparisong to most bytes entries end up at top of list
+        // Reverse the comparison to most bytes entries end up at top of list
         if (a->bytes > b->bytes) return -1;
         if (a->bytes < b->bytes) return +1;
         return 0;
     }
 
     static int
     compare_count (const Entry *a, const Entry *b)
     {
-        // Reverse the comparisong to most count entries end up at top of list
+        // Reverse the comparison to most count entries end up at top of list
         if (a->count > b->count) return -1;
         if (a->count < b->count) return +1;
         return 0;
     }
 
     Entry *m_entries;
     uint32_t m_size;    
     HeapInfoSortType m_sort_type;
#endif
         }
     }
 }
 
 //----------------------------------------------------------------------
 // dump_malloc_block_callback
 //
 // A simple callback that will dump each malloc block and all available
-// info from the enumeration callback perpective.
+// info from the enumeration callback perspective.
 //----------------------------------------------------------------------
 static void
 dump_malloc_block_callback (task_t task, void *baton, unsigned type, uint64_t ptr_addr, uint64_t ptr_size)
 {
     printf ("task = 0x%4.4x: baton = %p, type = %u, ptr_addr = 0x%llx + 0x%llu\n", task, baton, type, ptr_addr, ptr_size);
 }
 
 static void 

include/lldb/Core/Connection.h

public:
     /// Connect using the connect string \a url.
     ///
     /// @param[in] url
     ///     A string that contains all information needed by the
     ///     subclass to connect to another client.
     ///
     /// @param[out] error_ptr
     ///     A pointer to an error object that should be given an
-    ///     approriate error value if this method returns false. This
+    ///     appropriate error value if this method returns false. This
     ///     value can be NULL if the error value should be ignored.
     ///
     /// @return
     ///     \b True if the connect succeeded, \b false otherwise. The
     ///     internal error object should be filled in with an
     ///     appropriate value based on the result of this function.
     ///
     /// @see Error& Communication::GetError ();
     //------------------------------------------------------------------
     virtual lldb::ConnectionStatus
     Connect (const char *url, Error *error_ptr) = 0;
 
     //------------------------------------------------------------------
     /// Disconnect the communications connection if one is currently
     /// connected.
     ///
     /// @param[out] error_ptr
     ///     A pointer to an error object that should be given an
-    ///     approriate error value if this method returns false. This
+    ///     appropriate error value if this method returns false. This
     ///     value can be NULL if the error value should be ignored.
     ///
     /// @return
     ///     \b True if the disconnect succeeded, \b false otherwise. The
     ///     internal error object should be filled in with an
     ///     appropriate value based on the result of this function.
     ///
     /// @see Error& Communication::GetError ();
public:
     /// @param[in] dst_len
     ///     The number of bytes to attempt to read, and also the max
     ///     number of bytes that can be placed into \a dst.
     ///
     /// @param[in] timeout_usec
     ///     The number of microseconds to wait for the data.
     ///
     /// @param[out] status
-    ///     On return, indicates whether the call was sucessful or terminated
+    ///     On return, indicates whether the call was successful or terminated
     ///     due to some error condition.
     ///
     /// @param[out] error_ptr
     ///     A pointer to an error object that should be given an
-    ///     approriate error value if this method returns zero. This
+    ///     appropriate error value if this method returns zero. This
     ///     value can be NULL if the error value should be ignored.
     ///
     /// @return
     ///     The number of bytes actually read.
     ///
     /// @see size_t Communication::Read (void *, size_t, uint32_t);
     //------------------------------------------------------------------
     virtual size_t
public:
     ///     long.
     ///
     /// @param[in] dst_len
     ///     The number of bytes to attempt to write, and also the
     ///     number of bytes are currently available in \a dst.
     ///
     /// @param[out] error_ptr
     ///     A pointer to an error object that should be given an
-    ///     approriate error value if this method returns zero. This
+    ///     appropriate error value if this method returns zero. This
     ///     value can be NULL if the error value should be ignored.
     ///
     /// @return
     ///     The number of bytes actually Written.
     //------------------------------------------------------------------
     virtual size_t
     Write (const void *dst, size_t dst_len, lldb::ConnectionStatus &status, Error *error_ptr) = 0;
 
public:
     /// If there is an ongoing read operation in another thread, this operation
     /// return with status == eConnectionStatusInterrupted. Note that if there
     /// data waiting to be read and an interrupt request is issued, the Read()
     /// function will return the data immediately without processing the
     /// interrupt request (which will remain queued for the next Read()
     /// operation).
     ///
     /// @return
-    ///     Returns true is the interrupt request was sucessful.
+    ///     Returns true is the interrupt request was successful.
     //------------------------------------------------------------------
     virtual bool
     InterruptRead() = 0;
 
     //------------------------------------------------------------------
     /// Returns the underlying IOObject used by the Connection.
     ///
     /// The IOObject can be used to wait for data to become available

include/lldb/Core/Log.h

 {
 public:
   LogChannel();
 
   virtual ~LogChannel();
 
   static lldb::LogChannelSP FindPlugin(const char *plugin_name);
 
-    // categories is a an array of chars that ends with a NULL element.
+    // categories is an array of chars that ends with a NULL element.
   virtual void Disable(const char **categories, Stream *feedback_strm) = 0;
 
   virtual bool Enable(
       lldb::StreamSP &log_stream_sp, uint32_t log_options,
       Stream *feedback_strm,        // Feedback stream for argument errors etc
       const char **categories) = 0; // The categories to enable within this logging stream, if empty, enable default set
 
   virtual void ListCategories(Stream *strm) = 0;

include/lldb/Core/Timer.h

public:
     Initialize ();
 
     //--------------------------------------------------------------
     /// Default constructor.
     //--------------------------------------------------------------
     Timer(const char *category, const char *format, ...)  __attribute__ ((format (printf, 3, 4)));
 
     //--------------------------------------------------------------
-    /// Desstructor
+    /// Destructor
     //--------------------------------------------------------------
     ~Timer();
 
     void
     Dump ();
 
     static void
     SetDisplayDepth (uint32_t depth);

include/lldb/Host/Mutex.h

public:
         ///
         /// @param[in] m
         ///     A pointer to instance of a Mutex object that
         ///     contains a valid mutex object.
         //--------------------------------------------------------------
         Locker(Mutex* m);
 
         //--------------------------------------------------------------
-        /// Desstructor
+        /// Destructor
         ///
         /// Unlocks any valid pthread_mutex_t that this object may
         /// contain.
         //--------------------------------------------------------------
         ~Locker();
 
         //--------------------------------------------------------------
         /// Change the contained mutex.
public:
         /// Unlock the current mutex in this object (if it contains a
         /// valid mutex) and try to lock \a mutex. If \a mutex can be 
         /// locked this object will take ownership of the lock and will
         /// unlock it when it goes out of scope or Reset or TryLock are
         /// called again. If the mutex is already locked, this object
         /// will not take ownership of the mutex.
         ///
         /// @return
-        ///     Returns \b true if the lock was aquired and the this 
+        ///     Returns \b true if the lock was acquired and the this
         ///     object will unlock the mutex when it goes out of scope,
         ///     returns \b false otherwise.
         //--------------------------------------------------------------
         bool
         TryLock (Mutex &mutex, const char *failure_message = NULL);
         
         bool
         TryLock (Mutex *mutex, const char *failure_message = NULL)

source/Core/FastDemangle.cpp

#endif
 
     /// @brief Parses the provided mangled name and returns a newly allocated
     /// demangling
     ///
     /// @param mangled_name Valid null-terminated C++ mangled name following
     /// the Itanium C++ ABI mangling specification as implemented by Clang
     ///
     /// @result Newly allocated null-terminated demangled name when demangling
-    /// is succesful, and nullptr when demangling fails.  The caller is
+    /// is successful, and nullptr when demangling fails.  The caller is
     /// responsible for freeing the allocated memory.
 
     char *
     GetDemangledCopy(const char *mangled_name,
                      long mangled_name_length = 0)
     {
         if (!ParseMangling(mangled_name, mangled_name_length))
             return nullptr;

source/Core/ModuleList.cpp

 const ModuleList&
 ModuleList::operator= (const ModuleList& rhs)
 {
     if (this != &rhs)
     {
         // That's probably me nit-picking, but in theoretical situation:
         //
         // * that two threads A B and
-        // * two ModuleList's x y do opposite assignemnts ie.:
+        // * two ModuleList's x y do opposite assignments ie.:
         //
         //  in thread A: | in thread B:
         //    x = y;     |   y = x;
         //
         // This establishes correct(same) lock taking order and thus
         // avoids priority inversion.
         if (uintptr_t(this) > uintptr_t(&rhs))
         {
ModuleList::FindTypes (const SymbolContext& sc, const ConstString &name, bool name_is_fully_qualified, size_t max_matches, TypeList& types) const
     
     if (total_matches < max_matches)
     {
         SymbolContext world_sc;
         for (pos = m_modules.begin(); pos != end; ++pos)
         {
             // Search the module if the module is not equal to the one in the symbol
             // context "sc". If "sc" contains a empty module shared pointer, then
-            // the comparisong will always be true (valid_module_ptr != NULL).
+            // the comparison will always be true (valid_module_ptr != NULL).
             if (sc.module_sp.get() != (*pos).get())
                 total_matches += (*pos)->FindTypes (world_sc, name, name_is_fully_qualified, max_matches, types);
             
             if (total_matches >= max_matches)
                 break;
         }
     }
     

source/Core/RegisterValue.cpp

RegisterValue::GetAsMemoryData (const RegisterInfo *reg_info,
                                 Error &error) const
 {    
     if (reg_info == NULL)
     {
         error.SetErrorString ("invalid register info argument.");
         return 0;
     }
     
-    // ReadRegister should have already been called on tgus object prior to 
+    // ReadRegister should have already been called on this object prior to
     // calling this.
     if (GetType() == eTypeInvalid)
     {
         // No value has been read into this object...
         error.SetErrorStringWithFormat("invalid register value type for register %s", reg_info->name);
         return 0;
     }
     
if (value_type == eTypeInvalid)
         // No value has been read into this object...
         error.SetErrorStringWithFormat("invalid register value type for register %s", reg_info->name);
         return 0;
     }
     else if (value_type == eTypeBytes)
     {
         m_data.buffer.byte_order = src_byte_order;
         // Make sure to set the buffer length of the destination buffer to avoid
-        // problems due to uninitalized variables.
+        // problems due to uninitialized variables.
         m_data.buffer.length = src_len;
     }
 
     const uint32_t bytes_copied = src_data.CopyByteOrderedData (0,               // src offset
                                                                 src_len,         // src length
                                                                 GetBytes(),      // dst buffer
                                                                 GetByteSize(),   // dst length
                                                                 GetByteOrder()); // dst byte order

source/Host/common/XML.cpp

if (IsValid())
             if (name)
             {
                 if (strcmp((const char *)node->name, name) != 0)
                     continue; // Name mismatch, ignore this one
             }
             else
             {
                 if (node->name)
-                    continue; // nullptr name specified and this elemnt has a name, ignore this one
+                    continue; // nullptr name specified and this element has a name, ignore this one
             }
             
             if (callback(XMLNode(node)) == false)
                 return;
         }
     }
 #endif
 }

source/Host/windows/ConnectionGenericFileWindows.cpp

 #include "llvm/ADT/StringRef.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace
 {
 // This is a simple helper class to package up the information needed to return from a Read/Write
-// operation function.  Since there is alot of code to be run before exit regardless of whether the
+// operation function.  Since there is a lot of code to be run before exit regardless of whether the
 // operation succeeded or failed, combined with many possible return paths, this is the cleanest
 // way to represent it.
 class ReturnInfo
 {
   public:
     void
     Set(size_t bytes, ConnectionStatus status, DWORD error_code)
     {
ConnectionGenericFile::Read(void *dst, size_t dst_len, uint32_t timeout_usec, lldb::ConnectionStatus &status, Error *error_ptr)
     }
     else if (::GetLastError() == ERROR_BROKEN_PIPE)
     {
         // The write end of a pipe was closed.  This is equivalent to EOF.
         return_info.Set(0, eConnectionStatusEndOfFile, 0);
     }
     else
     {
-        // An unknown error occured.  Fail out.
+        // An unknown error occurred.  Fail out.
         return_info.Set(0, eConnectionStatusError, ::GetLastError());
     }
     goto finish;
 
 finish:
     status = return_info.GetStatus();
     if (error_ptr)
         *error_ptr = return_info.GetError();

source/Host/windows/EditLineWin.cpp

struct el_binding
     el_addfn_func func;
     // ascii key this function is bound to
     const char   *key;
 };
 
 // stored key bindings
 static std::vector<el_binding*> _bindings;
 
-//TODO: this should infact be related to the exact edit line context we create
+//TODO: this should in fact be related to the exact edit line context we create
 static void *clientData = NULL;
 
 // store the current prompt string
 // default to what we expect to receive anyway
 static const char *_prompt = "(lldb) ";
 
 #if !defined( _WIP_INPUT_METHOD )
 
el_get_s (char *buffer, int chars)
     for ( ;; Sleep( 10 ) )
     {
         //
         INPUT_RECORD _record;
         //
         DWORD _read = 0;
         if ( ReadConsoleInputA( GetStdHandle( STD_INPUT_HANDLE ), &_record, 1, &_read ) == FALSE )
             break;
-        // if we didnt read a key
+        // if we didn't read a key
         if ( _read == 0 )
             continue;
         // only interested in key events
         if ( _record.EventType != KEY_EVENT )
             continue;
         // is the key down
         if (! _record.Event.KeyEvent.bKeyDown )
             continue;
el_get_s (char *buffer, int chars)
     }
     // insert end of line character
     *head = '\0';
 
     return buffer;
 }
 #endif
 
-// edit line initalise
+// edit line initialize
 EditLine *
 el_init (const char *, FILE *, FILE *, FILE *)
 {
     //
     SetConsoleTitleA( "lldb" );
     // return dummy handle
     return (EditLine*) -1;
 }
case ( EL_EDITOR ):
         {
             // EL_EDITOR, const char *mode
             //      set editing mode to "emacs" or "vi"
         }
         break;
     case ( EL_HIST ):
         {
             // EL_HIST, History *(*fun)(History *, int op, ... ), const char *ptr
-            //      defines which histroy function to use, which is usualy history(). Ptr should be the
+            //      defines which history function to use, which is usually history(). Ptr should be the
             //      value returned by history_init().
         }
         break;
     case ( EL_ADDFN ):
         {
             // EL_ADDFN, const char *name, const char *help, unsigned char (*func)(EditLine *e, int ch)
             //      add a user defined function, func), referred to as 'name' which is invoked when a key which is bound to 'name' is
-            //      entered. 'help' is a description of 'name'. at involcation time, 'ch' is the key which caused the invocation. the
+            //      entered. 'help' is a description of 'name'. at invocation time, 'ch' is the key which caused the invocation. the
             //      return value of 'func()' should be one of:
             //          CC_NORM         add a normal character
             //          CC_NEWLINE      end of line was entered
             //          CC_EOF          EOF was entered
             //          CC_ARGHACK      expecting further command input as arguments, do nothing visually.
             //          CC_REFRESH      refresh display.
             //          CC_REFRESH_BEEP refresh display and beep.
             //          CC_CURSOR       cursor moved so update and perform CC_REFRESH
-            //          CC_REDISPLAY        redisplay entire input line. this is usefull if a key binding outputs extra information.
-            //          CC_ERROR            an error occured. beep and flush tty.
+            //          CC_REDISPLAY        redisplay entire input line. this is useful if a key binding outputs extra information.
+            //          CC_ERROR            an error occurred. beep and flush tty.
             //          CC_FATAL            fatal error, reset tty to known state.
 
             el_binding *binding = new el_binding;
             binding->name = va_arg( vl, const char *);
             binding->help = va_arg( vl, const char *);
             binding->func = va_arg( vl, el_addfn_func );
             binding->key  = 0;
             // add this to the bindings list
             _bindings.push_back( binding );
         }
         break;
     case ( EL_BIND ):
         {
             // EL_BIND, const char *, ..., NULL
-            //      perform the BIND buildin command.  Refer to editrc(5) for more information.
+            //      perform the BIND built-in command.  Refer to editrc(5) for more information.
 
             const char *name = va_arg( vl, const char* );
 
             for ( int i=0; i<_bindings.size(); i++ )
             {
                 el_binding *bind = _bindings[i];
                 if ( strcmp( bind->name, name ) == 0 )
                 {

source/Interpreter/Args.cpp

if (s && s[0])
                             error_ptr->SetErrorStringWithFormat("address expression \"%s\" resulted in a value whose type can't be converted to an address: %s", s, valobj_sp->GetTypeName().GetCString());
                         }
                     }
                     
                 }
                 else
                 {
                     // Since the compiler can't handle things like "main + 12" we should
-                    // try to do this for now. The compliler doesn't like adding offsets
+                    // try to do this for now. The compiler doesn't like adding offsets
                     // to function pointer types.
                     static RegularExpression g_symbol_plus_offset_regex("^(.*)([-\\+])[[:space:]]*(0x[0-9A-Fa-f]+|[0-9]+)[[:space:]]*$");
                     RegularExpression::Match regex_match(3);
                     if (g_symbol_plus_offset_regex.Execute(s, &regex_match))
                     {
                         uint64_t offset = 0;
                         bool add = true;
                         std::string name;

source/Interpreter/CommandObject.cpp

(
     int &cursor_index,
     int &cursor_char_position,
     int match_start_point,
     int max_return_elements,
     bool &word_complete,
     StringList &matches
 )
 {
-    // Default implmentation of WantsCompletion() is !WantsRawCommandString().
+    // Default implementation of WantsCompletion() is !WantsRawCommandString().
     // Subclasses who want raw command string but desire, for example,
     // argument completion should override WantsCompletion() to return true,
     // instead.
     if (WantsRawCommandString() && !WantsCompletion())
     {
         // FIXME: Abstract telling the completion to insert the completion character.
         matches.Clear();
         return -1;

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

if (!m_sections_ap.get() && ParseSectionHeaders())
                     assert (sect_type == eSectionTypeOther);
                     sect_type = eSectionTypeELFDynamicLinkInfo;
                     break;
             }
 
             if (eSectionTypeOther == sect_type)
             {
                 // the kalimba toolchain assumes that ELF section names are free-form. It does
-                // supports linkscripts which (can) give rise to various arbitarily named
+                // support linkscripts which (can) give rise to various arbitrarily named
                 // sections being "Code" or "Data". 
                 sect_type = kalimbaSectionType(m_header, header);
             }
 
             const uint32_t target_bytes_size =
                 (eSectionTypeData == sect_type || eSectionTypeZeroFill == sect_type) ? 
                 m_arch_spec.GetDataByteSize() :
                     eSectionTypeCode == sect_type ?
for (i = 0; i < num_symbols; ++i)
 
         // Symbol names may contain @VERSION suffixes. Find those and strip them temporarily.
         size_t version_pos = symbol_ref.find('@');
         bool has_suffix = version_pos != llvm::StringRef::npos;
         llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos);
         Mangled mangled(ConstString(symbol_bare), is_mangled);
 
         // Now append the suffix back to mangled and unmangled names. Only do it if the
-        // demangling was sucessful (string is not empty).
+        // demangling was successful (string is not empty).
         if (has_suffix)
         {
             llvm::StringRef suffix = symbol_ref.substr(version_pos);
 
             llvm::StringRef mangled_name = mangled.GetMangledName().GetStringRef();
             if (! mangled_name.empty())
                 mangled.SetMangledName( ConstString((mangled_name + suffix).str()) );
 
ObjectFileELF::PLTRelocationType()
 
     if (symbol)
         return symbol->d_val;
 
     return 0;
 }
 
 // Returns the size of the normal plt entries and the offset of the first normal plt entry. The
-// 0th entry in the plt table is ususally a resolution entry which have different size in some
+// 0th entry in the plt table is usually a resolution entry which have different size in some
 // architectures then the rest of the plt entries.
 static std::pair<uint64_t, uint64_t>
 GetPltEntrySizeAndOffset(const ELFSectionHeader* rel_hdr, const ELFSectionHeader* plt_hdr)
 {
     const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;
 
     // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are 16 bytes.
     // So round the entsize up by the alignment if addralign is set.
     elf_xword plt_entsize = plt_hdr->sh_addralign ?
         llvm::RoundUpToAlignment (plt_hdr->sh_entsize, plt_hdr->sh_addralign) : plt_hdr->sh_entsize;
 
     if (plt_entsize == 0)
     {
         // The linker haven't set the plt_hdr->sh_entsize field. Try to guess the size of the plt
         // entries based on the number of entries and the size of the plt section with the
-        // asumption that the size of the 0th entry is at least as big as the size of the normal
-        // entries and it isn't mutch bigger then that.
+        // assumption that the size of the 0th entry is at least as big as the size of the normal
+        // entries and it isn't much bigger then that.
         if (plt_hdr->sh_addralign)
             plt_entsize = plt_hdr->sh_size / plt_hdr->sh_addralign / (num_relocations + 1) * plt_hdr->sh_addralign;
         else
             plt_entsize = plt_hdr->sh_size / (num_relocations + 1);
     }
 
     elf_xword plt_offset = plt_hdr->sh_size - num_relocations * plt_entsize;
 

source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

PlatformDarwin::GetSoftwareBreakpointTrapOpcode (Target &target, BreakpointSite *bp_site)
     }
     return 0;
 
 }
 
 bool
 PlatformDarwin::GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info)
 {
-    bool sucess = false;
+    bool success = false;
     if (IsHost())
     {
-        sucess = Platform::GetProcessInfo (pid, process_info);
+        success = Platform::GetProcessInfo (pid, process_info);
     }
     else
     {
         if (m_remote_platform_sp)
-            sucess = m_remote_platform_sp->GetProcessInfo (pid, process_info);
+            success = m_remote_platform_sp->GetProcessInfo (pid, process_info);
     }
-    return sucess;
+    return success;
 }
 
 uint32_t
 PlatformDarwin::FindProcesses (const ProcessInstanceInfoMatch &match_info,
                                ProcessInstanceInfoList &process_infos)
 {
     uint32_t match_count = 0;
     if (IsHost())

source/Plugins/Process/elf-core/ProcessElfCore.h

 //===-- ProcessElfCore.h ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 // Notes about Linux Process core dumps:
 //  1) Linux core dump is stored as ELF file.
 //  2) The ELF file's PT_NOTE and PT_LOAD segments describes the program's
 //     address space and thread contexts.
 //  3) PT_NOTE segment contains note entries which describes a thread context.
-//  4) PT_LOAD segment describes a valid contigous range of process address
+//  4) PT_LOAD segment describes a valid contiguous range of process address
 //     space.
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ProcessElfCore_h_
 #define liblldb_ProcessElfCore_h_
 
 // C++ Includes
 #include <list>

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

(
     bool send_async
 )
 {
     PacketResult packet_result = PacketResult::ErrorSendFailed;
     Mutex::Locker locker;
     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
 
     // In order to stop async notifications from being processed in the middle of the
-    // send/recieve sequence Hijack the broadcast. Then rebroadcast any events when we are done.
+    // send/receive sequence Hijack the broadcast. Then rebroadcast any events when we are done.
     static Listener hijack_listener("lldb.NotifyHijacker");
     HijackBroadcaster(&hijack_listener, eBroadcastBitGdbReadThreadGotNotify);    
 
     if (GetSequenceMutex (locker))
     {
         packet_result = SendPacketAndWaitForResponseNoLock (payload, payload_length, response);
     }
     else
else
         }
         else
         {
             if (log) 
                 log->Printf("error: failed to get packet sequence mutex, not sending packet '%*s'", (int) payload_length, payload);
         }
     }
 
-    // Remove our Hijacking listner from the broadcast.
+    // Remove our Hijacking listener from the broadcast.
     RestoreBroadcaster();
 
-    // If a notification event occured, rebroadcast since it can now be processed safely.  
+    // If a notification event occurred, rebroadcast since it can now be processed safely.
     EventSP event_sp;
     if (hijack_listener.GetNextEvent(event_sp))
         BroadcastEvent(event_sp);
 
     return packet_result;
 }
 
 static const char *end_delimiter = "--end--;";

source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

protected:
     uint64_t m_max_memory_size;       // The maximum number of bytes to read/write when reading and writing memory
     uint64_t m_remote_stub_max_memory_size;    // The maximum memory size the remote gdb stub can handle
     MMapMap m_addr_to_mmap_size;
     lldb::BreakpointSP m_thread_create_bp_sp;
     bool m_waiting_for_attach;
     bool m_destroy_tried_resuming;
     lldb::CommandObjectSP m_command_sp;
     int64_t m_breakpoint_pc_offset;
-    lldb::tid_t m_initial_tid; // The inital thread ID, given by stub on attach
+    lldb::tid_t m_initial_tid; // The initial thread ID, given by stub on attach
 
     bool
     HandleNotifyPacket(StringExtractorGDBRemote &packet);
 
     bool
     StartAsyncThread ();
 
     void

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

#if defined (ENABLE_DEBUG_PRINTF)
                   GetObjectFile()->GetFileSpec().GetPath().c_str());
         s.Printf("\nFunction basenames:\n");    m_function_basename_index.Dump (&s);
         s.Printf("\nFunction fullnames:\n");    m_function_fullname_index.Dump (&s);
         s.Printf("\nFunction methods:\n");      m_function_method_index.Dump (&s);
         s.Printf("\nFunction selectors:\n");    m_function_selector_index.Dump (&s);
         s.Printf("\nObjective C class selectors:\n");    m_objc_class_selectors_index.Dump (&s);
         s.Printf("\nGlobals and statics:\n");   m_global_index.Dump (&s); 
         s.Printf("\nTypes:\n");                 m_type_index.Dump (&s);
-        s.Printf("\nNamepaces:\n");             m_namespace_index.Dump (&s);
+        s.Printf("\nNamespaces:\n")             m_namespace_index.Dump (&s);
 #endif
     }
 }
 
 bool
 SymbolFileDWARF::NamespaceDeclMatchesThisSymbolFile (const ClangNamespaceDecl *namespace_decl)
 {
     if (namespace_decl == NULL)
s.Printf ("DWARF index for (%s) '%s':",
               GetObjectFile()->GetFileSpec().GetPath().c_str());
     s.Printf("\nFunction basenames:\n");    m_function_basename_index.Dump (&s);
     s.Printf("\nFunction fullnames:\n");    m_function_fullname_index.Dump (&s);
     s.Printf("\nFunction methods:\n");      m_function_method_index.Dump (&s);
     s.Printf("\nFunction selectors:\n");    m_function_selector_index.Dump (&s);
     s.Printf("\nObjective C class selectors:\n");    m_objc_class_selectors_index.Dump (&s);
     s.Printf("\nGlobals and statics:\n");   m_global_index.Dump (&s); 
     s.Printf("\nTypes:\n");                 m_type_index.Dump (&s);
-    s.Printf("\nNamepaces:\n");             m_namespace_index.Dump (&s);
+    s.Printf("\nNamespaces:\n");            m_namespace_index.Dump (&s);
 }
 
 void
 SymbolFileDWARF::SearchDeclContext (const clang::DeclContext *decl_context, 
                                     const char *name, 
                                     llvm::SmallVectorImpl <clang::NamedDecl *> *results)
 {    
     DeclContextToDIEMap::iterator iter = m_decl_ctx_to_die.find(decl_context);

source/Symbol/ClangASTContext.cpp

if (ast)
                 
             case DW_ATE_float:
                 if (streq(type_name, "float") && QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
                     return ClangASTType (ast, ast->FloatTy.getAsOpaquePtr());
                 if (streq(type_name, "double") && QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
                     return ClangASTType (ast, ast->DoubleTy.getAsOpaquePtr());
                 if (streq(type_name, "long double") && QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy))
                     return ClangASTType (ast, ast->LongDoubleTy.getAsOpaquePtr());
-                // Fall back to not requring a name match
+                // Fall back to not requiring a name match
                 if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
                     return ClangASTType (ast, ast->FloatTy.getAsOpaquePtr());
                 if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
                     return ClangASTType (ast, ast->DoubleTy.getAsOpaquePtr());
                 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy))
                     return ClangASTType (ast, ast->LongDoubleTy.getAsOpaquePtr());
                 break;
                 

source/Symbol/CompactUnwindInfo.cpp

if (m_unwindinfo_data.GetByteSize() > 0)
         if (m_unwind_header.common_encodings_array_offset > m_unwindinfo_data.GetByteSize()
             || m_unwind_header.personality_array_offset > m_unwindinfo_data.GetByteSize()
             || indexSectionOffset > m_unwindinfo_data.GetByteSize()
             || offset > m_unwindinfo_data.GetByteSize())
         {
             Host::SystemLog (Host::eSystemLogError,
                     "error: Invalid offset encountered in compact unwind info, skipping\n");
             // don't trust anything from this compact_unwind section if it looks
-            // blatently invalid data in the header.
+            // blatantly invalid data in the header.
             m_indexes_computed = eLazyBoolNo;
             return;
         }
 
         // Parse the basic information from the indexes
         // We wait to scan the second level page info until it's needed
 
             // struct unwind_info_section_header_index_entry 

source/Symbol/DWARFCallFrameInfo.cpp

while (m_cfi_data.ValidOffsetForDataOfSize (offset, 8))
         }
 
         if (next_entry > m_cfi_data.GetByteSize() + 1)
         {
             Host::SystemLog (Host::eSystemLogError,
                     "error: Invalid fde/cie next entry offset of 0x%x found in cie/fde at 0x%x\n",
                     next_entry,
                     current_entry);
-            // Don't trust anything in this eh_frame section if we find blatently 
+            // Don't trust anything in this eh_frame section if we find blatantly
             // invalid data.
             m_fde_index.Clear();
             m_fde_index_initialized = true;
             return;
         }
         if (cie_offset > m_cfi_data.GetByteSize())
         {
             Host::SystemLog (Host::eSystemLogError,
                     "error: Invalid cie offset of 0x%x found in cie/fde at 0x%x\n",
                     cie_offset,
                     current_entry);
-            // Don't trust anything in this eh_frame section if we find blatently 
+            // Don't trust anything in this eh_frame section if we find blatantly
             // invalid data.
             m_fde_index.Clear();
             m_fde_index_initialized = true;
             return;
         }
 
         if (cie_id == 0 || cie_id == UINT32_MAX || len == 0)
         {

source/Symbol/LineTable.cpp

if (so_addr.GetModule().get() == m_comp_unit->GetModule().get())
             if (pos != end_pos)
             {
                 if (pos != begin_pos)
                 {
                     if (pos->file_addr != search_entry.file_addr)
                         --pos;
                     else if (pos->file_addr == search_entry.file_addr)
                     {
-                        // If this is a termination entry, it should't match since
+                        // If this is a termination entry, it shouldn't match since
                         // entries with the "is_terminal_entry" member set to true 
                         // are termination entries that define the range for the 
                         // previous entry.
                         if (pos->is_terminal_entry)
                         {
                             // The matching entry is a terminal entry, so we skip
                             // ahead to the next entry to see if there is another
                             // entry following this one whose section/offset matches.
for (size_t idx = 0; idx < count; ++idx)
         lldb::addr_t prev_end_entry_linked_file_addr = LLDB_INVALID_ADDRESS;
         lldb::addr_t entry_linked_file_addr = LLDB_INVALID_ADDRESS;
 
         bool terminate_previous_entry = false;
         if (file_range_entry)
         {
             entry_linked_file_addr = entry.file_addr - file_range_entry->GetRangeBase() + file_range_entry->data;
             // Determine if we need to terminate the previous entry when the previous
-            // entry was not contguous with this one after being linked.
+            // entry was not contiguous with this one after being linked.
             if (range_changed && prev_file_range_entry)
             {
                 prev_end_entry_linked_file_addr = std::min<lldb::addr_t>(entry.file_addr, prev_file_range_entry->GetRangeEnd()) - prev_file_range_entry->GetRangeBase() + prev_file_range_entry->data;
                 if (prev_end_entry_linked_file_addr != entry_linked_file_addr)
                     terminate_previous_entry = prev_entry_was_linked;                
             }
         }
         else if (prev_entry_was_linked)

source/Symbol/SymbolVendor.cpp

 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 SymbolVendor::~SymbolVendor()
 {
 }
 
 //----------------------------------------------------------------------
-// Add a represention given an object file.
+// Add a representation given an object file.
 //----------------------------------------------------------------------
 void
 SymbolVendor::AddSymbolFileRepresentation(const ObjectFileSP &objfile_sp)
 {
     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
         lldb_private::Mutex::Locker locker(module_sp->GetMutex());

source/Symbol/TypeList.cpp

for (pos = m_types.begin(); pos != end; ++pos)
                     {
                         if (match_type_scope_size > type_scope_size)
                         {
                             const size_t type_scope_pos = match_type_scope.rfind(type_scope);
                             if (type_scope_pos == match_type_scope_size - type_scope_size)
                             {
                                 if (type_scope_pos >= 2)
                                 {
-                                    // Our match scope ends with the type scope we were lookikng for,
+                                    // Our match scope ends with the type scope we were looking for,
                                     // but we need to make sure what comes before the matching
-                                    // type scope is a namepace boundary in case we are trying to match:
+                                    // type scope is a namespace boundary in case we are trying to match:
                                     // type_basename = "d"
                                     // type_scope = "b::c::"
                                     // We want to match:
                                     //  match_type_scope "a::b::c::"
                                     // But not:
                                     //  match_type_scope "a::bb::c::"
                                     // So below we make sure what comes before "b::c::" in match_type_scope
                                     // is "::", or the namespace boundary

source/Target/ThreadList.cpp

 }
 
 const ThreadList&
 ThreadList::operator = (const ThreadList& rhs)
 {
     if (this != &rhs)
     {
         // Lock both mutexes to make sure neither side changes anyone on us
-        // while the assignement occurs
+        // while the assignment occurs
         Mutex::Locker locker(GetMutex());
         m_process = rhs.m_process;
         m_stop_id = rhs.m_stop_id;
         m_threads = rhs.m_threads;
         m_selected_tid = rhs.m_selected_tid;
     }
     return *this;
 }

 }
 
 void
 ThreadList::Update (ThreadList &rhs)
 {
     if (this != &rhs)
     {
         // Lock both mutexes to make sure neither side changes anyone on us
-        // while the assignement occurs
+        // while the assignment occurs
         Mutex::Locker locker(GetMutex());
         m_process = rhs.m_process;
         m_stop_id = rhs.m_stop_id;
         m_threads.swap(rhs.m_threads);
         m_selected_tid = rhs.m_selected_tid;
         
         
         // Now we look for threads that we are done with and

source/Utility/JSON.cpp

switch (ch)
                                 ++m_index; // Skip this character
                             }
                             break;
 
                         case 'e':
                         case 'E':
                             if (exp_index != 0)
                             {
-                                error.Printf("error: extra expenent character found at offset %" PRIu64, start_index);
+                                error.Printf("error: extra exponent character found at offset %" PRIu64, start_index);
                                 value = std::move(error.GetString());
                                 return Token::Error;
                             }
                             else
                             {
                                 exp_index = m_index;
                                 ++m_index; // Skip this character
                             }

source/Utility/SharingPtr.cpp

 //===---------------------SharingPtr.cpp ------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/SharingPtr.h"
 
 #if defined (ENABLE_SP_LOGGING)
 
-// If ENABLE_SP_LOGGING is defined, then log all shared pointer assignements
+// If ENABLE_SP_LOGGING is defined, then log all shared pointer assignments
 // and allow them to be queried using a pointer by a call to:
 #include <execinfo.h>
 #include <map>
 #include <assert.h>
 #include "lldb/Host/Mutex.h"
 
 #include "llvm/ADT/STLExtras.h"
 

test/functionalities/thread/break_after_join/TestBreakAfterJoin.py

def breakpoint_after_join_test(self):
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
             substrs = ['stopped',
                        'stop reason = breakpoint'])
 
         # Get the target process
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
 
-        # The exit probably occured during breakpoint handling, but it isn't
+        # The exit probably occurred during breakpoint handling, but it isn't
         # guaranteed.  The main thing we're testing here is that the debugger
         # handles this cleanly is some way.
 
         # Get the number of threads
         num_threads = process.GetNumThreads()
 
         # Make sure we see at least six threads
         self.assertTrue(num_threads >= 6, 'Number of expected threads and actual threads do not match.')

test/functionalities/thread/exit_during_break/TestExitDuringBreak.py

def exit_during_breakpoint_test(self):
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
             substrs = ['stopped',
                        'stop reason = breakpoint'])
 
         # Get the target process
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
 
-        # The exit probably occured during breakpoint handling, but it isn't
+        # The exit probably occurred during breakpoint handling, but it isn't
         # guaranteed.  The main thing we're testing here is that the debugger
         # handles this cleanly is some way.
 
         # Get the number of threads
         num_threads = process.GetNumThreads()
 
         # Make sure we see at least five threads
         self.assertTrue(num_threads >= 5, 'Number of expected threads and actual threads do not match.')

test/python_api/event/TestEvents.py

def do_add_listener_to_broadcaster(self):
                                  error)     # error
 
         # Create an empty event object.
         event = lldb.SBEvent()
         self.assertFalse(event, "Event should not be valid initially")
 
 
         # The finite state machine for our custom listening thread, with an
-        # initail state of None, which means no event has been received.
+        # initial state of None, which means no event has been received.
         # It changes to 'connected' after 'connected' event is received (for remote platforms)
         # It changes to 'running' after 'running' event is received (should happen only if the
         # currentstate is either 'None' or 'connected')
         # It changes to 'stopped' if a 'stopped' event is received (should happen only if the
         # current state is 'running'.)
         self.state = None
 
         # Create MyListeningThread to wait for state changed events.

www/cpp_reference/html/SBListener_8h_source.html

 <div class="line"><a name="l00050"></a><span class="lineno">   50</span>&#160;    uint32_t</div>
 <div class="line"><a name="l00051"></a><span class="lineno">   51</span>&#160;    <a class="code" href="classlldb_1_1SBListener.html#af4da1d5bcae1d385e42c365f9b3b58a4">StartListeningForEvents</a> (<span class="keyword">const</span> <a class="code" href="classlldb_1_1SBBroadcaster.html">lldb::SBBroadcaster</a>&amp; broadcaster,</div>
 <div class="line"><a name="l00052"></a><span class="lineno">   52</span>&#160;                             uint32_t event_mask);</div>
 <div class="line"><a name="l00053"></a><span class="lineno">   53</span>&#160;</div>
 <div class="line"><a name="l00054"></a><span class="lineno">   54</span>&#160;    <span class="keywordtype">bool</span></div>
 <div class="line"><a name="l00055"></a><span class="lineno">   55</span>&#160;    <a class="code" href="classlldb_1_1SBListener.html#a40982b9b252a6c3a7e3a5315dbad42b4">StopListeningForEvents</a> (<span class="keyword">const</span> <a class="code" href="classlldb_1_1SBBroadcaster.html">lldb::SBBroadcaster</a>&amp; broadcaster,</div>
 <div class="line"><a name="l00056"></a><span class="lineno">   56</span>&#160;                            uint32_t event_mask);</div>
 <div class="line"><a name="l00057"></a><span class="lineno">   57</span>&#160;</div>
-<div class="line"><a name="l00058"></a><span class="lineno">   58</span>&#160;    <span class="comment">// Returns true if an event was recieved, false if we timed out.</span></div>
+<div class="line"><a name="l00058"></a><span class="lineno">   58</span>&#160;    <span class="comment">// Returns true if an event was received, false if we timed out.</span></div>
 <div class="line"><a name="l00059"></a><span class="lineno">   59</span>&#160;    <span class="keywordtype">bool</span></div>
 <div class="line"><a name="l00060"></a><span class="lineno">   60</span>&#160;    <a class="code" href="classlldb_1_1SBListener.html#a75d84b3582f798cfa1343bae4233f9d5">WaitForEvent</a> (uint32_t num_seconds,</div>
 <div class="line"><a name="l00061"></a><span class="lineno">   61</span>&#160;                  <a class="code" href="classlldb_1_1SBEvent.html">lldb::SBEvent</a> &amp;event);</div>
 <div class="line"><a name="l00062"></a><span class="lineno">   62</span>&#160;</div>
 <div class="line"><a name="l00063"></a><span class="lineno">   63</span>&#160;    <span class="keywordtype">bool</span></div>
 <div class="line"><a name="l00064"></a><span class="lineno">   64</span>&#160;    <a class="code" href="classlldb_1_1SBListener.html#a15e89c4e59c58173f85b645653f1aa0f">WaitForEventForBroadcaster</a> (uint32_t num_seconds,</div>
 <div class="line"><a name="l00065"></a><span class="lineno">   65</span>&#160;                                <span class="keyword">const</span> <a class="code" href="classlldb_1_1SBBroadcaster.html">lldb::SBBroadcaster</a> &amp;broadcaster,</div>
 <div class="line"><a name="l00066"></a><span class="lineno">   66</span>&#160;                                <a class="code" href="classlldb_1_1SBEvent.html">lldb::SBEvent</a> &amp;sb_event);</div>