summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorOndrej Bilka <neleai@seznam.cz>2013-07-11 09:57:32 +0200
committerIvan Maidanski <ivmai@mail.ru>2013-07-11 09:59:40 +0200
commitaf453022720d3ae2f0f7ecb0f11029421e553abb (patch)
tree16451cac8bb7e2f5a869fb9a77447208df9a578a
parent5f52b60915bc7effa5d68ea7da8c29584806e9ce (diff)
Fix typos in comments
* 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").
-rw-r--r--blacklst.c2
-rw-r--r--cord/cordbscs.c2
-rw-r--r--cord/cordxtra.c2
-rw-r--r--dyn_load.c4
-rw-r--r--extra/AmigaOS.c14
-rw-r--r--finalize.c2
-rw-r--r--include/cord.h2
-rw-r--r--include/gc.h6
-rw-r--r--include/gc_allocator.h6
-rw-r--r--include/gc_cpp.h42
-rw-r--r--mach_dep.c2
-rw-r--r--malloc.c19
-rw-r--r--mallocx.c4
-rw-r--r--mark.c10
-rw-r--r--misc.c2
-rw-r--r--os_dep.c8
-rw-r--r--tests/test.c4
-rw-r--r--tests/test_cpp.cc20
-rw-r--r--typd_mlc.c2
-rw-r--r--win32_threads.c4
20 files changed, 77 insertions, 80 deletions
diff --git a/blacklst.c b/blacklst.c
index 77ad675..dcac51a 100644
--- a/blacklst.c
+++ b/blacklst.c
@@ -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.
*/
/*
diff --git a/cord/cordbscs.c b/cord/cordbscs.c
index c7b3b51..a05e6e0 100644
--- a/cord/cordbscs.c
+++ b/cord/cordbscs.c
@@ -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.
diff --git a/cord/cordxtra.c b/cord/cordxtra.c
index fbf8163..8597b06 100644
--- a/cord/cordxtra.c
+++ b/cord/cordxtra.c
@@ -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;
diff --git a/dyn_load.c b/dyn_load.c
index 5e077b5..215967e 100644
--- a/dyn_load.c
+++ b/dyn_load.c
@@ -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 */
diff --git a/extra/AmigaOS.c b/extra/AmigaOS.c
index 4c747ab..8f99b74 100644
--- a/extra/AmigaOS.c
+++ b/extra/AmigaOS.c
@@ -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(
diff --git a/finalize.c b/finalize.c
index 0ca956a..c2e8af0 100644
--- a/finalize.c
+++ b/finalize.c
@@ -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) \
diff --git a/include/cord.h b/include/cord.h
index 05eb4c4..d3d555b 100644
--- a/include/cord.h
+++ b/include/cord.h
@@ -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. */
diff --git a/include/gc.h b/include/gc.h
index a370dea..5b7dae3 100644
--- a/include/gc.h
+++ b/include/gc.h
@@ -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. */
diff --git a/include/gc_allocator.h b/include/gc_allocator.h
index 086fac4..367cfe2 100644
--- a/include/gc_allocator.h
+++ b/include/gc_allocator.h
@@ -24,12 +24,12 @@
/*
* 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.
diff --git a/include/gc_cpp.h b/include/gc_cpp.h
index 6882786..6f3fce8 100644
--- a/include/gc_cpp.h
+++ b/include/gc_cpp.h
@@ -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
diff --git a/mach_dep.c b/mach_dep.c
index dec9e7d..9c95e69 100644
--- a/mach_dep.c
+++ b/mach_dep.c
@@ -105,7 +105,7 @@
# 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)
{
diff --git a/malloc.c b/malloc.c
index 969dbc3..c1e2ed2 100644
--- 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. */
diff --git a/mallocx.c b/mallocx.c
index db26510..5cb41a9 100644
--- 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 406c06c..4f1ffb7 100644
--- 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 d89babc..f0e4480 100644
--- 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)
{
diff --git a/os_dep.c b/os_dep.c
index 388bc4a..87fdc0d 100644
--- 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)
diff --git a/tests/test.c b/tests/test.c
index 15c0e11..12baa94 100644
--- a/tests/test.c
+++ b/tests/test.c
@@ -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
diff --git a/tests/test_cpp.cc b/tests/test_cpp.cc
index dd11b92..1a41377 100644
--- a/tests/test_cpp.cc
+++ b/tests/test_cpp.cc
@@ -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 ] );
diff --git a/typd_mlc.c b/typd_mlc.c
index ef191e5..00f78ce 100644
--- a/typd_mlc.c
+++ b/typd_mlc.c
@@ -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.
diff --git a/win32_threads.c b/win32_threads.c
index 050af5e..a241e93 100644
--- a/win32_threads.c
+++ b/win32_threads.c
@@ -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);