diff --git a/Makefile b/Makefile index 613f2ce8f5..8aeec64ba8 100644 --- a/Makefile +++ b/Makefile @@ -794,7 +794,7 @@ binary-catalog-server: # On each supported platform (for an installer build): # # The `client' and `win32-client' targets are also used by -# `distro-buid/drive-clients', which is in turn run by the +# `distro-build/drive-clients', which is in turn run by the # `installers' target. # # For a non-Windows machine, if "build/log" exists, then diff --git a/pkgs/net-lib/net/dns.rkt b/pkgs/net-lib/net/dns.rkt index 96036beada..7f31501204 100644 --- a/pkgs/net-lib/net/dns.rkt +++ b/pkgs/net-lib/net/dns.rkt @@ -262,7 +262,7 @@ ;; Run the given query function, trying until an answer is found (define (try-forwarding k nameserver) (let loop ([nameserver nameserver] [tried (list nameserver)]) - ;; Normally the recusion is done for us, but it's technically optional + ;; Normally the recursion is done for us, but it's technically optional (let-values ([(v ars auth?) (k nameserver)]) (or v (and (not auth?) diff --git a/pkgs/racket-benchmarks/tests/racket/benchmarks/common/cmdline.rkt b/pkgs/racket-benchmarks/tests/racket/benchmarks/common/cmdline.rkt index 5520c8ad24..86bacf029e 100644 --- a/pkgs/racket-benchmarks/tests/racket/benchmarks/common/cmdline.rkt +++ b/pkgs/racket-benchmarks/tests/racket/benchmarks/common/cmdline.rkt @@ -70,7 +70,7 @@ (unless (and (number? v) (exact? v) (positive? v)) - (error 'auto "bad interation count: ~a" n)) + (error 'auto "bad iteration count: ~a" n)) (set! num-iterations v))]) (args impl-or-benchmark impl-or-benchmark))) diff --git a/pkgs/racket-benchmarks/tests/racket/benchmarks/common/kanren.sch b/pkgs/racket-benchmarks/tests/racket/benchmarks/common/kanren.sch index 8d46a91dd8..19203b49cf 100644 --- a/pkgs/racket-benchmarks/tests/racket/benchmarks/common/kanren.sch +++ b/pkgs/racket-benchmarks/tests/racket/benchmarks/common/kanren.sch @@ -3515,7 +3515,7 @@ ; list in our case. ; Because type environments are regular lists, we can build them using -; regular cons. The empty type environemnt is the empty list. The +; regular cons. The empty type environment is the empty list. The ; following is a Kanren relation that searches the associative ; list. We are interested in the first match. diff --git a/pkgs/racket-benchmarks/tests/racket/benchmarks/control/config.rktl b/pkgs/racket-benchmarks/tests/racket/benchmarks/control/config.rktl index 93ac8acbbf..e7f93db982 100644 --- a/pkgs/racket-benchmarks/tests/racket/benchmarks/control/config.rktl +++ b/pkgs/racket-benchmarks/tests/racket/benchmarks/control/config.rktl @@ -10,7 +10,7 @@ ;; Number of iteraitons used for a loop, typically (define N (* L 10)) -;; Number of times to run each benchamrk: +;; Number of times to run each benchmark: (define I 3) (define-syntax times diff --git a/pkgs/racket-benchmarks/tests/racket/benchmarks/hash/config.rkt b/pkgs/racket-benchmarks/tests/racket/benchmarks/hash/config.rkt index 22204dd8f4..5b2f633f64 100644 --- a/pkgs/racket-benchmarks/tests/racket/benchmarks/hash/config.rkt +++ b/pkgs/racket-benchmarks/tests/racket/benchmarks/hash/config.rkt @@ -29,7 +29,7 @@ ;; Number of iteraitons used for a loop, typically (define N (* L 10)) -;; Number of times to run each benchamrk: +;; Number of times to run each benchmark: (define I 3) (define-syntax times diff --git a/pkgs/racket-doc/ffi/examples/magick.rkt b/pkgs/racket-doc/ffi/examples/magick.rkt index fe6e9c7c90..5241f9b78b 100644 --- a/pkgs/racket-doc/ffi/examples/magick.rkt +++ b/pkgs/racket-doc/ffi/examples/magick.rkt @@ -1101,7 +1101,7 @@ _MagickWand -> _ResolutionType) ;; MagickGetImageVirtualPixelMethod returns the virtual pixel method for the -;; sepcified image. +;; specified image. (defmagick* MagickGetImageVirtualPixelMethod : _MagickWand -> _VirtualPixelMethod) diff --git a/pkgs/racket-doc/ffi/examples/sndfile.rkt b/pkgs/racket-doc/ffi/examples/sndfile.rkt index 54474ef870..7a17aa32b6 100644 --- a/pkgs/racket-doc/ffi/examples/sndfile.rkt +++ b/pkgs/racket-doc/ffi/examples/sndfile.rkt @@ -25,7 +25,7 @@ ;; In libsndfile the sndfile object is represented as a pointer. When ;; translating scheme->c the struct will just return the pointer. When ;; translating from c->scheme, ie. creating the object in scheme it will be -;; wrapped by an object finalizer that uses the libsndfile fuction sf_close that +;; wrapped by an object finalizer that uses the libsndfile function sf_close that ;; returns a 0 upon successful termination or an error. (define-struct sndfile (ptr [info #:mutable])) (define _sndfile diff --git a/pkgs/racket-doc/file/scribblings/resource.scrbl b/pkgs/racket-doc/file/scribblings/resource.scrbl index 0deaab729d..37a8e51499 100644 --- a/pkgs/racket-doc/file/scribblings/resource.scrbl +++ b/pkgs/racket-doc/file/scribblings/resource.scrbl @@ -2,7 +2,7 @@ @(require "common.rkt" (for-label file/resource)) @(define-syntax-rule (compat file section indexed-racket what) - @elem{For backward compatibilty, the + @elem{For backward compatibility, the result is @racket[#f] for platforms other than Windows. The registry is @|what| when @racket[file] is @racket[#f] and when @racket[section] is diff --git a/pkgs/racket-doc/help/installer.rkt b/pkgs/racket-doc/help/installer.rkt index 00f862d495..1198ab9b88 100644 --- a/pkgs/racket-doc/help/installer.rkt +++ b/pkgs/racket-doc/help/installer.rkt @@ -3,7 +3,7 @@ setup/dirs) ;; Builds different kinds of executables for different platforms. -;; The `plt-help' executable is for backward compatibity. +;; The `plt-help' executable is for backward compatibility. ;; The `Racket Documentation' executable is to help Windows and ;; Mac users who are completely lost and need something to click. diff --git a/pkgs/racket-doc/json/json.scrbl b/pkgs/racket-doc/json/json.scrbl index 70f16b356c..13389e1815 100644 --- a/pkgs/racket-doc/json/json.scrbl +++ b/pkgs/racket-doc/json/json.scrbl @@ -161,7 +161,7 @@ should represent a JSON ``@tt{null}''. This library uses the Racket Racket symbols are used only as object keys, which are required to be strings in JSON. -Several other options have been used by various libaries. For example, +Several other options have been used by various libraries. For example, Dave Herman's PLaneT library (which has been the basis for this library) uses the @racket[#\nul] character, other libraries for Racket and other Lisps use @racket[(void)], @tt{NIL} (some use it also for JSON diff --git a/pkgs/racket-doc/scribblings/foreign/collect-callback.scrbl b/pkgs/racket-doc/scribblings/foreign/collect-callback.scrbl index e54757e706..ebcd1fe38c 100644 --- a/pkgs/racket-doc/scribblings/foreign/collect-callback.scrbl +++ b/pkgs/racket-doc/scribblings/foreign/collect-callback.scrbl @@ -38,7 +38,7 @@ icon.} (*)(void*, void*, void*)}.} @item{@racket['ptr_ptr->save] corresponds to @cpp{void* (*)(void*, - void*, void*)}, but the result is recored as the current ``save'' + void*, void*)}, but the result is recorded as the current ``save'' value. The current ``save'' value starts as @cpp{NULL}.} @item{@racket['save!_ptr->void] corresponds to @cpp{void (*)(void*, diff --git a/pkgs/racket-doc/scribblings/foreign/com-intf.scrbl b/pkgs/racket-doc/scribblings/foreign/com-intf.scrbl index 83342ecfec..c2af37e58d 100644 --- a/pkgs/racket-doc/scribblings/foreign/com-intf.scrbl +++ b/pkgs/racket-doc/scribblings/foreign/com-intf.scrbl @@ -156,7 +156,7 @@ foreign call as follows: @racket[_fun]) determines the result.} @item{If the result is @cpp{RPC_E_CALL_REJECTED} or - @cpp{RPC_E_SERVERCALL_RETRYLATER}, the call is autmatically + @cpp{RPC_E_SERVERCALL_RETRYLATER}, the call is automatically retried up to @racket[(current-hfun-retry-count)] times with a delay of @racket[(current-hfun-retry-delay)] seconds between each attempt.} diff --git a/pkgs/racket-doc/scribblings/guide/concurrency.scrbl b/pkgs/racket-doc/scribblings/guide/concurrency.scrbl index cab2cd2083..01fe4cc1c4 100644 --- a/pkgs/racket-doc/scribblings/guide/concurrency.scrbl +++ b/pkgs/racket-doc/scribblings/guide/concurrency.scrbl @@ -580,7 +580,7 @@ to wait until at least a certain number of items have been produced. (code:comment "production") (cond [(>= (car waiter) total-items-seen) - (code:comment "if so, we send a mesage back on the channel") + (code:comment "if so, we send a message back on the channel") (code:comment "and continue the loop without that item") (handle-evt (channel-put-evt diff --git a/pkgs/racket-doc/scribblings/inside/ports.scrbl b/pkgs/racket-doc/scribblings/inside/ports.scrbl index d16b8d36b0..55060c97e6 100644 --- a/pkgs/racket-doc/scribblings/inside/ports.scrbl +++ b/pkgs/racket-doc/scribblings/inside/ports.scrbl @@ -335,7 +335,7 @@ Closes the given output port.} Fills @cpp{*@var{fd}} with a file-descriptor value for @var{port} if one is available (i.e., the port is a file-stream port and it is not closed). The result is non-zero if the file-descriptor value is -available, zero otherwise. On Windows, a ``file dscriptor'' is a +available, zero otherwise. On Windows, a ``file descriptor'' is a file @cpp{HANDLE}.} @function[(intptr_t scheme_get_port_fd diff --git a/pkgs/racket-doc/scribblings/raco/test.scrbl b/pkgs/racket-doc/scribblings/raco/test.scrbl index 3fb82c29ad..862b436164 100644 --- a/pkgs/racket-doc/scribblings/raco/test.scrbl +++ b/pkgs/racket-doc/scribblings/raco/test.scrbl @@ -210,7 +210,7 @@ identifiers: @item{@racket[lock-name] --- a string that names a lock file that is used to serialize tests (i.e., tests that have the same lock name do not run concurrently). The lock file's location is - determined by the @envvar{PLTLOCKDIR} environment varible or + determined by the @envvar{PLTLOCKDIR} environment variable or defaults to @racket[(find-system-path 'temp-dir)]. The maximum time to wait on the lock file is determined by the @envvar{PLTLOCKTIME} environment variable or defaults to 4 diff --git a/pkgs/racket-doc/scribblings/reference/async-channels.scrbl b/pkgs/racket-doc/scribblings/reference/async-channels.scrbl index 9c4d6bcc85..ac2e8afa87 100644 --- a/pkgs/racket-doc/scribblings/reference/async-channels.scrbl +++ b/pkgs/racket-doc/scribblings/reference/async-channels.scrbl @@ -68,7 +68,7 @@ is full until space is available.} Returns a @tech{synchronizable event} that is @tech{ready for synchronization} when @racket[(async-channel-put ach v)] would return a value (i.e., when the channel holds fewer values already than its -limit); @resultItself{asychronous channel-put event}.} +limit); @resultItself{asynchronous channel-put event}.} @examples[#:eval (async-eval) #:once (eval:no-prompt diff --git a/pkgs/racket-doc/scribblings/reference/numbers.scrbl b/pkgs/racket-doc/scribblings/reference/numbers.scrbl index 7f5ee5868f..a392e15a6f 100644 --- a/pkgs/racket-doc/scribblings/reference/numbers.scrbl +++ b/pkgs/racket-doc/scribblings/reference/numbers.scrbl @@ -75,7 +75,7 @@ same for @racket[0.0f0] and @racket[-0.0f0] (which are single-precision variants @racketvalfont{-nan.0} refers to the same constant as @racket[+nan.0], and @racketvalfont{-nan.f} is the same as @racketvalfont{+nan.f}. -Calculations with infinites produce results consistent with IEEE +Calculations with infinities produce results consistent with IEEE double- or single-precision floating point where IEEE specifies the result; in cases where IEEE provides no specification, the result corresponds to the limit approaching diff --git a/pkgs/racket-test-core/tests/racket/macro.rktl b/pkgs/racket-test-core/tests/racket/macro.rktl index 33051e2531..65a97e0885 100644 --- a/pkgs/racket-test-core/tests/racket/macro.rktl +++ b/pkgs/racket-test-core/tests/racket/macro.rktl @@ -862,7 +862,7 @@ (require 'm-check-varref-expand) ;; ---------------------------------------- -;; Check that a modul-level binding with 0 marks +;; Check that a module-level binding with 0 marks ;; but lexical context is found correctly with ;; 1 and 2 marks (test case by Carl): @@ -2133,7 +2133,7 @@ (require (for-template racket/base)) (define (disarm s) (unless (syntax-tainted? (car (syntax-e (syntax-disarm s #f)))) - (error "disarm suceeded!")) + (error "disarm succeeded!")) #''ok) (provide disarm))) @@ -2338,7 +2338,7 @@ (restore)))) ;; ---------------------------------------- -;; Make sure somethign reasonable happens when a `for-syntax` `define` +;; Make sure something reasonable happens when a `for-syntax` `define` ;; is seen via `local-expand` but is not preserved in the expansion (module module-compiles-but-does-not-visit racket/base diff --git a/pkgs/racket-test-core/tests/racket/module.rktl b/pkgs/racket-test-core/tests/racket/module.rktl index f9b140f252..dc0c552c26 100644 --- a/pkgs/racket-test-core/tests/racket/module.rktl +++ b/pkgs/racket-test-core/tests/racket/module.rktl @@ -1086,7 +1086,7 @@ #:exists 'truncate (lambda () (write-bytes b-s))) ((dynamic-require (build-path temp-dir "check-gen.rkt") 'b) 10))) - ;; Triger JIT generation with constant function as `a': + ;; Trigger JIT generation with constant function as `a': (go a-s) ;; Check that we don't crash when trying to use a different `a': (err/rt-test (go am-s) exn:fail?) @@ -1128,7 +1128,7 @@ (require 'use-a-with-auto-field) ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; check that `require' inside `beging-for-syntax' sets up the right phase dependency +;; check that `require' inside `begin-for-syntax' sets up the right phase dependency (let ([o (open-output-bytes)]) (parameterize ([current-output-port o] diff --git a/pkgs/racket-test-core/tests/racket/optimize.rktl b/pkgs/racket-test-core/tests/racket/optimize.rktl index e46fb57280..bb1bcca073 100644 --- a/pkgs/racket-test-core/tests/racket/optimize.rktl +++ b/pkgs/racket-test-core/tests/racket/optimize.rktl @@ -5681,7 +5681,7 @@ (check pred t1 e1))))) ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Check unboxing with mutual recusion: +;; Check unboxing with mutual recursion: (let () ;; Literal lists thwart inlining: @@ -6105,7 +6105,7 @@ (void (read (open-input-bytes (get-output-bytes o)))))) ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Check for an optimizer regresssion +;; Check for an optimizer regression (err/rt-test (+ (let-values (((x y) (let-values ((() 9)) 2))) x) (error)) exn:fail?) @@ -6509,7 +6509,7 @@ m))) ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Regresssion test for an optimizer bug +;; Regression test for an optimizer bug (define (late-inline-with-single-use-that-turns-out-to-be-movable g) (let ([x (g)]) diff --git a/pkgs/racket-test-core/tests/racket/sync.rktl b/pkgs/racket-test-core/tests/racket/sync.rktl index d61a682fad..fa170563af 100644 --- a/pkgs/racket-test-core/tests/racket/sync.rktl +++ b/pkgs/racket-test-core/tests/racket/sync.rktl @@ -545,7 +545,7 @@ (test 'not-ready values ok?)) ;; If a `nack-guard-evt` function returns a `choice-evt`, -;; then chosing any of those should avoid a NACK: +;; then choosing any of those should avoid a NACK: (let ([n #f]) (sync (nack-guard-evt (lambda (nack) (set! n nack) @@ -868,7 +868,7 @@ ;; ---------------------------------------- -;; In the current implemenation, a depth of 10 for +;; In the current implementation, a depth of 10 for ;; waitable chains is a magic number; it causes the scheduler to ;; swap a thread in to check whether it can run, instead of ;; checking in the thread. (For a well-behaved chain, this @@ -1399,7 +1399,7 @@ (procedure-rename (mk-capturing 'act) 'act-capturing)))))) ;; ---------------------------------------- -;; Check wrap-evt result superceded by internally +;; Check wrap-evt result superseded by internally ;; installed constant (i.e., the input port): (let ([p (make-input-port diff --git a/pkgs/racket-test/tests/future/future.rkt b/pkgs/racket-test/tests/future/future.rkt index 67d1cad1de..8c8fb59197 100644 --- a/pkgs/racket-test/tests/future/future.rkt +++ b/pkgs/racket-test/tests/future/future.rkt @@ -77,7 +77,7 @@ We should also test deep continuations. (case (system-type 'vm) [(chez-scheme) (check-equal? 1 (length (get-blocks log))) - ;; `printf` is ok up to the point that it tries to get the currrent output port: + ;; `printf` is ok up to the point that it tries to get the current output port: (check-equal? 1 (length (get-blocks-on 'continuation-mark-set-first log)))] [else (check-equal? 3 (length (get-blocks log))) diff --git a/racket/collects/compiler/private/xform.rkt b/racket/collects/compiler/private/xform.rkt index 24a4559b1b..56be71ab15 100644 --- a/racket/collects/compiler/private/xform.rkt +++ b/racket/collects/compiler/private/xform.rkt @@ -1484,7 +1484,7 @@ ;; top-level converts the top-level tok list e into ;; a new top-level tok list, often collecting info ;; (such as function prototypes and typedefs). - ;; It expects that the tok list e reprsents one "thing", + ;; It expects that the tok list e represents one "thing", ;; which often means that it's terminated with a semicolon. (define (top-level e where can-drop-vars?) (cond @@ -2881,7 +2881,7 @@ local-vars) (append extra-vars local-vars))]) - ;; Convert calls and body (recusively) + ;; Convert calls and body (recursively) (let-values ([(orig-maxlive) (live-var-info-maxlive live-vars)] [(orig-maxpush) (live-var-info-maxpush live-vars)] [(orig-tag) (live-var-info-tag live-vars)] @@ -3527,7 +3527,7 @@ (tok-n (car func)))) ;; Lift out function calls as arguments. (Can re-order code. ;; Racket source code must live with this change to C's semantics.) - ;; Calls are replaced by varaibles, and setup code generated that + ;; Calls are replaced by variables, and setup code generated that ;; assigns to the variables. (let*-values ([(live-vars) ;; Check for special form (XXX -> ivar) = call, which will @@ -4054,7 +4054,7 @@ (eq? semi (tok-n (list-ref e (sub1 (length e))))) ;; Doesn't start with a star, decrement, increment, or global call (not (memq (tok-n (car e)) '(* -- ++ |::|))) - ;; Not an assignemnt + ;; Not an assignment (not (memq (tok-n (cadr e)) '(= += -=))) ;; Not a return, case, new, or delete (not (memq (tok-n (car e)) '(return case new delete delete_wxobject))) diff --git a/racket/collects/file/cache.rkt b/racket/collects/file/cache.rkt index 35beff08c3..5d436f759f 100644 --- a/racket/collects/file/cache.rkt +++ b/racket/collects/file/cache.rkt @@ -123,7 +123,7 @@ ;; Extract cache-db, holding file lock (in `lock-mode`) while calling ;; `success-handler` on the db. If the cache-db read fails, use an ;; empty db. If any failure happens other than reading the db, -;; including duing `success-handler`, then call `failure-handler` with +;; including during `success-handler`, then call `failure-handler` with ;; the exception after logging it. Note that breaks are disabled when ;; calling the failure handler, so it should return quickly. (define call-with-cache-db/catch-exn-until-success-finishes diff --git a/racket/collects/pkg/private/install.rkt b/racket/collects/pkg/private/install.rkt index 0dfa57634a..5aeb2128db 100644 --- a/racket/collects/pkg/private/install.rkt +++ b/racket/collects/pkg/private/install.rkt @@ -527,7 +527,7 @@ (valid-version? inst-vers*)))) (begin (log-pkg-error - "bad verson specification for ~a: ~e" + "bad version specification for ~a: ~e" name inst-vers*) "0.0") diff --git a/racket/collects/pkg/private/lock.rkt b/racket/collects/pkg/private/lock.rkt index 0024b363a9..83069c132e 100644 --- a/racket/collects/pkg/private/lock.rkt +++ b/racket/collects/pkg/private/lock.rkt @@ -18,7 +18,7 @@ (define pkg-lock-scope (make-parameter #f)) ;; Call `t' with lock held for the current scope. The intent is that -;; `t' reads and writes package information in the curent scope. It +;; `t' reads and writes package information in the current scope. It ;; may also *read* package information for wider package scopes ;; without a further lock --- which is questionable, but modification ;; of a shared scope while others are running can create trouble, diff --git a/racket/collects/planet/private/prefix-dispatcher.rkt b/racket/collects/planet/private/prefix-dispatcher.rkt index a53bdb677e..0953001732 100644 --- a/racket/collects/planet/private/prefix-dispatcher.rkt +++ b/racket/collects/planet/private/prefix-dispatcher.rkt @@ -67,7 +67,7 @@ [else (sorted-nelist-contains-prefix? (cdr nel))])) ;; prefix? : string string -> boolean -;; determins if s1 is a prefix of s2 +;; determines if s1 is a prefix of s2 (define (prefix? s1 s2) (and (<= (string-length s1) (string-length s2)) (string=? s1 (substring s2 0 (string-length s1))))) diff --git a/racket/collects/racket/HISTORY.txt b/racket/collects/racket/HISTORY.txt index a144a8426f..8d6ad8667f 100644 --- a/racket/collects/racket/HISTORY.txt +++ b/racket/collects/racket/HISTORY.txt @@ -119,7 +119,7 @@ Filesystem and environment variables: ---------- exn:missing-module?, and exn:missing-module-accessor Changed string->path-element and bytes->path-element to raise an exception for an empty [byte-]string argument - Changed path-replace-suffix to raise an excpetion when a path element + Changed path-replace-suffix to raise an exception when a path element would be made empty Changed syntax-local-lift-context to distinguish top-level environments Datatypes: ---------- @@ -884,7 +884,7 @@ MzLib: Added define-member-name, member-name-key, and Added syntax-local-lift-moule-end-declaration Changed namespace-attach-module and namespace-unprotect-module to accept quoted module paths, instead of only symbolic names -Fixed avoidable overflow and undeflow in magnitude and / for +Fixed avoidable overflow and underflow in magnitude and / for inexact complex numbers Fixed bug in continuation sharing Improved 3m performance @@ -1237,7 +1237,7 @@ Fixed a bug in the bytecode verifier that caused it to skip significant parts of typical bytecode Added a hook for (planet ...) module paths to the standard module name resolver -MzLib's contract.ss: changed and/f to and/c, or/f is deprected +MzLib's contract.ss: changed and/f to and/c, or/f is deprecated (use union), added object contracts, flat-contracts (without names) are a separate type; use flat-contract-predicate rather than flat-named-contract, added flat-rec-contract, improved @@ -1601,7 +1601,7 @@ Removed user-break-poll-handler; spawn a thread that sleeps and calls break-thread, instead Removed dynamic-enable-break (no long needed since dynamic-wind post thunks can't be broken), but moved it to MzLib's thread.ss -Removed execption-break-enabled (now always disabled) +Removed exception-break-enabled (now always disabled) Added call-in-nested-thread Removed thread-weight Renamed the call-with-escaping-continution procedure to @@ -1785,9 +1785,9 @@ Unit definitions and embedded definitions are not allowed Changed display for symbols containg special characters: the special characters are not escaped (or bar-quoted) Changed write to use the value of (read-accept-bar-quote) - for printing symbols containing special charaters; if + for printing symbols containing special characters; if bar qute reading is off, it is turned off for printing, too -Fixed unit/sig: correctly handles syntax where defintions in +Fixed unit/sig: correctly handles syntax where definitions in the unit shadow syntactic forms Fixed round of exact rational n/d in the case when (odd? d) and (= (remainder n d) (quotient d 2)) @@ -2237,7 +2237,7 @@ More general stack overflow-checking (when needed) Computations can overflow the stack and continue Changed command line flags; added -r (or --script) flag Added multiple inheritance and `rename', `share', and `local' declarations -Merged Patrick Barta's Windows DLL implementation for `load-extention' +Merged Patrick Barta's Windows DLL implementation for `load-extension' Re-implemented `quasiquote', `and', and `or' as a macros Re-implemented let-forms to make small `let's efficient `let*' expands to `let' diff --git a/racket/collects/racket/MzScheme_4.txt b/racket/collects/racket/MzScheme_4.txt index cbd47025c2..bf42da1ae0 100644 --- a/racket/collects/racket/MzScheme_4.txt +++ b/racket/collects/racket/MzScheme_4.txt @@ -298,7 +298,7 @@ uses of mutable pairs are isolated and easy to convert to either mpairs or functional style. The new `scheme/mpair' library provides functions for processing mutable lists. -For compatbility, the `cons' exported by the `r5rs' language module is +For compatibility, the `cons' exported by the `r5rs' language module is an alias for `mcons', and the various list-consuming and -producing functions expetced by `r5rs' also use mutable pairs. Even the `lambda' form of `r5rs' converts rest arguments to mutable lists. diff --git a/racket/collects/racket/contract/private/arr-i.rkt b/racket/collects/racket/contract/private/arr-i.rkt index 8e33b12d56..844349254c 100644 --- a/racket/collects/racket/contract/private/arr-i.rkt +++ b/racket/collects/racket/contract/private/arr-i.rkt @@ -340,7 +340,7 @@ ;; -> (values (listof (or/c pre/pos arg) (listof (or/c #f nat))) ;; sorts the arguments according to the dependency order. ;; returns them in the reverse of that order, ie expressions that need -;; to be evaluted first come later in the list. +;; to be evaluated first come later in the list. ;; the second result maps back from the sorted order ;; (in the first result) to the original order (in `args`) (define-for-syntax (find-ordering args) @@ -371,7 +371,7 @@ evaluted left-to-right.) (arg/res-var arg) (hash-ref pre/post-fake-vars arg))) - ;; track the indicies into `args` for the nodes in the graph + ;; track the indices into `args` for the nodes in the graph ;; and do the same thing but only for the subset that are actually args ;; (unfortuntately we rely on `eq?` here) (define numbers (make-hasheq)) diff --git a/racket/collects/racket/enter.rkt b/racket/collects/racket/enter.rkt index e1ebd4f4f4..f274f0e6aa 100644 --- a/racket/collects/racket/enter.rkt +++ b/racket/collects/racket/enter.rkt @@ -70,7 +70,7 @@ ;; Try to switch to the module namespace, ;; even if there was an exception, because the ;; idea is to allow debugging from inside the - ;; module. If any excepiton happens in trying to + ;; module. If any exception happens in trying to ;; switch to the declared module, log that as ;; an internal exception. (with-handlers ([void (lambda (exn) diff --git a/racket/collects/racket/private/class-internal.rkt b/racket/collects/racket/private/class-internal.rkt index ec88d35b72..e6031bdbff 100644 --- a/racket/collects/racket/private/class-internal.rkt +++ b/racket/collects/racket/private/class-internal.rkt @@ -2662,7 +2662,7 @@ last few projections. (unless (vector-ref meth-flags index) (vector-set! meth-flags index (not make-struct:prim))) - ;; clear out external contracts for methods that are overriden + ;; clear out external contracts for methods that are overridden (when wci-neg-extra-arg-vec (vector-set! wci-neg-extra-arg-vec index #f) (hash-remove! wci-neg-acceptors-ht method))) diff --git a/racket/collects/racket/private/class-undef.rkt b/racket/collects/racket/private/class-undef.rkt index 8980040d55..e2e7efd1d3 100644 --- a/racket/collects/racket/private/class-undef.rkt +++ b/racket/collects/racket/private/class-undef.rkt @@ -105,7 +105,7 @@ (or (free-identifier=? #'decl #'declare-field-use) (free-identifier=? #'decl #'declare-field-assignment))) ;; A field is used or assigned. If tracking has started, make sure the - ;; field is definitely initalized: + ;; field is definitely initialized: (or (and ready (ormap (lambda (id) (not (module-identifier-mapping-get ready id (lambda () #f)))) diff --git a/racket/collects/racket/private/classidmap.rkt b/racket/collects/racket/private/classidmap.rkt index 7de2bc30e8..f961e2f5df 100644 --- a/racket/collects/racket/private/classidmap.rkt +++ b/racket/collects/racket/private/classidmap.rkt @@ -98,7 +98,7 @@ #'id (with-syntax ([bindings (syntax/loc stx ([obj obj-expr] [id expr]))] [set (quasisyntax/loc stx - ;; This continuation mark disables the chaperone on field assignement + ;; This continuation mark disables the chaperone on field assignment ;; (if any) installed via `prop:chaperone-unsafe-undefined`: (with-continuation-mark prop:chaperone-unsafe-undefined unsafe-undefined #,(quasisyntax/loc stx diff --git a/racket/collects/racket/private/dict.rkt b/racket/collects/racket/private/dict.rkt index 03fb4958bb..632d21399b 100644 --- a/racket/collects/racket/private/dict.rkt +++ b/racket/collects/racket/private/dict.rkt @@ -6,7 +6,7 @@ (only-in racket/private/hash paired-fold) (for-syntax racket/base)) -;; `assoc?` is not constant time, but it's likely to be called mutiple +;; `assoc?` is not constant time, but it's likely to be called multiple ;; times on a given argument, so keep a weak hash of known associates: (define known-assocs (make-weak-hasheq)) diff --git a/racket/collects/racket/private/kw.rkt b/racket/collects/racket/private/kw.rkt index 18692d5508..9efc738006 100644 --- a/racket/collects/racket/private/kw.rkt +++ b/racket/collects/racket/private/kw.rkt @@ -1325,7 +1325,7 @@ [n (length args)] [lift-args (lambda (k) (if (not lifted?) - ;; caller didn't lift expresions out + ;; caller didn't lift expressions out (let ([ids (generate-temporaries args)]) #`(let #,(map list ids args) #,(k ids))) diff --git a/racket/collects/racket/string.rkt b/racket/collects/racket/string.rkt index 8a71c47554..c7622c5bd0 100644 --- a/racket/collects/racket/string.rkt +++ b/racket/collects/racket/string.rkt @@ -181,7 +181,7 @@ ;; string-contains? uses a variant of the Knuth-Morris-Pratt string search ;; algorithm. It start with a direct search without the KMP table, until ;; it finds a partial match that long enough (currently 4 characters). -;; The table is also skiped when there are only a few characters left +;; The table is also skipped when there are only a few characters left ;; to test (currently 4 characters). ;; The first time a partial match is found, it buils a small partial table ;; and if it is necesay it builds the complete table. diff --git a/racket/collects/setup/path-relativize.rkt b/racket/collects/setup/path-relativize.rkt index 1a05be5a7b..4a02adf8a7 100644 --- a/racket/collects/setup/path-relativize.rkt +++ b/racket/collects/setup/path-relativize.rkt @@ -42,7 +42,7 @@ ;; Note: in some cases this returns the input path as is, which ;; could be a byte string -- it should be possible to return ;; `path1', but that messes up the xform compilation somehow, by - ;; having # vaules written into dep files. + ;; having # values written into dep files. [(null? path) path0] [(equal? (normal-case-path (car path)) (normal-case-path (car root))) (loop (cdr path) (cdr root))] diff --git a/racket/collects/xml/private/reader.rkt b/racket/collects/xml/private/reader.rkt index 3ba469ee0e..90d9e153ed 100644 --- a/racket/collects/xml/private/reader.rkt +++ b/racket/collects/xml/private/reader.rkt @@ -289,7 +289,7 @@ (unless (eq? (read-char in) #\=) (lex-error in pos "expected = in attribute ~a" name)) (skip-space in) - ;; more here - handle entites and disallow "<" + ;; more here - handle entities and disallow "<" (let* ([delimiter (read-char-or-special in)] [value (case delimiter [(#\' #\") @@ -307,7 +307,7 @@ (string->list (pcdata-string entity))] [(number? (entity-text entity)) (list (integer->char (entity-text entity)))] - ;; more here - do something with user defined entites + ;; more here - do something with user defined entities [else '()]) (read-more)))] [else (read-char in) (cons c (read-more))]))))] diff --git a/racket/src/cify/runstack.rkt b/racket/src/cify/runstack.rkt index 221daf777f..79e88adb3b 100644 --- a/racket/src/cify/runstack.rkt +++ b/racket/src/cify/runstack.rkt @@ -29,7 +29,7 @@ runstack-stage-clear!) (struct runstack (rs-state ; shared state table - depth ; curent stack depth + depth ; current stack depth max-depth ; max reached stack depth sync-depth ; depth that MZ_RUNSTACK currently has, `#f` if unknown vars ; list of pushed vars, newest first diff --git a/racket/src/cify/state.rkt b/racket/src/cify/state.rkt index ccbd6340bb..0fd2f7ab2c 100644 --- a/racket/src/cify/state.rkt +++ b/racket/src/cify/state.rkt @@ -26,7 +26,7 @@ ;; * '#:runstack to information recorded and used ;; by "runstack.rkt" ;; -;; * '#:implicit to a table of implicity referenced +;; * '#:implicit to a table of implicitly referenced ;; variables; an implicit reference happens when ;; a variable is passed in-place in a tail call ;; diff --git a/racket/src/cs/README.txt b/racket/src/cs/README.txt index 6cf99e6b26..02f027b0cf 100644 --- a/racket/src/cs/README.txt +++ b/racket/src/cs/README.txt @@ -202,7 +202,7 @@ of Chez Scheme to compile Chez Scheme boot files. * Obtain a sufficiently new Racket implementation, possibly by following the directions in "../README.txt" to build the - traditional implemenation of Racket. No extra packages are needed + traditional implementation of Racket. No extra packages are needed beyond a minimal Racket build. * Set the current directory to a "ChezScheme" directory --- either a diff --git a/racket/src/cs/bootstrap/README.txt b/racket/src/cs/bootstrap/README.txt index aec527546c..552d78df2d 100644 --- a/racket/src/cs/bootstrap/README.txt +++ b/racket/src/cs/bootstrap/README.txt @@ -7,7 +7,7 @@ build.) The "make-boot.rkt" programs builds Chez Scheme ".boot" and ".h" files from source. The output is written to "/boot/" in a Chez Scheme source directory. Build boot files that way before -`configure` and `make` to boostrap the build. +`configure` and `make` to bootstrap the build. The Chez Scheme simulation hasn't been made especially fast, so expect the bootstrap process to take 5-10 times as long as using an existing diff --git a/racket/src/cs/rumble/char-range.ss b/racket/src/cs/rumble/char-range.ss index c4e4cc2b15..8fa7fc3423 100644 --- a/racket/src/cs/rumble/char-range.ss +++ b/racket/src/cs/rumble/char-range.ss @@ -55,7 +55,7 @@ (delta char-downcase b)) (eqv? (delta char-titlecase a) (delta char-titlecase b)) - ;; Check whether decomposition behavor is different + ;; Check whether decomposition behavior is different (eqv? (non-decomp? a) (non-decomp? b)) ;; Detect different combining classes diff --git a/racket/src/cs/rumble/engine.ss b/racket/src/cs/rumble/engine.ss index 8e23f9fd92..49822c9f81 100644 --- a/racket/src/cs/rumble/engine.ss +++ b/racket/src/cs/rumble/engine.ss @@ -32,7 +32,7 @@ (define (currently-in-engine?) (current-engine-complete-or-expire)) -;; An engine is repesented by a procedure that takes three arguments, where the +;; An engine is represented by a procedure that takes three arguments, where the ;; procedure must be tail-called either within `call-with-engine-completion` or ;; in an engine call's `complete-or-expire` callback: ;; * ticks: number of ticks to run before exire diff --git a/racket/src/cs/rumble/foreign.ss b/racket/src/cs/rumble/foreign.ss index 1559c69a22..4ada81f986 100644 --- a/racket/src/cs/rumble/foreign.ss +++ b/racket/src/cs/rumble/foreign.ss @@ -146,7 +146,7 @@ (define (addr->gcpointer-memory v) ; call with GC disabled (#%$address->object v bytevector-content-offset)) -(define (addr->vector v) ; call with GC disabled or when reuslt is locked +(define (addr->vector v) ; call with GC disabled or when result is locked (#%$address->object v vector-content-offset)) ;; Converts a primitive cpointer (normally the result of @@ -1353,7 +1353,7 @@ (let ([duplicate-argument (lambda (what a1 a2) (raise-arguments-error 'malloc - (string-append "mulitple " what " arguments") + (string-append "multiple " what " arguments") "first" a1 "second" a2))]) (let loop ([args args] [count #f] [type #f] [copy-from #f] [mode #f] [fail-mode #f]) diff --git a/racket/src/cs/rumble/intmap.ss b/racket/src/cs/rumble/intmap.ss index de5db5aaee..b3b968c29c 100644 --- a/racket/src/cs/rumble/intmap.ss +++ b/racket/src/cs/rumble/intmap.ss @@ -17,7 +17,7 @@ ;; (include "rumble/hamt-vector.ss") ;; -;; This HAMT implementaiton uses plain vectors instead of stencil +;; This HAMT implementation uses plain vectors instead of stencil ;; vectors. Its speed and memory use are both worse than the ;; stencil-vector HAMT implementation, but it was the original source ;; of the stencil-vector implementation. diff --git a/racket/src/cs/rumble/memory.ss b/racket/src/cs/rumble/memory.ss index 596f0dac0b..022730ea5f 100644 --- a/racket/src/cs/rumble/memory.ss +++ b/racket/src/cs/rumble/memory.ss @@ -386,7 +386,7 @@ ;; ---------------------------------------- -;; Weak table of (cons 
 ) keys, currently suported
+;; Weak table of (cons 
 ) keys, currently supported
 ;; only in the original host thread of the original place
 (define collect-callbacks (make-weak-eq-hashtable))
 
diff --git a/racket/src/cs/rumble/place.ss b/racket/src/cs/rumble/place.ss
index d3e1b1435b..f59d5f097f 100644
--- a/racket/src/cs/rumble/place.ss
+++ b/racket/src/cs/rumble/place.ss
@@ -8,7 +8,7 @@
 ;; the rest are used by the thread, io, etc., layers for directly
 ;; accessed variables.
 
-(define NUM-PLACE-REGISTERS 128) ; 3 thorugh 126 available for subsystems
+(define NUM-PLACE-REGISTERS 128) ; 3 through 126 available for subsystems
 
 (define LOCAL_TABLE-INDEX 0)
 (define ASYNC-CALLBACK-REGISTER-INDEX 1)
diff --git a/racket/src/expander/extract/linklet-info.rkt b/racket/src/expander/extract/linklet-info.rkt
index 5d9a4fd746..0c97abe0cf 100644
--- a/racket/src/expander/extract/linklet-info.rkt
+++ b/racket/src/expander/extract/linklet-info.rkt
@@ -10,4 +10,4 @@
                       re-exports       ; list of links: links whose variables are re-exported
                       variables        ; set of symbols: defined in the implementation, for detecting re-exports
                       in-variables     ; list of list of symbols: for each import, variables used from the import
-                      side-effects?))  ; whether the implementaiton has side effects other than variable definition
+                      side-effects?))  ; whether the implementation has side effects other than variable definition
diff --git a/racket/src/expander/read/indentation.rkt b/racket/src/expander/read/indentation.rkt
index 150584fd23..25696407d3 100644
--- a/racket/src/expander/read/indentation.rkt
+++ b/racket/src/expander/read/indentation.rkt
@@ -12,7 +12,7 @@
    [suspicious-closer #:mutable] ; expected closer when suspicious line found
    [multiline? #:mutable] ; set to #f if the match attempt spans a line
    start-line ; opener's line
-   [last-line #:mutable] ; current line, already checked the identation
+   [last-line #:mutable] ; current line, already checked the indentation
    [suspicious-line #:mutable] ; non-#f => first suspicious line since opener
    [max-indent #:mutable] ; max indentation encountered since opener, not counting brackets by a more neseted opener
    [suspicious-quote #:mutable])) ; non-#f => first suspicious quote whose closer is on a different line
diff --git a/racket/src/expander/read/number.rkt b/racket/src/expander/read/number.rkt
index 53a8d68835..3da66fd58c 100644
--- a/racket/src/expander/read/number.rkt
+++ b/racket/src/expander/read/number.rkt
@@ -5,7 +5,7 @@
          "parse-case.rkt"
          "parameter.rkt"
          ;; Used only to coerce strings to extflonums
-         ;; when extflonums are not fully suported:
+         ;; when extflonums are not fully supported:
          (prefix-in host: "../host/string-to-number.rkt"))
 
 (provide string->number
diff --git a/racket/src/expander/read/parse-case.rkt b/racket/src/expander/read/parse-case.rkt
index c0c23d6120..f8c76f7fd8 100644
--- a/racket/src/expander/read/parse-case.rkt
+++ b/racket/src/expander/read/parse-case.rkt
@@ -2,7 +2,7 @@
 (require racket/fixnum
          (for-syntax racket/base))
 
-;; `parse-case` is used for numebr parsing in "number.rkt"
+;; `parse-case` is used for number parsing in "number.rkt"
 
 (provide parse-case
          parse-case*
diff --git a/racket/src/expander/read/readtable.rkt b/racket/src/expander/read/readtable.rkt
index 4825bb6145..4317752bde 100644
--- a/racket/src/expander/read/readtable.rkt
+++ b/racket/src/expander/read/readtable.rkt
@@ -28,7 +28,7 @@
                    char-ht
                    ;; The dispatch table maps character for `#` dispatch
                    dispatch-ht
-                   ;; The delimter table maps a character to 'delimit,
+                   ;; The delimiter table maps a character to 'delimit,
                    ;; 'no-delimit, or a character whose default to use;
                    ;; absence of a mapping is the default for that character
                    delimiter-ht)
diff --git a/racket/src/expander/read/sequence.rkt b/racket/src/expander/read/sequence.rkt
index 90a6543196..e064607a65 100644
--- a/racket/src/expander/read/sequence.rkt
+++ b/racket/src/expander/read/sequence.rkt
@@ -108,7 +108,7 @@
         (cond
          [(special-comment? v) (loop depth accum #f #f read-one)]
          [(depth . > . 1024)
-          ;; At some large depth, it's better to accumlate than recur
+          ;; At some large depth, it's better to accumulate than recur
           (loop depth (cons v accum) #f #f read-one)]
          [else 
           (cons v (loop (add1 depth) null #f #f read-one))])])))
diff --git a/racket/src/expander/syntax/debug.rkt b/racket/src/expander/syntax/debug.rkt
index 60ce7ad7b9..413a819eca 100644
--- a/racket/src/expander/syntax/debug.rkt
+++ b/racket/src/expander/syntax/debug.rkt
@@ -40,7 +40,7 @@
                          ([sc (in-set s-scs)]
                           [(scs b) (in-binding-table sym (scope-binding-table sc) s null)]
                           #:when (and scs b
-                                      ;; Skip overidden:
+                                      ;; Skip overridden:
                                       (not (set-member? covered-scope-sets scs))))
                 (values
                  (cons
diff --git a/racket/src/foreign/foreign.c b/racket/src/foreign/foreign.c
index b6a4962a52..eca964d3f7 100644
--- a/racket/src/foreign/foreign.c
+++ b/racket/src/foreign/foreign.c
@@ -1888,7 +1888,7 @@ static void *wrong_value(const char *who, const char *type, Scheme_Object *val)
 
 /* Usually writes the C object to dst and returns NULL.  When basetype_p is not
  * NULL, then any pointer value (any pointer or a struct or array) is returned, and the
- * basetype_p is set to the corrsponding number tag.  If basetype_p is NULL,
+ * basetype_p is set to the corresponding number tag.  If basetype_p is NULL,
  * then a struct or array value will be *copied* into dst. */
 static void* SCHEME2C(const char *who,
                       Scheme_Object *type, void *dst, intptr_t delta,
@@ -3999,7 +3999,7 @@ static void ffi_do_callback(ffi_cif* cif, void* resultp, void** args, void *user
 
 #ifdef MZ_USE_MZRT
 
-/* When OS-level thread support is avaiable, support callbacks
+/* When OS-level thread support is available, support callbacks
    in foreign threads that are executed on the main Racket thread. */
 
 typedef struct Queued_Callback {
diff --git a/racket/src/foreign/foreign.rktc b/racket/src/foreign/foreign.rktc
index d9c6879564..0b7fd88e5e 100755
--- a/racket/src/foreign/foreign.rktc
+++ b/racket/src/foreign/foreign.rktc
@@ -1621,7 +1621,7 @@ static void *wrong_value(const char *who, const char *type, Scheme_Object *val)
 
 /* Usually writes the C object to dst and returns NULL.  When basetype_p is not
  * NULL, then any pointer value (any pointer or a struct or array) is returned, and the
- * basetype_p is set to the corrsponding number tag.  If basetype_p is NULL,
+ * basetype_p is set to the corresponding number tag.  If basetype_p is NULL,
  * then a struct or array value will be *copied* into dst. */
 static void* SCHEME2C(const char *who,
                       Scheme_Object *type, void *dst, intptr_t delta,
@@ -3160,7 +3160,7 @@ static void ffi_do_callback(ffi_cif* cif, void* resultp, void** args, void *user
 
 #ifdef MZ_USE_MZRT
 
-/* When OS-level thread support is avaiable, support callbacks
+/* When OS-level thread support is available, support callbacks
    in foreign threads that are executed on the main Racket thread. */
 
 typedef struct Queued_Callback {
diff --git a/racket/src/foreign/libffi/ChangeLog.libffi-3.1 b/racket/src/foreign/libffi/ChangeLog.libffi-3.1
index 09476f008a..435e7164f6 100644
--- a/racket/src/foreign/libffi/ChangeLog.libffi-3.1
+++ b/racket/src/foreign/libffi/ChangeLog.libffi-3.1
@@ -1037,7 +1037,7 @@
 
 2012-03-23  Peter Rosin  
 
-	* testsuite/libffi.call/ffitest.h: Provide abstration of
+	* testsuite/libffi.call/ffitest.h: Provide abstraction of
 	__attribute__((fastcall)) in the form of a __FASTCALL__
 	define.  Define it to __fastcall for MSVC.
 	* testsuite/libffi.call/fastthis1_win32.c: Use the above.
@@ -3083,7 +3083,7 @@
 
 2007-05-18  Aurelien Jarno  
 
-	* src/arm/ffi.c (ffi_prep_closure_loc): Renamed and ajusted
+	* src/arm/ffi.c (ffi_prep_closure_loc): Renamed and adjusted
 	from (ffi_prep_closure): ... this.
 	(FFI_INIT_TRAMPOLINE): Adjust.
 
@@ -4151,7 +4151,7 @@
 	* Makefile.am: Add m32r support.
 	* configure.ac: Likewise.
 	* Makefile.in: Regenerate.
-	* confiugre: Regenerate.
+	* configure: Regenerate.
 	* src/types.c: Add m32r port to FFI_INTERNAL_TYPEDEF
 	(uint64, sint64, double, longdouble)
 	* src/m32r: New directory.
@@ -4182,7 +4182,7 @@
 
 2004-09-05  Andreas Tobler  
 
-	* src/powerpc/darwin.S: Fix comments and identation.
+	* src/powerpc/darwin.S: Fix comments and indentation.
 	* src/powerpc/darwin_closure.S: Likewise.
 
 2004-09-02  Andreas Tobler  
diff --git a/racket/src/foreign/libffi/include/ffi.h.in b/racket/src/foreign/libffi/include/ffi.h.in
index 93c776fbbe..f28ca5778f 100644
--- a/racket/src/foreign/libffi/include/ffi.h.in
+++ b/racket/src/foreign/libffi/include/ffi.h.in
@@ -352,7 +352,7 @@ typedef struct {
 
   /* if this is enabled, then a raw closure has the same layout 
      as a regular closure.  We use this to install an intermediate 
-     handler to do the transaltion, void** -> ffi_raw*. */
+     handler to do the translation, void** -> ffi_raw*. */
 
   void     (*translate_args)(ffi_cif*,void*,void**,void*);
   void      *this_closure;
@@ -378,7 +378,7 @@ typedef struct {
 
   /* if this is enabled, then a raw closure has the same layout 
      as a regular closure.  We use this to install an intermediate 
-     handler to do the transaltion, void** -> ffi_raw*. */
+     handler to do the translation, void** -> ffi_raw*. */
 
   void     (*translate_args)(ffi_cif*,void*,void**,void*);
   void      *this_closure;
diff --git a/racket/src/foreign/libffi/ltmain.sh b/racket/src/foreign/libffi/ltmain.sh
index 67f0ac4ff0..d27c646aa5 100644
--- a/racket/src/foreign/libffi/ltmain.sh
+++ b/racket/src/foreign/libffi/ltmain.sh
@@ -1438,7 +1438,7 @@ func_run_hooks ()
 
     case " $hookable_fns " in
       *" $1 "*) ;;
-      *) func_fatal_error "'$1' does not support hook funcions.n" ;;
+      *) func_fatal_error "'$1' does not support hook functions.n" ;;
     esac
 
     eval _G_hook_fns=\$$1_hooks; shift
@@ -5648,7 +5648,7 @@ EOF
         {
           /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
              namespace, but it is not one of the ones we know about and
-             have already dealt with, above (inluding dump-script), then
+             have already dealt with, above (including dump-script), then
              report an error. Otherwise, targets might begin to believe
              they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
              namespace. The first time any user complains about this, we'll
diff --git a/racket/src/foreign/libffi/m4/libtool.m4 b/racket/src/foreign/libffi/m4/libtool.m4
index 4bc6b22c80..12bc2ea7ba 100644
--- a/racket/src/foreign/libffi/m4/libtool.m4
+++ b/racket/src/foreign/libffi/m4/libtool.m4
@@ -639,7 +639,7 @@ configured by $[0], generated by m4_PACKAGE_STRING.
 
 Copyright (C) 2011 Free Software Foundation, Inc.
 This config.lt script is free software; the Free Software Foundation
-gives unlimited permision to copy, distribute and modify it."
+gives unlimited permission to copy, distribute and modify it."
 
 while test 0 != $[#]
 do
diff --git a/racket/src/foreign/libffi/src/bfin/sysv.S b/racket/src/foreign/libffi/src/bfin/sysv.S
index f4278be242..66938366bc 100644
--- a/racket/src/foreign/libffi/src/bfin/sysv.S
+++ b/racket/src/foreign/libffi/src/bfin/sysv.S
@@ -72,7 +72,7 @@ _ffi_call_SYSV:
 	[FP+16] = R2;
 
 .allocate_stack:
-	//alocate cif->bytes into the stack
+	//allocate cif->bytes into the stack
 	R1 = [FP+8];
 	R0 = SP;
 	R0 = R0 - R1;
@@ -92,7 +92,7 @@ _ffi_call_SYSV:
 	call (P1);
 
 .call_user_function:
-	//ajust SP so as to allow the user function access the parameters on the stack
+	//adjust SP so as to allow the user function access the parameters on the stack
 	SP = [FP-16]; //point to function parameters
 	R0 = [SP];
 	R1 = [SP+4];
diff --git a/racket/src/foreign/libffi/src/dlmalloc.c b/racket/src/foreign/libffi/src/dlmalloc.c
index 8725b4fd60..4e33104380 100644
--- a/racket/src/foreign/libffi/src/dlmalloc.c
+++ b/racket/src/foreign/libffi/src/dlmalloc.c
@@ -1336,7 +1336,7 @@ static void* os2mmap(size_t size) {
 
 #define os2direct_mmap(n)     os2mmap(n)
 
-/* This function supports releasing coalesed segments */
+/* This function supports releasing coalesced segments */
 static int os2munmap(void* ptr, size_t size) {
   while (size) {
     ULONG ulSize = size;
@@ -1373,7 +1373,7 @@ static void* win32direct_mmap(size_t size) {
   return (ptr != 0)? ptr: MFAIL;
 }
 
-/* This function supports releasing coalesed segments */
+/* This function supports releasing coalesced segments */
 static int win32munmap(void* ptr, size_t size) {
   MEMORY_BASIC_INFORMATION minfo;
   char* cptr = ptr;
diff --git a/racket/src/foreign/libffi/src/m88k/ffi.c b/racket/src/foreign/libffi/src/m88k/ffi.c
index 68df494955..451547ac89 100644
--- a/racket/src/foreign/libffi/src/m88k/ffi.c
+++ b/racket/src/foreign/libffi/src/m88k/ffi.c
@@ -38,7 +38,7 @@
  * - the logic deciding whether a function argument gets passed through
  *   registers, or on the stack, has changed several times in OpenBSD in
  *   edge cases (especially for structs larger than 32 bytes being passed
- *   by value). The code below attemps to match the logic used by the
+ *   by value). The code below attempts to match the logic used by the
  *   system compiler of OpenBSD 5.3, i.e. gcc 3.3.6 with many m88k backend
  *   fixes.
  */
diff --git a/racket/src/foreign/libffi/src/tile/tile.S b/racket/src/foreign/libffi/src/tile/tile.S
index d1f82cb3db..55020ec69c 100644
--- a/racket/src/foreign/libffi/src/tile/tile.S
+++ b/racket/src/foreign/libffi/src/tile/tile.S
@@ -31,7 +31,7 @@
 /* Number of bytes in a register. */
 #define REG_SIZE FFI_SIZEOF_ARG
 
-/* Number of bytes in stack linkage area for backtracing.
+/* Number of bytes in stack linkage area for backtracking.
 
    A note about the ABI: on entry to a procedure, sp points to a stack
    slot where it must spill the return address if it's not a leaf.
diff --git a/racket/src/native-libs/install.rkt b/racket/src/native-libs/install.rkt
index 7ce3dce69a..1185bf9132 100644
--- a/racket/src/native-libs/install.rkt
+++ b/racket/src/native-libs/install.rkt
@@ -89,14 +89,14 @@
       "libgobject"
       "libgthread"
       ["libintl" "libintl is released under the GNU Library General Public License (GNU LGPL)."]
-      ["libharfbuzz" "HarfBuzz is relased under a MIT license."]
+      ["libharfbuzz" "HarfBuzz is released under a MIT license."]
       ["libfribidi" "FriBidi is released under the GNU Library General Public License (GNU LGPL)."]
       ["libpango" "Pango is released under the GNU Library General Public License (GNU LGPL)."]
       "libpangocairo"
       "libpangoft2"
       "libpangowin32"
       "libexpat"
-      ["libuuid" "libuuid is relased under a Modified BSD license."]
+      ["libuuid" "libuuid is released under a Modified BSD license."]
       ["libfontconfig" ,(~a "FontConfig:\n"
                             " Copyright © 2000,2001,2002,2003,2004,2006,2007 Keith Packard\n"
                             " Copyright © 2005 Patrick Lam\n"
@@ -104,9 +104,9 @@
                             " Copyright © 2008,2009 Red Hat, Inc.\n"
                             " Copyright © 2008 Danilo Šegan\n"
                             " Copyright © 2012 Google, Inc.")]
-      ["libfreetype" "Pixman is relased under the FreeType project license."]
+      ["libfreetype" "Pixman is released under the FreeType project license."]
       ["libcairo" "Cairo is released under the GNU Library General Public License (GNU LGPL)."]
-      ["libpixman" "Pixman is relased under a MIT license."]
+      ["libpixman" "Pixman is released under a MIT license."]
       ["libpng" "Libpng is released under the libpng license."]
       ["libjpeg" "This software is based in part on the work of the Independent JPEG Group."]
       ["zlib1" "zlib is by Jean-loup Gailly and Mark Adler."]
diff --git a/racket/src/racket/gc/AmigaOS.c b/racket/src/racket/gc/AmigaOS.c
index c57105bf47..c0442b0bb3 100644
--- a/racket/src/racket/gc/AmigaOS.c
+++ b/racket/src/racket/gc/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,7 +230,7 @@ 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.
diff --git a/racket/src/racket/gc/Makefile.am b/racket/src/racket/gc/Makefile.am
index 5565a532d7..3b4c3ba80f 100644
--- a/racket/src/racket/gc/Makefile.am
+++ b/racket/src/racket/gc/Makefile.am
@@ -23,7 +23,7 @@
 # use the internal version.  This is done since libatomic_ops doesn't
 # use libtool, since it has no real use for it.  But that seems to make
 # it hard to use either the resulting object files or libraries.
-# Thus there seems too be no real reason to recusively build in the
+# Thus there seems too be no real reason to recursively build in the
 # libatomic_ops directory.
 # if USE_INTERNAL_LIBATOMICS_OPS
 # SUBDIRS = @maybe_libatomic_ops@
diff --git a/racket/src/racket/gc/configure b/racket/src/racket/gc/configure
index 603b587b10..29ac928289 100755
--- a/racket/src/racket/gc/configure
+++ b/racket/src/racket/gc/configure
@@ -1534,7 +1534,7 @@ Optional Features:
   --enable-redirect-malloc
                           Redirect malloc and friends to GC routines
   --enable-large-config   Optimize for large (> 100 MB) heap or root set
-  --enable-gc-debug       include full support for pointer backtracing etc.
+  --enable-gc-debug       include full support for pointer backtracking etc.
   --enable-gc-assertions  collector-internal assertion checking
   --enable-munmap=N       return page to the os if empty for N collections
 
@@ -4706,8 +4706,8 @@ _ACEOF
 #define THREAD_LOCAL_ALLOC 1
 _ACEOF
 
-	{ echo "$as_me:$LINENO: WARNING: \"Explict GC_INIT() calls may be required.\"" >&5
-echo "$as_me: WARNING: \"Explict GC_INIT() calls may be required.\"" >&2;};
+	{ echo "$as_me:$LINENO: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&5
+echo "$as_me: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&2;};
 	;;
      *-*-linux*)
 	cat >>confdefs.h <<\_ACEOF
@@ -4750,8 +4750,8 @@ _ACEOF
 #define THREAD_LOCAL_ALLOC 1
 _ACEOF
 
-	{ echo "$as_me:$LINENO: WARNING: \"Explict GC_INIT() calls may be required.\"" >&5
-echo "$as_me: WARNING: \"Explict GC_INIT() calls may be required.\"" >&2;};
+	{ echo "$as_me:$LINENO: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&5
+echo "$as_me: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&2;};
 	THREADDLLIBS="-lpthread -lrt"
 	# HPUX needs REENTRANT for the _r calls.
 
@@ -4871,8 +4871,8 @@ _ACEOF
 #define THREAD_LOCAL_ALLOC 1
 _ACEOF
 
-	{ echo "$as_me:$LINENO: WARNING: \"Explict GC_INIT() calls may be required.\"" >&5
-echo "$as_me: WARNING: \"Explict GC_INIT() calls may be required.\"" >&2;};
+	{ echo "$as_me:$LINENO: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&5
+echo "$as_me: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&2;};
 	# Parallel-mark is currently unreliable on Darwin; ignore request
 	# if test "${enable_parallel_mark}" = yes; then
 	#   AC_DEFINE(PARALLEL_MARK)
@@ -4893,8 +4893,8 @@ _ACEOF
 #define THREAD_LOCAL_ALLOC 1
 _ACEOF
 
-	  { echo "$as_me:$LINENO: WARNING: \"Explict GC_INIT() calls may be required.\"" >&5
-echo "$as_me: WARNING: \"Explict GC_INIT() calls may be required.\"" >&2;};
+	  { echo "$as_me:$LINENO: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&5
+echo "$as_me: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&2;};
 	  # May want to enable it in other cases, too.
 	  # Measurements havent yet been done.
 	fi
@@ -4934,8 +4934,8 @@ _ACEOF
 #define THREAD_LOCAL_ALLOC 1
 _ACEOF
 
-    { echo "$as_me:$LINENO: WARNING: \"Explict GC_INIT() calls may be required.\"" >&5
-echo "$as_me: WARNING: \"Explict GC_INIT() calls may be required.\"" >&2;};
+    { echo "$as_me:$LINENO: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&5
+echo "$as_me: WARNING: \"Explicit GC_INIT() calls may be required.\"" >&2;};
     cat >>confdefs.h <<\_ACEOF
 #define GC_DGUX386_THREADS 1
 _ACEOF
diff --git a/racket/src/racket/gc/configure.in b/racket/src/racket/gc/configure.in
index 0b3a31b731..38889843a6 100644
--- a/racket/src/racket/gc/configure.in
+++ b/racket/src/racket/gc/configure.in
@@ -421,7 +421,7 @@ fi
 
 UNWINDLIBS=
 AC_ARG_ENABLE(full-debug,
-[  --enable-full-debug	include full support for pointer backtracing etc.],
+[  --enable-full-debug	include full support for pointer backtracking etc.],
 [ if test "$enable_full_debug" = "yes"; then
     AC_MSG_WARN("Should define GC_DEBUG and use debug alloc. in clients.")
     AC_DEFINE(KEEP_BACK_PTRS)
diff --git a/racket/src/racket/gc/cord/de_win.h b/racket/src/racket/gc/cord/de_win.h
index ab29891d4c..2630cdd1e6 100644
--- a/racket/src/racket/gc/cord/de_win.h
+++ b/racket/src/racket/gc/cord/de_win.h
@@ -80,7 +80,7 @@ void set_position(int x, int y);
 
 void do_command(int);
 			/* Execute an editor command.			*/
-			/* Agument is a command character or one	*/
+			/* Argument is a command character or one	*/
 			/* of the IDM_ commands.			*/
 
 void generic_init(void);
diff --git a/racket/src/racket/gc/doc/README b/racket/src/racket/gc/doc/README
index d9d49e827f..0617f0974e 100644
--- a/racket/src/racket/gc/doc/README
+++ b/racket/src/racket/gc/doc/README
@@ -133,7 +133,7 @@ There are a number of routines which modify the pointer recognition
 algorithm.  GC_register_displacement allows certain interior pointers
 to be recognized even if ALL_INTERIOR_POINTERS is nor defined.
 GC_malloc_ignore_off_page allows some pointers into the middle of large objects
-to be disregarded, greatly reducing the probablility of accidental
+to be disregarded, greatly reducing the probability of accidental
 retention of large objects.  For most purposes it seems best to compile
 with ALL_INTERIOR_POINTERS and to use GC_malloc_ignore_off_page if
 you get collector warnings from allocations of very large objects.
@@ -390,7 +390,7 @@ proposal without compiler changes.
 
   Very often it will also be necessary to use gc_allocator.h and the
 allocator declared there to construct STL data structures.  Otherwise
-subobjects of STL data structures wil be allcoated using a system
+subobjects of STL data structures wil be allocated using a system
 allocator, and objects they refer to may be prematurely collected.
 
 USE AS LEAK DETECTOR:
@@ -445,7 +445,7 @@ the debugger.
 or GC_free, and conversely.  It is however acceptable to allocate only
 some objects with GC_debug_malloc, and to use GC_malloc for other objects,
 provided the two pools are kept distinct.  In this case, there is a very
-low probablility that GC_malloc allocated objects may be misidentified as
+low probability that GC_malloc allocated objects may be misidentified as
 having been overwritten.  This should happen with probability at most
 one in 2**32.  This probability is zero if GC_debug_malloc is never called.
 
diff --git a/racket/src/racket/gc/doc/README.amiga b/racket/src/racket/gc/doc/README.amiga
index 730dce3fe9..de7e7f5a22 100644
--- a/racket/src/racket/gc/doc/README.amiga
+++ b/racket/src/racket/gc/doc/README.amiga
@@ -34,7 +34,7 @@ WHATS NEW:
    If you absolutely must call abort() instead of exit(), try calling
    the GC_amiga_free_all_mem function before abort().
 
-   New amiga-spesific compilation flags:
+   New amiga-specific compilation flags:
 
    GC_AMIGA_FASTALLOC - By NOT defining this option, GC will work like before,
                         it will not try to force fast-mem out of the OS, and
@@ -95,7 +95,7 @@ WHATS NEW:
    define f.ex GC_malloc as GC_amiga_malloc should allso work).
 
 
-   New amiga-spesific function:
+   New amiga-specific function:
 
      void GC_amiga_set_toany(void (*func)(void));
 
@@ -104,7 +104,7 @@ WHATS NEW:
    it will return chip-mem.
 
 
-2. A few small compiler-spesific additions to make it compile with SAS/C again.
+2. A few small compiler-specific additions to make it compile with SAS/C again.
 
 3. Updated and rewritten the smakefile, so that it works again and that
    the "unnecesarry" 'SCOPTIONS' files could be removed. Allso included
@@ -120,14 +120,14 @@ Programs can not be started from workbench, at least not for SAS/C. (Martin
 Tauchmanns note about that it now works with workbench is definitely wrong
 when concerning SAS/C). I guess it works if you use the old "#if 0'ed"-code,
 but I haven't tested it. I think the reason for MT to replace the
-"#if 0'ed"-code was only because it was a bit to SAS/C-spesific. But I
+"#if 0'ed"-code was only because it was a bit to SAS/C-specific. But I
 don't know. An iconx-script solves this problem anyway.
 
 
 BEWARE!
 
 -To run gctest, set the stack to around 200000 bytes first.
--SAS/C-spesific: cord will crash if you compile gc.lib with
+-SAS/C-specific: cord will crash if you compile gc.lib with
  either parm=reg or parm=both. (missing legal prototypes for
  function-pointers someplace is the reason I guess.).
 
@@ -283,7 +283,7 @@ If you allocate your own stack in client code, you will have to
 assign the pointer plus stack size to GC_stackbottom.
 
 The initial stack size of the target program can be compiled in by
-setting the __stack symbol (see SAS documentaion). It can be over-
+setting the __stack symbol (see SAS documentation). It can be over-
 ridden from the CLI by running the AmigaDOS "stack" program, or from
 the WorkBench by setting the stack size in the tool types window.
 
diff --git a/racket/src/racket/gc/doc/README.autoconf b/racket/src/racket/gc/doc/README.autoconf
index 53fcf5a50b..2f58b5154b 100644
--- a/racket/src/racket/gc/doc/README.autoconf
+++ b/racket/src/racket/gc/doc/README.autoconf
@@ -47,7 +47,7 @@ Important options to configure:
                           [same as prefix]
   --enable-threads=TYPE   choose threading package
   --enable-parallel-mark  parallelize marking and free list construction
-  --enable-full-debug	include full support for pointer backtracing etc.
+  --enable-full-debug	include full support for pointer backtracking etc.
 
 Unless --prefix is set (or --exec-prefix or one of the more obscure options),
 make install will install libgc.a and libgc.so in /usr/local/bin, which
diff --git a/racket/src/racket/gc/doc/README.changes b/racket/src/racket/gc/doc/README.changes
index c269aa5a9d..3005d9aeed 100644
--- a/racket/src/racket/gc/doc/README.changes
+++ b/racket/src/racket/gc/doc/README.changes
@@ -2517,7 +2517,7 @@ Since gc7.0alpha5
  - Do not try to do thread-local gcj allocation in incremental mode.  There
    are races in setting up the descriptor.
  - Add GC_INIT() to middle.c, fix some more GC_printfn calls.
- - Some assertions erroneously used I_HOLD_LOCK() negatively, eventhough
+ - Some assertions erroneously used I_HOLD_LOCK() negatively, even though
    it can now spuriously return TRUE.
  - Rename SUNOS5 macro and OS name to SOLARIS and SUNOS5DL to SOLARISDL.
  - On Linux and some Un*x variants, allocate memory by first trying sbrk,
diff --git a/racket/src/racket/gc/include/gc_typed.h b/racket/src/racket/gc/include/gc_typed.h
index 1086acdd12..30e05a9a3a 100644
--- a/racket/src/racket/gc/include/gc_typed.h
+++ b/racket/src/racket/gc/include/gc_typed.h
@@ -87,7 +87,7 @@ GC_API void * GC_calloc_explicitly_typed(size_t nelements,
   				         GC_descr d);
   	/* Allocate an array of nelements elements, each of the	*/
   	/* given size, and with the given descriptor.		*/
-  	/* The elemnt size must be a multiple of the byte	*/
+  	/* The element size must be a multiple of the byte	*/
   	/* alignment required for pointers.  E.g. on a 32-bit	*/
   	/* machine with 16-bit aligned pointers, size_in_bytes	*/
   	/* must be a multiple of 2.				*/
diff --git a/racket/src/racket/gc/os_dep.c b/racket/src/racket/gc/os_dep.c
index 697855df05..5e7a2e072a 100644
--- a/racket/src/racket/gc/os_dep.c
+++ b/racket/src/racket/gc/os_dep.c
@@ -3389,7 +3389,7 @@ GC_bool GC_page_was_ever_dirty(struct hblk *h)
  */
  
 /*
- * This implementaion assumes a Solaris 2.X like /proc pseudo-file-system
+ * This implementation assumes a Solaris 2.X like /proc pseudo-file-system
  * from which we can read page modified bits.  This facility is far from
  * optimal (e.g. we would like to get the info for only some of the
  * address space), but it avoids intercepting system calls.
diff --git a/racket/src/racket/gc/solaris_threads.c b/racket/src/racket/gc/solaris_threads.c
index 386736d923..547e53d5ef 100644
--- a/racket/src/racket/gc/solaris_threads.c
+++ b/racket/src/racket/gc/solaris_threads.c
@@ -612,7 +612,7 @@ void GC_delete_thread(thread_t id)
     }
 }
 
-/* Return the GC_thread correpsonding to a given thread_t.	*/
+/* Return the GC_thread corresponding to a given thread_t.	*/
 /* Returns 0 if it's not there.					*/
 /* Caller holds  allocation lock.				*/
 GC_thread GC_lookup_thread(thread_t id)
diff --git a/racket/src/racket/gc2/README b/racket/src/racket/gc2/README
index ea2fb02299..e9053c69d1 100644
--- a/racket/src/racket/gc2/README
+++ b/racket/src/racket/gc2/README
@@ -16,7 +16,7 @@ of the object). The exception is that a pointer may reference the
 interior of an "Interior" object, but Racket allocates such objects
 infrequently, and only as relatively large objects.
 
-All alocated memory must be longword-aligned. For architectures where
+All allocated memory must be longword-aligned. For architectures where
 `double' values must be 8-byte aligned, the GC must provide 8-byte
 aligned memory in response to an allocation request for a memory size
 divisible by 8. Except for atomic memory, allocated objects must be
diff --git a/racket/src/racket/gc2/gc2.h b/racket/src/racket/gc2/gc2.h
index a901706bb9..3552c46101 100644
--- a/racket/src/racket/gc2/gc2.h
+++ b/racket/src/racket/gc2/gc2.h
@@ -387,7 +387,7 @@ GC2_EXTERN void *GC_fixup_self(void *p);
    only when objects are moved before fixup, but objects might
    be moved after fixup. */
 
-/* INTERNAL for the current implemenation (used by macros): */
+/* INTERNAL for the current implementation (used by macros): */
 GC2_EXTERN void GC_mark(void *p);
 GC2_EXTERN void GC_fixup(void *p);
 GC2_EXTERN void GC_mark2(void *p, struct NewGC *gc);
diff --git a/racket/src/racket/gc2/vm_osx.c b/racket/src/racket/gc2/vm_osx.c
index 3a4365e369..cad91620b6 100644
--- a/racket/src/racket/gc2/vm_osx.c
+++ b/racket/src/racket/gc2/vm_osx.c
@@ -236,7 +236,7 @@ static unsigned long determine_max_heap_size()
 
 /* The catch_exception_raise() functions are treated specially by the
    linker, and Mach looks them up at run time. We provide
-   GC_... variants due to linker confusion when the implementaiton of
+   GC_... variants due to linker confusion when the implementation of
    these are in a framework instead of the main binary, so that the
    main binary needs to define them and jump to the implemenations
    here. (This linker problem seems to occur when we use
diff --git a/racket/src/racket/gc2/xform-mod.rkt b/racket/src/racket/gc2/xform-mod.rkt
index 1aa2691128..6fd910daf3 100644
--- a/racket/src/racket/gc2/xform-mod.rkt
+++ b/racket/src/racket/gc2/xform-mod.rkt
@@ -25,7 +25,7 @@
    #:program "xform"
    #:argv (current-command-line-arguments)
    #:once-each
-   [("--setup") dir "ignored; for compatbility with makefile"
+   [("--setup") dir "ignored; for compatibility with makefile"
     (void)]
    [("--precompile") "generate precompiled header; or set XFORM_PRECOMP"
     (set! precompiling-header? #t)]
diff --git a/racket/src/racket/main.c b/racket/src/racket/main.c
index 287ef75385..d55932f381 100644
--- a/racket/src/racket/main.c
+++ b/racket/src/racket/main.c
@@ -19,7 +19,7 @@
 /*    STANDALONE_WITH_EMBEDDED_EXTENSION builds an executable with
       built-in extensions. The extension is initialized by calling
       scheme_initialize(env), where `env' is the initial environment.
-      By default, command-line parsing, the REPL, and initilization
+      By default, command-line parsing, the REPL, and initialization
       file loading are turned off. */
 
 #ifdef STANDALONE_WITH_EMBEDDED_EXTENSION
diff --git a/racket/src/racket/sgc/sgc.c b/racket/src/racket/sgc/sgc.c
index 9ea81694bd..8857f9c7d7 100644
--- a/racket/src/racket/sgc/sgc.c
+++ b/racket/src/racket/sgc/sgc.c
@@ -152,7 +152,7 @@
 /* Keep source offsets for path traces */
 
 #define CHECK_SKIP_MARK_AT_FIRST 0
-/* Enables skipping certain marks during collection from the inital
+/* Enables skipping certain marks during collection from the initial
    root supplied as GC_initial_trace_root */
 
 #define ALLOW_SET_LOCKING 0
@@ -235,7 +235,7 @@
 /****************************************************************************/
 
 /* GC frequency: MEM_USE_FACTOR is max factor between current
-   allocated bytes and alocated bytes after last GC. */
+   allocated bytes and allocated bytes after last GC. */
 #ifdef SMALL_HASH_TABLES
 # define FIRST_GC_LIMIT 20000
 # define MEM_USE_FACTOR 1.40
@@ -901,7 +901,7 @@ static SectorPage **sector_pagetables;
      malloc_sector = returns new SECTOR_SEGMENT_SIZE-aligned memory;
                      relies on nothing else; the memeory blocks must
 		     be explicitly freed with free_sector; all GC
-		     allocation is perfomed via sectors
+		     allocation is performed via sectors
      
      malloc_managed = malloc "atomic" block used by GC implementation
                       itself; no GCing should occur during the malloc;
@@ -4482,7 +4482,7 @@ static intptr_t started, rightnow, old;
 # define PRINTTIME(x) /* empty */
 #endif
 
-/* Immitate Boehm's private GC call; used by Racket */
+/* Imitate Boehm's private GC call; used by Racket */
 void GC_push_all_stack(void *sp, void *ep)
 {
   uintptr_t s, e;
diff --git a/racket/src/racket/src/compile.c b/racket/src/racket/src/compile.c
index 4f457ad5e9..c03a7a1b6c 100644
--- a/racket/src/racket/src/compile.c
+++ b/racket/src/racket/src/compile.c
@@ -1367,7 +1367,7 @@ int scheme_get_eval_type(Scheme_Object *obj)
 }    
 
 Scheme_Object *scheme_try_apply(Scheme_Object *f, Scheme_Object *args, Optimize_Info *info)
-     /* Apply `f' to `args' and ignore failues --- used for constant
+     /* Apply `f' to `args' and ignore failures --- used for constant
         folding attempts */
 {
   Scheme_Object * volatile result;
diff --git a/racket/src/racket/src/env.c b/racket/src/racket/src/env.c
index 90c26ab661..074bcd5720 100644
--- a/racket/src/racket/src/env.c
+++ b/racket/src/racket/src/env.c
@@ -398,7 +398,7 @@ static void init_foreign(Scheme_Startup_Env *env)
 }
 
 /*========================================================================*/
-/*                     place-specific intialization                       */
+/*                     place-specific initialization                       */
 /*========================================================================*/
 
 static Scheme_Env *place_instance_init(void *stack_base, int initial_main_os_thread)
diff --git a/racket/src/racket/src/error.c b/racket/src/racket/src/error.c
index 37d6ce3037..84198b3d8f 100644
--- a/racket/src/racket/src/error.c
+++ b/racket/src/racket/src/error.c
@@ -273,7 +273,7 @@ Scheme_Config *scheme_init_error_escape_proc(Scheme_Config *config)
   %- = skip int
 
   %L = line number as intptr_t, -1 means no line
-  %R = get error numebr and string from rktio
+  %R = get error number and string from rktio
   %e = error number for strerror()
   %E = error number for platform-specific error string
   %Z = potential platform-specific error number; additional char*
diff --git a/racket/src/racket/src/file.c b/racket/src/racket/src/file.c
index 9b228e4a62..b277c27152 100644
--- a/racket/src/racket/src/file.c
+++ b/racket/src/racket/src/file.c
@@ -1608,7 +1608,7 @@ static char *do_expand_filename(Scheme_Object *o, char* filename, int ilen, cons
       drive_end = clean_start;
     }
 
-    /* Check whether to clean up the name, removing mulitple // and
+    /* Check whether to clean up the name, removing multiple // and
        adding "/" after "c:" if necessary */
     if (!drive_end 
 	&& is_drive_letter(filename[0])
diff --git a/racket/src/racket/src/fun.c b/racket/src/racket/src/fun.c
index 4d198fd1ae..71dfc7b570 100644
--- a/racket/src/racket/src/fun.c
+++ b/racket/src/racket/src/fun.c
@@ -2556,7 +2556,7 @@ const char *scheme_get_proc_name(Scheme_Object *p, int *len, int for_error)
       /* Native closure: */
       name = ((Scheme_Native_Closure *)p)->code->u2.name;
       if (name && SAME_TYPE(SCHEME_TYPE(name), scheme_lambda_type)) {
-	/* Not yet jitted. Use `name' as the other alternaive of 
+	/* Not yet jitted. Use `name' as the other alternative of 
 	   the union: */
 	name = ((Scheme_Lambda *)name)->name;
       }
@@ -6257,7 +6257,7 @@ static Scheme_Object *continuation_p (int argc, Scheme_Object *argv[])
 }
 
 void scheme_takeover_stacks(Scheme_Thread *p)
-     /* When a contination captured in on e thread is invoked in another,
+     /* When a continuation captured in on e thread is invoked in another,
 	the two threads can start using the same runstack, and possibly
 	also the same cont-mark stack. This function swaps out the
 	current owner in favor of p */
diff --git a/racket/src/racket/src/future.c b/racket/src/racket/src/future.c
index 89f1a3b21e..98c5d9416d 100644
--- a/racket/src/racket/src/future.c
+++ b/racket/src/racket/src/future.c
@@ -1354,7 +1354,7 @@ Scheme_Object *scheme_future(int argc, Scheme_Object *argv[])
         && scheme_native_arity_check(proc, 0)
         && (((Scheme_Native_Closure *)proc)->code->start_code != scheme_on_demand_jit_code)
         && scheme_can_apply_native_in_future(proc)) {
-      /* try to alocate a future in the future thread */
+      /* try to allocate a future in the future thread */
       future_t *ft;
       ft = MALLOC_ONE_TAGGED(future_t);
       if (ft) {
diff --git a/racket/src/racket/src/hamt_subset.inc b/racket/src/racket/src/hamt_subset.inc
index 1424c271e6..2df44ba577 100644
--- a/racket/src/racket/src/hamt_subset.inc
+++ b/racket/src/racket/src/hamt_subset.inc
@@ -112,7 +112,7 @@ HAMT_NONGCING int HAMT_SUBSET_OF(Scheme_Hash_Tree *t1, Scheme_Hash_Tree *t2, int
               return 0;
           }
         } else {
-          /* A single element in t2 can't cover eveything in the collision */
+          /* A single element in t2 can't cover everything in the collision */
           return 0;
         }
       } else {
@@ -129,7 +129,7 @@ HAMT_NONGCING int HAMT_SUBSET_OF(Scheme_Hash_Tree *t1, Scheme_Hash_Tree *t2, int
           if (_mzHAMT_CODE(t1, pos1, popcount1) != _mzHAMT_CODE(t2, pos2, popcount2))
             return 0;
           if (HASHTR_COLLISIONP(k2)) {
-            /* look for an invidual value in t2: */
+            /* look for an individual value in t2: */
             if (!HAMT_ELEMENT_OF_COLLISION(k1, HAMT_IF_VAL(_mzHAMT_VAL(t1, pos1, popcount1), NULL),
                                            (Scheme_Hash_Tree *)k2,
                                            stype, eql_data))
diff --git a/racket/src/racket/src/jit.c b/racket/src/racket/src/jit.c
index ad146a6560..88b870ffbf 100644
--- a/racket/src/racket/src/jit.c
+++ b/racket/src/racket/src/jit.c
@@ -2612,7 +2612,7 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w
         (void)jit_jmpi(refloop);
         CHECK_LIMIT();
         mz_patch_branch(ref3);
-        /* clear array pointer and re-laod argc: */
+        /* clear array pointer and re-load argc: */
         (void)mz_tl_ldi_p(JIT_R0, tl_scheme_current_thread);
         (void)jit_movi_p(JIT_R1, NULL);
         jit_stxi_l(&((Scheme_Thread *)0x0)->ku.multiple.array, JIT_R0, JIT_R1);
diff --git a/racket/src/racket/src/letrec_check.c b/racket/src/racket/src/letrec_check.c
index ac66a8668a..a38a17eb31 100644
--- a/racket/src/racket/src/letrec_check.c
+++ b/racket/src/racket/src/letrec_check.c
@@ -40,7 +40,7 @@
  *
  * - When `lambda` is in such a position, record the `lambda`
  *   expression as "deferred" for the variable --- but only if the
- *   varible was not previously accessed in an unsafe position. (Grep
+ *   variable was not previously accessed in an unsafe position. (Grep
  *   "EXPL-4" for implementation.) Each deferred expression will be
  *   forced at most once.
  *
@@ -713,7 +713,7 @@ static Scheme_Object *letrec_check_lets(Scheme_Object *o, Letrec_Check_Frame *ol
     frame_type = FRAME_TYPE_LET; 
 
   /* push the new bindings on to the frame, where `frame_type`
-     determines how the variables are initialzed and counted when
+     determines how the variables are initialized and counted when
      resolving local-variable offsets */
   frame = init_letrec_check_frame(frame_type, LET_RHS_EXPR,
                                   count, old_frame, NULL,
diff --git a/racket/src/racket/src/mk-uchar.rkt b/racket/src/racket/src/mk-uchar.rkt
index c3e2ea15f6..301845ee45 100644
--- a/racket/src/racket/src/mk-uchar.rkt
+++ b/racket/src/racket/src/mk-uchar.rkt
@@ -111,7 +111,7 @@
 	(set! range-top c))
       (begin
 	;; Drop surrogate from range.
-	;;  At the time of implemenation, the following
+	;;  At the time of implementation, the following
 	;;  was never executed, because #D7FF wasn't mapped:
 	(when (and (< range-bottom #xD800)
 		   (> range-top #xD800))
diff --git a/racket/src/racket/src/network.c b/racket/src/racket/src/network.c
index fa26d31ce0..c7af08ace1 100644
--- a/racket/src/racket/src/network.c
+++ b/racket/src/racket/src/network.c
@@ -1691,7 +1691,7 @@ void scheme_close_socket_fd(intptr_t fd)
 /*                                 UDP                                    */
 /*========================================================================*/
 
-/* Based on a design and implemenation by Eduardo Cavazos. */
+/* Based on a design and implementation by Eduardo Cavazos. */
 
 typedef struct Scheme_UDP_Evt {
   Scheme_Object so; /* scheme_udp_evt_type */
diff --git a/racket/src/racket/src/number.c b/racket/src/racket/src/number.c
index ca62214756..5a5e5ca3df 100644
--- a/racket/src/racket/src/number.c
+++ b/racket/src/racket/src/number.c
@@ -3392,7 +3392,7 @@ static long_double protected_powl(long_double x, long_double y)
 #else
 XFORM_NONGCING static double sch_pow(double x, double y)
 {
-  /* Explciitly handle all cases described by C99 */
+  /* Explicitly handle all cases described by C99 */
   if (x == 1.0)
     return 1.0; /* even for NaN */
   else if (y == 0.0)
diff --git a/racket/src/racket/src/numstr.c b/racket/src/racket/src/numstr.c
index a3095c5ba2..c5ad62e1e2 100644
--- a/racket/src/racket/src/numstr.c
+++ b/racket/src/racket/src/numstr.c
@@ -356,7 +356,7 @@ static Scheme_Object *read_special_number(const mzchar *str, int pos)
 
 /* Exponent threshold for obvious infinity. Must be at least
    max(MAX_FAST_FLOATREAD_LEN, MAX_FLOATREAD_PRECISION_DIGITS) more
-   than the larget possible FP exponent. */
+   than the largest possible FP exponent. */
 #define CHECK_INF_EXP_THRESHOLD(extfl) (extfl ? 32768 : 2048)
 
 /* Don't bother reading more than the following number of digits in a
diff --git a/racket/src/racket/src/optimize.c b/racket/src/racket/src/optimize.c
index 95eb8defef..f596bb9dc1 100644
--- a/racket/src/racket/src/optimize.c
+++ b/racket/src/racket/src/optimize.c
@@ -1159,7 +1159,7 @@ static int is_proc_spec_proc(Scheme_Object *p, int init_field_count)
 
 static int is_local_ref(Scheme_Object *e, int p, int r, Scheme_IR_Local **vars)
 /* Does `e` refer to...
-    In resolved mode: variables at offet `p` though `p+r`?
+    In resolved mode: variables at offset `p` though `p+r`?
     In optimizer IR mode: variables in `vars`? */
 {
   if (!vars && SAME_TYPE(SCHEME_TYPE(e), scheme_local_type)) {
diff --git a/racket/src/racket/src/schpriv.h b/racket/src/racket/src/schpriv.h
index fb4046c985..152d77f40a 100644
--- a/racket/src/racket/src/schpriv.h
+++ b/racket/src/racket/src/schpriv.h
@@ -1389,7 +1389,7 @@ typedef struct Scheme_IR_Local
      are not yet initialized: */
   unsigned int optimize_unready : 1;
   /* After optimizing a `let[rec]` form, we might still go into
-     the body (e.g., for funciton inlining), but mark the variable
+     the body (e.g., for function inlining), but mark the variable
      as having a binding set up: */
   unsigned int optimize_outside_binding : 1;
   /* Records an anlaysis during the resolve pass: */
diff --git a/racket/src/racket/src/struct.c b/racket/src/racket/src/struct.c
index 9b993a99eb..35b4fcfe89 100644
--- a/racket/src/racket/src/struct.c
+++ b/racket/src/racket/src/struct.c
@@ -1586,7 +1586,7 @@ static int evt_struct_is_ready(Scheme_Object *o, Scheme_Schedule_Info *sinfo)
       result = scheme_apply(f, 1, a);
 
       if (scheme_is_evt(result)) {
-	SCHEME_USE_FUEL(1); /* Needed beause an apply of a mzc-generated function
+	SCHEME_USE_FUEL(1); /* Needed because an apply of a mzc-generated function
 			       might not check for breaks. */
 	scheme_set_sync_target(sinfo, result, NULL, NULL, 0, 1, NULL);
 	return 0;
diff --git a/racket/src/racket/src/thread.c b/racket/src/racket/src/thread.c
index 4b41b8556e..5b6ab7adbc 100644
--- a/racket/src/racket/src/thread.c
+++ b/racket/src/racket/src/thread.c
@@ -8935,7 +8935,7 @@ static void run_gc_callbacks(int pre)
       for (j = 0; j < SCHEME_VEC_SIZE(acts); j++) {
         act = SCHEME_VEC_ELS(acts)[j];
         protocol = SCHEME_VEC_ELS(act)[0];
-        /* The set of suported protocols is arbitrary, based on what we've needed
+        /* The set of supported protocols is arbitrary, based on what we've needed
            so far. */
         if (!strcmp(SCHEME_SYM_VAL(protocol), "int->void")) {
           gccb_Int_to_Void proc;
diff --git a/racket/src/rktio/rktio.h b/racket/src/rktio/rktio.h
index ef4b9b490f..3cc6b4dbb4 100644
--- a/racket/src/rktio/rktio.h
+++ b/racket/src/rktio/rktio.h
@@ -1180,7 +1180,7 @@ RKTIO_EXTERN void rktio_set_locale(rktio_t *rktio, rktio_const_string_t name);
 
 RKTIO_EXTERN_NOERR char *rktio_push_c_numeric_locale(rktio_t *rktio);
 RKTIO_EXTERN void rktio_pop_c_numeric_locale(rktio_t *rktio, char *prev);
-/* Use this pair of funtions to temporarily switch the locale to the C
+/* Use this pair of functions to temporarily switch the locale to the C
    locale for number parsing and printing. The result of the first
    function is deallocated when passed to second function. */
 
diff --git a/racket/src/rktio/rktio_network.c b/racket/src/rktio/rktio_network.c
index 0cdb330e9e..68b83fae05 100644
--- a/racket/src/rktio/rktio_network.c
+++ b/racket/src/rktio/rktio_network.c
@@ -1103,7 +1103,7 @@ static intptr_t do_socket_write(rktio_t *rktio, rktio_fd_t *rfd, const char *buf
 
   while (1) {
     if (addr) {
-      /* Use first address that dosn't result in a bad-address error: */
+      /* Use first address that doesn't result in a bad-address error: */
       for (; addr; addr = (rktio_addrinfo_t *)RKTIO_AS_ADDRINFO(addr)->ai_next) {
         do {
           sent = sendto(s, buffer, len, 0,
diff --git a/racket/src/rktio/rktio_poll_set.c b/racket/src/rktio/rktio_poll_set.c
index ee7066adf5..2c230bf5ee 100644
--- a/racket/src/rktio/rktio_poll_set.c
+++ b/racket/src/rktio/rktio_poll_set.c
@@ -353,7 +353,7 @@ static rktio_poll_set_t *alloc_fdset_arrays(rktio_t *rktio)
 #endif
 
   /* Allocate an array with 1 extra intptr_t in each set to hold a
-     "max" fd counter, and 1 extra intger used to record "no
+     "max" fd counter, and 1 extra integer used to record "no
      sleeping" */
 
   p = malloc(3 * (dynamic_fd_size + sizeof(intptr_t) + sizeof(int)));
diff --git a/racket/src/schemify/interp-stack.rkt b/racket/src/schemify/interp-stack.rkt
index de6c7da9b4..d1b0c4817e 100644
--- a/racket/src/schemify/interp-stack.rkt
+++ b/racket/src/schemify/interp-stack.rkt
@@ -71,7 +71,7 @@
 ;; Compile-time stack information
 
 (struct stack-info (capture-depth   ; boundary for the enclosing function in compile-time env
-                    closure-map     ; hash table to collect variables byond boundary to capture
+                    closure-map     ; hash table to collect variables beyond boundary to capture
                     [use-map #:mutable] ; table of uses; an entry here means the binding is used later
                     [local-use-map #:mutable] ; subset of `use-map` used to tracked needed merging for branches
                     [non-tail-call-later? #:mutable])) ; non-tail call afterward?
@@ -111,7 +111,7 @@
     [else
      ;; Record the use of this position. If it's the last use (i.e.,
      ;; first from the end), then box the position, which means "clear
-     ;; after retreiving" and implements space safety.
+     ;; after retrieving" and implements space safety.
      (define use-map (stack-info-use-map stk-i))
      (cond
        [(or (not use-map)
diff --git a/racket/src/schemify/interpret.rkt b/racket/src/schemify/interpret.rkt
index 837168e0c1..e9e07cadff 100644
--- a/racket/src/schemify/interpret.rkt
+++ b/racket/src/schemify/interpret.rkt
@@ -906,7 +906,7 @@
               (let loop ([i 3] [captureds captureds] [full-mask 0])
                 (cond
                   [(fx= i n)
-                   ;; We shouldn't get here, because the wrapper shoudl enforce arity,
+                   ;; We shouldn't get here, because the wrapper should enforce arity,
                    ;; but just in case:
                    (apply raise-arity-mask-error '|#| full-mask args)]
                   [else
diff --git a/racket/src/schemify/schemify.rkt b/racket/src/schemify/schemify.rkt
index f13dbd43d8..4b966bab48 100644
--- a/racket/src/schemify/schemify.rkt
+++ b/racket/src/schemify/schemify.rkt
@@ -54,7 +54,7 @@
 ;;   - convert all `letrec` patterns that might involve `call/cc` to
 ;;     ensure that locations are allocated at the right time;
 ;;
-;;   - explicily handle all potential too-early variable uses, so that
+;;   - explicitly handle all potential too-early variable uses, so that
 ;;     the right name and enclosing module are reported;
 ;;
 ;;   - convert `make-struct-type` bindings to a pattern that Chez can
diff --git a/racket/src/setup-go.rkt b/racket/src/setup-go.rkt
index 98dc6e3266..4dc81a5848 100644
--- a/racket/src/setup-go.rkt
+++ b/racket/src/setup-go.rkt
@@ -73,7 +73,7 @@
         (loop (add1 n))))
 
     (with-handlers ([exn? (lambda (exn)
-                            ;; On any execption, try to delete the target file
+                            ;; On any exception, try to delete the target file
                             (with-handlers ([exn:fail:filesystem?
                                              (lambda (exn) (log-error "~s" exn))])
                               (when (file-exists? target-file)
diff --git a/racket/src/thread/place-message.rkt b/racket/src/thread/place-message.rkt
index fa5dfd4b9e..c8cc7adf96 100644
--- a/racket/src/thread/place-message.rkt
+++ b/racket/src/thread/place-message.rkt
@@ -13,7 +13,7 @@
          prop:place-message)
 
 ;; A prop:place-message value is a procedure that takes self
-;; and returns either #f [=> not a place mesage after all] or
+;; and returns either #f [=> not a place message after all] or
 ;; (-> (-> v))
 (define-values (prop:place-message place-message? place-message-ref)
   (make-struct-type-property 'place-message))
diff --git a/racket/src/worksp/libffi/ffi.h b/racket/src/worksp/libffi/ffi.h
index 7c52e2b2be..bf25f3d3b4 100644
--- a/racket/src/worksp/libffi/ffi.h
+++ b/racket/src/worksp/libffi/ffi.h
@@ -304,7 +304,7 @@ typedef struct {
 
   /* if this is enabled, then a raw closure has the same layout 
      as a regular closure.  We use this to install an intermediate 
-     handler to do the transaltion, void** -> ffi_raw*. */
+     handler to do the translation, void** -> ffi_raw*. */
 
   void     (*translate_args)(ffi_cif*,void*,void**,void*);
   void      *this_closure;
@@ -325,7 +325,7 @@ typedef struct {
 
   /* if this is enabled, then a raw closure has the same layout 
      as a regular closure.  We use this to install an intermediate 
-     handler to do the transaltion, void** -> ffi_raw*. */
+     handler to do the translation, void** -> ffi_raw*. */
 
   void     (*translate_args)(ffi_cif*,void*,void**,void*);
   void      *this_closure;