(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)
;;; 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))
\f
-;;; 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))
(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*))
;;; *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*)
(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*)
;;; 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:
;; (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))
projects / sbcl.git / blobdiff