0.6.11.23:

[sbcl.git] / src / code / loop.lisp

diff --git a/src/code/loop.lisp b/src/code/loop.lisp
index 784a2f1..affebfb 100644 (file)
--- a/src/code/loop.lisp
+++ b/src/code/loop.lisp
@@ -66,9 +66,6 @@
 
 (in-package "SB!LOOP")
 
-(sb!int:file-comment
- "$Header$")
-
 ;;;; The design of this LOOP is intended to permit, using mostly the same
 ;;;; kernel of code, up to three different "loop" macros:
 ;;;;
@@ -916,16 +913,16 @@ a LET-like macro, and a SETQ-like macro, which perform LOOP-style destructuring.
                            (loop-lookup-keyword keyword
                                                 (loop-universe-keywords
                                                  *loop-universe*)))
-                     ;; It's a "miscellaneous" toplevel LOOP keyword (do,
-                     ;; collect, named, etc.)
+                     ;; It's a "miscellaneous" toplevel LOOP keyword (DO,
+                     ;; COLLECT, NAMED, etc.)
                      (apply (symbol-function (first tem)) (rest tem)))
                     ((setq tem
                            (loop-lookup-keyword keyword
                                                 (loop-universe-iteration-keywords *loop-universe*)))
                      (loop-hack-iteration tem))
                     ((loop-tmember keyword '(and else))
-                     ;; Alternative is to ignore it, ie let it go around to
-                     ;; the next keyword...
+                     ;; The alternative is to ignore it, i.e. let it go
+                     ;; around to the next keyword...
                      (loop-error "secondary clause misplaced at top level in LOOP macro: ~S ~S ~S ..."
                                  keyword
                                  (car *loop-source-code*)
@@ -1201,8 +1198,8 @@ a LET-like macro, and a SETQ-like macro, which perform LOOP-style destructuring.
 ;;;; value accumulation: LIST
 
 (defstruct (loop-collector
-            (:copier nil)
-            (:predicate nil))
+           (:copier nil)
+           (:predicate nil))
   name
   class
   (history nil)
@@ -1310,9 +1307,9 @@ a LET-like macro, and a SETQ-like macro, which perform LOOP-style destructuring.
                                                      ,specifically
                                                      ,form)))))
 \f
-;;;; value accumulation:  aggregate booleans
+;;;; value accumulation: aggregate booleans
 
-;;; ALWAYS and NEVER
+;;; handling the ALWAYS and NEVER loop keywords
 ;;;
 ;;; Under ANSI these are not permitted to appear under conditionalization.
 (defun loop-do-always (restrictive negate)
@@ -1322,7 +1319,7 @@ a LET-like macro, and a SETQ-like macro, which perform LOOP-style destructuring.
                      ,(loop-construct-return nil)))
     (loop-emit-final-value t)))
 
-;;; THEREIS
+;;; handling the THEREIS loop keyword
 ;;;
 ;;; Under ANSI this is not permitted to appear under conditionalization.
 (defun loop-do-thereis (restrictive)
@@ -1582,8 +1579,8 @@ a LET-like macro, and a SETQ-like macro, which perform LOOP-style destructuring.
 ;;;; iteration paths
 
 (defstruct (loop-path
-            (:copier nil)
-            (:predicate nil))
+           (:copier nil)
+           (:predicate nil))
   names
   preposition-groups
   inclusive-permitted