diff --git a/Makefile b/Makefile index 13096b81be..3b78288887 100644 --- a/Makefile +++ b/Makefile @@ -45,7 +45,7 @@ DEFAULT_SRC_CATALOG = https://pkgs.racket-lang.org PLT_SETUP_OPTIONS = # Belongs in the "Configuration options" section, but here -# to accomodate nmake: +# to accommodate nmake: SRC_CATALOG = $(DEFAULT_SRC_CATALOG) CPUS = diff --git a/README.md b/README.md index bfe69ff10a..da9d649409 100644 --- a/README.md +++ b/README.md @@ -7,7 +7,7 @@ Quick Start ----------- Pre-built versions of Racket for a variety of operating systems and -architectures, as well as convienient source distributions are +architectures, as well as convenient source distributions are available at [https://download.racket-lang.org](https://download.racket-lang.org) diff --git a/pkgs/racket-benchmarks/tests/racket/benchmarks/common/index-template.html b/pkgs/racket-benchmarks/tests/racket/benchmarks/common/index-template.html index e9b3d60b42..b27bbefdcb 100644 --- a/pkgs/racket-benchmarks/tests/racket/benchmarks/common/index-template.html +++ b/pkgs/racket-benchmarks/tests/racket/benchmarks/common/index-template.html @@ -51,7 +51,7 @@ every other benchmark’s compile time.

These configurations are all “safe mode,” but they allow a compiler to assume that built-in Scheme functions are not redefined -and that no top-level defintion is ever changed. Such assumptions +and that no top-level definition is ever changed. Such assumptions correspond to putting the benchmark in an R6RS library. We attempt to use the various implementations in a compentent way, but not in a sophisticated way. For example, we do not tweak inlining parameters or diff --git a/pkgs/racket-benchmarks/tests/racket/benchmarks/common/psyntax-input.txt b/pkgs/racket-benchmarks/tests/racket/benchmarks/common/psyntax-input.txt index 4bc27130f1..3a8d047284 100644 --- a/pkgs/racket-benchmarks/tests/racket/benchmarks/common/psyntax-input.txt +++ b/pkgs/racket-benchmarks/tests/racket/benchmarks/common/psyntax-input.txt @@ -215,7 +215,7 @@ ;;; implementation for this code to run. ;;; ;;; (voide) -;;; returns the implementation's cannonical "unspecified value". The +;;; returns the implementation's canonical "unspecified value". The ;;; following usually works: ;;; ;;; (define voide (lambda () (if #f #f))). @@ -298,7 +298,7 @@ ;;; When porting to a new Scheme implementation, you should define the ;;; procedures listed above, load the expanded version of psyntax.ss -;;; (psyntax.pp, which should be available whereever you found +;;; (psyntax.pp, which should be available wherever you found ;;; psyntax.ss), and register sc-expand as the current expander (how ;;; you do this depends upon your implementation of Scheme). You may ;;; change the hooks and constructors defined toward the beginning of @@ -1054,7 +1054,7 @@ ;;; and pairs <> ;;; indirect labels, which are implemented as pairs, are used to support -;;; import aliasing for identifiers exported (explictly or implicitly) from +;;; import aliasing for identifiers exported (explicitly or implicitly) from ;;; top-level modules. chi-external creates an indirect label for each ;;; defined identifier, import causes the pair to be shared with aliases it ;;; establishes, and chi-top-module whacks the pair to hold the top-level diff --git a/pkgs/racket-doc/scribblings/foreign/com-auto.scrbl b/pkgs/racket-doc/scribblings/foreign/com-auto.scrbl index b46a3aea34..60a49f5a04 100644 --- a/pkgs/racket-doc/scribblings/foreign/com-auto.scrbl +++ b/pkgs/racket-doc/scribblings/foreign/com-auto.scrbl @@ -17,7 +17,7 @@ interface.} @margin-note{The @racketmodname[ffi/com] library is based on the @deftech{MysterX} library by Paul Steckler. MysterX is included with Racket but deprecated, and it will be replaced in the next version -with a partial compability library that redirects to this one.} +with a partial compatibility library that redirects to this one.} @; ---------------------------------------- diff --git a/pkgs/racket-doc/scribblings/foreign/com-intf.scrbl b/pkgs/racket-doc/scribblings/foreign/com-intf.scrbl index f7545751e5..83342ecfec 100644 --- a/pkgs/racket-doc/scribblings/foreign/com-intf.scrbl +++ b/pkgs/racket-doc/scribblings/foreign/com-intf.scrbl @@ -59,8 +59,8 @@ information for a method along the lines of @racketmodname[ffi/unsafe/alloc]. If the @racket[maybe-alloc-spec] is @racket[#:release-with-function function-id], then @racket[function-id] is used to deallocate the result produced by the -method, unless the result is explictly deallocated before it becomes -unreachable; for exmaple, @racket[#:release-with-function Release] is +method, unless the result is explicitly deallocated before it becomes +unreachable; for example, @racket[#:release-with-function Release] is suitable for a method that returns a COM interface reference that must be eventually released. The @racket[#:release-with-method method-id] form is similar, except that the deallocator is a method on the same diff --git a/pkgs/racket-doc/scribblings/raco/test.scrbl b/pkgs/racket-doc/scribblings/raco/test.scrbl index 27e1811431..3fb82c29ad 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} enviornment varible or + determined by the @envvar{PLTLOCKDIR} environment varible 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/raco/zo-struct.scrbl b/pkgs/racket-doc/scribblings/raco/zo-struct.scrbl index 5d0f527d1c..3fb9e44d37 100644 --- a/pkgs/racket-doc/scribblings/raco/zo-struct.scrbl +++ b/pkgs/racket-doc/scribblings/raco/zo-struct.scrbl @@ -109,7 +109,7 @@ structures that are produced by @racket[zo-parse] and consumed by original source names for the definition. The @racket[source-names] table is used only for debugging. - When a linklet is instantiated, variables correponding to the + When a linklet is instantiated, variables corresponding to the flattening of the lists @racket[importss], @racket[exports], @racket[internals], and @racket[lifts] are placed in an array (in that order) for access via @racket[toplevel] references. The initial diff --git a/pkgs/racket-doc/syntax/scribblings/parse/stxclasses.scrbl b/pkgs/racket-doc/syntax/scribblings/parse/stxclasses.scrbl index 074c14e723..2a0f8f3a8a 100644 --- a/pkgs/racket-doc/syntax/scribblings/parse/stxclasses.scrbl +++ b/pkgs/racket-doc/syntax/scribblings/parse/stxclasses.scrbl @@ -142,7 +142,7 @@ It is an error to use both @racket[#:commit] and Declares the literals and conventions that apply to the syntax class's variant patterns and their immediate @racket[#:with] clauses. Patterns -occuring within subexpressions of the syntax class (for example, on +occurring within subexpressions of the syntax class (for example, on the right-hand side of a @racket[#:fail-when] clause) are not affected. diff --git a/pkgs/racket-test-core/tests/racket/chaperone.rktl b/pkgs/racket-test-core/tests/racket/chaperone.rktl index 78a74c8bbc..0d562f1e90 100644 --- a/pkgs/racket-test-core/tests/racket/chaperone.rktl +++ b/pkgs/racket-test-core/tests/racket/chaperone.rktl @@ -3441,7 +3441,7 @@ (test #t impersonator? (impersonate-struct (b 1 2 3 4) set-a-y! void))) ;; ---------------------------------------- -;; Make sure `struct->vector` doesnt' have memory-management issues +;; Make sure `struct->vector` doesn't have memory-management issues ;; with impersonated structs: (let () diff --git a/pkgs/racket-test-core/tests/racket/file.rktl b/pkgs/racket-test-core/tests/racket/file.rktl index 38f39df769..c66d12d77e 100644 --- a/pkgs/racket-test-core/tests/racket/file.rktl +++ b/pkgs/racket-test-core/tests/racket/file.rktl @@ -2091,7 +2091,7 @@ ;; Wait until the other end has read: (write-bytes-avail #"noise" (current-output-port)) (close-output-port (current-output-port)) - ;; Drain the OS-level input pipe, suceeding if we + ;; Drain the OS-level input pipe, succeeding if we ;; find a "!". (let loop () (define b (read-byte (current-input-port))) diff --git a/pkgs/racket-test-core/tests/racket/optimize.rktl b/pkgs/racket-test-core/tests/racket/optimize.rktl index 7aeb05f7af..9aec6ae377 100644 --- a/pkgs/racket-test-core/tests/racket/optimize.rktl +++ b/pkgs/racket-test-core/tests/racket/optimize.rktl @@ -914,7 +914,7 @@ (test-comp '(lambda (w) (cons)) '(lambda (w) (cons) (k:random))) -; test for unary aplications +; test for unary applications (test-comp -1 '(- 1)) (test-comp '(lambda (f) (begin (f) -1)) @@ -1205,7 +1205,7 @@ x) '3) -;; The compiler doens't currently recognize the expansion of `quote-syntax` +;; The compiler doesn't currently recognize the expansion of `quote-syntax` #; (test-comp '(if (lambda () 10) 'ok @@ -2161,7 +2161,7 @@ (void 10)) '(module m racket/base)) -;; The compiler doens't currently recognize the expansion of `quote-syntax` +;; The compiler doesn't currently recognize the expansion of `quote-syntax` #; (test-comp '(module m racket/base (void (quote-syntax unused!))) @@ -4727,7 +4727,7 @@ (err/rt-test (cwv-2-5-f (lambda () (values 1 2 3)) (lambda (y z) (+ y 2))) exn:fail:contract:arity?) ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Transform call-with-values to direct aplication: +;; Transform call-with-values to direct application: (test-comp '(lambda (f) (f 7)) '(lambda (f) (call-with-values (lambda () 7) (lambda (x) (f x))))) (test-comp '(lambda () (car 7)) @@ -5254,7 +5254,7 @@ list))) ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Originally: make sure compiler isn't too agressive for the +;; Originally: make sure compiler isn't too aggressive for the ;; validator in terms of typed arguments: (let ([m '(module m racket/base diff --git a/pkgs/racket-test-core/tests/racket/serialize.rktl b/pkgs/racket-test-core/tests/racket/serialize.rktl index 057b3d5f4b..e6f2a1b298 100644 --- a/pkgs/racket-test-core/tests/racket/serialize.rktl +++ b/pkgs/racket-test-core/tests/racket/serialize.rktl @@ -23,7 +23,7 @@ (serializable-struct d/auto b/auto ([v #:auto #:mutable]) #:inspector insp) (define (same? v1 v2) - ;; This is not quite the same as `equal?', becuase it knows + ;; This is not quite the same as `equal?', because it knows ;; about the structure types a, b, etc. (define ht (make-hasheq)) (let loop ([v1 v1][v2 v2]) diff --git a/pkgs/racket-test-core/tests/racket/string.rktl b/pkgs/racket-test-core/tests/racket/string.rktl index c7f8106216..23e526e3a4 100644 --- a/pkgs/racket-test-core/tests/racket/string.rktl +++ b/pkgs/racket-test-core/tests/racket/string.rktl @@ -547,7 +547,7 @@ (test #f string-contains? "" "racket") (test #f string-contains? "racket" "a..e") (test #t string-contains? "ra..et" "a..e") - ; string-contains? sometimes uses diferent code paths for short and long string, + ; string-contains? sometimes uses different code paths for short and long string, ; so add some long test too. (test #t string-contains? "racket012345678901234567890123456789012345678901234567890123456789racket" "racket012345678901234567890123456789012345678901234567890123456789racket") diff --git a/pkgs/racket-test-core/tests/racket/syntax.rktl b/pkgs/racket-test-core/tests/racket/syntax.rktl index aef170f6fa..ae3d8f3c5d 100644 --- a/pkgs/racket-test-core/tests/racket/syntax.rktl +++ b/pkgs/racket-test-core/tests/racket/syntax.rktl @@ -1823,7 +1823,7 @@ (q))))))) ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; check that the compiler is not too agressive with `letrec' -> `let*' +;; check that the compiler is not too aggressive with `letrec' -> `let*' (test "\nready\n" get-output-string diff --git a/pkgs/racket-test/tests/racket/contract/make-contract.rkt b/pkgs/racket-test/tests/racket/contract/make-contract.rkt index 0af6f061c0..fff49b50a3 100644 --- a/pkgs/racket-test/tests/racket/contract/make-contract.rkt +++ b/pkgs/racket-test/tests/racket/contract/make-contract.rkt @@ -210,7 +210,7 @@ val "bad"))))) #:name (λ (x) 'the-name) - ;; make a very aproximate first-order check + ;; make a very approximate first-order check #:first-order (λ (c) (λ (x) #t)) #:stronger (λ (x y) #f))) @@ -240,7 +240,7 @@ "bad")]))))) #:list-contract? (λ (c) #t) #:name (λ (x) 'the-name) - ;; make a very aproximate first-order check + ;; make a very approximate first-order check #:first-order (λ (c) (λ (x) #t)) #:stronger (λ (x y) #f))) (list-contract? (odd-length-list-of-integers))) diff --git a/pkgs/racket-test/tests/racket/contract/random-generate.rkt b/pkgs/racket-test/tests/racket/contract/random-generate.rkt index b9533cdf27..e104ce7052 100644 --- a/pkgs/racket-test/tests/racket/contract/random-generate.rkt +++ b/pkgs/racket-test/tests/racket/contract/random-generate.rkt @@ -271,7 +271,7 @@ any/c number?))))) -;; in this test, the and/c shoudl generate a dynamic +;; in this test, the and/c should generate a dynamic ;; failure, which should trigger the 'cons/c' failing ;; it shouldn't make a pair of a strange value and #t (check-not-exn diff --git a/racket/collects/net/git-checkout.rkt b/racket/collects/net/git-checkout.rkt index 26714a47e3..c2213569c0 100644 --- a/racket/collects/net/git-checkout.rkt +++ b/racket/collects/net/git-checkout.rkt @@ -177,7 +177,7 @@ (retry-loop #f #f #f))))))) (maybe-save-objects objs "objs") - ;; Convert deltas into full objects withing `tmp`: + ;; Convert deltas into full objects within `tmp`: (rewrite-deltas objs tmp status)])) (maybe-save-objects obj-ids "all-objs") @@ -397,7 +397,7 @@ (values ref-commit want-commits)) ;; ---------------------------------------- -;; A "pkt" is the basic unit of communiation in many parts +;; A "pkt" is the basic unit of communication in many parts ;; of the git protocol. The first four bytes specify the ;; length of the package (including those bytes). diff --git a/racket/collects/planet/private/planet-shared.rkt b/racket/collects/planet/private/planet-shared.rkt index c95280a4b3..18ecc3ec1f 100644 --- a/racket/collects/planet/private/planet-shared.rkt +++ b/racket/collects/planet/private/planet-shared.rkt @@ -798,7 +798,7 @@ Various common pieces of code that both the client and server need to access (λ () (do-installation)) (λ () (close-output-port p))))] [else - ;; we didn't get the lock (and didn't alreayd have it); poll for the SUCCESS FILE + ;; we didn't get the lock (and didn't already have it); poll for the SUCCESS FILE (planet-log "waiting for someone else to finish installation in ~s" dir) (let loop () (cond diff --git a/racket/collects/racket/HISTORY.txt b/racket/collects/racket/HISTORY.txt index 96b8d5cb6d..a144a8426f 100644 --- a/racket/collects/racket/HISTORY.txt +++ b/racket/collects/racket/HISTORY.txt @@ -520,7 +520,7 @@ Changed eqv? so that inexacts are equivalent only when they Changed file-or-directory-permission to add 'bits mode and permission-setting mode Added special treatment of void as an 'inferred-name property -Removed the "MrEd" compatability executable under Windows +Removed the "MrEd" compatibility executable under Windows and Mac OS X, but the "mred" compatibility script remains racket/gui: added multi-column support to list-box% racket/gui: added scrollbar support to panel%, vertical-panel%, diff --git a/racket/collects/racket/contract/region.rkt b/racket/collects/racket/contract/region.rkt index 053292d221..7f54c958b8 100644 --- a/racket/collects/racket/contract/region.rkt +++ b/racket/collects/racket/contract/region.rkt @@ -601,7 +601,7 @@ ;; rewrite-define returns: ;; * The unused parts of id-info ;; * The definition, possibly rewritten to replace certain identifiers - ;; along with any auxillary definitions that should be introduced + ;; along with any auxiliary definitions that should be introduced ;; (contract and external id defs) (define (rewrite-define head ids expr) (let ([id-pairs (map syntax->list (syntax->list #'id-info))]) diff --git a/racket/collects/racket/list.rkt b/racket/collects/racket/list.rkt index 1283a38b54..0f471d4cb0 100644 --- a/racket/collects/racket/list.rkt +++ b/racket/collects/racket/list.rkt @@ -183,7 +183,7 @@ (cons x (loop (cdr list))) '())) ;; could return `list' here, but make it behave like `take' - ;; exmaple: (takef '(a b c . d) symbol?) should be similar + ;; example: (takef '(a b c . d) symbol?) should be similar ;; to (take '(a b c . d) 3) '()))) diff --git a/racket/collects/racket/vector.rkt b/racket/collects/racket/vector.rkt index 9e21a3ddba..f885746ffc 100644 --- a/racket/collects/racket/vector.rkt +++ b/racket/collects/racket/vector.rkt @@ -273,7 +273,7 @@ (unless (vector? vec) (raise-argument-error 'vector-sort "vector?" vec)) - ;; calulate end if not provided + ;; calculate end if not provided (let ([end (or end (vector-length vec))]) (perform-common-sort-arg-checks vector-sort vec less? start end getkey) (if getkey @@ -290,7 +290,7 @@ "(and/c vector? (not/c immutable?))" vec)) - ;; calulate end if not provided + ;; calculate end if not provided (let ([end (or end (vector-length vec))]) (perform-common-sort-arg-checks vector-sort! vec less? start end getkey) (if getkey diff --git a/racket/collects/version/check.rkt b/racket/collects/version/check.rkt index b2f7a7fb0e..7bb9cbbb9d 100644 --- a/racket/collects/version/check.rkt +++ b/racket/collects/version/check.rkt @@ -87,7 +87,7 @@ ;; You have an old version, please upgrade to `version' you may consider also ;; the alpha version ;; * `(error ,message [,additional-info]) -;; An error occured, the third (optional) value can be shown as the system +;; An error occurred, the third (optional) value can be shown as the system ;; error that happened or the value that caused an error. (provide check-version) (define (check-version) diff --git a/racket/collects/xml/private/reader.rkt b/racket/collects/xml/private/reader.rkt index 3cbf978453..3ba469ee0e 100644 --- a/racket/collects/xml/private/reader.rkt +++ b/racket/collects/xml/private/reader.rkt @@ -327,7 +327,7 @@ (loop))))) ;; lex-pcdata : Input-port (-> Location) -> Pcdata -;; deviation - disallow ]]> "for compatability" with SGML, sec 2.4 XML spec +;; deviation - disallow ]]> "for compatibility" with SGML, sec 2.4 XML spec (define (lex-pcdata in pos) (let ([start (pos)] [data (let loop () diff --git a/racket/src/README.txt b/racket/src/README.txt index d49dadbf79..e3778796fa 100644 --- a/racket/src/README.txt +++ b/racket/src/README.txt @@ -372,7 +372,7 @@ Some less commonly needed `configure` flags for traditional Racket: * `--enable-bigendian`, if target platform is big-endian. - * `--enable-cify` or `--disable-cify` if the JIT availablity on the + * `--enable-cify` or `--disable-cify` if the JIT availability on the target platform is different than the build platform; use `--enable-cify` if the JIT is not abailable on the target platform. diff --git a/racket/src/cify/README.txt b/racket/src/cify/README.txt index 4dd77d5ca0..7bbc1cf8d5 100644 --- a/racket/src/cify/README.txt +++ b/racket/src/cify/README.txt @@ -14,7 +14,7 @@ Compilation by cify is UNSAFE. For example: is applied to an instance of the struct, and so on. * cify assumes that a variable is not referenced before its - defintion. + definition. * cify assumes that a function defined within the linklet is called within the linklet with the right number of arguments. diff --git a/racket/src/cify/ref.rkt b/racket/src/cify/ref.rkt index 8631811f50..39ea20e65b 100644 --- a/racket/src/cify/ref.rkt +++ b/racket/src/cify/ref.rkt @@ -18,7 +18,7 @@ wrap-ref) -;; Wrap each refernce to a local variable with a `ref` record, which +;; Wrap each reference to a local variable with a `ref` record, which ;; provides an identity for tracking last references to implement ;; space safety. diff --git a/racket/src/cs/bootstrap/README.txt b/racket/src/cs/bootstrap/README.txt index 235105857b..aec527546c 100644 --- a/racket/src/cs/bootstrap/README.txt +++ b/racket/src/cs/bootstrap/README.txt @@ -16,4 +16,4 @@ Chez Scheme. While the similation of Chez Scheme should be robust to common Chez Scheme changes, it does rely on details of the Chez Scheme implementation and source, So, the simulation will have to be updated -to accomodate some Chez Scheme changes. +to accommodate some Chez Scheme changes. diff --git a/racket/src/cs/rumble/memory.ss b/racket/src/cs/rumble/memory.ss index a6e8b717ba..ecf8d6ac1f 100644 --- a/racket/src/cs/rumble/memory.ss +++ b/racket/src/cs/rumble/memory.ss @@ -423,7 +423,7 @@ [else #'(foreign-procedure s ...)])])) ;; This is an inconvenient callback interface, certainly, but it -;; accomodates a limitation of the traditional Racket implementation +;; accommodates a limitation of the traditional Racket implementation (define (run-one-collect-callback v save sel) (let ([protocol (#%vector-ref v 0)] [proc (cpointer-address (#%vector-ref v 1))] diff --git a/racket/src/expander/compile/serialize.rkt b/racket/src/expander/compile/serialize.rkt index e95d2c771a..eba4871003 100644 --- a/racket/src/expander/compile/serialize.rkt +++ b/racket/src/expander/compile/serialize.rkt @@ -41,7 +41,7 @@ ;; can refer to mutable values) ;; ;; - a vector of "fill" descriptions to complete the construction of -;; mutable values (whcih can refer to mutable and shared values); +;; mutable values (which can refer to mutable and shared values); ;; and ;; ;; - a final value construction (which can refer to shared and diff --git a/racket/src/expander/compile/write-linklet.rkt b/racket/src/expander/compile/write-linklet.rkt index 59eb189883..929be3ec2f 100644 --- a/racket/src/expander/compile/write-linklet.rkt +++ b/racket/src/expander/compile/write-linklet.rkt @@ -44,7 +44,7 @@ ;; bundle count as 4-byte integer ;; binary tree: ;; bundle-name length as 4-byte integer - ;; bundle name [encoding decribed below] + ;; bundle name [encoding described below] ;; bundle offset as 4-byte integer ;; bundle size as 4-byte integer ;; left-branch offset as 4-byte integer diff --git a/racket/src/expander/expand/def-id.rkt b/racket/src/expander/expand/def-id.rkt index ecb2711fb3..c4ca880822 100644 --- a/racket/src/expander/expand/def-id.rkt +++ b/racket/src/expander/expand/def-id.rkt @@ -21,7 +21,7 @@ ;; linklet-level symbol. ;; As a concession to top-level evaluation, reserve plain symbols for -;; identifers that have only the module's scopes. That way, if a +;; identifiers that have only the module's scopes. That way, if a ;; reference to an identifier is encountered before a definition, the ;; reference can still work in normal cases. diff --git a/racket/src/expander/expand/main.rkt b/racket/src/expander/expand/main.rkt index 3d5766dd72..32a76bf299 100644 --- a/racket/src/expander/expand/main.rkt +++ b/racket/src/expander/expand/main.rkt @@ -177,7 +177,7 @@ (cond [(transformer? t) (define fail-non-transformer - ;; Make sure a rename transformer eventualy leads to syntax + ;; Make sure a rename transformer eventually leads to syntax (and (rename-transformer? t) (lambda () (raise-syntax-implicit-error s sym trigger-id ctx)))) @@ -359,8 +359,8 @@ ;; Given a macro transformer `t`, apply it --- adding appropriate ;; scopes to represent the expansion step; the `insp-of-t` inspector -;; is the inspector of the module that defines `t`, which gives it -;; priviledge for `syntax-arm` and similar +;; is the inspector of the module that defines `t`, which gives its +;; privilege for `syntax-arm` and similar (define (apply-transformer t insp-of-t s id ctx binding #:origin-id [origin-id #f]) (performance-region diff --git a/racket/src/expander/extract/underscore.rkt b/racket/src/expander/extract/underscore.rkt index e919180881..eebe099c3a 100644 --- a/racket/src/expander/extract/underscore.rkt +++ b/racket/src/expander/extract/underscore.rkt @@ -8,7 +8,7 @@ ;; for local variables, where the expander adds "_" suffixes to ;; generate local-variable names, and the ""s count up across all ;; symbols. Renumber with symbol-specific counting to reduce -;; unneccessary changes to generated code. A relatively simple +;; unnecessary changes to generated code. A relatively simple ;; strategy works because no primitive or exported name has a "_" ;; suffix. diff --git a/racket/src/expander/read/number.rkt b/racket/src/expander/read/number.rkt index db4326785d..53a8d68835 100644 --- a/racket/src/expander/read/number.rkt +++ b/racket/src/expander/read/number.rkt @@ -14,7 +14,7 @@ ;; The `string->number` parser is responsible for handling Racket's ;; elaborate number syntax (mostly inherited from Scheme). It relies ;; on a host-system `string->number` only for generating -;; psuedo-extflonums when flonums aren't really supported. Otherwise, +;; pseudo-extflonums when flonums aren't really supported. Otherwise, ;; the parser here performs all checking and arithmetic that the ;; reader needs. diff --git a/racket/src/expander/syntax/fallback.rkt b/racket/src/expander/syntax/fallback.rkt index 4bf8dd0db1..4d733eba63 100644 --- a/racket/src/expander/syntax/fallback.rkt +++ b/racket/src/expander/syntax/fallback.rkt @@ -14,7 +14,7 @@ ;; scope set that doesn't include the additional scope for B. This ;; fallback makes it easier to work across namespaces (including ;; moving from the top level to a module body or vice versa), and it -;; accomodates existing Racket programs. +;; accommodates existing Racket programs. ;; ;; A syntax object contains a fallback search list only if ;; `push-scope` has been used. The fallback chain is in the diff --git a/racket/src/expander/syntax/scope.rkt b/racket/src/expander/syntax/scope.rkt index ecaf6c3f39..dfc5372350 100644 --- a/racket/src/expander/syntax/scope.rkt +++ b/racket/src/expander/syntax/scope.rkt @@ -493,7 +493,7 @@ (for/fold ([s s]) ([sc (in-list scs)]) (flip-scope s sc))) -;; Pushes a multi-scope to accomodate multiple top-level namespaces. +;; Pushes a multi-scope to accommodate multiple top-level namespaces. ;; See "fallback.rkt". (define (push-scope s sms) (define-memo-lite (push smss/maybe-fallbacks) @@ -519,7 +519,7 @@ scope-ops ; scope -> (or/c 'add 'remove 'flip) ;; mpi-shifts and inspectors are mostly ;; implemented at the "binding.rkt" layer, - ;; but we accomodate them here + ;; but we accommodate them here prev-mss ; owner's mpi-shifts before adds add-mpi-shifts ; #f or (mpi-shifts -> mpi-shifts) inspector ; #f or inspector diff --git a/racket/src/foreign/libffi/ChangeLog b/racket/src/foreign/libffi/ChangeLog index c85cbe621a..1e0969f6f2 100644 --- a/racket/src/foreign/libffi/ChangeLog +++ b/racket/src/foreign/libffi/ChangeLog @@ -310,7 +310,7 @@ Date: Sat Mar 22 10:00:53 2014 -0700 win32.S: Add handling for position-independent code on Darwin Newer versions of Darwin generate the necessary stub functions - automatically and just need a call instruction, but accomodating older + automatically and just need a call instruction, but accommodating older versions as well requires adding the stub. commit ef5890ebafb7cd2fbf9acf161edb55fe1382871c diff --git a/racket/src/foreign/libffi/ChangeLog.libffi-3.1 b/racket/src/foreign/libffi/ChangeLog.libffi-3.1 index 8f7f50d6f9..09476f008a 100644 --- a/racket/src/foreign/libffi/ChangeLog.libffi-3.1 +++ b/racket/src/foreign/libffi/ChangeLog.libffi-3.1 @@ -20,7 +20,7 @@ * Makefile.am: Compile in src/x86/win32.S on non-Windows x86-32. * src/x86/ffitarget.h: Add FFI_STDCALL, FFI_THISCALL, and FFI_FASTCALL on non-Windows x86-32. Increase trampoline size to - accomodate these calling conventions, and unify some ifdeffery. + accommodate these calling conventions, and unify some ifdeffery. * src/x86/ffi.c: Add support for FFI_STDCALL, FFI_THISCALL, and FFI_FASTCALL on non-Windows x86-32 platforms; update ifdeffery. * src/x86/win32.S: Support compiling on non-Windows x86-32 @@ -2844,7 +2844,7 @@ 2007-11-25 Andreas Tobler - * src/closures.c: Move defintion of MAYBE_UNUSED from here to ... + * src/closures.c: Move definition of MAYBE_UNUSED from here to ... * include/ffi_common.h: ... here. Update copyright. diff --git a/racket/src/foreign/libffi/ltmain.sh b/racket/src/foreign/libffi/ltmain.sh index a50a21a67c..67f0ac4ff0 100644 --- a/racket/src/foreign/libffi/ltmain.sh +++ b/racket/src/foreign/libffi/ltmain.sh @@ -1522,7 +1522,7 @@ func_run_hooks () # } # func_add_hook func_validate_options my_option_validation # -# You'll alse need to manually amend $usage_message to reflect the extra +# You'll also need to manually amend $usage_message to reflect the extra # options you parse. It's preferable to append if you can, so that # multiple option parsing hooks can be added safely. @@ -1555,7 +1555,7 @@ func_options () # All initialisations required before starting the option parse loop. # Note that when calling hook functions, we pass through the list of # positional parameters. If a hook function modifies that list, and -# needs to propogate that back to rest of this script, then the complete +# needs to propagate that back to rest of this script, then the complete # modified list must be put in 'func_run_hooks_result' before # returning. func_hookable func_options_prep diff --git a/racket/src/foreign/libffi/src/mips/n32.S b/racket/src/foreign/libffi/src/mips/n32.S index c6985d30a6..5ae982b9a4 100644 --- a/racket/src/foreign/libffi/src/mips/n32.S +++ b/racket/src/foreign/libffi/src/mips/n32.S @@ -76,7 +76,7 @@ ffi_call_N32: bigger: ADDU t4, v0, 2 * FFI_SIZEOF_ARG -1 # make sure it is aligned - and v0, t4, -2 * FFI_SIZEOF_ARG # to a proper boundry. + and v0, t4, -2 * FFI_SIZEOF_ARG # to a proper boundary. sixteen: SUBU $sp, $sp, v0 # move the stack pointer to reflect the diff --git a/racket/src/io/port/commit-port.rkt b/racket/src/io/port/commit-port.rkt index f1c464baac..287ac7cdf4 100644 --- a/racket/src/io/port/commit-port.rkt +++ b/racket/src/io/port/commit-port.rkt @@ -40,7 +40,7 @@ #t] [else ;; General case to support blocking and potentially multiple - ;; commiting threads: + ;; committing threads: (unless commit-manager (set! commit-manager (make-commit-manager))) (commit-manager-wait commit-manager progress-evt ext-evt finish)]))] diff --git a/racket/src/io/unsafe/schedule.rkt b/racket/src/io/unsafe/schedule.rkt index 1657b85f87..bdc681a6ff 100644 --- a/racket/src/io/unsafe/schedule.rkt +++ b/racket/src/io/unsafe/schedule.rkt @@ -26,7 +26,7 @@ (when vals ;; The rule here is that we cancel any sleep so ;; that the event will be polled again; we do not - ;; select the event now. That rule accomodates + ;; select the event now. That rule accommodates ;; the old Racket scheduler. (sandman-poll-ctx-merge-timeout poll-ctx (current-inexact-milliseconds))) (values #f self)] diff --git a/racket/src/lt/aclocal.m4 b/racket/src/lt/aclocal.m4 index 9656eac3a0..484c4802f9 100644 --- a/racket/src/lt/aclocal.m4 +++ b/racket/src/lt/aclocal.m4 @@ -1143,7 +1143,7 @@ if test -n "$_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)" || \ test -n "$_LT_AC_TAGVAR(runpath_var, $1)" || \ test "X$_LT_AC_TAGVAR(hardcode_automatic, $1)" = "Xyes" ; then - # We can hardcode non-existant directories. + # We can hardcode non-existent directories. if test "$_LT_AC_TAGVAR(hardcode_direct, $1)" != no && # If the only mechanism to avoid hardcoding is shlibpath_var, we # have to relink, otherwise we might link with an installed library diff --git a/racket/src/mzcom/com_glue.c b/racket/src/mzcom/com_glue.c index 9c8fcf0866..bd11d9563a 100644 --- a/racket/src/mzcom/com_glue.c +++ b/racket/src/mzcom/com_glue.c @@ -438,7 +438,7 @@ static STDMETHODIMP GetConnectionPointContainer(IConnectionPoint *com_obj, IConn // app object from which we can request the app to give us its IMzObjEvents. All of // this convoluted stuff is a combination of poor pre-planning by Microsoft // programmers when they designed this stuff, as well as the colossal blunder of -// designing COM to accomodate the limitations of early, primitive editions of +// designing COM to accommodate the limitations of early, primitive editions of // Visual Basic. // // The second arg passed here is some app object whose QueryInterface function diff --git a/racket/src/racket/gc/blacklst.c b/racket/src/racket/gc/blacklst.c index afcad9c216..3b2da485a3 100644 --- a/racket/src/racket/gc/blacklst.c +++ b/racket/src/racket/gc/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/racket/src/racket/gc/configure.in b/racket/src/racket/gc/configure.in index 247760c408..0b3a31b731 100644 --- a/racket/src/racket/gc/configure.in +++ b/racket/src/racket/gc/configure.in @@ -411,7 +411,7 @@ AC_DEFINE(ATOMIC_UNCOLLECTABLE) dnl This is something of a hack. When cross-compiling we turn off dnl some functionality. We also enable the "small" configuration. -dnl These is only correct when targetting an embedded system. FIXME. +dnl These is only correct when targeting an embedded system. FIXME. if test -n "${with_cross_host}"; then AC_DEFINE(NO_SIGSET) AC_DEFINE(NO_CLOCK) diff --git a/racket/src/racket/gc/doc/README.DGUX386 b/racket/src/racket/gc/doc/README.DGUX386 index 9d6d84788e..625a55c2e0 100644 --- a/racket/src/racket/gc/doc/README.DGUX386 +++ b/racket/src/racket/gc/doc/README.DGUX386 @@ -88,7 +88,7 @@ Note (HB): + # that compilation of execitables will put them in correct order + # in any case and sometimes are wrong when listed as deplibs (or missing some deplibs) + # However when GNU ld and --whole-archive needs to be used we have the problem -+ # that if the -fPIC *_s.a archive is linked through deplibs list we ommiting crucial ++ # that if the -fPIC *_s.a archive is linked through deplibs list we omitting crucial + # .lo/.o files from the created shared lib. This I think is not the case here. + archive_cmds='$CC -shared -h $soname -o $lib $libobjs $linkopts' + thread_safe_flag_spec='-pthread' diff --git a/racket/src/racket/gc/doc/README.changes b/racket/src/racket/gc/doc/README.changes index d2eaf01014..c269aa5a9d 100644 --- a/racket/src/racket/gc/doc/README.changes +++ b/racket/src/racket/gc/doc/README.changes @@ -1875,7 +1875,7 @@ Since 6.2alpha6: - Fixed Makefile.direct for DARWIN. (Thanks to Manuel Serrano.) - There was a race between GC_pthread_detach and thread exit that could result in a thread structure being deallocated by GC_pthread_detach - eventhough it was still needed by the thread exit code. (Thanks to + even though it was still needed by the thread exit code. (Thanks to Dick Porter for the small test case that allowed this to be debugged.) - Fixed version parsing for non-alpha versions in acinclude.m4 and version checking in version.h. @@ -2550,7 +2550,7 @@ Since first gc7.0alpha8 version: - __GNUC__ was misspelled as __GNUC in thread_local_alloc.h. (Thanks to Peter Wang.) - Integrated various MacOSX patches and tried to reconcile them. - Thanks to Allan Hsu, several contributers at Apple, and probably + Thanks to Allan Hsu, several contributors at Apple, and probably others. - Added some casts to powerpc.h in libatomic_ops to silence warnings. diff --git a/racket/src/racket/gc/doc/README.ews4800 b/racket/src/racket/gc/doc/README.ews4800 index 80bca2b3d9..45b5ec5264 100644 --- a/racket/src/racket/gc/doc/README.ews4800 +++ b/racket/src/racket/gc/doc/README.ews4800 @@ -20,7 +20,7 @@ GC on EWS4800 AR = /usr/ccs64/bin/ar 3. ELF file format - *** Caution: The following infomation is empirical. *** + *** Caution: The following information is empirical. *** 32bit: ELF file has an unique format. (See a.out(4) and end(3C).) diff --git a/racket/src/racket/gc/doc/gcdescr.html b/racket/src/racket/gc/doc/gcdescr.html index dc08470e40..25afe1151e 100644 --- a/racket/src/racket/gc/doc/gcdescr.html +++ b/racket/src/racket/gc/doc/gcdescr.html @@ -546,7 +546,7 @@ accomplished with # define's in gc.h (really gc_pthread_redirects.h), or optionally by using ld's function call wrapping mechanism under Linux.

-Recent versions of the collector support several facilites to enhance +Recent versions of the collector support several facilities to enhance the processor-scalability and thread performance of the collector. These are discussed in more detail here. We briefly outline the data approach to thread-local allocation in the diff --git a/racket/src/racket/gc/dyn_load.c b/racket/src/racket/gc/dyn_load.c index ef4db4219d..87f9daba56 100644 --- a/racket/src/racket/gc/dyn_load.c +++ b/racket/src/racket/gc/dyn_load.c @@ -959,7 +959,7 @@ void GC_register_dynamic_libraries() /* 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/racket/src/racket/gc/include/gc.h b/racket/src/racket/gc/include/gc.h index 18de0c1672..5dcb73dc34 100644 --- a/racket/src/racket/gc/include/gc.h +++ b/racket/src/racket/gc/include/gc.h @@ -151,7 +151,7 @@ GC_API int GC_use_entire_heap; /* entire heap before collecting. This was the only */ /* option for GC versions < 5.0. This sometimes */ /* results in more large block fragmentation, since */ - /* very larg blocks will tend to get broken up */ + /* very large blocks will tend to get broken up */ /* during each GC cycle. It is likely to result in a */ /* larger working set, but lower collection */ /* frequencies, and hence fewer instructions executed */ diff --git a/racket/src/racket/gc/include/gc_mark.h b/racket/src/racket/gc/include/gc_mark.h index 8ee50b5d4d..bcaa52629a 100644 --- a/racket/src/racket/gc/include/gc_mark.h +++ b/racket/src/racket/gc/include/gc_mark.h @@ -32,7 +32,7 @@ /* A client supplied mark procedure. Returns new mark stack pointer. */ /* Primary effect should be to push new entries on the mark stack. */ /* Mark stack pointer values are passed and returned explicitly. */ -/* Global variables decribing mark stack are not necessarily valid. */ +/* Global variables describing mark stack are not necessarily valid. */ /* (This usually saves a few cycles by keeping things in registers.) */ /* Assumed to scan about GC_PROC_BYTES on average. If it needs to do */ /* much more work than that, it should do it in smaller pieces by */ diff --git a/racket/src/racket/gc/include/private/gcconfig.h b/racket/src/racket/gc/include/private/gcconfig.h index d2a85c7bce..8848ad046b 100644 --- a/racket/src/racket/gc/include/private/gcconfig.h +++ b/racket/src/racket/gc/include/private/gcconfig.h @@ -418,7 +418,7 @@ # if defined(_MSC_VER) && defined(_M_IA64) # define IA64 # define MSWIN32 /* Really win64, but we don't treat 64-bit */ - /* variants as a differnt platform. */ + /* variants as a different platform. */ # endif # endif # if defined(__DJGPP__) @@ -1188,7 +1188,7 @@ # define PREFETCH(x) \ __asm__ __volatile__ (" prefetchnta %0": : "m"(*(char *)(x))) /* Empirically prefetcht0 is much more effective at reducing */ - /* cache miss stalls for the targetted load instructions. But it */ + /* cache miss stalls for the targeted load instructions. But it */ /* seems to interfere enough with other cache traffic that the net */ /* result is worse than prefetchnta. */ # if 0 diff --git a/racket/src/racket/gc/mark.c b/racket/src/racket/gc/mark.c index c53a307bd6..f9ab80f21d 100644 --- a/racket/src/racket/gc/mark.c +++ b/racket/src/racket/gc/mark.c @@ -984,7 +984,7 @@ 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; diff --git a/racket/src/racket/gc/os_dep.c b/racket/src/racket/gc/os_dep.c index 4e647a287b..f5af266a4d 100644 --- a/racket/src/racket/gc/os_dep.c +++ b/racket/src/racket/gc/os_dep.c @@ -1737,7 +1737,7 @@ ptr_t GC_SysVGetDataStart(size_t max_page_size, ptr_t etext_addr) & ~((word)max_page_size - 1)); word page_offset = (text_end & ((word)max_page_size - 1)); volatile char * result = (char *)(next_page + page_offset); - /* Note that this isnt equivalent to just adding */ + /* Note that this isn't equivalent to just adding */ /* max_page_size to &etext if &etext is at a page boundary */ GC_setup_temporary_fault_handler(); @@ -2379,7 +2379,7 @@ PCR_ERes GC_push_thread_stack(PCR_Th_T *t, PCR_Any dummy) } /* Push the contents of an old object. We treat this as stack */ -/* data only becasue that makes it robust against mark stack */ +/* data only because that makes it robust against mark stack */ /* overflow. */ PCR_ERes GC_push_old_obj(void *p, size_t size, PCR_Any data) { @@ -3836,7 +3836,7 @@ static void *GC_mprotect_thread(void *arg) } /* All this SIGBUS code shouldn't be necessary. All protection faults should - be going throught the mach exception handler. However, it seems a SIGBUS is + be going through the mach exception handler. However, it seems a SIGBUS is occasionally sent for some unknown reason. Even more odd, it seems to be meaningless and safe to ignore. */ #ifdef BROKEN_EXCEPTION_HANDLING diff --git a/racket/src/racket/gc/pthread_support.c b/racket/src/racket/gc/pthread_support.c index 8c59a4479a..0ca4ae5176 100644 --- a/racket/src/racket/gc/pthread_support.c +++ b/racket/src/racket/gc/pthread_support.c @@ -129,7 +129,7 @@ unsigned long GC_lock_holder = NO_THREAD; # define REAL_FUNC(f) GC_real_##f /* We define both GC_f and plain f to be the wrapped function. */ /* In that way plain calls work, as do calls from files that */ - /* included gc.h, wich redefined f to GC_f. */ + /* included gc.h, which redefined f to GC_f. */ /* FIXME: Needs work for DARWIN and True64 (OSF1) */ typedef int (* GC_pthread_create_t)(pthread_t *, const pthread_attr_t *, void * (*)(void *), void *); diff --git a/racket/src/racket/gc/threadlibs.c b/racket/src/racket/gc/threadlibs.c index 667fa2f602..273dcdd3b2 100644 --- a/racket/src/racket/gc/threadlibs.c +++ b/racket/src/racket/gc/threadlibs.c @@ -57,7 +57,7 @@ int main() printf("-pthread -lrt"); /* DOB: must be -pthread, not -lpthread */ # endif /* You need GCC 3.0.3 to build this one! */ - /* DG/UX native gcc doesnt know what "-pthread" is */ + /* DG/UX native gcc doesn't know what "-pthread" is */ # if defined(GC_DGUX386_THREADS) printf("-ldl -pthread\n"); # endif diff --git a/racket/src/racket/gc/typd_mlc.c b/racket/src/racket/gc/typd_mlc.c index dc0118a591..4e4f6817f9 100644 --- a/racket/src/racket/gc/typd_mlc.c +++ b/racket/src/racket/gc/typd_mlc.c @@ -28,7 +28,7 @@ * must trace the complex_descriptor. * * Note that descriptors inside objects may appear cleared, if we encounter a - * false refrence to an object on a free list. In the GC_descr case, this + * false reference to an object on a free list. In the GC_descr case, this * is OK, since a 0 descriptor corresponds to examining no fields. * In the complex_descriptor case, we explicitly check for that case. * diff --git a/racket/src/racket/gc2/block_cache.c b/racket/src/racket/gc2/block_cache.c index fc341c804d..e2ee50ce81 100644 --- a/racket/src/racket/gc2/block_cache.c +++ b/racket/src/racket/gc2/block_cache.c @@ -439,7 +439,7 @@ static void block_cache_protect_one_page(BlockCache* bc, void *p, size_t len, in GC_ASSERT(pos < (b->size >> LOG_APAGE_SIZE)); GC_ASSERT(BD_MAP_GET_BIT(b->alloc_map, pos)); /* Since a queued mprotect affects more pages than the client can be sure of, - we have to accomodate redundant requests. */ + we have to accommodate redundant requests. */ if (writeable) { if (BD_MAP_GET_BIT(b->protect_map, pos)) { BD_MAP_UNSET_BIT(b->protect_map, pos); diff --git a/racket/src/racket/gc2/newgc.c b/racket/src/racket/gc2/newgc.c index ec7581d87e..f762269462 100644 --- a/racket/src/racket/gc2/newgc.c +++ b/racket/src/racket/gc2/newgc.c @@ -5841,9 +5841,9 @@ static void garbage_collect(NewGC *gc, int force_full, int no_full, /* new memory use; gen0_phantom_count can be non-zero due to phantom-bytes record in generation 1/2: */ gc->memory_in_use + gc->gen0_phantom_count, - /* original memory use, including adminstrative structures: */ + /* original memory use, including administrative structures: */ old_mem_allocated, - /* new memory use with adminstrative structures: */ + /* new memory use with administrative structures: */ mmu_memory_allocated(gc->mmu)+gc->phantom_count+gc->gen0_phantom_count, gc->child_gc_total); unpark_for_inform_callback(gc); diff --git a/racket/src/racket/src/gmp/gmp.c b/racket/src/racket/src/gmp/gmp.c index 40d1006cdb..58a811ee39 100644 --- a/racket/src/racket/src/gmp/gmp.c +++ b/racket/src/racket/src/gmp/gmp.c @@ -3111,7 +3111,7 @@ mpn_sqrtrem (mp_ptr sp, mp_ptr rp, mp_srcptr np, mp_size_t nn) return rn; } -/* mpn_bz_divrem_n and auxilliary routines. */ +/* mpn_bz_divrem_n and auxiliary routines. */ /* [1] Fast Recursive Division, by Christoph Burnikel and Joachim Ziegler, diff --git a/racket/src/racket/src/jitstate.c b/racket/src/racket/src/jitstate.c index 4bd28fbc0f..3c525a7d09 100644 --- a/racket/src/racket/src/jitstate.c +++ b/racket/src/racket/src/jitstate.c @@ -67,7 +67,7 @@ int scheme_mz_retain_it(mz_jit_state *jitter, void *v) } void scheme_mz_load_retained(mz_jit_state *jitter, int rs, void *obj) -/* obj is a pointer, but not necesarily tagged (in CGC) */ +/* obj is a pointer, but not necessarily tagged (in CGC) */ { if (!SCHEME_INTP((Scheme_Object *)obj) && !SAME_OBJ((Scheme_Object *)obj, scheme_true) diff --git a/racket/src/racket/src/letrec_check.c b/racket/src/racket/src/letrec_check.c index 3040bfed24..ac66a8668a 100644 --- a/racket/src/racket/src/letrec_check.c +++ b/racket/src/racket/src/letrec_check.c @@ -140,7 +140,7 @@ typedef struct Scheme_Deferred_Expr { only need to process it once */ int done; - /* the expression that has been deferred -- usally a Scheme_Lambda, + /* the expression that has been deferred -- usually a Scheme_Lambda, but can be a Scheme_IR_Local for propagation */ Scheme_Object *expr; diff --git a/racket/src/racket/src/linklet.c b/racket/src/racket/src/linklet.c index 16a003010c..e5b3ae29d4 100644 --- a/racket/src/racket/src/linklet.c +++ b/racket/src/racket/src/linklet.c @@ -1267,7 +1267,7 @@ Scheme_Object *scheme_linklet_run_finish(Scheme_Linklet* linklet, Scheme_Instanc /* Double-check that the definition-installing part of the continuation was not skipped. Otherwise, the compiler would not be able to assume that a variable reference that is - lexically later (incuding a reference to an imported + lexically later (including a reference to an imported variable) always references a defined variable. Putting the prompt around a definition's RHS might be a better approach, but that would change the language (so mabe next diff --git a/racket/src/racket/src/resolve.c b/racket/src/racket/src/resolve.c index 4e56ca457d..b97b8a398e 100644 --- a/racket/src/racket/src/resolve.c +++ b/racket/src/racket/src/resolve.c @@ -51,7 +51,7 @@ struct Resolve_Info `instance_pos` in an `Scheme_IR_Topelevel`). */ int *toplevel_deltas; /* shifts for toplevels in the import range to - accomodate removals */ + accommodate removals */ Scheme_Hash_Table *toplevel_defns; /* for pruning unused definitions, if some definitions are unexported diff --git a/racket/src/racket/src/thread.c b/racket/src/racket/src/thread.c index 9aa5c7e148..4b41b8556e 100644 --- a/racket/src/racket/src/thread.c +++ b/racket/src/racket/src/thread.c @@ -1456,8 +1456,8 @@ Scheme_Thread *scheme_do_close_managed(Scheme_Custodian *m, Scheme_Exit_Closer_F m->shut_down = 1; /* Need to kill children first, transitively, so find - last decendent. The family will be the global-list from - m to this last decendent, inclusive. */ + last descendant. The family will be the global-list from + m to this last descendant, inclusive. */ for (c = m; CUSTODIAN_FAM(c->children); ) { for (c = CUSTODIAN_FAM(c->children); CUSTODIAN_FAM(c->sibling); ) { c = CUSTODIAN_FAM(c->sibling); @@ -4560,7 +4560,7 @@ void scheme_break_main_thread_at(void *p) } void scheme_break_main_thread() -/* Calling this function from an arbitary +/* Calling this function from an arbitrary thread is dangerous when therad locals are enabled. */ { scheme_break_main_thread_at((void *)&delayed_break_ready); @@ -4844,8 +4844,8 @@ void scheme_thread_block(float sleep_time) shrink_cust_box_array(); /* Scheduling queries might involve callbacks through the FFI that put - the runtime system into `scheme_no_stack_overflow` mode. Immitate - the foriegn-call entry point with an extra check that we have enough + the runtime system into `scheme_no_stack_overflow` mode. Imitate + the foreign-call entry point with an extra check that we have enough stack to survive in foreign functions. */ if (!scheme_no_stack_overflow && scheme_is_stack_too_shallow()) { p->sleep_end = sleep_time; /* an abuse of the `sleep_end` field to @@ -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 arbitary, based on what we've needed + /* The set of suported 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/racket/src/unwind/libunwind.c b/racket/src/racket/src/unwind/libunwind.c index 7b478d0ac5..74c7da13ba 100644 --- a/racket/src/racket/src/unwind/libunwind.c +++ b/racket/src/racket/src/unwind/libunwind.c @@ -855,7 +855,7 @@ parse_cie (unw_addr_space_t as, unw_accessors_t *a, unw_word_t addr, return 0; } -/* Extract proc-info from the FDE starting at adress ADDR. +/* Extract proc-info from the FDE starting at address ADDR. Pass BASE as zero for eh_frame behaviour, or a pointer to debug_frame base for debug_frame behaviour. */ diff --git a/racket/src/regexp/match/interp.rkt b/racket/src/regexp/match/interp.rkt index d27ff560d5..7647a193a8 100644 --- a/racket/src/regexp/match/interp.rkt +++ b/racket/src/regexp/match/interp.rkt @@ -5,7 +5,7 @@ ;; Compilation produces a matcher function; see "match.rkt" (define (interp m ; the compiled matcher function s ; input bytes or lazy-bytes - pos ; starting seach position, can be > `start`, must be < `limit` + pos ; starting search position, can be > `start`, must be < `limit` start ; input start in the sense of `^`; don't read before this limit/end ; don't read past `limit`; `end` corresponds to `$` and can be < `limit` state) ; vector where group position-pair matches are installed diff --git a/racket/src/rktio/rktio.h b/racket/src/rktio/rktio.h index a4dbbaef11..ef4b9b490f 100644 --- a/racket/src/rktio/rktio.h +++ b/racket/src/rktio/rktio.h @@ -475,7 +475,7 @@ RKTIO_EXTERN_ERR(RKTIO_WRITE_ERROR) intptr_t rktio_udp_sendto(rktio_t *rktio, rktio_fd_t *rfd, RKTIO_NULLABLE rktio_addrinfo_t *addr, const char *buffer, intptr_t len); /* Extends `rktio_write` to accept a destination `addr`, and binds `rfd` if it - is not bound aready. The `addr` can be NULL if the socket is connected. */ + is not bound already. The `addr` can be NULL if the socket is connected. */ RKTIO_EXTERN_ERR(RKTIO_WRITE_ERROR) intptr_t rktio_udp_sendto_in(rktio_t *rktio, rktio_fd_t *rfd, RKTIO_NULLABLE rktio_addrinfo_t *addr, @@ -541,7 +541,7 @@ RKTIO_EXTERN rktio_bool_t rktio_is_ok_envvar_name(rktio_t *rktio, rktio_const_st RKTIO_EXTERN rktio_bool_t rktio_are_envvar_names_case_insensitive(rktio_t *rktio); /* Checks whether environment variables are case-folded by the OS. That doesn't mean that clients need to case-fold names, but clients - may want to immitate the OS. */ + may want to imitate the OS. */ RKTIO_EXTERN char *rktio_getenv(rktio_t *rktio, rktio_const_string_t name); /* Gets an environment variable value, or reports @@ -710,7 +710,7 @@ RKTIO_EXTERN void rktio_poll_set_add_eventmask(rktio_t *rktio, rktio_poll_set_t RKTIO_EXTERN void rkio_reset_sleep_backoff(rktio_t *rktio); /* Call this function when using `rktio_poll_set_add_eventmask` and when matching events are not always consumed from the queue between - sleeps. To accomodate messages that are not consumed, the poll set + sleeps. To accommodate messages that are not consumed, the poll set will actually only sleep a short while at first, and then back off exponentially. Call this function when your program does useful work (instead of spinning on sleep) to reset the backoff diff --git a/racket/src/rktio/rktio_convert.c b/racket/src/rktio/rktio_convert.c index 0eb814ae7a..bc57524d36 100644 --- a/racket/src/rktio/rktio_convert.c +++ b/racket/src/rktio/rktio_convert.c @@ -143,7 +143,7 @@ static void init_iconv() iconv_errno = (errno_proc_t)GetProcAddress(m, "_errno"); if (!iconv_errno) { /* The iconv.dll distributed with Racket links to msvcrt.dll. - It's a slighly dangerous assumption that whatever iconv we + It's a slightly dangerous assumption that whatever iconv we found also uses msvcrt.dll. */ m = LoadLibraryW(L"msvcrt.dll"); if (m) { diff --git a/racket/src/rktio/rktio_fd.c b/racket/src/rktio/rktio_fd.c index 44c6a45b8f..78d9fe2546 100644 --- a/racket/src/rktio/rktio_fd.c +++ b/racket/src/rktio/rktio_fd.c @@ -1423,7 +1423,7 @@ intptr_t rktio_write(rktio_t *rktio, rktio_fd_t *rfd, const char *buffer, intptr if (towrite) ok = WriteConsoleW((HANDLE)rfd->fd, w_buffer, towrite, &winwrote, NULL); else { - /* can happend if can_leftover is > 0 */ + /* can happen if can_leftover is > 0 */ ok = 1; winwrote = 0; } diff --git a/racket/src/schemify/interpret.rkt b/racket/src/schemify/interpret.rkt index bc43d446fd..225b89f97b 100644 --- a/racket/src/schemify/interpret.rkt +++ b/racket/src/schemify/interpret.rkt @@ -106,7 +106,7 @@ (hash-set env arg (+ stack-depth i)))) (define body-vars-index (+ num-args stack-depth)) ;; Gather all the names that have `define`s, and build up the - ;; enviornment that has them consceptually pushed after the + ;; environment that has them consceptually pushed after the ;; import and export variables. (define-values (body-env num-body-vars) (for/fold ([env args-env] [num-body-vars 0]) ([e (in-wrap-list body)]) diff --git a/racket/src/schemify/intmap.rkt b/racket/src/schemify/intmap.rkt index a81fc9f764..aab5ecb7d3 100644 --- a/racket/src/schemify/intmap.rkt +++ b/racket/src/schemify/intmap.rkt @@ -4,7 +4,7 @@ ;; Simplified version of Jon Zeppieri's intmap ;; implementation for Racket-on-Chez. -;; This one always has fixnum keys, doens't have +;; This one always has fixnum keys, doesn't have ;; to hash, doesn't have to deal with collisions, ;; and doesn't need a wrapper to distinguish ;; the type and record the comparison function. diff --git a/racket/src/setup-go.rkt b/racket/src/setup-go.rkt index 21cd27d790..98dc6e3266 100644 --- a/racket/src/setup-go.rkt +++ b/racket/src/setup-go.rkt @@ -29,7 +29,7 @@ ;; The point of going through `setup/main` is that the Racket module ;; gets compiled as needed, so that it doesn't have to be loaded from ;; source every time. At the same time `setup/main` detects when files -;; need to be recompiled, either becuase the underlying Racket's +;; need to be recompiled, either because the underlying Racket's ;; version changed or because a dependency changed. (provide go) diff --git a/racket/src/start/MemoryModule.h b/racket/src/start/MemoryModule.h index a728f6b141..3aaade1f7a 100644 --- a/racket/src/start/MemoryModule.h +++ b/racket/src/start/MemoryModule.h @@ -139,7 +139,7 @@ BOOL MemoryDefaultFree(LPVOID, SIZE_T, DWORD, void *); /** * Default implementation of CustomLoadLibraryFunc that calls LoadLibraryA - * internally to load an additional libary. + * internally to load an additional library. * * This is the default as used by MemoryLoadLibrary. */ @@ -155,7 +155,7 @@ FARPROC MemoryDefaultGetProcAddress(HCUSTOMMODULE, LPCSTR, void *); /** * Default implementation of CustomFreeLibraryFunc that calls FreeLibrary - * internally to release an additional libary. + * internally to release an additional library. * * This is the default as used by MemoryLoadLibrary. */ diff --git a/racket/src/thread/custodian-object.rkt b/racket/src/thread/custodian-object.rkt index 43af066c37..c261d361cf 100644 --- a/racket/src/thread/custodian-object.rkt +++ b/racket/src/thread/custodian-object.rkt @@ -22,7 +22,7 @@ [gc-roots #:mutable] ; weak references to charge to custodian; access without interrupts [memory-limits #:mutable] ; list of (cons limit cust) [immediate-limit #:mutable] ; limit on immediate allocation - [sync-futures? #:mutable] ; whether a sync witht future threads is needed on shutdown + [sync-futures? #:mutable] ; whether a sync with future threads is needed on shutdown [post-shutdown #:mutable]) ; callbacks to run in atomic mode after shutdown #:authentic) diff --git a/racket/src/thread/custodian.rkt b/racket/src/thread/custodian.rkt index 48a4950d0a..c6aeb5777c 100644 --- a/racket/src/thread/custodian.rkt +++ b/racket/src/thread/custodian.rkt @@ -445,7 +445,7 @@ (define compute-memory-sizes 0) (void (set-reachable-size-increments-callback! - ;; Called in an arbitary host thread, with interrupts off and all other threads suspended: + ;; Called in an arbitrary host thread, with interrupts off and all other threads suspended: (lambda (compute-size-increments) (unless (zero? compute-memory-sizes) (host:call-with-current-place-continuation diff --git a/racket/src/thread/thread.rkt b/racket/src/thread/thread.rkt index 79ccd02d71..5adad30509 100644 --- a/racket/src/thread/thread.rkt +++ b/racket/src/thread/thread.rkt @@ -444,7 +444,7 @@ ;; Extends `do-thread-deschdule!` where `t` is always `(current-thread)`. ;; The `interrupt-callback` is called if the thread receives a break ;; signal, is killed, or is suspended; if the break signal is -;; supressed or resumed, then `retry-callback` is called to try again +;; suppressed or resumed, then `retry-callback` is called to try again ;; --- but `retry-callback` will only be used if `interrupt-callback` ;; was previously called, and neither is called if the thread is ;; "internal"-resumed normally instead of by a break signal of a