]> granicus.if.org Git - gc/commitdiff
Fix typos in comments
authorOndrej Bilka <neleai@seznam.cz>
Thu, 11 Jul 2013 07:57:32 +0000 (11:57 +0400)
committerIvan Maidanski <ivmai@mail.ru>
Thu, 11 Jul 2013 07:59:40 +0000 (11:59 +0400)
* blacklst.c: Fix typo ("even though").
* cord/cordbscs.c: Fix typo ("exponentially").
* cord/cordxtra.c: Fix typo ("represented").
* dyn_load.c: Fix typos ("uncollectible", "occurred").
* extra/AmigaOS: Fix typos ("specific", "necessary", "always",
"effectiveness").
* finalize.c: Fix typo ("descendants").
* include/cord.h: Fix typo ("idiosyncrasies").
* include/gc.h: Fix typo ("collectible").
* include/gc_allocator.h: Fix typos ("allocator", "[un]collectible").
* mach_dep.c: Fix typo ("erroneously").
* malloc.c: Fix typos ("[un]collectible", "pointer-free",
"initialization").
* mallocx.c: Fix typos ("largely", "pointer-free", "uncollectible").
* mark.c: Fix typos ("[un]collectible", "even though").
* misc.c: Fix typo ("erroneously").
* os_dep.c: Fix typos ("non-addressable", "happening", "pointer-free").
* tests/test.c: Fix typos ("uncollectible", "reversed").
* tests/test_cpp.cc: Fix typos ("[un]collectible").
* typd_mlc.c: Fix typo ("copyright").
* win32_threads.c: Fix typos ("optimization", "uncollectible").

20 files changed:
blacklst.c
cord/cordbscs.c
cord/cordxtra.c
dyn_load.c
extra/AmigaOS.c
finalize.c
include/cord.h
include/gc.h
include/gc_allocator.h
include/gc_cpp.h
mach_dep.c
malloc.c
mallocx.c
mark.c
misc.c
os_dep.c
tests/test.c
tests/test_cpp.cc
typd_mlc.c
win32_threads.c

index 77ad6758eacb6c0c75c7a84496a96f3406bc8a2d..dcac51a7af3a7bffd9949ac5d994d7317f75d1bf 100644 (file)
@@ -21,7 +21,7 @@
  * See the definition of page_hash_table in gc_private.h.
  * False hits from the stack(s) are much more dangerous than false hits
  * from elsewhere, since the former can pin a large object that spans the
- * block, eventhough it does not start on the dangerous block.
+ * block, even though it does not start on the dangerous block.
  */
 
 /*
index c7b3b51f2201546ad57d1826cd651f05fc31ca08..a05e6e0425af410050c5d884d0641cb3276b84ae 100644 (file)
@@ -570,7 +570,7 @@ int CORD_riter(CORD x, CORD_iter_fn f1, void * client_data)
  * The following functions are concerned with balancing cords.
  * Strategy:
  * Scan the cord from left to right, keeping the cord scanned so far
- * as a forest of balanced trees of exponentialy decreasing length.
+ * as a forest of balanced trees of exponentially decreasing length.
  * When a new subtree needs to be added to the forest, we concatenate all
  * shorter ones to the new tree in the appropriate order, and then insert
  * the result into the forest.
index fbf8163b1c6057f1b04f2e706534c73d21621732..8597b0611708c4c9ed70f3260ecf5950bce47c34 100644 (file)
@@ -461,7 +461,7 @@ CORD CORD_from_file_eager(FILE * f)
         c = getc(f);
         if (c == 0) {
           /* Append the right number of NULs                            */
-          /* Note that any string of NULs is rpresented in 4 words,     */
+          /* Note that any string of NULs is represented in 4 words,    */
           /* independent of its length.                                 */
             register size_t count = 1;
 
index 5e077b5b61fdb6e56bfd4a801b7aff68202d51fa..215967e955f1c99d30097693c6c801dfc0b7738f 100644 (file)
@@ -335,7 +335,7 @@ STATIC word GC_register_map_entries(char *maps)
               /* away pointers in pieces of the stack segment that we   */
               /* don't scan.  We work around this                       */
               /* by treating anything allocated by libpthread as        */
-              /* uncollectable, as we do in some other cases.           */
+              /* uncollectible, as we do in some other cases.           */
               /* A specifically identified problem is that              */
               /* thread stacks contain pointers to dynamic thread       */
               /* vectors, which may be reused due to thread caching.    */
@@ -1116,7 +1116,7 @@ GC_INNER void GC_register_dynamic_libraries(void)
       /* Get info about next shared library */
         status = shl_get(index, &shl_desc);
 
-      /* Check if this is the end of the list or if some error occured */
+      /* Check if this is the end of the list or if some error occurred */
         if (status != 0) {
 #        ifdef GC_HPUX_THREADS
            /* I've seen errno values of 0.  The man page is not clear   */
index 4c747abdee7d05e69c09bedc00564f4d24e63afe..8f99b746b9d161d26c4e0d0e1fd11ed5a394f18b 100644 (file)
@@ -2,7 +2,7 @@
 
 /******************************************************************
 
-  AmigaOS-spesific routines for GC.
+  AmigaOS-specific routines for GC.
   This file is normally included from os_dep.c
 
 ******************************************************************/
@@ -230,10 +230,10 @@ void *(*GC_amiga_allocwrapper_do)(size_t size,void *(*AllocFunction)(size_t size
 
 
 /******************************************************************
-   Amiga-spesific routines to obtain memory, and force GC to give
+   Amiga-specific routines to obtain memory, and force GC to give
    back fast-mem whenever possible.
         These hacks makes gc-programs go many times faster when
-   the amiga is low on memory, and are therefore strictly necesarry.
+   the Amiga is low on memory, and are therefore strictly necessary.
 
    -Kjetil S. Matheussen, 2000.
 ******************************************************************/
@@ -331,7 +331,7 @@ char *chipmax;
 
 
 /*
- * Allways set to the last size of memory tried to be allocated.
+ * Always set to the last size of memory tried to be allocated.
  * Needed to ensure allocation when the size is bigger than 100000.
  *
  */
@@ -429,7 +429,7 @@ void *GC_amiga_rec_alloc(size_t size,void *(*AllocFunction)(size_t size2),const
 #endif
 
 
-/* The allocating-functions defined inside the amiga-blocks in gc.h is called
+/* The allocating-functions defined inside the Amiga-blocks in gc.h is called
  * via these functions.
  */
 
@@ -437,7 +437,7 @@ void *GC_amiga_rec_alloc(size_t size,void *(*AllocFunction)(size_t size2),const
 void *GC_amiga_allocwrapper_any(size_t size,void *(*AllocFunction)(size_t size2)){
         void *ret,*ret2;
 
-        GC_amiga_dontalloc=TRUE;        // Pretty tough thing to do, but its indeed necesarry.
+        GC_amiga_dontalloc=TRUE;        // Pretty tough thing to do, but its indeed necessary.
         latestsize=size;
 
         ret=(*AllocFunction)(size);
@@ -471,7 +471,7 @@ void *GC_amiga_allocwrapper_any(size_t size,void *(*AllocFunction)(size_t size2)
 #ifdef GC_AMIGA_RETRY
                 else{
                         /* We got chip-mem. Better try again and again and again etc., we might get fast-mem sooner or later... */
-                        /* Using gctest to check the effectiviness of doing this, does seldom give a very good result. */
+                        /* Using gctest to check the effectiveness of doing this, does seldom give a very good result. */
                         /* However, real programs doesn't normally rapidly allocate and deallocate. */
 //                      printf("trying to force... %d bytes... ",size);
                         if(
index 0ca956a464bfc81fe995994acb7b6b125933b0a7..c2e8af026bf1abc6f1ad4150a1b92d83b750b9a7 100644 (file)
@@ -20,7 +20,7 @@
 
 /* Type of mark procedure used for marking from finalizable object.     */
 /* This procedure normally does not mark the object, only its           */
-/* descendents.                                                         */
+/* descendants.                                                         */
 typedef void (* finalization_mark_proc)(ptr_t /* finalizable_obj_ptr */);
 
 #define HASH3(addr,size,log_size) \
index 05eb4c4c1ef55324f8b11029d67d432063a82eab..d3d555b6b970c72acab5d87366db22c04eb385c0 100644 (file)
@@ -326,7 +326,7 @@ CORD_API size_t CORD_rchr(CORD x, size_t i, int c);
 /*    the correct buffer size.                                          */
 /* 4. Most of the conversions are implement through the native          */
 /*    vsprintf.  Hence they are usually no faster, and                  */
-/*    idiosyncracies of the native printf are preserved.  However,      */
+/*    idiosyncrasies of the native printf are preserved.  However,      */
 /*    CORD arguments to CORD_sprintf and CORD_vsprintf are NOT copied;  */
 /*    the result shares the original structure.  This may make them     */
 /*    very efficient in some unusual applications.                      */
index a370deaeab78a2c429d63dd97bf16a300de9e7e8..5b7dae3d73ceca619bd178d15c900ff59e82def2 100644 (file)
@@ -401,8 +401,8 @@ GC_API void GC_CALL GC_init(void);
 /* new object is cleared.  GC_malloc_stubborn promises that no changes  */
 /* to the object will occur after GC_end_stubborn_change has been       */
 /* called on the result of GC_malloc_stubborn.  GC_malloc_uncollectable */
-/* allocates an object that is scanned for pointers to collectable      */
-/* objects, but is not itself collectable.  The object is scanned even  */
+/* allocates an object that is scanned for pointers to collectible      */
+/* objects, but is not itself collectible.  The object is scanned even  */
 /* if it does not appear to be reachable.  GC_malloc_uncollectable and  */
 /* GC_free called on the resulting object implicitly update             */
 /* GC_non_gc_bytes appropriately.                                       */
@@ -954,7 +954,7 @@ GC_API void GC_CALL GC_debug_register_finalizer(void * /* obj */,
         /* allocated by GC_malloc or friends. Obj may also be   */
         /* NULL or point to something outside GC heap (in this  */
         /* case, fn is ignored, *ofn and *ocd are set to NULL). */
-        /* Note that any garbage collectable object referenced  */
+        /* Note that any garbage collectible object referenced  */
         /* by cd will be considered accessible until the        */
         /* finalizer is invoked.                                */
 
index 086fac4b3db3a8cbb0ac88cc9a5871ba39cb55de..367cfe24ff99b47c88915cdf689733162c4a1f0b 100644 (file)
 
 /*
  * This implements standard-conforming allocators that interact with
- * the garbage collector.  Gc_alloctor<T> allocates garbage-collectable
+ * the garbage collector.  Gc_allocator<T> allocates garbage-collectible
  * objects of type T.  Traceable_allocator<T> allocates objects that
  * are not themselves garbage collected, but are scanned by the
- * collector for pointers to collectable objects.  Traceable_alloc
+ * collector for pointers to collectible objects.  Traceable_alloc
  * should be used for explicitly managed STL containers that may
- * point to collectable objects.
+ * point to collectible objects.
  *
  * This code was derived from an earlier version of the GNU C++ standard
  * library, which itself was derived from the SGI STL implementation.
index 6882786b0a5434713f2f60b3e2d031760aaef43d..6f3fce8875641dd63e4f9f54bdbd8a7eae8e8c93 100644 (file)
@@ -24,43 +24,43 @@ basic facilities similar to those described in "Safe, Efficient
 Garbage Collection for C++", by John R. Elis and David L. Detlefs
 (ftp://ftp.parc.xerox.com/pub/ellis/gc).
 
-All heap-allocated objects are either "collectable" or
-"uncollectable".  Programs must explicitly delete uncollectable
+All heap-allocated objects are either "collectible" or
+"uncollectible".  Programs must explicitly delete uncollectible
 objects, whereas the garbage collector will automatically delete
-collectable objects when it discovers them to be inaccessible.
-Collectable objects may freely point at uncollectable objects and vice
+collectible objects when it discovers them to be inaccessible.
+Collectible objects may freely point at uncollectible objects and vice
 versa.
 
-Objects allocated with the built-in "::operator new" are uncollectable.
+Objects allocated with the built-in "::operator new" are uncollectible.
 
-Objects derived from class "gc" are collectable.  For example:
+Objects derived from class "gc" are collectible.  For example:
 
     class A: public gc {...};
-    A* a = new A;       // a is collectable.
+    A* a = new A;       // a is collectible.
 
-Collectable instances of non-class types can be allocated using the GC
+Collectible instances of non-class types can be allocated using the GC
 (or UseGC) placement:
 
     typedef int A[ 10 ];
     A* a = new (GC) A;
 
-Uncollectable instances of classes derived from "gc" can be allocated
+Uncollectible instances of classes derived from "gc" can be allocated
 using the NoGC placement:
 
     class A: public gc {...};
-    A* a = new (NoGC) A;   // a is uncollectable.
+    A* a = new (NoGC) A;   // a is uncollectible.
 
-The new(PointerFreeGC) syntax allows the allocation of collectable
+The new(PointerFreeGC) syntax allows the allocation of collectible
 objects that are not scanned by the collector.  This useful if you
 are allocating compressed data, bitmaps, or network packets.  (In
 the latter case, it may remove danger of unfriendly network packets
 intentionally containing values that cause spurious memory retention.)
 
-Both uncollectable and collectable objects can be explicitly deleted
+Both uncollectible and collectible objects can be explicitly deleted
 with "delete", which invokes an object's destructors and frees its
 storage immediately.
 
-A collectable object may have a clean-up function, which will be
+A collectible object may have a clean-up function, which will be
 invoked when the collector discovers the object to be inaccessible.
 An object derived from "gc_cleanup" or containing a member derived
 from "gc_cleanup" has a default clean-up function that invokes the
@@ -79,7 +79,7 @@ B, B is considered accessible.  After A's clean-up is invoked and its
 storage released, B will then become inaccessible and will have its
 clean-up invoked.  If A points at B and B points to A, forming a
 cycle, then that's considered a storage leak, and neither will be
-collectable.  See the interface gc.h for low-level facilities for
+collectible.  See the interface gc.h for low-level facilities for
 handling such cycles of objects with clean-up.
 
 The collector cannot guarantee that it will find all inaccessible
@@ -96,14 +96,14 @@ add -DGC_OPERATOR_NEW_ARRAY to the Makefile.
 
 If your compiler doesn't support "operator new[]", beware that an
 array of type T, where T is derived from "gc", may or may not be
-allocated as a collectable object (it depends on the compiler).  Use
-the explicit GC placement to make the array collectable.  For example:
+allocated as a collectible object (it depends on the compiler).  Use
+the explicit GC placement to make the array collectible.  For example:
 
     class A: public gc {...};
-    A* a1 = new A[ 10 ];        // collectable or uncollectable?
-    A* a2 = new (GC) A[ 10 ];   // collectable
+    A* a1 = new A[ 10 ];        // collectible or uncollectible?
+    A* a2 = new (GC) A[ 10 ];   // collectible.
 
-3. The destructors of collectable arrays of objects derived from
+3. The destructors of collectible arrays of objects derived from
 "gc_cleanup" will not be invoked properly.  For example:
 
     class A: public gc_cleanup {...};
@@ -250,10 +250,10 @@ inline void* operator new( size_t size, GC_NS_QUALIFY(GCPlacement) gcp,
                           GC_NS_QUALIFY(GCCleanUpFunc) cleanup = 0,
                           void* clientData = 0 );
     /*
-    Allocates a collectable or uncollected object, according to the
+    Allocates a collectible or uncollectible object, according to the
     value of "gcp".
 
-    For collectable objects, if "cleanup" is non-null, then when the
+    For collectible objects, if "cleanup" is non-null, then when the
     allocated object "obj" becomes inaccessible, the collector will
     invoke the function "cleanup( obj, clientData )" but will not
     invoke the object's destructors.  It is an error to explicitly
index dec9e7dfe9dbd24f1ae6c867c827752471dfa31b..9c95e698137d60c6ac2a33318e458b9d7715c90a 100644 (file)
 
 # if defined(M68K) && defined(AMIGA)
     /* This function is not static because it could also be             */
-    /* errorneously defined in .S file, so this error would be caught   */
+    /* erroneously defined in .S file, so this error would be caught    */
     /* by the linker.                                                   */
     void GC_push_regs(void)
     {
index 969dbc3ad041a1beff938ad9207c0c413cda98c2..c1e2ed2cf8bad470273a520a7b158fc1781a7b50 100644 (file)
--- a/malloc.c
+++ b/malloc.c
@@ -222,7 +222,7 @@ GC_API void * GC_CALL GC_generic_malloc(size_t lb, int k)
     }
 }
 
-/* Allocate lb bytes of atomic (pointerfree) data */
+/* Allocate lb bytes of atomic (pointer-free) data. */
 #ifdef THREAD_LOCAL_ALLOC
   GC_INNER void * GC_core_malloc_atomic(size_t lb)
 #else
@@ -288,7 +288,7 @@ GC_API void * GC_CALL GC_generic_malloc(size_t lb, int k)
    }
 }
 
-/* Allocate lb bytes of pointerful, traced, but not collectable data */
+/* Allocate lb bytes of pointerful, traced, but not collectible data.   */
 GC_API void * GC_CALL GC_malloc_uncollectable(size_t lb)
 {
     void *op;
@@ -365,13 +365,10 @@ void * malloc(size_t lb)
     /* But any decent compiler should reduce the extra procedure call   */
     /* to at most a jump instruction in this case.                      */
 #   if defined(I386) && defined(GC_SOLARIS_THREADS)
-      /*
-       * Thread initialisation can call malloc before
-       * we're ready for it.
-       * It's not clear that this is enough to help matters.
-       * The thread implementation may well call malloc at other
-       * inopportune times.
-       */
+      /* Thread initialization can call malloc before we're ready for.  */
+      /* It's not clear that this is enough to help matters.            */
+      /* The thread implementation may well call malloc at other        */
+      /* inopportune times.                                             */
       if (!EXPECT(GC_is_initialized, TRUE)) return sbrk(lb);
 #   endif /* I386 && GC_SOLARIS_THREADS */
     return((void *)REDIRECT_MALLOC(lb));
@@ -417,7 +414,7 @@ void * calloc(size_t n, size_t lb)
       return NULL;
 #   if defined(GC_LINUX_THREADS) /* && !defined(USE_PROC_FOR_LIBRARIES) */
         /* libpthread allocated some memory that is only pointed to by  */
-        /* mmapped thread stacks.  Make sure it's not collectable.      */
+        /* mmapped thread stacks.  Make sure it is not collectible.     */
         {
           static GC_bool lib_bounds_set = FALSE;
           ptr_t caller = (ptr_t)__builtin_return_address(0);
@@ -592,7 +589,7 @@ GC_API void GC_CALL GC_free(void * p)
         {
           /* Don't bother with initialization checks.  If nothing       */
           /* has been initialized, the check fails, and that's safe,    */
-          /* since we haven't allocated uncollectable objects either.   */
+          /* since we have not allocated uncollectible objects neither. */
           ptr_t caller = (ptr_t)__builtin_return_address(0);
           /* This test does not need to ensure memory visibility, since */
           /* the bounds will be set when/if we create another thread.   */
index db265103e8b9e474cdfd8fa877526035e1ea36fe..5cb41a9b885e7fc8121effe5d611d03bf08a5881 100644 (file)
--- a/mallocx.c
+++ b/mallocx.c
@@ -480,7 +480,7 @@ GC_API void * GC_CALL GC_memalign(size_t align, size_t lb)
     return result;
 }
 
-/* This one exists largerly to redirect posix_memalign for leaks finding. */
+/* This one exists largely to redirect posix_memalign for leaks finding. */
 GC_API int GC_CALL GC_posix_memalign(void **memptr, size_t align, size_t lb)
 {
   /* Check alignment properly.  */
@@ -503,7 +503,7 @@ GC_API int GC_CALL GC_posix_memalign(void **memptr, size_t align, size_t lb)
 }
 
 #ifdef ATOMIC_UNCOLLECTABLE
-  /* Allocate lb bytes of pointerfree, untraced, uncollectable data     */
+  /* Allocate lb bytes of pointer-free, untraced, uncollectible data    */
   /* This is normally roughly equivalent to the system malloc.          */
   /* But it may be useful if malloc is redefined.                       */
   GC_API void * GC_CALL GC_malloc_atomic_uncollectable(size_t lb)
diff --git a/mark.c b/mark.c
index 406c06c41dc15c586c598ff31e023387da2fed96..4f1ffb76cd6b0f05691fc54e9cb7034b97901e9e 100644 (file)
--- a/mark.c
+++ b/mark.c
@@ -130,7 +130,7 @@ GC_INNER GC_bool GC_mark_stack_too_small = FALSE;
 static struct hblk * scan_ptr;
 
 STATIC GC_bool GC_objects_are_marked = FALSE;
-                /* Are there collectable marked objects in the heap?    */
+                /* Are there collectible marked objects in the heap?    */
 
 /* Is a collection in progress?  Note that this can return true in the  */
 /* nonincremental case, if a collection has been abandoned and the      */
@@ -149,7 +149,7 @@ GC_INNER void GC_clear_hdr_marks(hdr *hhdr)
     hhdr -> hb_n_marks = 0;
 }
 
-/* Set all mark bits in the header.  Used for uncollectable blocks. */
+/* Set all mark bits in the header.  Used for uncollectible blocks. */
 GC_INNER void GC_set_hdr_marks(hdr *hhdr)
 {
     unsigned i;
@@ -284,7 +284,7 @@ GC_INNER void GC_initiate_gc(void)
 STATIC struct hblk * GC_push_next_marked(struct hblk *h);
                 /* Ditto, but also mark from clean pages.       */
 STATIC struct hblk * GC_push_next_marked_uncollectable(struct hblk *h);
-                /* Ditto, but mark only from uncollectable pages.       */
+                /* Ditto, but mark only from uncollectible pages.       */
 
 static void alloc_mark_stack(size_t);
 
@@ -991,7 +991,7 @@ STATIC void GC_do_local_mark(mse *local_mark_stack, mse *local_top)
             /* Try to share the load, since the main stack is empty,    */
             /* and helper threads are waiting for a refill.             */
             /* The entries near the bottom of the stack are likely      */
-            /* to require more work.  Thus we return those, eventhough  */
+            /* to require more work.  Thus we return those, even though */
             /* it's harder.                                             */
             mse * new_bottom = local_mark_stack
                                 + (local_top - local_mark_stack)/2;
@@ -1866,7 +1866,7 @@ STATIC struct hblk * GC_push_next_marked(struct hblk *h)
   }
 #endif /* !GC_DISABLE_INCREMENTAL */
 
-/* Similar to above, but for uncollectable pages.  Needed since we      */
+/* Similar to above, but for uncollectible pages.  Needed since we      */
 /* do not clear marks for such pages, even for full collections.        */
 STATIC struct hblk * GC_push_next_marked_uncollectable(struct hblk *h)
 {
diff --git a/misc.c b/misc.c
index d89babcd07aae65c974c4c68905d5e313bbbbba4..f0e4480f3d94381736d62d57805195b6bd3b8aaf 100644 (file)
--- a/misc.c
+++ b/misc.c
@@ -323,7 +323,7 @@ GC_INNER void GC_extend_size_map(size_t i)
   void *GC_clear_stack_inner(void *, ptr_t);
 #else
   /* Clear the stack up to about limit.  Return arg.  This function is  */
-  /* not static because it could also be errorneously defined in .S     */
+  /* not static because it could also be erroneously defined in .S      */
   /* file, so this error would be caught by the linker.                 */
   void * GC_clear_stack_inner(void *arg, ptr_t limit)
   {
index 388bc4a4d181b6f55809cf7a7eb96b5fe54d0659..87fdc0d043f64ce5cfc51de10a8e6222076cc0bd 100644 (file)
--- a/os_dep.c
+++ b/os_dep.c
@@ -542,7 +542,7 @@ GC_INNER char * GC_get_maps(void)
      siglongjmp(GC_jmp_buf_openbsd, 1);
   }
 
-  /* Return the first non-addressible location > p or bound.    */
+  /* Return the first non-addressable location > p or bound.    */
   /* Requires the allocation lock.                              */
   STATIC ptr_t GC_find_limit_openbsd(ptr_t p, ptr_t bound)
   {
@@ -2902,13 +2902,13 @@ GC_API GC_push_other_roots_proc GC_CALL GC_get_push_other_roots(void)
    * SIGBUS or SIGSEGV.  We assume no write faults occur in system calls.
    * This means that clients must ensure that system calls don't write
    * to the write-protected heap.  Probably the best way to do this is to
-   * ensure that system calls write at most to POINTERFREE objects in the
+   * ensure that system calls write at most to pointer-free objects in the
    * heap, and do even that only if we are on a platform on which those
    * are not protected.  Another alternative is to wrap system calls
    * (see example for read below), but the current implementation holds
    * applications.
    * We assume the page size is a multiple of HBLKSIZE.
-   * We prefer them to be the same.  We avoid protecting POINTERFREE
+   * We prefer them to be the same.  We avoid protecting pointer-free
    * objects only if they are the same.
    */
 # ifdef DARWIN
@@ -3431,7 +3431,7 @@ STATIC void GC_protect_heap(void)
 }
 
 /* We assume that either the world is stopped or its OK to lose dirty   */
-/* bits while this is happenning (as in GC_enable_incremental).         */
+/* bits while this is happening (as in GC_enable_incremental).          */
 GC_INNER void GC_read_dirty(void)
 {
 #   if defined(GWW_VDB)
index 15c0e110f306a0c32ac6d32210cb95e7e90cc5e6..12baa943d63a0e1bc288bbd02352c6d179f667c7 100644 (file)
@@ -402,7 +402,7 @@ sexpr gcj_ints(int low, int up)
 }
 #endif /* GC_GCJ_SUPPORT */
 
-/* To check uncollectable allocation we build lists with disguised cdr  */
+/* To check uncollectible allocation we build lists with disguised cdr  */
 /* pointers, and make sure they don't go away.                          */
 sexpr uncollectable_ints(int low, int up)
 {
@@ -623,7 +623,7 @@ void *GC_CALLBACK reverse_test_inner(void *data)
       h[1999] = gcj_ints(1,200);
       for (i = 0; i < 51; ++i)
         h[1999] = gcj_reverse(h[1999]);
-      /* Leave it as the reveresed list for now. */
+      /* Leave it as the reversed list for now. */
 #   else
       h[1999] = ints(1,200);
 #   endif
index dd11b92791b03fe54f761c8d22f78cf55b4126a0..1a413774de751734f049aad76343c4a012d70ab2 100644 (file)
@@ -77,7 +77,7 @@ extern "C" {
 #endif
 
 class A {public:
-    /* An uncollectable class. */
+    /* An uncollectible class. */
 
     A( int iArg ): i( iArg ) {}
     void Test( int iArg ) {
@@ -86,7 +86,7 @@ class A {public:
 
 
 class B: public GC_NS_QUALIFY(gc), public A { public:
-    /* A collectable class. */
+    /* A collectible class. */
 
     B( int j ): A( j ) {}
     ~B() {
@@ -99,7 +99,7 @@ int B::deleting = 0;
 
 
 class C: public GC_NS_QUALIFY(gc_cleanup), public A { public:
-    /* A collectable class with cleanup and virtual multiple inheritance. */
+    /* A collectible class with cleanup and virtual multiple inheritance. */
 
     C( int levelArg ): A( levelArg ), level( levelArg ) {
         nAllocated++;
@@ -130,7 +130,7 @@ int C::nAllocated = 0;
 
 
 class D: public GC_NS_QUALIFY(gc) { public:
-    /* A collectable class with a static member function to be used as
+    /* A collectible class with a static member function to be used as
     an explicit clean-up function supplied to ::new. */
 
     D( int iArg ): i( iArg ) {
@@ -151,7 +151,7 @@ int D::nAllocated = 0;
 
 
 class E: public GC_NS_QUALIFY(gc_cleanup) { public:
-    /* A collectable class with clean-up for use by F. */
+    /* A collectible class with clean-up for use by F. */
 
     E() {
         nAllocated++;}
@@ -166,7 +166,7 @@ int E::nAllocated = 0;
 
 
 class F: public E {public:
-    /* A collectable class with clean-up, a base with clean-up, and a
+    /* A collectible class with clean-up, a base with clean-up, and a
     member with clean-up. */
 
     F() {
@@ -242,9 +242,9 @@ int APIENTRY WinMain( HINSTANCE instance ATTR_UNUSED,
     for (iters = 1; iters <= n; iters++) {
         GC_printf( "Starting iteration %d\n", iters );
 
-            /* Allocate some uncollectable As and disguise their pointers.
+            /* Allocate some uncollectible As and disguise their pointers.
             Later we'll check to see if the objects are still there.  We're
-            checking to make sure these objects really are uncollectable. */
+            checking to make sure these objects really are uncollectible. */
         GC_word as[ 1000 ];
         GC_word bs[ 1000 ];
         for (i = 0; i < 1000; i++) {
@@ -264,7 +264,7 @@ int APIENTRY WinMain( HINSTANCE instance ATTR_UNUSED,
             (void)f;
             if (0 == i % 10) delete c;}
 
-            /* Allocate a very large number of collectable As and Bs and
+            /* Allocate a very large number of collectible As and Bs and
             drop the references to them immediately, forcing many
             collections. */
         for (i = 0; i < 1000000; i++) {
@@ -284,7 +284,7 @@ int APIENTRY WinMain( HINSTANCE instance ATTR_UNUSED,
 #           endif
             }
 
-            /* Make sure the uncollectable As and Bs are still there. */
+            /* Make sure the uncollectible As and Bs are still there. */
         for (i = 0; i < 1000; i++) {
             A* a = (A*) Undisguise( as[ i ] );
             B* b = (B*) Undisguise( bs[ i ] );
index ef191e525bbb6842d06e879c6647e32b2b8a5f3d..00f78ce569f3c0b57049d46c2f966f7904c9ad00 100644 (file)
@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
- * opyright (c) 1999-2000 by Hewlett-Packard Company.  All rights reserved.
+ * Copyright (c) 1999-2000 by Hewlett-Packard Company.  All rights reserved.
  *
  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
  * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
index 050af5eb754ea55ee594077d4f1e89a05f1a9c40..a241e9306fa944321417a46c4c2eb21f340c6930 100644 (file)
@@ -1367,7 +1367,7 @@ STATIC word GC_push_stack_for(GC_thread thread, DWORD me)
 
     /* Push all registers that might point into the heap.  Frame        */
     /* pointer registers are included in case client code was           */
-    /* compiled with the 'omit frame pointer' optimisation.             */
+    /* compiled with the 'omit frame pointer' optimization.             */
 #   define PUSH1(reg) GC_push_one((word)context.reg)
 #   define PUSH2(r1,r2) (PUSH1(r1), PUSH1(r2))
 #   define PUSH4(r1,r2,r3,r4) (PUSH2(r1,r2), PUSH2(r3,r4))
@@ -2667,7 +2667,7 @@ GC_INNER void GC_thr_init(void)
     start = si -> start_routine;
     start_arg = si -> arg;
 
-    GC_free(si); /* was allocated uncollectable */
+    GC_free(si); /* was allocated uncollectible */
 
     pthread_cleanup_push(GC_thread_exit_proc, (void *)me);
     result = (*start)(start_arg);