0.6.12.4:

[sbcl.git] / src / code / target-eval.lisp

diff --git a/src/code/target-eval.lisp b/src/code/target-eval.lisp
index 0baf841..3d6a727 100644 (file)
--- a/src/code/target-eval.lisp
+++ b/src/code/target-eval.lisp
@@ -7,28 +7,6 @@
 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
 ;;;; files for more information.
 
 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
 ;;;; files for more information.
 

-(in-package "SB!IMPL")
-
-;;; FIXME: These probably belong in some package other than SB!IMPL.
-;;; Perhaps SB!KERNEL?
-
-(defconstant call-arguments-limit most-positive-fixnum
-  #!+sb-doc
-  "The exclusive upper bound on the number of arguments which may be passed
-  to a function, including rest args.")
-
-(defconstant lambda-parameters-limit most-positive-fixnum
-  #!+sb-doc
-  "The exclusive upper bound on the number of parameters which may be specifed
-  in a given lambda list. This is actually the limit on required and optional
-  parameters. With &key and &aux you can get more.")
-
-(defconstant multiple-values-limit most-positive-fixnum
-  #!+sb-doc
-  "The exclusive upper bound on the number of multiple-values that you can
-  have.")
-\f
-;;; FIXME: more than one IN-PACKAGE in one file, ick

 (in-package "SB!EVAL")
 
 ;;; This is defined here so that the printer etc. can call
 (in-package "SB!EVAL")
 
 ;;; This is defined here so that the printer etc. can call

@@ -84,7 +62,7 @@
 ;;;; debuggable macros anyway). In that environment, a stub no-op version of
 ;;;; this function is used.
 (defun try-to-rename-interpreted-function-as-macro (f name lambda-list)
 ;;;; debuggable macros anyway). In that environment, a stub no-op version of
 ;;;; this function is used.
 (defun try-to-rename-interpreted-function-as-macro (f name lambda-list)

-  (assert (sb!eval:interpreted-function-p f))
+  (aver (sb!eval:interpreted-function-p f))

   (setf (sb!eval:interpreted-function-name f)
        (format nil "DEFMACRO ~S" name)
        (sb!eval:interpreted-function-arglist f)
   (setf (sb!eval:interpreted-function-name f)
        (format nil "DEFMACRO ~S" name)
        (sb!eval:interpreted-function-arglist f)

@@ -93,16 +71,17 @@
 \f
 ;;;; EVAL and friends
 
 \f
 ;;;; EVAL and friends
 

-;;; This needs to be initialized in the cold load, since the top-level catcher
-;;; will always restore the initial value.
+;;; This needs to be initialized in the cold load, since the top-level
+;;; catcher will always restore the initial value.

 (defvar *eval-stack-top* 0)
 
 ;;; Pick off a few easy cases, and call INTERNAL-EVAL for the rest. If
 (defvar *eval-stack-top* 0)
 
 ;;; Pick off a few easy cases, and call INTERNAL-EVAL for the rest. If

-;;; *ALREADY-EVALED-THIS* is true, then we bind it to NIL before doing a call
-;;; so that the effect is confined to the lexical scope of the EVAL-WHEN.
+;;; *ALREADY-EVALED-THIS* is true, then we bind it to NIL before doing
+;;; a call so that the effect is confined to the lexical scope of the
+;;; EVAL-WHEN.

 (defun eval (original-exp)
   #!+sb-doc
 (defun eval (original-exp)
   #!+sb-doc

-  "Evaluates its single arg in a null lexical environment, returns the
+  "Evaluates its single argument in a null lexical environment, returns the

   result or results."
   (declare (optimize (safety 1)))
   (let ((exp (macroexpand original-exp)))
   result or results."
   (declare (optimize (safety 1)))
   (let ((exp (macroexpand original-exp)))

@@ -140,8 +119,8 @@
                  ((null name)
                   (do ((args (cdr exp) (cddr args)))
                       ((null (cddr args))
                  ((null name)
                   (do ((args (cdr exp) (cddr args)))
                       ((null (cddr args))

-                       ;; We duplicate the call to SET so that the correct
-                       ;; value gets returned.
+                       ;; We duplicate the call to SET so that the
+                       ;; correct value gets returned.

                        (set (first args) (eval (second args))))
                     (set (first args) (eval (second args)))))
                (let ((symbol (first name)))
                        (set (first args) (eval (second args))))
                     (set (first args) (eval (second args)))))
                (let ((symbol (first name)))