Fix typos.

[teemperor]

This looks all good to me. I'm a bit worried about the changes to AppleObjCTrampolineHandler.cpp, but from what I can see we don't actually rely on this specific field name anywhere in our code.

include/lldb/Utility/ConstString.h

public:
   ///     Returns the number of bytes that this string occupies in
   ///     memory, not including the NULL termination byte.
   //------------------------------------------------------------------
   size_t GetLength() const;
 
   //------------------------------------------------------------------
   /// Clear this object's state.
   ///
-  /// Clear any contained string and reset the value to the an empty string
+  /// Clear any contained string and reset the value to the empty string
   /// value.
   //------------------------------------------------------------------
   void Clear() { m_string = nullptr; }
 
   //------------------------------------------------------------------
   /// Equal to operator
   ///
   /// Returns true if this string is equal to the string in \a rhs. If case

packages/Python/lldbsuite/test/tools/lldb-vscode/vscode.py

def main():
     parser = optparse.OptionParser(
         description=('A testing framework for the Visual Studio Code Debug '
                      'Adaptor protocol'))
 
     parser.add_option(
         '--vscode',
         type='string',
         dest='vscode_path',
-        help=('The path to the a command line program that implements the '
+        help=('The path to the command line program that implements the '
               'Visual Studio Code Debug Adaptor protocol.'),
         default=None)
 
     parser.add_option(
         '--program',
         type='string',
         dest='program',
         help='The path to the program to debug.',

source/Host/common/MainLoop.cpp

#else
   new_action.sa_flags = SA_SIGINFO;
   sigemptyset(&new_action.sa_mask);
   sigaddset(&new_action.sa_mask, signo);
   sigset_t old_set;
 
   g_signal_flags[signo] = 0;
 
   // Even if using kqueue, the signal handler will still be invoked, so it's
-  // important to replace it with our "bening" handler.
+  // important to replace it with our "benign" handler.
   int ret = sigaction(signo, &new_action, &info.old_action);
   assert(ret == 0 && "sigaction failed");
 
 #if HAVE_SYS_EVENT_H
   struct kevent ev;
   EV_SET(&ev, signo, EVFILT_SIGNAL, EV_ADD, 0, 0, 0);
   ret = kevent(m_kqueue, &ev, 1, nullptr, 0, nullptr);
   assert(ret == 0);
 #endif
 
   // If we're using kqueue, the signal needs to be unblocked in order to
-  // recieve it. If using pselect/ppoll, we need to block it, and later unblock
+  // receive it. If using pselect/ppoll, we need to block it, and later unblock
   // it as a part of the system call.
   ret = pthread_sigmask(HAVE_SYS_EVENT_H ? SIG_UNBLOCK : SIG_BLOCK,
                         &new_action.sa_mask, &old_set);
   assert(ret == 0 && "pthread_sigmask failed");
   info.was_blocked = sigismember(&old_set, signo);
   m_signals.insert({signo, info});
 
   return SignalHandleUP(new SignalHandle(*this, signo));

source/Host/posix/ProcessLauncherPosixFork.cpp

if (ptrace(PT_TRACE_ME, 0, nullptr, 0) == -1)
       ExitWithError(error_fd, "ptrace");
   }
 
   // Execute.  We should never return...
   execve(argv[0], const_cast<char *const *>(argv), envp);
 
 #if defined(__linux__)
   if (errno == ETXTBSY) {
-    // On android M and earlier we can get this error because the adb deamon
+    // On android M and earlier we can get this error because the adb daemon
     // can hold a write handle on the executable even after it has finished
     // uploading it. This state lasts only a short time and happens only when
     // there are many concurrent adb commands being issued, such as when
     // running the test suite. (The file remains open when someone does an "adb
     // shell" command in the fork() child before it has had a chance to exec.)
     // Since this state should clear up quickly, wait a while and then give it
     // one more go.
     usleep(50000);

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

bool AppleObjCRuntimeV2::NonPointerISACache::EvaluateNonPointerISA(
   if (log)
     log->Printf("AOCRT::NPI Evalulate(isa = 0x%" PRIx64 ")", (uint64_t)isa);
 
   if ((isa & ~m_objc_debug_isa_class_mask) == 0)
     return false;
 
   // If all of the indexed ISA variables are set, then its possible that this
   // ISA is indexed, and we should first try to get its value using the index.
-  // Note, we check these varaibles first as the ObjC runtime will set at least
+  // Note, we check these variables first as the ObjC runtime will set at least
   // one of their values to 0 if they aren't needed.
   if (m_objc_debug_indexed_isa_magic_mask &&
       m_objc_debug_indexed_isa_magic_value &&
       m_objc_debug_indexed_isa_index_mask &&
       m_objc_debug_indexed_isa_index_shift && m_objc_indexed_classes) {
     if ((isa & ~m_objc_debug_indexed_isa_index_mask) == 0)
       return false;
 
if ((isa & m_objc_debug_indexed_isa_magic_mask) ==
 
       ret_isa = m_indexed_isa_cache[index];
       return (ret_isa != 0); // this is a pointer so 0 is not a valid value
     }
 
     return false;
   }
 
-  // Definately not an indexed ISA, so try to use a mask to extract the pointer
+  // Definitely not an indexed ISA, so try to use a mask to extract the pointer
   // from the ISA.
   if ((isa & m_objc_debug_isa_magic_mask) == m_objc_debug_isa_magic_value) {
     ret_isa = isa & m_objc_debug_isa_class_mask;
     return (ret_isa != 0); // this is a pointer so 0 is not a valid value
   }
   return false;
 }
 

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp

struct __lldb_imp_return_struct                                          \n\
         void *impl_addr;                                                     \n\
     };                                                                       \n\
                                                                              \n\
     struct __lldb_objc_class {                                               \n\
         void *isa;                                                           \n\
         void *super_ptr;                                                     \n\
     };                                                                       \n\
     struct __lldb_objc_super {                                               \n\
-        void *reciever;                                                      \n\
+        void *receiver;                                                      \n\
         struct __lldb_objc_class *class_ptr;                                 \n\
     };                                                                       \n\
     struct __lldb_msg_ref {                                                  \n\
         void *dont_know;                                                     \n\
         void *sel;                                                           \n\
     };                                                                       \n\
                                                                              \n\
     struct __lldb_imp_return_struct return_struct;                           \n\
struct __lldb_imp_return_struct                                          \n\
         void *impl_addr;                                                     \n\
     };                                                                       \n\
                                                                              \n\
     struct __lldb_objc_class {                                               \n\
         void *isa;                                                           \n\
         void *super_ptr;                                                     \n\
     };                                                                       \n\
     struct __lldb_objc_super {                                               \n\
-        void *reciever;                                                      \n\
+        void *receiver;                                                      \n\
         struct __lldb_objc_class *class_ptr;                                 \n\
     };                                                                       \n\
     struct __lldb_msg_ref {                                                  \n\
         void *dont_know;                                                     \n\
         void *sel;                                                           \n\
     };                                                                       \n\
                                                                              \n\
     struct __lldb_imp_return_struct return_struct;                           \n\

source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

static constexpr OptionDefinition g_enable_option_table[] = {
     // Message formatting options
     {LLDB_OPT_SET_ALL, false, "timestamp-relative", 'r',
      OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone,
      "Include timestamp in the message header when printing a log "
      "message.  The timestamp is relative to the first displayed "
      "message."},
     {LLDB_OPT_SET_ALL, false, "subsystem", 's', OptionParser::eNoArgument,
      nullptr, {}, 0, eArgTypeNone,
-     "Include the subsystem in the the message header when displaying "
+     "Include the subsystem in the message header when displaying "
      "a log message."},
     {LLDB_OPT_SET_ALL, false, "category", 'c', OptionParser::eNoArgument,
      nullptr, {}, 0, eArgTypeNone,
-     "Include the category in the the message header when displaying "
+     "Include the category in the message header when displaying "
      "a log message."},
     {LLDB_OPT_SET_ALL, false, "activity-chain", 'C', OptionParser::eNoArgument,
      nullptr, {}, 0, eArgTypeNone,
      "Include the activity parent-child chain in the message header "
      "when displaying a log message.  The activity hierarchy is "
      "displayed as {grandparent-activity}:"
      "{parent-activity}:{activity}[:...]."},
     {LLDB_OPT_SET_ALL, false, "all-fields", 'A', OptionParser::eNoArgument,

source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp

if (reg_num != LLDB_INVALID_REGNUM &&
                                                 false /*must_replace*/);
           m_curr_row_modified = true;
         }
         break;
       case EmulateInstruction::eInfoTypeISA:
         assert(
             (generic_regnum == LLDB_REGNUM_GENERIC_PC ||
              generic_regnum == LLDB_REGNUM_GENERIC_FLAGS) &&
-            "eInfoTypeISA used for poping a register other the the PC/FLAGS");
+            "eInfoTypeISA used for popping a register other the PC/FLAGS");
         if (generic_regnum != LLDB_REGNUM_GENERIC_FLAGS) {
           m_curr_row->SetRegisterLocationToSame(reg_num,
                                                 false /*must_replace*/);
           m_curr_row_modified = true;
         }
         break;
       default:
         assert(false && "unhandled case, add code to handle this!");

tools/lldb-mi/MICmnResources.cpp

CMICmnResources::ms_pResourceId2TextData[] = {
         {IDE_MI_APP_INFORMATION,
          "Information:\nCurrent limitations. The MI Driver currently only "
          "handles remote target\ndebugging. Local "
          "debugging has not been implemented. The MI Driver has\nbeen designed "
          "primarily to be used with Eclipse Juno "
          "and a custom plugin.\nThe custom plugin is not necessary to operate "
          "the MI Driver."},
         {IDE_MI_APP_ARG_USAGE, "\nMI driver usage:\n\n\tlldb-mi [--longOption] "
-                               "[-s hortOption] [executeable]\n\n[] = optional "
+                               "[-s hortOption] [executable]\n\n[] = optional "
                                "argument."},
         {IDE_MI_APP_ARG_HELP, "-h\n--help\n\tPrints out usage information for "
                               "the MI debugger. Exit the MI\n\tDriver "
                               "immediately."},
         {IDE_MI_APP_ARG_VERSION, "--version\n\tPrints out GNU (gdb) version "
                                  "information. Exit the MI "
                                  "Driver\n\timmediately."},
         {IDE_MI_APP_ARG_VERSION_LONG, "--versionLong\n\tPrints out MI Driver "

tools/lldb-vscode/JSONUtils.h

 
 //----------------------------------------------------------------------
 /// Create a "Variable" object for a LLDB thread object.
 ///
 /// This function will fill in the following keys in the returned
 /// object:
 ///   "name" - the name of the variable
 ///   "value" - the value of the variable as a string
-///   "type" - the typename of the varaible as a string
+///   "type" - the typename of the variable as a string
 ///   "id" - a unique identifier for a value in case there are multiple
 ///          variables with the same name. Other parts of the VSCode
 ///          protocol refer to values by name so this can help
 ///          disambiguate such cases if a IDE passes this "id" value
 ///          back down.
 ///   "variablesReference" - Zero if the variable has no children,
 ///          non-zero integer otherwise which can be used to expand
 ///          the variable.
 ///   "evaluateName" - The name of the variable to use in expressions
 ///                    as a string.
 ///
 /// @param[in] v
 ///     The LLDB value to use when populating out the "Variable"
 ///     object.
 ///
 /// @param[in] variablesReference
 ///     The variable reference. Zero if this value isn't structured
 ///     and has no children, non-zero if it does have children and
 ///     might be asked to expand itself.
 ///
 /// @param[in] varID
-///     A unique variable indentifier to help in properly identifying
+///     A unique variable identifier to help in properly identifying
 ///     variables with the same name. This is an extension to the
 ///     VS protocol.
 ///
 /// @param[in] format_hex
 ///     It set to true the variable will be formatted as hex in
 ///     the "value" key value pair for the value of the variable.
 ///
 /// @return

tools/lldb-vscode/LLDBUtils.h

 ///----------------------------------------------------------------------
 /// Run a list of LLDB commands in the LLDB command interpreter.
 ///
 /// All output from every command, including the prompt + the command
 /// is placed into the "strm" argument.
 ///
 /// @param[in] prefix
 ///     A string that will be printed into \a strm prior to emitting
-///     the prmopt + command and command output. Can be NULL.
+///     the prompt + command and command output. Can be NULL.
 ///
 /// @param[in] commands
 ///     An array of LLDB commands to execute.
 ///
 /// @param[in] strm
 ///     The stream that will receive the prefix, prompt + command and
 ///     all command output.
 //----------------------------------------------------------------------
 void RunLLDBCommands(llvm::StringRef prefix,
                      const llvm::ArrayRef<std::string> &commands,
                      llvm::raw_ostream &strm);
 
 ///----------------------------------------------------------------------
 /// Run a list of LLDB commands in the LLDB command interpreter.
 ///
 /// All output from every command, including the prompt + the command
 /// is returned in the std::string return value.
 ///
 /// @param[in] prefix
 ///     A string that will be printed into \a strm prior to emitting
-///     the prmopt + command and command output. Can be NULL.
+///     the prompt + command and command output. Can be NULL.
 ///
 /// @param[in] commands
 ///     An array of LLDB commands to execute.
 ///
 /// @return
 ///     A std::string that contains the prefix and all commands and
 ///     command output
 //----------------------------------------------------------------------

tools/lldb-vscode/README.md

 |**name**           |string|Y| A configuration name that will be displayed in the IDE.
 |**type**           |string|Y| Must be "lldb-vscode".
 |**request**        |string|Y| Must be "launch".
 |**program**        |string|Y| Path to the executable to launch.
 |**args**           |[string]|| An array of command line argument strings to be passed to the program being launched.
 |**cwd**            |string| | The program working directory.
 |**env**            |dictionary| | Environment variables to set when launching the program. The format of each environment variable string is "VAR=VALUE" for environment variables with values or just "VAR" for environment variables with no values.
 |**stopOnEntry**    |boolean| | Whether to stop program immediately after launching.
-|**initCommands**   |[string]| | LLDB commands executed upon debugger startup prior to creating a the LLDB target. Commands and command output will be sent to the debugger console when they are executed.
+|**initCommands**   |[string]| | LLDB commands executed upon debugger startup prior to creating the LLDB target. Commands and command output will be sent to the debugger console when they are executed.
 |**preRunCommands** |[string]| | LLDB commands executed just before launching after the LLDB target has been created. Commands and command output will be sent to the debugger console when they are executed.
 |**stopCommands**   |[string]| | LLDB commands executed just after each stop. Commands and command output will be sent to the debugger console when they are executed.
 |**exitCommands**   |[string]| | LLDB commands executed when the program exits. Commands and command output will be sent to the debugger console when they are executed.
 |**sourceMap**      |[string[2]]| | Specify an array of path re-mappings. Each element in the array must be a two element array containing a source and destination pathname.
 |**debuggerRoot**   | string| |Specify a working directory to use when launching lldb-vscode. If the debug information in your executable contains relative paths, this option can be used so that `lldb-vscode` can find source files and object files that have relative paths.
 
 ## Attaching Settings
 

 |-------------------|--------|:--:|---------|
 |**name**           |string  |Y| A configuration name that will be displayed in the IDE.
 |**type**           |string  |Y| Must be "lldb-vscode".
 |**request**        |string  |Y| Must be "attach".
 |**program**        |string  | | Path to the executable to attach to. This value is optional but can help to resolve breakpoints prior the attaching to the program.
 |**pid**            |number  | | The process id of the process you wish to attach to. If **pid** is omitted, the debugger will attempt to attach to the program by finding a process whose file name matches the file name from **porgram**. Setting this value to `${command:pickMyProcess}` will allow interactive process selection in the IDE.
 |**stopOnEntry**    |boolean| | Whether to stop program immediately after launching.
 |**waitFor**        |boolean | | Wait for the process to launch.
-|**initCommands**   |[string]| | LLDB commands executed upon debugger startup prior to creating a the LLDB target. Commands and command output will be sent to the debugger console when they are executed.
+|**initCommands**   |[string]| | LLDB commands executed upon debugger startup prior to creating the LLDB target. Commands and command output will be sent to the debugger console when they are executed.
 |**preRunCommands** |[string]| | LLDB commands executed just before launching after the LLDB target has been created. Commands and command output will be sent to the debugger console when they are executed.
 |**stopCommands**   |[string]| | LLDB commands executed just after each stop. Commands and command output will be sent to the debugger console when they are executed.
 |**exitCommands**   |[string]| | LLDB commands executed when the program exits. Commands and command output will be sent to the debugger console when they are executed.
 |**attachCommands** |[string]| | LLDB commands that will be executed after **preRunCommands** which take place of the code that normally does the attach. The commands can create a new target and attach or launch it however desired. This allows custom launch and attach configurations. Core files can use `target create --core /path/to/core` to attach to core files.
 
 
 ## Example configurations
 

tools/lldb-vscode/lldb-vscode.cpp

if (!g_vsc.sent_terminated_event) {
     g_vsc.sent_terminated_event = true;
     // Send a "terminated" event
     llvm::json::Object event(CreateEventObject("terminated"));
     g_vsc.SendJSON(llvm::json::Value(std::move(event)));
   }
 }
 
 //----------------------------------------------------------------------
-// Send a thread stopped event for all threads as lons as the process
+// Send a thread stopped event for all threads as long as the process
 // is stopped.
 //----------------------------------------------------------------------
 void SendThreadStoppedEvent() {
   lldb::SBProcess process = g_vsc.target.GetProcess();
   if (process.IsValid()) {
     auto state = process.GetState();
     if (state == lldb::eStateStopped) {
       llvm::DenseSet<lldb::tid_t> old_thread_ids;
if (state == lldb::eStateStopped) {
       }
 
       // We will have cleared g_vsc.focus_tid if he focus thread doesn't
       // have a stop reason, so if it was cleared, or wasn't set, then set the
       // focus thread to the first thread with a stop reason.
       if (g_vsc.focus_tid == LLDB_INVALID_THREAD_ID)
         g_vsc.focus_tid = first_tid_with_reason;
 
-      // If no threads stopped with a reaspon, then report the first one so
+      // If no threads stopped with a reason, then report the first one so
       // we at least let the UI know we stopped.
       if (num_threads_with_reason == 0) {
         lldb::SBThread thread = process.GetThreadAtIndex(0);
         g_vsc.SendJSON(CreateThreadStopped(thread, stop_id));
       } else {
         for (uint32_t thread_idx = 0; thread_idx < num_threads; ++thread_idx) {
           lldb::SBThread thread = process.GetThreadAtIndex(thread_idx);
           g_vsc.thread_ids.insert(thread.GetThreadID());
void SendStdOutStdErr(lldb::SBProcess &process) {
   size_t count;
   while ((count = process.GetSTDOUT(buffer, sizeof(buffer))) > 0)
   g_vsc.SendOutput(OutputType::Stdout, llvm::StringRef(buffer, count));
   while ((count = process.GetSTDERR(buffer, sizeof(buffer))) > 0)
     g_vsc.SendOutput(OutputType::Stderr, llvm::StringRef(buffer, count));
 }
 
 //----------------------------------------------------------------------
-// All events from a the debugger, target, process, thread and frames are
+// All events from the debugger, target, process, thread and frames are
 // received in this function that runs in its own thread. We are using a
 // "FILE *" to output packets back to VS Code and they have mutexes in them
 // them prevent multiple threads from writing simultaneously so no locking
 // is required.
 //----------------------------------------------------------------------
 void EventThreadFunction() {
   lldb::SBEvent event;
   lldb::SBListener listener = g_vsc.debugger.GetListener();
if (old_src_bp_pos != g_vsc.source_breakpoints.end()) {
     for (auto &pair: old_src_bp_pos->second) {
       auto request_pos = request_bps.find(pair.first);
       if (request_pos == request_bps.end()) {
         // This breakpoint no longer exists in this source file, delete it
         g_vsc.target.BreakpointDelete(pair.second.bp.GetID());
         remove_lines.push_back(pair.first);
       } else {
         pair.second.UpdateBreakpoint(request_pos->second);
-        // Remove this breakpopint from the request breakpoints since we have
+        // Remove this breakpoint from the request breakpoints since we have
         // handled it here and we don't need to set a new breakpoint below.
         request_bps.erase(request_pos);
         // Add this breakpoint info to the response
         AppendBreakpoint(pair.second.bp, response_breakpoints);
       }
     }
     // Remove any lines from this existing source breakpoint map
     for (auto line: remove_lines)
for (auto &pair: g_vsc.function_breakpoints) {
     if (request_pos == request_bps.end()) {
       // This function breakpoint no longer exists delete it from LLDB
       g_vsc.target.BreakpointDelete(pair.second.bp.GetID());
       remove_names.push_back(pair.first());
     } else {
       // Update the existing breakpoint as any setting withing the function
       // breakpoint might have changed.
       pair.second.UpdateBreakpoint(request_pos->second);
-      // Remove this breakpopint from the request breakpoints since we have
+      // Remove this breakpoint from the request breakpoints since we have
       // handled it here and we don't need to set a new breakpoint below.
       request_bps.erase(request_pos);
       // Add this breakpoint info to the response
       AppendBreakpoint(pair.second.bp, response_breakpoints);
     }
   }
   // Remove any breakpoints that are no longer in our list
   for (const auto &name: remove_names)
void request_setVariable(const llvm::json::Object &request) {
   // The "id" is the unique integer ID that is unique within the enclosing
   // variablesReference. It is optionally added to any "interface Variable"
   // objects to uniquely identify a variable within an enclosing
   // variablesReference. It helps to disambiguate between two variables that
   // have the same name within the same scope since the "setVariables" request
   // only specifies the variable reference of the enclosing scope/variable, and
   // the name of the variable. We could have two shadowed variables with the
   // same name in "Locals" or "Globals". In our case the "id" absolute index
-  // of the variable within the the g_vsc.variables list.
+  // of the variable within the g_vsc.variables list.
   const auto id_value = GetUnsigned(arguments, "id", UINT64_MAX);
   if (id_value != UINT64_MAX) {
     variable = g_vsc.variables.GetValueAtIndex(id_value);
   } else if (VARREF_IS_SCOPE(variablesReference)) {
     // variablesReference is one of our scopes, not an actual variable it is
-    // asking for a variable inlocals or globals or registers
+    // asking for a variable in locals or globals or registers
     int64_t start_idx = 0;
     int64_t end_idx = 0;
     switch (variablesReference) {
     case VARREF_LOCALS:
       start_idx = 0;
       end_idx = start_idx + g_vsc.num_locals;
       break;
     case VARREF_GLOBALS:

unittests/Core/BroadcasterTest.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 TEST(BroadcasterTest, BroadcastEvent) {
   EventSP event_sp;
   Broadcaster broadcaster(nullptr, "test-broadcaster");
   std::chrono::seconds timeout(0);
 
-  // Create a listener, sign it up, make sure it recieves an event.
+  // Create a listener, sign it up, make sure it receives an event.
   ListenerSP listener1_sp = Listener::MakeListener("test-listener1");
   const uint32_t event_mask1 = 1;
   EXPECT_EQ(event_mask1,
             listener1_sp->StartListeningForEvents(&broadcaster, event_mask1));
   broadcaster.BroadcastEvent(event_mask1, nullptr);
   EXPECT_TRUE(listener1_sp->GetEvent(event_sp, timeout));
   EXPECT_EQ(event_mask1, event_sp->GetType());
 

unittests/Core/ListenerTest.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 TEST(ListenerTest, GetEventImmediate) {
   EventSP event_sp;
   Broadcaster broadcaster(nullptr, "test-broadcaster");
 
-  // Create a listener, sign it up, make sure it recieves an event.
+  // Create a listener, sign it up, make sure it receives an event.
   ListenerSP listener_sp = Listener::MakeListener("test-listener");
   const uint32_t event_mask = 1;
   ASSERT_EQ(event_mask,
             listener_sp->StartListeningForEvents(&broadcaster, event_mask));
 
   const std::chrono::seconds timeout(0);
   // Without any events sent, these should return false.
   EXPECT_FALSE(listener_sp->GetEvent(event_sp, timeout));
TEST(ListenerTest, GetEventImmediate) {
   EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
       &broadcaster, event_mask, event_sp, timeout));
 }
 
 TEST(ListenerTest, GetEventWait) {
   EventSP event_sp;
   Broadcaster broadcaster(nullptr, "test-broadcaster");
 
-  // Create a listener, sign it up, make sure it recieves an event.
+  // Create a listener, sign it up, make sure it receives an event.
   ListenerSP listener_sp = Listener::MakeListener("test-listener");
   const uint32_t event_mask = 1;
   ASSERT_EQ(event_mask,
             listener_sp->StartListeningForEvents(&broadcaster, event_mask));
 
   // Without any events sent, these should make a short wait and return false.
   std::chrono::microseconds timeout(10);
   EXPECT_FALSE(listener_sp->GetEvent(event_sp, timeout));

utils/sync-source/README.txt

# Configuration blocks can chain back to a parent by name.
         # * should be excluded from deletion on the destination
         #
         # By default, ".git", ".svn" and ".pyc" are added to
         # all dir-id exclusions.  The default excludes can be
         # controlled by the syncsource.py --default-excludes
         # option.
         #
         # Below, I have transfer of the lldb dir skip everything
-        # rooted at "/llvm" below the the lldb dir.  This is
+        # rooted at "/llvm" below the lldb dir.  This is
         # because we want the source OS X lldb to move to
         # a destination of {some-dest-root}/llvm/tools/lldb, and
         # not have the OS-X-inverted llvm copy over with the lldb
         # transfer portion.  We'll see the complete picture of
         # how this works when we get to specifying destinations
         # later on in the config.
         #
         # We also exclude the "/build" and "/llvm-build" dir rooted in

www/python_reference/epydoc.css

 table.summary
      a.summary-name:link    { color: #006080; font-weight: bold;
                               font-family: monospace; }
 table.summary
     a.summary-name:visited  { color: #006080; font-weight: bold;
                               font-family: monospace; }
 
 /* Variable values
- *   - In the 'variable details' sections, each varaible's value is
+ *   - In the 'variable details' sections, each variable's value is
  *     listed in a 'pre.variable' box.  The width of this box is
  *     restricted to 80 chars; if the value's repr is longer than
  *     this it will be wrapped, using a backslash marked with
  *     class 'variable-linewrap'.  If the value's repr is longer
  *     than 3 lines, the rest will be ellided; and an ellipsis
  *     marker ('...' marked with 'variable-ellipsis') will be used.
  *   - If the value is a string, its quote marks will be marked
  *     with 'variable-quote'.