;;; definition of NAME.
(declaim (ftype (function (t string) leaf) find-lexically-apparent-fun))
(defun find-lexically-apparent-fun (name context)
- (let ((var (lexenv-find name functions :test #'equal)))
+ (let ((var (lexenv-find name funs :test #'equal)))
(cond (var
(unless (leaf-p var)
(aver (and (consp var) (eq (car var) 'macro)))
(find-free-fun name context)))))
;;; Return the LEAF node for a global variable reference to NAME. If
-;;; NAME is already entered in *FREE-VARIABLES*, then we just return
-;;; the corresponding value. Otherwise, we make a new leaf using
+;;; NAME is already entered in *FREE-VARS*, then we just return the
+;;; corresponding value. Otherwise, we make a new leaf using
;;; information from the global environment and enter it in
-;;; *FREE-VARIABLES*. If the variable is unknown, then we emit a
-;;; warning.
-(defun find-free-variable (name)
+;;; *FREE-VARS*. If the variable is unknown, then we emit a warning.
+(defun find-free-var (name)
(declare (values (or leaf heap-alien-info)))
(unless (symbolp name)
(compiler-error "Variable name is not a symbol: ~S." name))
- (or (gethash name *free-variables*)
+ (or (gethash name *free-vars*)
(let ((kind (info :variable :kind name))
(type (info :variable :type name))
(where-from (info :variable :where-from name)))
(when (and (eq where-from :assumed) (eq kind :global))
(note-undefined-reference name :variable))
- (setf (gethash name *free-variables*)
+ (setf (gethash name *free-vars*)
(case kind
(:alien
(info :variable :alien-info name))
(cons form *current-path*))))
(if (atom form)
(cond ((and (symbolp form) (not (keywordp form)))
- (ir1-convert-variable start cont form))
+ (ir1-convert-var start cont form))
((leaf-p form)
(reference-leaf start cont form))
(t
(reference-constant start cont form)))
(let ((opname (car form)))
(cond ((symbolp opname)
- (let ((lexical-def (lexenv-find opname functions)))
+ (let ((lexical-def (lexenv-find opname funs)))
(typecase lexical-def
(null (ir1-convert-global-functoid start cont form))
(functional
(use-continuation res cont)))
;;; Convert a reference to a symbolic constant or variable. If the
-;;; symbol is entered in the LEXENV-VARIABLES we use that definition,
+;;; symbol is entered in the LEXENV-VARS we use that definition,
;;; otherwise we find the current global definition. This is also
;;; where we pick off symbol macro and alien variable references.
-(defun ir1-convert-variable (start cont name)
+(defun ir1-convert-var (start cont name)
(declare (type continuation start cont) (symbol name))
- (let ((var (or (lexenv-find name variables) (find-free-variable name))))
+ (let ((var (or (lexenv-find name vars) (find-free-var name))))
(etypecase var
(leaf
(when (lambda-var-p var)
(defun muffle-warning-or-die ()
(muffle-warning)
- (error "internal error -- no MUFFLE-WARNING restart"))
+ (bug "no MUFFLE-WARNING restart"))
;;; Expand FORM using the macro whose MACRO-FUNCTION is FUN, trapping
;;; errors which occur during the macroexpansion.
\f
;;;; converting combinations
-;;; Convert a function call where the function (i.e. the FUN argument)
-;;; is a LEAF. We return the COMBINATION node so that the caller can
-;;; poke at it if it wants to.
+;;; Convert a function call where the function FUN is a LEAF. FORM is
+;;; the source for the call. We return the COMBINATION node so that
+;;; the caller can poke at it if it wants to.
(declaim (ftype (function (continuation continuation list leaf) combination)
ir1-convert-combination))
(defun ir1-convert-combination (start cont form fun)
(reference-leaf start fun-cont fun)
(ir1-convert-combination-args fun-cont cont (cdr form))))
-;;; Convert the arguments to a call and make the COMBINATION node.
-;;; FUN-CONT is the continuation which yields the function to call.
-;;; FORM is the source for the call. ARGS is the list of arguments for
-;;; the call, which defaults to the cdr of source. We return the
-;;; COMBINATION node.
+;;; Convert the arguments to a call and make the COMBINATION
+;;; node. FUN-CONT is the continuation which yields the function to
+;;; call. ARGS is the list of arguments for the call, which defaults
+;;; to the cdr of source. We return the COMBINATION node.
(defun ir1-convert-combination-args (fun-cont cont args)
(declare (type continuation fun-cont cont) (list args))
(let ((node (make-combination fun-cont)))
(dolist (var-name (rest decl))
(let* ((bound-var (find-in-bindings vars var-name))
(var (or bound-var
- (lexenv-find var-name variables)
- (find-free-variable var-name))))
+ (lexenv-find var-name vars)
+ (find-free-var var-name))))
(etypecase var
(leaf
(let* ((old-type (or (lexenv-find var type-restrictions)
(if (or (restr) (new-vars))
(make-lexenv :default res
:type-restrictions (restr)
- :variables (new-vars))
+ :vars (new-vars))
res))))
;;; This is somewhat similar to PROCESS-TYPE-DECL, but handles
(unless (assoc name (new-venv) :test #'eq)
(new-venv (cons name (specvar-for-binding name))))))))
(if (new-venv)
- (make-lexenv :default res :variables (new-venv))
+ (make-lexenv :default res :vars (new-venv))
res)))
;;; Return a DEFINED-FUN which copies a GLOBAL-VAR but for its INLINEP.
new-fenv)))))))
(if new-fenv
- (make-lexenv :default res :functions new-fenv)
+ (make-lexenv :default res :funs new-fenv)
res)))
-;;; Like FIND-IN-BINDINGS, but looks for #'foo in the fvars.
+;;; like FIND-IN-BINDINGS, but looks for #'FOO in the FVARS
(defun find-in-bindings-or-fbindings (name vars fvars)
(declare (list vars fvars))
(if (consp name)
(special (process-special-decl spec res vars))
(ftype
(unless (cdr spec)
- (compiler-error "No type specified in FTYPE declaration: ~S" spec))
+ (compiler-error "no type specified in FTYPE declaration: ~S" spec))
(process-ftype-decl (second spec) res (cddr spec) fvars))
((inline notinline maybe-inline)
(process-inline-decl spec res fvars))
(if *suppress-values-declaration*
res
(let ((types (cdr spec)))
- (do-the-stuff (if (eql (length types) 1)
- (car types)
- `(values ,@types))
- cont res 'values))))
+ (ir1ize-the-or-values (if (eql (length types) 1)
+ (car types)
+ `(values ,@types))
+ cont
+ res
+ 'values))))
(dynamic-extent
(when (policy *lexenv* (> speed inhibit-warnings))
(compiler-note
(dolist (decl decls)
(dolist (spec (rest decl))
(unless (consp spec)
- (compiler-error "malformed declaration specifier ~S in ~S"
- spec
- decl))
+ (compiler-error "malformed declaration specifier ~S in ~S" spec decl))
(setq env (process-1-decl spec env vars fvars cont))))
env)
;;; anonymous GLOBAL-VAR.
(defun specvar-for-binding (name)
(cond ((not (eq (info :variable :where-from name) :assumed))
- (let ((found (find-free-variable name)))
+ (let ((found (find-free-var name)))
(when (heap-alien-info-p found)
(compiler-error
"~S is an alien variable and so can't be declared special."
;;;; function representation" before you seriously mess with this
;;;; stuff.
-;;; Verify that a thing is a legal name for a variable and return a
-;;; Var structure for it, filling in info if it is globally special.
-;;; If it is losing, we punt with a Compiler-Error. Names-So-Far is an
-;;; alist of names which have previously been bound. If the name is in
+;;; Verify that the NAME is a legal name for a variable and return a
+;;; VAR structure for it, filling in info if it is globally special.
+;;; If it is losing, we punt with a COMPILER-ERROR. NAMES-SO-FAR is a
+;;; list of names which have previously been bound. If the NAME is in
;;; this list, then we error out.
(declaim (ftype (function (t list) lambda-var) varify-lambda-arg))
(defun varify-lambda-arg (name names-so-far)
(declare (inline member))
(unless (symbolp name)
- (compiler-error "The lambda-variable ~S is not a symbol." name))
+ (compiler-error "The lambda variable ~S is not a symbol." name))
(when (member name names-so-far :test #'eq)
(compiler-error "The variable ~S occurs more than once in the lambda-list."
name))
(let ((kind (info :variable :kind name)))
(when (or (keywordp name) (eq kind :constant))
- (compiler-error "The name of the lambda-variable ~S is a constant."
+ (compiler-error "The name of the lambda variable ~S is already in use to name a constant."
name))
(cond ((eq kind :special)
- (let ((specvar (find-free-variable name)))
+ (let ((specvar (find-free-var name)))
(make-lambda-var :%source-name name
:type (leaf-type specvar)
:where-from (leaf-where-from specvar)
(dolist (spec optional)
(if (atom spec)
(let ((var (varify-lambda-arg spec (names-so-far))))
- (setf (lambda-var-arg-info var) (make-arg-info :kind :optional))
+ (setf (lambda-var-arg-info var)
+ (make-arg-info :kind :optional))
(vars var)
(names-so-far spec))
(let* ((name (first spec))
;;; Create a lambda node out of some code, returning the result. The
;;; bindings are specified by the list of VAR structures VARS. We deal
-;;; with adding the names to the LEXENV-VARIABLES for the conversion.
-;;; The result is added to the NEW-FUNS in the *CURRENT-COMPONENT* and
+;;; with adding the names to the LEXENV-VARS for the conversion. The
+;;; result is added to the NEW-FUNS in the *CURRENT-COMPONENT* and
;;; linked to the component head and tail.
;;;
;;; We detect special bindings here, replacing the original VAR in the
(note-lexical-binding (leaf-source-name var))
(new-venv (cons (leaf-source-name var) var))))))
- (let ((*lexenv* (make-lexenv :variables (new-venv)
+ (let ((*lexenv* (make-lexenv :vars (new-venv)
:lambda lambda
:cleanup nil)))
(setf (bind-lambda bind) lambda)
(body
`(when (oddp ,n-count)
- (%odd-key-arguments-error)))
+ (%odd-key-args-error)))
(body
`(locally
(unless allowp
(body `(when (and ,n-losep (not ,n-allowp))
- (%unknown-key-argument-error ,n-losep)))))))
+ (%unknown-key-arg-error ,n-losep)))))))
(let ((ep (ir1-convert-lambda-body
`((let ,(temps)
:default (process-decls decls nil nil
(make-continuation)
(make-null-lexenv))
- :variables (copy-list symbol-macros)
- :functions
- (mapcar (lambda (x)
- `(,(car x) .
- (macro . ,(coerce (cdr x) 'function))))
- macros)
+ :vars (copy-list symbol-macros)
+ :funs (mapcar (lambda (x)
+ `(,(car x) .
+ (macro . ,(coerce (cdr x) 'function))))
+ macros)
:policy (lexenv-policy *lexenv*))))
(ir1-convert-lambda `(lambda ,@body)
:source-name source-name
projects / sbcl.git / blobdiff