Fix a few typos.

book/a-map-of-the-territory.md

@@ -373,7 +373,7 @@ collector going in order to reclaim unused bits. If our language supports
 "instance of" tests so you can see what kind of object you have, then we need
 some representation to keep track of the type of each object during execution.
 
-All of this stuff is going at runtime, so it's called, appropriately, the
+All of this stuff is going on at runtime, so it's called, appropriately, the
 **runtime**. In a fully compiled language, the code implementing the runtime
 gets inserted directly into the resulting executable. In, say, [Go][], each
 compiled application has its own copy of Go's runtime directly embedded in it.

book/resolving-and-binding.md

@@ -621,7 +621,7 @@ analysis, we immediately traverse into the body right then and there.
 
 ### Resolving the other syntax tree nodes
 
-That covers the interesting corners of the grammars. We handle every place where
+That covers the interesting corners of the grammar. We handle every place where
 a variable is declared, read, or written, and every place where a scope is
 created or destroyed. Even though they aren't affected by variable resolution,
 we also need visit methods for all of the other syntax tree nodes in order to

book/strings.md

@@ -209,7 +209,7 @@ That's bad if the expression has side effects. If we put the body of
 `isObjType()` into the macro definition and then you did, say,
 
 ```c
-IS_STRING(POP())
+IS_STRING(pop())
 ```
 
 then it would pop two values off the stack! Using a function fixes that.

book/superclasses.md

@@ -504,7 +504,7 @@ the given class's method table and creates an ObjBoundMethod to bundle the
 resulting closure to the current instance.
 
 The key <span name="field">difference</span> is *which* class we pass to
-`bindMethod()`. With a normal property access, we use the ObjInstances's own
+`bindMethod()`. With a normal property access, we use the ObjInstance's own
 class, which gives us the dynamic dispatch we want. For a super call, we don't
 use the instance's class. Instead, we use the statically resolved superclass of
 the containing class, which the compiler has conveniently ensured is sitting on

book/types-of-values.md

@@ -595,7 +595,7 @@ each token type. We add cases for the six new operators.
 ^code comparison-operators (1 before, 1 after)
 
 The `==`, `<`, and `>` operators output a single instruction. The others output
-a pair of instructions, one to evalute the inverse operation, and then an
+a pair of instructions, one to evaluate the inverse operation, and then an
 `OP_NOT` to flip the result. Six operators for the price of three instructions!
 
 That means over in the VM, our job is simpler. Equality is the most general

site/a-map-of-the-territory.html

@@ -370,7 +370,7 @@ <h3><a href="#runtime" id="runtime"><small>2&#8202;.&#8202;1&#8202;.&#8202;8</sm
 collector going in order to reclaim unused bits. If our language supports
 &ldquo;instance of&rdquo; tests so you can see what kind of object you have, then we need
 some representation to keep track of the type of each object during execution.</p>
-<p>All of this stuff is going at runtime, so it&rsquo;s called, appropriately, the
+<p>All of this stuff is going on at runtime, so it&rsquo;s called, appropriately, the
 <strong>runtime</strong>. In a fully compiled language, the code implementing the runtime
 gets inserted directly into the resulting executable. In, say, <a href="https://golang.org/">Go</a>, each
 compiled application has its own copy of Go&rsquo;s runtime directly embedded in it.

site/resolving-and-binding.html

@@ -731,7 +731,7 @@ <h3><a href="#resolving-function-declarations" id="resolving-function-declaratio
 doesn&rsquo;t get touched until later when the function is called. In a <em>static</em>
 analysis, we immediately traverse into the body right then and there.</p>
 <h3><a href="#resolving-the-other-syntax-tree-nodes" id="resolving-the-other-syntax-tree-nodes"><small>11&#8202;.&#8202;3&#8202;.&#8202;6</small>Resolving the other syntax tree nodes</a></h3>
-<p>That covers the interesting corners of the grammars. We handle every place where
+<p>That covers the interesting corners of the grammar. We handle every place where
 a variable is declared, read, or written, and every place where a scope is
 created or destroyed. Even though they aren&rsquo;t affected by variable resolution,
 we also need visit methods for all of the other syntax tree nodes in order to

site/superclasses.html

@@ -656,7 +656,7 @@ <h3><a href="#executing-super-accesses" id="executing-super-accesses"><small>29&
 the given class&rsquo;s method table and creates an ObjBoundMethod to bundle the
 resulting closure to the current instance.</p>
 <p>The key <span name="field">difference</span> is <em>which</em> class we pass to
-<code>bindMethod()</code>. With a normal property access, we use the ObjInstances&rsquo;s own
+<code>bindMethod()</code>. With a normal property access, we use the ObjInstance&rsquo;s own
 class, which gives us the dynamic dispatch we want. For a super call, we don&rsquo;t
 use the instance&rsquo;s class. Instead, we use the statically resolved superclass of
 the containing class, which the compiler has conveniently ensured is sitting on

site/types-of-values.html

@@ -824,7 +824,7 @@ <h3><a href="#equality-and-comparison-operators" id="equality-and-comparison-ope
 <div class="source-file-narrow"><em>compiler.c</em>, in <em>binary</em>()</div>
 
 <p>The <code>==</code>, <code>&lt;</code>, and <code>&gt;</code> operators output a single instruction. The others output
-a pair of instructions, one to evalute the inverse operation, and then an
+a pair of instructions, one to evaluate the inverse operation, and then an
 <code>OP_NOT</code> to flip the result. Six operators for the price of three instructions!</p>
 <p>That means over in the VM, our job is simpler. Equality is the most general
 operation.</p>