Everywhere: Fix typos

Mostly in comments, but sprintf() now prints "August" instead of
"Auguest" so that's something.

Libraries/LibDebug/DebugInfo.cpp

@@ -80,7 +80,7 @@ void DebugInfo::parse_scopes_impl(const Dwarf::DIE& die)
 
         if (!child.get_attribute(Dwarf::Attribute::LowPc).has_value()) {
 #ifdef DEBUG_SPAM
-            dbg() << "DWARF: Couldn't find attribtue LowPc for scope";
+            dbg() << "DWARF: Couldn't find attribute LowPc for scope";
 #endif
             return;
         }
@@ -165,7 +165,7 @@ NonnullOwnPtrVector<DebugInfo::VariableInfo> DebugInfo::get_variables_in_current
 {
     NonnullOwnPtrVector<DebugInfo::VariableInfo> variables;
 
-    // TODO: We can store the scopes in a better data strucutre
+    // TODO: We can store the scopes in a better data structure
     for (const auto& scope : m_scopes) {
         if (regs.eip < scope.address_low || regs.eip >= scope.address_high)
             continue;
@@ -236,7 +236,7 @@ OwnPtr<DebugInfo::VariableInfo> DebugInfo::create_variable_info(const Dwarf::DIE
 
     if (variable_die.tag() == Dwarf::EntryTag::FormalParameter
         && !variable_die.get_attribute(Dwarf::Attribute::Name).has_value()) {
-        // We don't want to display info for unused paramters
+        // We don't want to display info for unused parameters
         return {};
     }
 

Libraries/LibDebug/DebugSession.cpp

@@ -244,7 +244,7 @@ void* DebugSession::single_step()
 {
     // Single stepping works by setting the x86 TRAP flag bit in the eflags register.
     // This flag causes the cpu to enter single-stepping mode, which causes
-    // Interupt 1 (debug interrupt) to be emitted after every instruction.
+    // Interrupt 1 (debug interrupt) to be emitted after every instruction.
     // To single step the program, we set the TRAP flag and continue the debugee.
     // After the debugee has stopped, we clear the TRAP flag.
 

Libraries/LibDebug/DebugSession.h

@@ -180,7 +180,7 @@ void DebugSession::run(Callback callback)
         }
 
         if (current_breakpoint.has_value()) {
-            // We want to make the breakpoint transparrent to the user of the debugger.
+            // We want to make the breakpoint transparent to the user of the debugger.
             // To achieive this, we perform two rollbacks:
             // 1. Set regs.eip to point at the actual address of the instruction we breaked on.
             //    regs.eip currently points to one byte after the address of the original instruction,
@@ -212,7 +212,7 @@ void DebugSession::run(Callback callback)
 
         // Re-enable the breakpoint if it wasn't removed by the user
         if (current_breakpoint.has_value() && m_breakpoints.contains(current_breakpoint.value().address)) {
-            // The current breakpoint was removed to make it transparrent to the user.
+            // The current breakpoint was removed to make it transparent to the user.
             // We now want to re-enable it - the code execution flow could hit it again.
             // To re-enable the breakpoint, we first perform a single step and execute the
             // instruction of the breakpoint, and then redo the INT3 patch in its first byte.

Libraries/LibDebug/Dwarf/AbbreviationsMap.cpp

@@ -46,8 +46,8 @@ void AbbreviationsMap::populate_map()
     while (!abbreviation_stream.eof()) {
         size_t abbreviation_code = 0;
         abbreviation_stream.read_LEB128_unsigned(abbreviation_code);
-        // An abbrevation code of 0 marks the end of the
-        // abbrevations for a given compilation unit
+        // An abbreviation code of 0 marks the end of the
+        // abbreviations for a given compilation unit
         if (abbreviation_code == 0)
             break;
 

Libraries/LibDebug/Dwarf/DIE.cpp

@@ -42,7 +42,7 @@ DIE::DIE(const CompilationUnit& unit, u32 offset)
     m_data_offset = stream.offset();
 
     if (m_abbreviation_code == 0) {
-        // An abbrevation code of 0 ( = null DIE entry) means the end of a chain of sibilings
+        // An abbreviation code of 0 ( = null DIE entry) means the end of a chain of siblings
         m_tag = EntryTag::None;
     } else {
         auto abbreviation_info = m_compilation_unit.abbreviations_map().get(m_abbreviation_code);
@@ -218,7 +218,7 @@ void DIE::for_each_child(Function<void(const DIE& child)> callback) const
         }
 
         if (!sibling.has_value()) {
-            // NOTE: According to the spec, the compiler does't have to supply the sibling information.
+            // NOTE: According to the spec, the compiler doesn't have to supply the sibling information.
             // When it doesn't, we have to recursively iterate the current child's children to find where they end
             current_child->for_each_child([&](const DIE& sub_child) {
                 sibling_offset = sub_child.offset() + sub_child.size();