Fix typos

[brucem]

Summary

Fixes more typos.

[emaste]

One comment, otherwise looks fine to me if you've confirmed the tests pass.

examples/synthetic/unordered_multi.py

18 ↗

(On Diff #28946)

My guess, "made up of a" was what was originally intended?

[brucem]

Minor update. Addresses concern raised by emaste.

[clayborg]

Looks good.

lldb/trunk/examples/synthetic/unordered_multi.py

def __init__(self, valobj, dict):
     self.bucket_count = None
 
   def update(self):
     logger = lldb.formatters.Logger.Logger()
     self.num_elements = None
     self.next_element = None
     self.bucket_count = None
     try:
-      # unordered_map is made up a a hash_map, which has 4 pieces in it:
+      # unordered_map is made up of a hash_map, which has 4 pieces in it:
       #   bucket list :
       #      array of buckets
       #   p1 (pair):
       #      first - pointer to first loaded element
       #   p2 (pair):
       #      first - number of elements
       #      second - hash function
       #   p3 (pair):
       #      first - max_load_factor
       #      second - equality operator function
       #
-      # For display, we actually dont need to go inside the buckets, since 'p1' has a way to iterate over all
+      # For display, we actually don't need to go inside the buckets, since 'p1' has a way to iterate over all
       # the elements directly.
       #
       # We will calculate other values about the map because they will be useful for the summary.
       #
       table = self.valobj.GetChildMemberWithName('__table_')
 
       bl_ptr = table.GetChildMemberWithName('__bucket_list_').GetChildMemberWithName('__ptr_')
       self.bucket_array_ptr = bl_ptr.GetChildMemberWithName('__first_').GetValueAsUnsigned(0)
       self.bucket_count = bl_ptr.GetChildMemberWithName('__second_').GetChildMemberWithName('__data_').GetChildMemberWithName('__first_').GetValueAsUnsigned(0)
       logger >> "Bucket count = %r" % self.bucket_count
 
       self.begin_ptr = table.GetChildMemberWithName('__p1_').GetChildMemberWithName('__first_').GetChildMemberWithName('__next_')
 
       self.num_elements    = table.GetChildMemberWithName('__p2_').GetChildMemberWithName('__first_').GetValueAsUnsigned(0)
       self.max_load_factor = table.GetChildMemberWithName('__p3_').GetChildMemberWithName('__first_').GetValueAsUnsigned(0)
       logger >> "Num elements = %r" % self.num_elements
 
       # save the pointers as we get them
-      #   -- dont access this first element if num_element==0!
+      #   -- don't access this first element if num_element==0!
       self.elements_cache = []
       if self.num_elements:
         self.next_element = self.begin_ptr
       else:
         self.next_element = None
     except Exception, e:
       logger >> "Caught exception: %r" % e
       pass

lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp

 #include "lldb/Interpreter/Property.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Process.h"
 
 #if defined(__linux__)
 #include "../../Process/Linux/NativeProcessLinux.h"
 #endif
 
-// Define these constants from Linux mman.h for use when targetting
+// Define these constants from Linux mman.h for use when targeting
 // remote linux systems even when host has different values.
 #define MAP_PRIVATE 2
 #define MAP_ANON 0x20
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::platform_linux;
 

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

PlatformDarwinKernel::Terminate ()
 
     PlatformDarwin::Terminate ();
 }
 
 PlatformSP
 PlatformDarwinKernel::CreateInstance (bool force, const ArchSpec *arch)
 {
     // This is a special plugin that we don't want to activate just based on an ArchSpec for normal
-    // userlnad debugging.  It is only useful in kernel debug sessions and the DynamicLoaderDarwinPlugin
+    // userland debugging.  It is only useful in kernel debug sessions and the DynamicLoaderDarwinPlugin
     // (or a user doing 'platform select') will force the creation of this Platform plugin.
     if (force == false)
         return PlatformSP();
 
     bool create = force;
     LazyBool is_ios_debug_session = eLazyBoolCalculate;
 
     if (create == false && arch && arch->IsValid())

lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

 ProcessKDP::UpdateThreadList (ThreadList &old_thread_list, ThreadList &new_thread_list)
 {
     // locker will keep a mutex locked until it goes out of scope
     Log *log (ProcessKDPLog::GetLogIfAllCategoriesSet (KDP_LOG_THREAD));
     if (log && log->GetMask().Test(KDP_LOG_VERBOSE))
         log->Printf ("ProcessKDP::%s (pid = %" PRIu64 ")", __FUNCTION__, GetID());
     
     // Even though there is a CPU mask, it doesn't mean we can see each CPU
-    // indivudually, there is really only one. Lets call this thread 1.
+    // individually, there is really only one. Lets call this thread 1.
     ThreadSP thread_sp (old_thread_list.FindThreadByProtocolID(g_kernel_tid, false));
     if (!thread_sp)
         thread_sp = GetKernelThread ();
     new_thread_list.AddThread(thread_sp);
 
     return new_thread_list.GetSize(false) > 0;
 }
 

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

while (state == eStateRunning)
                             // which will just re-send a copy of the last stop reply
                             // packet. If we don't do this, then the reply for our
                             // async packet will be the repeat stop reply packet and cause
                             // a lot of trouble for us!
                             if (signo != sigint_signo && signo != sigstop_signo)
                             {
                                 continue_after_async = false;
 
-                                // We didn't get a a SIGINT or SIGSTOP, so try for a
+                                // We didn't get a SIGINT or SIGSTOP, so try for a
                                 // very brief time (1 ms) to get another stop reply
                                 // packet to make sure it doesn't get in the way
                                 StringExtractorGDBRemote extra_stop_reply_packet;
                                 uint32_t timeout_usec = 1000;
                                 if (ReadPacket (extra_stop_reply_packet, timeout_usec, false) == PacketResult::Success)
                                 {
                                     switch (extra_stop_reply_packet.GetChar())
                                     {

lldb/trunk/test/lang/c/stepping/TestStepAndBreakpoints.py

def step_over_stepping(self):
         self.assertTrue (func_name == "b", "Should be in 'b', were in %s"%(func_name))
 
         # Okay, now if we continue, we will finish off our function call and we should end up back in "a" as if nothing had happened:
         process.Continue ()
 
         self.assertTrue (thread.GetFrameAtIndex(0).GetLineEntry().GetLine() == current_line)
         self.assertTrue (thread.GetFrameAtIndex(0).GetLineEntry().GetFileSpec() == current_file)
 
-        # Now we are going to test step in targetting a function:
+        # Now we are going to test step in targeting a function:
 
         break_in_b.SetEnabled (False)
 
-        break_before_complex_1 = target.BreakpointCreateBySourceRegex ('// Stop here to try step in targetting b.', self.main_source_spec)
+        break_before_complex_1 = target.BreakpointCreateBySourceRegex ('// Stop here to try step in targeting b.', self.main_source_spec)
         self.assertTrue(break_before_complex_1, VALID_BREAKPOINT)
 
-        break_before_complex_2 = target.BreakpointCreateBySourceRegex ('// Stop here to try step in targetting complex.', self.main_source_spec)
+        break_before_complex_2 = target.BreakpointCreateBySourceRegex ('// Stop here to try step in targeting complex.', self.main_source_spec)
         self.assertTrue(break_before_complex_2, VALID_BREAKPOINT)
 
-        break_before_complex_3 = target.BreakpointCreateBySourceRegex ('// Stop here to step targetting b and hitting breakpoint.', self.main_source_spec)
+        break_before_complex_3 = target.BreakpointCreateBySourceRegex ('// Stop here to step targeting b and hitting breakpoint.', self.main_source_spec)
         self.assertTrue(break_before_complex_3, VALID_BREAKPOINT)
 
         break_before_complex_4 = target.BreakpointCreateBySourceRegex ('// Stop here to make sure bogus target steps over.', self.main_source_spec)
         self.assertTrue(break_before_complex_4, VALID_BREAKPOINT)
 
         threads = lldbutil.continue_to_breakpoint(process, break_before_complex_1)
         self.assertTrue (len(threads) == 1)
         thread = threads[0]
         break_before_complex_1.SetEnabled(False)
 
         thread.StepInto ("b")
         self.assertTrue (thread.GetFrameAtIndex(0).GetFunctionName() == "b")
 
         # Now continue out and stop at the next call to complex.  This time step all the way into complex:
         threads = lldbutil.continue_to_breakpoint (process, break_before_complex_2)
         self.assertTrue (len(threads) == 1)
         thread = threads[0]
         break_before_complex_2.SetEnabled(False)
 
         thread.StepInto ("complex")
         self.assertTrue (thread.GetFrameAtIndex(0).GetFunctionName() == "complex")
         
-        # Now continue out and stop at the next call to complex.  This time enable breakpoints in a and c and then step targetting b:
+        # Now continue out and stop at the next call to complex.  This time enable breakpoints in a and c and then step targeting b:
         threads = lldbutil.continue_to_breakpoint (process, break_before_complex_3)
         self.assertTrue (len(threads) == 1)
         thread = threads[0]
         break_before_complex_3.SetEnabled(False)
 
         break_at_start_of_a = target.BreakpointCreateByName ('a')
         break_at_start_of_c = target.BreakpointCreateByName ('c')
 
         thread.StepInto ("b")
         threads = lldbutil.get_stopped_threads(process, lldb.eStopReasonBreakpoint);
 
         self.assertTrue (len(threads) == 1)
         thread = threads[0]
         stop_break_id = thread.GetStopReasonDataAtIndex(0)
         self.assertTrue(stop_break_id == break_at_start_of_a.GetID() or stop_break_id == break_at_start_of_c.GetID())
 
         break_at_start_of_a.SetEnabled(False)
         break_at_start_of_c.SetEnabled(False)
 
         process.Continue()
         self.assertTrue (thread.GetFrameAtIndex(0).GetFunctionName() == "b")
         
-        # Now continue out and stop at the next call to complex.  This time enable breakpoints in a and c and then step targetting b:
+        # Now continue out and stop at the next call to complex.  This time enable breakpoints in a and c and then step targeting b:
         threads = lldbutil.continue_to_breakpoint (process, break_before_complex_4)
         self.assertTrue (len(threads) == 1)
         thread = threads[0]
         break_before_complex_4.SetEnabled(False)
 
         thread.StepInto("NoSuchFunction")
         self.assertTrue (thread.GetFrameAtIndex(0).GetFunctionName() == "main")
         
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()

lldb/trunk/test/lang/c/stepping/main.c

 
 int c(int val)
 {
     return val + 3; // Find the line number of function "c" here.
 }
 
 int complex (int first, int second, int third)
 {
-    return first + second + third;  // Step in targetting complex should stop here
+    return first + second + third;  // Step in targeting complex should stop here
 }
 
 int main (int argc, char const *argv[])
 {
     int A1 = a(1); // frame select 2, thread step-out while stopped at "c(1)"
     printf("a(1) returns %d\n", A1);
     
     int B2 = b(2);
     printf("b(2) returns %d\n", B2);
     
     int A3 = a(3); // frame select 1, thread step-out while stopped at "c(3)"
     printf("a(3) returns %d\n", A3);
     
-    int A4 = complex (a(1), b(2), c(3)); // Stop here to try step in targetting b.
+    int A4 = complex (a(1), b(2), c(3)); // Stop here to try step in targeting b.
 
-    int A5 = complex (a(2), b(3), c(4)); // Stop here to try step in targetting complex.
+    int A5 = complex (a(2), b(3), c(4)); // Stop here to try step in targeting complex.
 
-    int A6 = complex (a(4), b(5), c(6)); // Stop here to step targetting b and hitting breakpoint.
+    int A6 = complex (a(4), b(5), c(6)); // Stop here to step targeting b and hitting breakpoint.
 
     int A7 = complex (a(5), b(6), c(7)); // Stop here to make sure bogus target steps over.
 
     printf ("I am using print_string: %s.\n", print_string);
     return 0;
 }