(in-package "SB!C")
-;;; 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)
+;;; 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.")
+
+(defconstant-eqx sb!xc:lambda-list-keywords
+ '(&allow-other-keys
+ &aux
+ &body
+ &environment
+ &key
+ &more
+ &optional
+ &rest
+ &whole)
#'equal
+ #!+sb-doc
"symbols which are magical in a lambda list")
\f
;;;; cross-compiler-only versions of CL special variables, so that we
;;; 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::policy-quality () '(or (rational 0 3) null))
-\f
-;;;; policy stuff
-
-;;; a map from optimization policy quality to corresponding POLICY
-;;; slot name, used to automatically keep POLICY-related definitions
-;;; in sync even if future maintenance changes POLICY slots
-(eval-when (:compile-toplevel :load-toplevel :execute)
- (defstruct (policy-quality-slot (:constructor %make-pqs (quality accessor)))
- ;; the name of the quality
- (quality (required-argument) :type symbol)
- ;; the name of the structure slot accessor
- (accessor (required-argument) :type symbol))
- (defparameter *policy-quality-slots*
- (list (%make-pqs 'speed 'policy-speed)
- (%make-pqs 'space 'policy-space)
- (%make-pqs 'safety 'policy-safety)
- (%make-pqs 'cspeed 'policy-cspeed)
- (%make-pqs 'brevity 'policy-brevity)
- (%make-pqs 'debug 'policy-debug)))
- (defun named-policy-quality-slot (name)
- (find name *policy-quality-slots* :key #'policy-quality-slot-quality)))
-
-;;; A POLICY object holds information about the compilation policy for
-;;; a node. See the LEXENV definition for a description of how it is used.
-#.`(def!struct (policy
- (:copier nil)) ; (but see DEFUN COPY-POLICY)
- ,@(mapcar (lambda (pqs)
- `(,(policy-quality-slot-quality pqs) nil
- :type policy-quality))
- *policy-quality-slots*))
-
-;;; an annoyingly hairy way of doing COPY-STRUCTURE on POLICY objects
-;;;
-;;; (We need this explicit, separate, hairy DEFUN only because we need
-;;; to be able to copy POLICY objects 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).)
-#.`(defun copy-policy (policy)
- (make-policy
- ,@(mapcan (lambda (pqs)
- `(,(keywordicate (policy-quality-slot-quality pqs))
- (,(policy-quality-slot-accessor pqs) policy)))
- *policy-quality-slots*)))
-
-;;; *DEFAULT-POLICY* 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-POLICY* holds any values specified by an
-;;; OPTIMIZE-INTERFACE declaration.
-(declaim (type policy *default-policy* *default-interface-policy*))
-(defvar *default-policy*) ; initialized in cold init
-(defvar *default-interface-policy*) ; initialized in cold init
\f
;;; possible values for the INLINE-ness of a function.
(deftype inlinep ()
(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* translates from the names of variables referenced
-;;; globally to the LEAF structures for them. *FREE-FUNCTIONS* is like
+;;; globally to the LEAF structures for them. *FREE-FUNS* is like
;;; *FREE-VARIABLES*, only it deals with function names.
(defvar *free-variables*)
-(defvar *free-functions*)
-(declaim (hash-table *free-variables* *free-functions*))
+(defvar *free-funs*)
+(declaim (type hash-table *free-variables* *free-funs*))
-;;; 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 *converting-for-interpreter*)
+(defvar *compiler-trace-output*)
+(defvar *constraint-number*)
(defvar *count-vop-usages*)
(defvar *current-path*)
(defvar *current-component*)
-(defvar *default-policy*)
-(defvar *default-interface-policy*)
+(defvar *delayed-ir1-transforms*)
+(defvar *policy*)
(defvar *dynamic-counts-tn*)
(defvar *elsewhere*)
(defvar *event-info*)
(defvar *trace-table*)
(defvar *undefined-warnings*)
(defvar *warnings-p*)
+
+;;; unique ID for the next object created (to let us track object
+;;; identity even across GC, useful for understanding weird compiler
+;;; bugs where something is supposed to be unique but is instead
+;;; exists as duplicate objects)
+#!+sb-show
+(progn
+ (defvar *object-id-counter* 0)
+ (defun new-object-id ()
+ (prog1
+ *object-id-counter*
+ (incf *object-id-counter*))))
\f
;;;; miscellaneous utilities
note-name-defined))
(defun note-name-defined (name kind)
;; We do this BOUNDP check because this function can be called when
- ;; not in a compilation unit (as when loading top-level forms).
+ ;; not in a compilation unit (as when loading top level forms).
(when (boundp '*undefined-warnings*)
(setq *undefined-warnings*
(delete-if (lambda (x)
;;; 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