From 372d68ae1432a96a527c662de3af3bb334808856 Mon Sep 17 00:00:00 2001 From: Lutz Euler Date: Fri, 20 Apr 2012 19:48:51 +0200 Subject: [PATCH] Typo fixes in comments --- src/code/list.lisp | 4 ++-- src/compiler/assem.lisp | 2 +- src/compiler/constraint.lisp | 4 ++-- src/compiler/float-tran.lisp | 2 +- src/compiler/generic/vm-tran.lisp | 2 +- src/compiler/ir2tran.lisp | 6 +++--- src/compiler/meta-vmdef.lisp | 2 +- src/compiler/pack.lisp | 14 +++++++------- src/compiler/represent.lisp | 2 +- src/compiler/srctran.lisp | 10 +++++----- src/compiler/vop.lisp | 4 ++-- src/runtime/gencgc.c | 2 +- 12 files changed, 27 insertions(+), 27 deletions(-) diff --git a/src/code/list.lisp b/src/code/list.lisp index 39af79e..d74cc1c 100644 --- a/src/code/list.lisp +++ b/src/code/list.lisp @@ -879,7 +879,7 @@ (declare (inline member)) (when (and testp notp) (error ":TEST and :TEST-NOT were both supplied.")) - ;; We have to possibilities here: for shortish lists we pick up the + ;; We have two possibilities here: for shortish lists we pick up the ;; shorter one as the result, and add the other one to it. For long ;; lists we use a hash-table when possible. (let ((n1 (length list1)) @@ -928,7 +928,7 @@ (declare (inline member)) (when (and testp notp) (error ":TEST and :TEST-NOT were both supplied.")) - ;; We have to possibilities here: for shortish lists we pick up the + ;; We have two possibilities here: for shortish lists we pick up the ;; shorter one as the result, and add the other one to it. For long ;; lists we use a hash-table when possible. (let ((n1 (length list1)) diff --git a/src/compiler/assem.lisp b/src/compiler/assem.lisp index 7cdc688..88a40d2 100644 --- a/src/compiler/assem.lisp +++ b/src/compiler/assem.lisp @@ -903,7 +903,7 @@ (setf (segment-alignment segment) bits) (setf (segment-sync-posn segment) (segment-current-posn segment))) (t - ;; The last alignment was more restrictive then this one. + ;; The last alignment was more restrictive than this one. ;; So we can just figure out how much noise to emit ;; assuming the last alignment was met. (let* ((mask (1- (ash 1 bits))) diff --git a/src/compiler/constraint.lisp b/src/compiler/constraint.lisp index 550f9b9..b30ecd2 100644 --- a/src/compiler/constraint.lisp +++ b/src/compiler/constraint.lisp @@ -654,7 +654,7 @@ (var2 (ok-lvar-lambda-var arg2 constraints))) ;; The code below assumes that the constant is the ;; second argument in case of variable to constant - ;; comparision which is sometimes true (see source + ;; comparison which is sometimes true (see source ;; transformations for EQ, EQL and CHAR=). Fixing ;; that would result in more constant substitutions ;; which is not a universally good thing, thus the @@ -965,7 +965,7 @@ (add-test-constraints use node gen)))))) ;;; Starting from IN compute OUT and (consequent/alternative -;;; constraints if the block ends with and IF). Return the list of +;;; constraints if the block ends with an IF). Return the list of ;;; successors that may need to be recomputed. (defun find-block-type-constraints (block final-pass-p) (declare (type cblock block)) diff --git a/src/compiler/float-tran.lisp b/src/compiler/float-tran.lisp index 68c1ccd..3efdaa1 100644 --- a/src/compiler/float-tran.lisp +++ b/src/compiler/float-tran.lisp @@ -691,7 +691,7 @@ ;; LONG-FLOAT doesn't actually buy us anything. FIXME. (setf *read-default-float-format* #!+long-float 'long-float #!-long-float 'double-float)) -;;; Test whether the numeric-type ARG is within in domain specified by +;;; Test whether the numeric-type ARG is within the domain specified by ;;; DOMAIN-LOW and DOMAIN-HIGH, consider negative and positive zero to ;;; be distinct. #-sb-xc-host ; (See CROSS-FLOAT-INFINITY-KLUDGE.) diff --git a/src/compiler/generic/vm-tran.lisp b/src/compiler/generic/vm-tran.lisp index 1196ba2..c4044a3 100644 --- a/src/compiler/generic/vm-tran.lisp +++ b/src/compiler/generic/vm-tran.lisp @@ -109,7 +109,7 @@ ;;; This and the corresponding -SET transform work equally well on non-simple ;;; arrays, but after benchmarking (on x86), Nikodemus didn't find any cases ;;; where it actually helped with non-simple arrays -- to the contrary, it -;;; only made for bigger and up 1o 100% slower code. +;;; only made for bigger and up to 100% slower code. (deftransform hairy-data-vector-ref ((array index) (simple-array t) *) "avoid runtime dispatch on array element type" (let* ((type (lvar-type array)) diff --git a/src/compiler/ir2tran.lisp b/src/compiler/ir2tran.lisp index 4386573..0ae854b 100644 --- a/src/compiler/ir2tran.lisp +++ b/src/compiler/ir2tran.lisp @@ -434,7 +434,7 @@ ;;; an lvar. ;;; ;;; If the lvar isn't annotated (meaning the values are discarded) or -;;; is unknown-values, the then we make temporaries for each supplied +;;; is unknown-values, then we make temporaries for each supplied ;;; value, providing a place to compute the result in until we decide ;;; what to do with it (if anything.) ;;; @@ -483,7 +483,7 @@ ;;; Return a list of TNs wired to the standard value passing ;;; conventions that can be used to receive values according to the -;;; unknown-values convention. This is used with together +;;; unknown-values convention. This is used together with ;;; MOVE-LVAR-RESULT for delivering unknown values to a fixed values ;;; lvar. ;;; @@ -541,7 +541,7 @@ ;;; If necessary, emit coercion code needed to deliver the RESULTS to ;;; the specified lvar. NODE and BLOCK provide context for emitting ;;; code. Although usually obtained from STANDARD-RESULT-TNs or -;;; LVAR-RESULT-TNs, RESULTS my be a list of any type or +;;; LVAR-RESULT-TNs, RESULTS may be a list of any type or ;;; number of TNs. ;;; ;;; If the lvar is fixed values, then move the results into the lvar diff --git a/src/compiler/meta-vmdef.lisp b/src/compiler/meta-vmdef.lisp index 3f6d93c..d59da64 100644 --- a/src/compiler/meta-vmdef.lisp +++ b/src/compiler/meta-vmdef.lisp @@ -1537,7 +1537,7 @@ ;;; :LOAD-IF EXPRESSION ;;; Controls whether automatic operand loading is done. ;;; EXPRESSION is evaluated with the fixed operand TNs bound. -;;; If EXPRESSION is true,then loading is done and the variable +;;; If EXPRESSION is true, then loading is done and the variable ;;; is bound to the load TN in the generator body. Otherwise, ;;; loading is not done, and the variable is bound to the actual ;;; operand. diff --git a/src/compiler/pack.lisp b/src/compiler/pack.lisp index 87464f7..cdc2318 100644 --- a/src/compiler/pack.lisp +++ b/src/compiler/pack.lisp @@ -598,7 +598,7 @@ (values)) ;;; Load the TN from its save location, allocating one if necessary. -;;; The load is inserted BEFORE the specifier VOP. CONTEXT is a VOP +;;; The load is inserted BEFORE the specified VOP. CONTEXT is a VOP ;;; used to tell which node/block to use for the new VOP. (defun restore-tn (tn before context) (declare (type tn tn) (type (or vop null) before) (type vop context)) @@ -919,8 +919,8 @@ ;;; aren't any TN-REFs to represent the implicit reading of results or ;;; writing of arguments. ;;; -;;; The second bullet corresponds conflicts with temporaries or between -;;; arguments and results. +;;; The second bullet corresponds to conflicts with temporaries or +;;; between arguments and results. ;;; ;;; We consider both the TN-REF-TN and the TN-REF-LOAD-TN (if any) to ;;; be referenced simultaneously and in the same way. This causes @@ -1057,9 +1057,9 @@ ;;; This is called by PACK-LOAD-TN where there isn't any location free ;;; that we can pack into. What we do is move some live TN in one of -;;; the specified SCs to memory, then mark this block all blocks that -;;; reference the TN as needing repacking. If we succeed, we throw to -;;; UNPACKED-TN. If we fail, we return NIL. +;;; the specified SCs to memory, then mark all blocks that reference +;;; the TN as needing repacking. If we succeed, we throw to UNPACKED-TN. +;;; If we fail, we return NIL. ;;; ;;; We can unpack any live TN that appears in the NORMAL-TNs list ;;; (isn't wired or restricted.) We prefer to unpack TNs that are not @@ -1117,7 +1117,7 @@ ;;; if that location is in a SC not allowed by the primitive type. ;;; (The SC must still be allowed by the operand restriction.) This ;;; makes move VOPs more efficient, since we won't do a move from the -;;; stack into a non-descriptor any-reg though a descriptor argument +;;; stack into a non-descriptor any-reg through a descriptor argument ;;; load-TN. This does give targeting some real semantics, making it ;;; not a pure advisory to pack. It allows pack to do some packing it ;;; wouldn't have done before. diff --git a/src/compiler/represent.lisp b/src/compiler/represent.lisp index 8d2418e..7c24005 100644 --- a/src/compiler/represent.lisp +++ b/src/compiler/represent.lisp @@ -417,7 +417,7 @@ :t-ok nil)) (return info)))))) -;;; Emit a coercion VOP for OP BEFORE the specifed VOP or die trying. +;;; Emit a coercion VOP for OP BEFORE the specified VOP or die trying. ;;; SCS is the operand's LOAD-SCS vector, which we use to determine ;;; what SCs the VOP will accept. We pick any acceptable coerce VOP, ;;; since it practice it seems uninteresting to have more than one diff --git a/src/compiler/srctran.lisp b/src/compiler/srctran.lisp index 09842e9..e666b87 100644 --- a/src/compiler/srctran.lisp +++ b/src/compiler/srctran.lisp @@ -529,7 +529,7 @@ :high (copy-interval-limit (interval-high x)))) ;;; Given a point P contained in the interval X, split X into two -;;; interval at the point P. If CLOSE-LOWER is T, then the left +;;; intervals at the point P. If CLOSE-LOWER is T, then the left ;;; interval contains P. If CLOSE-UPPER is T, the right interval ;;; contains P. You can specify both to be T or NIL. (defun interval-split (p x &optional close-lower close-upper) @@ -976,7 +976,7 @@ ;;; a utility for defining derive-type methods of integer operations. If ;;; the types of both X and Y are integer types, then we compute a new -;;; integer type with bounds determined Fun when applied to X and Y. +;;; integer type with bounds determined by FUN when applied to X and Y. ;;; Otherwise, we use NUMERIC-CONTAGION. (defun derive-integer-type-aux (x y fun) (declare (type function fun)) @@ -2326,7 +2326,7 @@ (if (and divisor-low divisor-high) ;; We know the range of the divisor, and the remainder must be ;; smaller than the divisor. We can tell the sign of the - ;; remainer if we know the sign of the number. + ;; remainder if we know the sign of the number. (let ((divisor-max (1- (max (abs divisor-low) (abs divisor-high))))) `(integer ,(if (or (null number-low) (minusp number-low)) @@ -2337,7 +2337,7 @@ divisor-max 0))) ;; The divisor is potentially either very positive or very - ;; negative. Therefore, the remainer is unbounded, but we might + ;; negative. Therefore, the remainder is unbounded, but we might ;; be able to tell something about the sign from the number. `(integer ,(if (and number-low (not (minusp number-low))) ;; The number we are dividing is positive. @@ -3872,7 +3872,7 @@ (define-source-transform > (&rest args) (multi-compare '> args nil 'real)) ;;; We cannot do the inversion for >= and <= here, since both ;;; (< NaN X) and (> NaN X) -;;; are false, and we don't have type-inforation available yet. The +;;; are false, and we don't have type-information available yet. The ;;; deftransforms for two-argument versions of >= and <= takes care of ;;; the inversion to > and < when possible. (define-source-transform <= (&rest args) (multi-compare '<= args nil 'real)) diff --git a/src/compiler/vop.lisp b/src/compiler/vop.lisp index 55fd6ae..49307e2 100644 --- a/src/compiler/vop.lisp +++ b/src/compiler/vop.lisp @@ -894,7 +894,7 @@ ;; :SAVE-ONCE ;; A TN used for saving a :NORMAL TN across function calls. The ;; lifetime information slots are unitialized: get the original - ;; TN our of the SAVE-TN slot and use it for conflicts. SAVE-ONCE + ;; TN out of the SAVE-TN slot and use it for conflicts. SAVE-ONCE ;; is like :SAVE, except that it is only save once at the single ;; writer of the original TN. ;; @@ -989,7 +989,7 @@ ;;; The GLOBAL-CONFLICTS structure represents the conflicts for global ;;; TNs. Each global TN has a list of these structures, one for each -;;; block that it is live in. In addition to repsenting the result of +;;; block that it is live in. In addition to representing the result of ;;; lifetime analysis, the global conflicts structure is used during ;;; lifetime analysis to represent the set of TNs live at the start of ;;; the IR2 block. diff --git a/src/runtime/gencgc.c b/src/runtime/gencgc.c index e97b756..f0b9c13 100644 --- a/src/runtime/gencgc.c +++ b/src/runtime/gencgc.c @@ -168,7 +168,7 @@ boolean gc_active_p = 0; static boolean conservative_stack = 1; /* An array of page structures is allocated on gc initialization. - * This helps quickly map between an address its page structure. + * This helps to quickly map between an address and its page structure. * page_table_pages is set from the size of the dynamic space. */ page_index_t page_table_pages; struct page *page_table; -- 1.7.10.4