Fix some typos

Author: higuoxing

advanced-constructs/generators.rst

@@ -6,7 +6,7 @@ that the function's state is preserved across the repeated calls of the
 function; this includes the function's local offset at the point it
 yielded a value.
 
-The most straigthforward way to implement a generator is by wrapping all
+The most straightforward way to implement a generator is by wrapping all
 of its state variables (arguments, local variables, and return values)
 up into an ad-hoc structure and then pass the address of that structure
 to the generator.
@@ -24,7 +24,7 @@ The important thing is to think of iterators as a sort of micro-thread
 that is resumed whenever the iterator is called again. In other words,
 we need to save the address of how far the iterator got on each pass
 through so that it can resume as if a microscopic thread switch had
-occured. So we save the address of the instruction after the return
+occurred. So we save the address of the instruction after the return
 instruction so that we can resume running as if we never had returned in
 the first place.
 

appendix-a-how-to-implement-a-string-type-in-llvm/index.rst

@@ -10,7 +10,7 @@ There are two ways to implement a string type in LLVM:
 I'd personally much prefer to use the second method, but for the sake of
 the example, I'll go ahead and illustrate a simple but useful string
 type in LLVM IR. It assumes a 32-bit architecture, so please replace all
-occurences of ``i32`` with ``i64`` if you are targetting a 64-bit
+occurrences of ``i32`` with ``i64`` if you are targeting a 64-bit
 architecture.
 
 We'll be making a dynamic, mutable string type that can be appended to

basic-constructs/functions.rst

@@ -72,7 +72,7 @@ Functions with a Variable Number of Parameters
 
 To call a so-called vararg function, you first need to define or declare
 it using the elipsis (...) and then you need to make use of a special
-syntax for function calls that allows you to explictly list the types of
+syntax for function calls that allows you to explicitly list the types of
 the parameters of the function that is being called. This "hack" exists
 to allow overriding a call to a function such as a function with
 variable parameters. Please notice that you only need to specify the
@@ -184,9 +184,9 @@ This simple example is in turn compiled to
  ret void
  }
 
-We can see that the funtion now actually returns ``void`` and another
+We can see that the function now actually returns ``void`` and another
 parameter was added. The first parameter is a pointer to the result,
-which is allocated by the caller. The pointer has the attirbute
+which is allocated by the caller. The pointer has the attribute
 ``noalias`` because there is no way that one of the parameters might
 point to the same location. The ``sret`` attribute indicates that this
 is the return value.

basic-constructs/global-variables.rst

@@ -1,7 +1,7 @@
 Global Variables
 ----------------
 
-Global varibles are trivial to implement in LLVM IR:
+Global variables are trivial to implement in LLVM IR:
 
 .. code-block:: cpp
 

object-oriented-constructs/multiple-inheritance.rst

@@ -89,7 +89,7 @@ This is equivalent to the following LLVM IR:
  }
 
 And the compiler then supplies the needed type casts and pointer
-arithmentic whenever ``baseB`` is being referenced as an instance
+arithmetic whenever ``baseB`` is being referenced as an instance
 
 of ``BaseB``. Please notice that all it takes is a ``bitcast`` from one
 class to another as well as an adjustment of the last argument to

object-oriented-constructs/virtual-inheritance.rst

@@ -2,7 +2,7 @@ Virtual Inheritance
 -------------------
 
 Virtual inheritance is actually quite simple as it dictates that
-identical base classes are to be merged into a single occurence. For
+identical base classes are to be merged into a single occurrence. For
 instance, given this:
 
 .. code-block:: cpp