X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fearly-c.lisp;h=0ff78207e27d3e47477a1ae758fcff51ff8b4047;hb=31361af9eb64344f521abbb245ea784c76c746e5;hp=54fe4cf58f4625423640f747de602bb6a96d7b01;hpb=77360ee4a1f94c41b807be7ad0e8687199fceef1;p=sbcl.git

diff --git a/src/compiler/early-c.lisp b/src/compiler/early-c.lisp
index 54fe4cf..0ff7820 100644
--- a/src/compiler/early-c.lisp
+++ b/src/compiler/early-c.lisp
@@ -15,6 +15,21 @@
 
 (in-package "SB!C")
 
+;;; ANSI limits on compilation
+(defconstant sb!xc: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 sb!xc: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 sb!xc:multiple-values-limit most-positive-fixnum
+  #!+sb-doc
+  "The exclusive upper bound on the number of multiple VALUES that you can
+  return.")
+
 ;;; FIXME: Shouldn't SB!C::&MORE be in this list?
 (defconstant-eqx sb!xc:lambda-list-keywords
   '(&optional &rest &key &aux &body &whole &allow-other-keys &environment)
@@ -38,48 +53,7 @@
 
 ;;; the type of LAYOUT-DEPTHOID slot values
 (def!type sb!kernel::layout-depthoid () '(or index (integer -1 -1)))
-
-;;; a value for an optimization declaration
-(def!type sb!c::cookie-quality () '(or (rational 0 3) null))
 
-;;; A COOKIE holds information about the compilation environment for a
-;;; node. See the LEXENV definition for a description of how it is
-;;; used.
-(def!struct (cookie (:copier nil))
-  (speed   nil :type cookie-quality)
-  (space   nil :type cookie-quality)
-  (safety  nil :type cookie-quality)
-  (cspeed  nil :type cookie-quality)
-  (brevity nil :type cookie-quality)
-  (debug   nil :type cookie-quality))
-
-;;; KLUDGE: This needs to be executable in cold init toplevel forms,
-;;; earlier than the default copier closure created by DEFSTRUCT
-;;; toplevel forms would be available, and earlier than LAYOUT-INFO is
-;;; initialized (which is a prerequisite for COPY-STRUCTURE to work),
-;;; so we define it explicitly using DEFUN, so that it can be
-;;; installed by the cold loader, and using hand-written,
-;;; hand-maintained slot-by-slot copy it doesn't need to call
-;;; COPY-STRUCTURE. -- WHN 19991019
-(defun copy-cookie (cookie)
-  (make-cookie :speed   (cookie-speed   cookie)
-	       :space   (cookie-space   cookie)
-	       :safety  (cookie-safety  cookie)
-	       :cspeed  (cookie-cspeed  cookie)
-	       :brevity (cookie-brevity cookie)
-	       :debug   (cookie-debug   cookie)))
-
-;;; *DEFAULT-COOKIE* holds the current global compiler policy
-;;; information. Whenever the policy is changed, we copy the structure
-;;; so that old uses will still get the old values.
-;;; *DEFAULT-INTERFACE-COOKIE* holds any values specified by an
-;;; OPTIMIZE-INTERFACE declaration.
-;;;
-;;; FIXME: Why isn't COOKIE called POLICY?
-(declaim (type cookie *default-cookie* *default-interface-cookie*))
-(defvar *default-cookie*)	   ; initialized in cold init
-(defvar *default-interface-cookie*) ; initialized in cold init
-
 ;;; possible values for the INLINE-ness of a function.
 (deftype inlinep ()
   '(member :inline :maybe-inline :notinline nil))
@@ -88,7 +62,7 @@
     (notinline . :notinline)
     (maybe-inline . :maybe-inline)))
 
-;;; The lexical environment we are currently converting in.
+;;; the lexical environment we are currently converting in
 (defvar *lexenv*)
 (declaim (type lexenv *lexenv*))
 
@@ -97,13 +71,13 @@
 ;;; *FREE-VARIABLES*, only it deals with function names.
 (defvar *free-variables*)
 (defvar *free-functions*)
-(declaim (hash-table *free-variables* *free-functions*))
+(declaim (type hash-table *free-variables* *free-functions*))
 
-;;; We use the same Constant structure to represent all equal anonymous
-;;; constants. This hashtable translates from constants to the Leafs that
+;;; We use the same CONSTANT structure to represent all equal anonymous
+;;; constants. This hashtable translates from constants to the LEAFs that
 ;;; represent them.
 (defvar *constants*)
-(declaim (hash-table *constants*))
+(declaim (type hash-table *constants*))
 
 ;;; miscellaneous forward declarations
 (defvar *code-segment*)
@@ -114,12 +88,14 @@
 (defvar *compiler-warning-count*)
 (defvar *compiler-style-warning-count*)
 (defvar *compiler-note-count*)
+(defvar *compiler-trace-output*)
+(defvar *constraint-number*)
 (defvar *converting-for-interpreter*)
 (defvar *count-vop-usages*)
 (defvar *current-path*)
 (defvar *current-component*)
-(defvar *default-cookie*)
-(defvar *default-interface-cookie*)
+(defvar *delayed-ir1-transforms*)
+(defvar *policy*)
 (defvar *dynamic-counts-tn*)
 (defvar *elsewhere*)
 (defvar *event-info*)
@@ -155,7 +131,6 @@
 ;;; to be called when a variable is lexically bound
 (declaim (ftype (function (symbol) (values)) note-lexical-binding))
 (defun note-lexical-binding (symbol)
-  (let ((name (symbol-name symbol)))
     ;; This check is intended to protect us from getting silently
     ;; burned when we define
     ;;   foo.lisp:
@@ -166,10 +141,9 @@
     ;;       (LET ((*FOO* X))
     ;;         (FOO 14)))
     ;; and then we happen to compile bar.lisp before foo.lisp.
-    (when (and (char= #\* (aref name 0))
-	       (char= #\* (aref name (1- (length name)))))
+  (when (looks-like-name-of-special-var-p symbol)
       ;; FIXME: should be COMPILER-STYLE-WARNING?
       (style-warn "using the lexical binding of the symbol ~S, not the~@
 dynamic binding, even though the symbol name follows the usual naming~@
-convention (names like *FOO*) for special variables" symbol)))
+convention (names like *FOO*) for special variables" symbol))
   (values))