Fix typos.

code/addrobj.c

@@ -205,7 +205,7 @@ int main(int argc, char *argv[])
 
   test_main();
 
-  printf("%s: Conculsion, failed to find any defects.\n", argv[0]);
+  printf("%s: Conclusion, failed to find any defects.\n", argv[0]);
 
   return 0;
 }

code/arena.c

@@ -987,7 +987,7 @@ Res ArenaFreeLandDelete(Arena arena, Addr base, Addr limit)
 }
 
 
-/* ArenaFreeLandAlloc -- allocate a continguous range of tracts of
+/* ArenaFreeLandAlloc -- allocate a contiguous range of tracts of
  * size bytes from the arena's free land.
  *
  * size, zones, and high are as for LandFindInZones.

code/commpre.nmk

@@ -7,7 +7,7 @@
 #
 # .description: This makefile fragment is included in more specific
 # makefiles for platforms which use the "mv" builder.  This is
-# the first of two common makefile fragements (the other is commpost.nmk).
+# the first of two common makefile fragments (the other is commpost.nmk).
 # Alas, due to shortcomings in nmake, it is not possible to use only one
 # common fragment.
 #
@@ -41,7 +41,7 @@
 #
 # EDITING
 #
-# To add new targets. varieties, and parts:
+# To add new targets, varieties, and parts:
 # Search for the string "%%TARGET", "%%VARIETY", or "%%PART" in this makefile
 # and follow the instructions.
 #

code/dbgpool.c

@@ -333,7 +333,7 @@ static Bool patternCheck(ReadonlyAddr pattern, Size size, Addr base, Addr limit)
 
 /* debugPoolSegIterate -- iterate over a range of segments in an arena
  *
- * Expects to be called on a range corresponding to objects withing a
+ * Expects to be called on a range corresponding to objects within a
  * single pool.
  *
  * NOTE: This relies on pools consistently using segments

code/gcbench.c

@@ -139,7 +139,7 @@ static obj_t new_tree(mps_ap_t ap, obj_t oldtree, unsigned d)
 
 /* Update tree to be identical tree but with nodes reallocated
  * with probability pupdate.  This avoids writing to vector slots
- * if unecessary. */
+ * if unnecessary. */
 static obj_t update_tree(mps_ap_t ap, obj_t oldtree, unsigned d)
 {
   obj_t tree;

code/ld.c

@@ -171,7 +171,7 @@ void LDReset(mps_ld_t ld, Arena arena)
  * .add.sync: Add must take place _before_ the location of the reference
  * is depended on.  If the reference changes between adding and
  * depending it will show up as moved because the movement will have
- * occured since the epoch recorded in the dependency.  If the location
+ * occurred since the epoch recorded in the dependency.  If the location
  * were used first only the new location of the reference would end up
  * in the set.
  *
@@ -212,7 +212,7 @@ void LDAdd(mps_ld_t ld, Arena arena, Addr addr)
  * to use the prehistory instead.
  *
  * .stale.old: Otherwise, if the dependency is older than the length
- * of the history, check it against all movement that has ever occured.
+ * of the history, check it against all movement that has ever occurred.
  */
 Bool LDIsStaleAny(mps_ld_t ld, Arena arena)
 {

code/mpsi.c

@@ -58,7 +58,7 @@ SRCID(mpsi, "$Id$");
 /* mpsi_check -- check consistency of interface mappings
  *
  * .check.purpose: The mpsi_check function attempts to check whether
- * the defintions in <code/mpsi.h> match the equivalent definition in
+ * the definitions in <code/mpsi.h> match the equivalent definition in
  * the MPM.  It is checking the assumptions made in the other functions
  * in this implementation.
  *

code/policy.c

@@ -22,7 +22,7 @@ SRCID(policy, "$Id$");
  *
  * pref describes the address space preferences for the allocation.
  * size is the amount of memory requested to be allocated, in bytes.
- * pool is the pool that is requresting the memory.
+ * pool is the pool that is requesting the memory.
  *
  * If successful, update *tractReturn to point to the initial tract of
  * the allocated memory and return ResOK. Otherwise return a result
@@ -198,7 +198,7 @@ Bool PolicyShouldCollectWorld(Arena arena, double availableTime,
 }
 
 
-/* policyCondemnChain -- condemn approriate parts of this chain
+/* policyCondemnChain -- condemn appropriate parts of this chain
  *
  * If successful, set *mortalityReturn to an estimate of the mortality
  * of the condemned parts of this chain and return ResOK.

code/pool.c

@@ -59,7 +59,7 @@ Bool PoolClassCheck(PoolClass klass)
   CHECKL(FUNCHECK(klass->freeSize));
   CHECKL(FUNCHECK(klass->addrObject));
 
-  /* Check that pool classes overide sets of related methods. */
+  /* Check that pool classes override sets of related methods. */
   CHECKL((klass->init == PoolAbsInit) ==
          (klass->instClassStruct.finish == PoolAbsFinish));
   CHECKL((klass->bufferFill == PoolNoBufferFill) ==

code/poolamc.c

@@ -83,7 +83,7 @@ enum {
 /* amcSegStruct -- AMC-specific fields appended to GCSegStruct
  *
  * .seg.accounted-as-buffered: The "accountedAsBuffered" flag is TRUE
- * if the segment has an atached buffer and is accounted against the
+ * if the segment has an attached buffer and is accounted against the
  * pool generation's bufferedSize. But note that if this is FALSE, the
  * segment might still have an attached buffer -- this happens if the
  * segment was condemned while the buffer was attached.

code/poolawl.c

@@ -424,7 +424,7 @@ static void AWLNoteScan(Seg seg, ScanState ss)
         /* This is "successful" scan at proper rank. */
         ++ awl->stats.goodScans;
         if (0 < awlseg->singleAccesses) {
-          /* Accesses have been proceesed singly. Record that we
+          /* Accesses have been processed singly. Record that we
            * genuinely did save a protection-provoked scan */
           ++ awl->stats.savedScans;
           awl->stats.savedAccesses += awlseg->singleAccesses;

code/poolmrg.c

@@ -679,7 +679,7 @@ static void MRGFinish(Inst inst)
   /* We call RingRemove on the master node for the rings, thereby */
   /* effectively emptying them, but leaving the rest of the ring */
   /* "dangling".  This is okay as we are about to destroy all the */
-  /* segments so the contents of the rings will dissappear soon. */
+  /* segments so the contents of the rings will disappear soon. */
 
   /* .finish.no-final: Note that this relies on the fact that no */
   /* Guardians are in the FINAL state and hence on the Arena Message */

code/shield.c

@@ -89,7 +89,7 @@ Bool ShieldCheck(Shield shield)
      remember to sync it before we return to the mutator. */
   CHECKL(shield->limit + shield->queuePending >= shield->unsynced);
 
-  /* The mutator is suspeneded if there are any holds. */
+  /* The mutator is suspended if there are any holds. */
   CHECKL(shield->holds == 0 || shield->suspended);
 
   /* This is too expensive to check all the time since we have an

code/splay.c

@@ -717,7 +717,7 @@ static Compare SplaySplay(SplayTree splay, TreeKey key,
 #endif
 
   /* Short-circuit common cases.  Splay trees often bring recently
-     acccessed nodes to the root. */
+     accessed nodes to the root. */
   if (SplayTreeIsEmpty(splay) ||
       compare(SplayTreeRoot(splay), key) == CompareEQUAL)
     return CompareEQUAL;
@@ -1337,7 +1337,7 @@ Bool SplayFindLast(Tree *nodeReturn, SplayTree splay,
  * node affected by the change in properties at the given node (which has
  * the given key) in an appropriate order.
  *
- * The function fullfils its job by first splaying at the given node, and
+ * The function fulfils its job by first splaying at the given node, and
  * updating the single node.  In the MPS it is used by the CBS during
  * coalescing, when the node is likely to be at (or adjacent to) the top
  * of the tree anyway.

code/tagtest.c

@@ -22,7 +22,7 @@ typedef struct cons_s {
 } cons_s, *cons_t;
 
 typedef mps_word_t imm_t;       /* Immediate value. */
-typedef mps_word_t fwd_t;       /* Fowarding pointer. */
+typedef mps_word_t fwd_t;       /* Forwarding pointer. */
 
 static mps_word_t tag_bits;     /* Number of tag bits */
 static mps_word_t tag_cons;     /* Tag bits indicating pointer to cons */

code/trans.c

@@ -179,7 +179,7 @@ Res TransformAddOldNew(Transform transform,
 
     /* .old-white: Old refs must be in managed memory, because
        transformFix is only reached when a reference is to something
-       in the condemned set.  Other referenes are eliminated by
+       in the condemned set.  Other references are eliminated by
        TraceFix, and we can't (currently) transformation of them. */
     {
       Seg seg;

design/finalize.txt

@@ -114,7 +114,7 @@ is that if an object is finalized multiple times, then multiple
 guardians are created in the final pool, and so multiple messages will
 be posted to the message queue when the object is determined to be
 finalizable. But this behaviour is not guaranteed by the
-documentation, leaving us free to change the iplementation.
+documentation, leaving us free to change the implementation.
 
 _`.int.finalize.write`: Writes a reference to the object into the
 guardian object.

design/freelist.txt

@@ -116,7 +116,7 @@ it is merged with adjacent ranges so as to maintain
 
 _`.impl.rule.break`: The use of ``freelistEND`` to mark the end of the
 list violates the rule that exceptional values should not be used to
-distinguish exeptional situations. This infraction allows the
+distinguish exceptional situations. This infraction allows the
 implementation to meet `.req.zero-overhead`_. (There are other ways to
 do this, such as using another tag to indicate the last block in the
 list, but these would be more complicated.)

design/io.txt

@@ -164,7 +164,7 @@ modify their modules.
 _`.if.msg.dgram`: Neither the MPM nor the external tools should assume
 that the messages will be delivered in finite time, exactly once, or
 in order. This will allow the I/O modules to be implemented using
-unreliable transport layers such as the Internet User Datagram Protocl
+unreliable transport layers such as the Internet User Datagram Protocol
 (UDP). It will also give the I/O module the freedom to drop
 information rather than block on a congested network, or stop the
 memory manager when the disk is full, or similar events which really

design/message-gc.txt

@@ -139,7 +139,7 @@ collections in those circumstances.
 
 _`.req.queue`: Must support a client that enables, but does not
 promptly retrieve, GC messages. Messages that have not yet been
-retrived must remain queued, and the client must be able to retrieve
+retrieved must remain queued, and the client must be able to retrieve
 them later without loss. It is not acceptable to stop issuing GC
 messages for subsequent collections merely because messages from
 previous collections have not yet been retrieved. _`.req.queue.why`:
@@ -185,7 +185,7 @@ using ``ControlAlloc()``.
 
     .. _job001570: https://www.ravenbrook.com/project/mps/issue/job001570/
 
-Poiters to these messages are stored in ``tsMessage[ti]`` and
+Pointers to these messages are stored in ``tsMessage[ti]`` and
 ``tMessage[ti]`` arrays in the ``ArenaStruct``.
 
 .. note::

design/nailboard.txt

@@ -50,7 +50,7 @@ is *no* ambiguous reference to that address, but that can only be
 established when the trace is complete.)
 
 _`.req.range`: A nailboard must be able to determine if any nail is
-set in a continguous range. (Because we must preserve the whole object
+set in a contiguous range. (Because we must preserve the whole object
 if there is any ambiguous reference to it.)
 
 _`.req.range.cost`: Determining if any nail is set in a continuous

design/object-debug.txt

@@ -130,7 +130,7 @@ in the fencepost pattern. Possibly something like this (while we could
 still store the parameters in the pool or allocation point, there
 seems little point in doing so in this case, and having them as
 explicit parameters to the macros allows the client to specify
-constants to gain effiency)::
+constants to gain efficiency)::
 
     #define mps_add_fencepost(size, fp_size)
     #define mps_fill_fenceposts(obj, size, fp_size, fp_pattern)
@@ -227,7 +227,7 @@ problem; we can turn features on or off with pool init parameters.
 
 _`.fence.pool.abstract`: We could simply use pool init parameters only
 to control all debugging features (optargs would be useful here).
-While there migh be subclasses and wrappers internally, the client
+While there might be subclasses and wrappers internally, the client
 would only see a single pool class; in the internal view, this would
 be an abstract class, and the parameters would determine which
 concrete class actually gets instantiated.
@@ -325,7 +325,7 @@ _`.interface.fenceposting.format`: A function to wrap a format
 ``typedef void (*mps_fmt_adjust_fencepost_t)(size_t *size_io)``
 
 _`.interface.fenceposting.adjust`: A format method to adjust size of a
-block about to be allocted to allow for fenceposts.
+block about to be allocated to allow for fenceposts.
 
 ``typedef void (*mps_fmt_put_fencepost_t)(mps_addr_t * addr_io, size_t size)``
 

design/pool.txt

@@ -45,7 +45,7 @@ _`.struct.outer`: The *outer structure* of a pool belonging to the ABC
 pool class is a C object of type ``ABCPoolStruct``, which is a typedef
 for ``struct PoolABCStruct``.
 
-_`.stuct.outer.sig`: See `design.mps.sig.field.end.outer`_.
+_`.struct.outer.sig`: See `design.mps.sig.field.end.outer`_.
 
 .. _design.mps.sig.field.end.outer: sig.txt#field-end-outer
 

design/poolams.txt

@@ -219,7 +219,7 @@ white sets, each trace needs its own set of tables.
 
 _`.colour.check`: The grey-and-non-white state is illegal, and free
 objects must be white as explained in
-analysis.non-moving-colour.contraint.reclaim.
+analysis.non-moving-colour.constraint.reclaim.
 
 
 Iteration

design/poolmvt.txt

@@ -171,10 +171,10 @@ with a particular response time or throughput, just so long as we
 don't block for too long. Clearly there is a missing requirement.]
 
 _`.req.attr.performance.time`: By inference, the time overhead must be
-competetive.
+competitive.
 
 _`.req.attr.performance.space`: By inference, the space overhead must
-be competetive.
+be competitive.
 
 _`.req.attr.reliability`: The pool class must have "rock-solid
 reliability" (source: req.dylan.attr.rel.mtbf, req.epcore.attr.rel,

design/prot.txt

@@ -108,7 +108,7 @@ if write accesses to the range are to be forbidden, and contains the
 ``AccessREAD`` bit if read accesses to the range are to be forbidden.
 
 _`.if.set.read`: If the request is to forbid read accesses (that is,
-``AccessREAD`` is set) then the implemntation may also forbid write
+``AccessREAD`` is set) then the implementation may also forbid write
 accesses, but read accesses must not be forbidden unless
 ``AccessREAD`` is set.
 

design/pthreadext.txt

@@ -213,10 +213,10 @@ object with other objects corresponding to the same thread (same
 suspended state, or when this is the only ``PThreadext`` object with
 this ``id`` in the suspended state, this ring is single.
 
-_`.impl.global.suspend-ring`: The module maintains a global varaible
+_`.impl.global.suspend-ring`: The module maintains a global variable
 ``suspendedRing``, a ring of ``PThreadext`` objects which are in a
 suspended state. This is primarily so that it's possible to determine
-whether a thread is curently suspended anyway because of another
+whether a thread is currently suspended anyway because of another
 ``PThreadext`` object, when a suspend attempt is made.
 
 _`.impl.global.victim`: The module maintains a global variable

design/range.txt

@@ -130,7 +130,7 @@ Document history
 
 - 2013-05-21 GDR_ Created.
 - 2014-01-15 GDR_ Added ``RangeContains()``.
-- 2016-03-27 RB_ Addded ``RangeSetBase()`` and ``RangeSetLimit()``.
+- 2016-03-27 RB_ Added ``RangeSetBase()`` and ``RangeSetLimit()``.
 
 .. _GDR: https://www.ravenbrook.com/consultants/gdr/
 .. _RB: https://www.ravenbrook.com/consultants/rb/

design/strategy.txt

@@ -267,7 +267,7 @@ Debit *total*, credit *free*. (But see `.account.total.negated`_.)
 _`.accounting.op.free`: Free a segment. First, ensure that the
 contents of the segment are accounted as free, by artificially ageing
 any memory accounted as *new* or *newDeferred* (see
-`.accounting.op.age`_) and then artifically reclaiming any memory
+`.accounting.op.age`_) and then artificially reclaiming any memory
 accounted as *old* or *oldDeferred* (see `.accounting.op.reclaim`_).
 Finally, debit *free*, credit *total*. (But see
 `.account.total.negated`_.)

design/write-barrier.txt

@@ -94,7 +94,7 @@ _`.deferral.reset`: The count is reset after three events:
 
   3. a barrier hit (``WB_DEFER_HIT``)
 
-_`.deferral.dabble`: The set of objects condemend by the garbage
+_`.deferral.dabble`: The set of objects condemned by the garbage
 collector changes, and so does what is interesting or boring.  For
 example, a collection of a nursery space in zone 3 might be followed
 by a collection of a top generation in zone 7.  This will upset
@@ -107,7 +107,7 @@ Improvements
 
 _`.improv.by-os`: The overheads hardware barriers varies widely between
 operating systems.  On Windows it is very cheap to change memory
-protection and to handle protecion faults.  On macOS it is very
+protection and to handle protection faults.  On macOS it is very
 expensive.  The balance between barriers and scanning work is
 different.  We should measure the relative costs and tune the deferral
 for each separately.

manual/source/release.rst

@@ -846,7 +846,7 @@ New features
 
 #. The new pool class :ref:`pool-mvt` provides manually managed
    allocation of variable-size objects using a *temporal fit*
-   allocation policy (that is, objects that are allocated togther are
+   allocation policy (that is, objects that are allocated together are
    expected to be freed together).
 
 

manual/source/topic/arena.rst

@@ -1172,7 +1172,7 @@ not access any memory managed by the MPS.
 
 .. note::
 
-    The extenstion callback is also called immediately after the arena
+    The extension callback is also called immediately after the arena
     is created, in other words, the creation of the arena is treated as
     a special example of an extension of the arena.
 

manual/source/topic/cache.rst

@@ -36,7 +36,7 @@ Allocations through the cache (using :c:func:`mps_sac_alloc` or
 :c:macro:`MPS_SAC_ALLOC_FAST`) are serviced from the cache if possible,
 otherwise from the pool. Similarly, deallocations through the cache
 (using :c:func:`mps_sac_free` or :c:macro:`MPS_SAC_FREE_FAST`) return
-the block to the appopriate free list for its size. For example::
+the block to the appropriate free list for its size. For example::
 
     Foo *foo;
     mps_addr_t p;

manual/source/topic/debugging.rst

@@ -42,7 +42,7 @@ debugging:
   :dfn:`free space splatting` overwrites recycled space with a pattern
   of data. If the pattern is designed so that it does not resemble a
   live object (and if code checks the consistency of its data
-  structues), then this helps to detect :term:`dangling pointer`
+  structures), then this helps to detect :term:`dangling pointer`
   dereferences. The pattern is checked just before allocation, and
   when a block of memory is released from the pool to the arena, to
   see that it is unchanged. All free space in a pool can be checked

manual/source/topic/format.rst

@@ -27,7 +27,7 @@ the means by which the client program communicates this information to
 the MPS.
 
 An object format is a collection of :term:`format methods` and other
-(usually scalar) values which together describe programatically the
+(usually scalar) values which together describe programmatically the
 layout of objects belonging to the format. Format methods include the
 :term:`skip method` (which calculates an object's size), the
 :term:`scan method` (which :term:`fixes <fix>` references in the