(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 already in use to name a constant."
- name))
+ (cond ((or (keywordp name) (eq kind :constant))
+ (compiler-error "The name of the lambda variable ~S is already in use to name a constant."
+ name))
+ ((eq :global kind)
+ (compiler-error "The name of the lambda variable ~S is already in use to name a global variable."
+ name)))
(cond ((eq kind :special)
(let ((specvar (find-free-var name)))
(make-lambda-var :%source-name name
(source-name '.anonymous.)
debug-name
(note-lexical-bindings t)
- post-binding-lexenv)
+ post-binding-lexenv
+ system-lambda)
(declare (list body vars aux-vars aux-vals))
;; We're about to try to put new blocks into *CURRENT-COMPONENT*.
(lambda (make-lambda :vars vars
:bind bind
:%source-name source-name
- :%debug-name debug-name))
+ :%debug-name debug-name
+ :system-lambda-p system-lambda))
(result-ctran (make-ctran))
(result-lvar (make-lvar)))
(fun (collect ((default-bindings)
(default-vals))
(dolist (default defaults)
- (if (constantp default)
+ (if (sb!xc:constantp default)
(default-vals default)
(let ((var (gensym)))
(default-bindings `(,var ,default))
(default-vals var))))
- (ir1-convert-lambda-body `((let (,@(default-bindings))
- (%funcall ,fun
- ,@(reverse vals)
- ,@(default-vals))))
- arg-vars
- ;; FIXME: Would be nice to
- ;; share these names instead
- ;; of consing up several
- ;; identical ones. Oh well.
- :debug-name (debug-name
- '&optional-processor
- name)
- :note-lexical-bindings nil))))
+ (let ((bindings (default-bindings))
+ (call `(%funcall ,fun ,@(reverse vals) ,@(default-vals))))
+ (ir1-convert-lambda-body (if bindings
+ `((let (,@bindings) ,call))
+ `(,call))
+ arg-vars
+ ;; FIXME: Would be nice to
+ ;; share these names instead
+ ;; of consing up several
+ ;; identical ones. Oh well.
+ :debug-name (debug-name
+ '&optional-processor
+ name)
+ :note-lexical-bindings nil
+ :system-lambda t)))))
(mapc (lambda (var arg-var)
(when (cdr (leaf-refs arg-var))
(setf (leaf-ever-used var) t)))
vars supplied-p-p body
aux-vars aux-vals
source-name debug-name
- force post-binding-lexenv)
+ force post-binding-lexenv
+ system-lambda)
(declare (type optional-dispatch res)
(list default-vars default-vals entry-vars entry-vals vars body
aux-vars aux-vals))
(list* t arg-name entry-vals)
(rest vars) t body aux-vars aux-vals
source-name debug-name
- force post-binding-lexenv)
+ force post-binding-lexenv system-lambda)
(ir1-convert-hairy-args
res
(cons arg default-vars)
(cons arg-name entry-vals)
(rest vars) supplied-p-p body aux-vars aux-vals
source-name debug-name
- force post-binding-lexenv))))
+ force post-binding-lexenv system-lambda))))
;; We want to delay converting the entry, but there exist
;; problems: hidden references should not be established to
:type (leaf-type var)
:where-from (leaf-where-from var))))
- (let* ((*allow-instrumenting* nil)
- (n-context (gensym "N-CONTEXT-"))
+ (let* ((n-context (gensym "N-CONTEXT-"))
(context-temp (make-lambda-var :%source-name n-context))
(n-count (gensym "N-COUNT-"))
(count-temp (make-lambda-var :%source-name n-count
,@(arg-vals))))
(arg-vars)
:debug-name (debug-name '&more-processor name)
- :note-lexical-bindings nil)))
+ :note-lexical-bindings nil
+ :system-lambda t)))
(setf (optional-dispatch-more-entry res)
(register-entry-point ep res)))))
;;; incoming value is NIL, so we must union NULL with the declared
;;; type when computing the type for the main entry's argument.
(defun ir1-convert-more (res default-vars default-vals entry-vars entry-vals
- rest more-context more-count keys supplied-p-p
- body aux-vars aux-vals
- source-name debug-name post-binding-lexenv)
+ rest more-context more-count keys supplied-p-p
+ body aux-vars aux-vals source-name debug-name
+ post-binding-lexenv system-lambda)
(declare (type optional-dispatch res)
(list default-vars default-vals entry-vars entry-vals keys body
aux-vars aux-vals))
:aux-vars (append (bind-vars) aux-vars)
:aux-vals (append (bind-vals) aux-vals)
:post-binding-lexenv post-binding-lexenv
- :debug-name (debug-name 'varargs-entry name)))
+ :debug-name (debug-name 'varargs-entry name)
+ :system-lambda system-lambda))
(last-entry (convert-optional-entry main-entry default-vars
(main-vals) () name)))
(setf (optional-dispatch-main-entry res)
vars supplied-p-p body aux-vars
aux-vals
source-name debug-name
- force post-binding-lexenv)
+ force post-binding-lexenv
+ system-lambda)
(declare (type optional-dispatch res)
(list default-vars default-vals entry-vars entry-vals vars body
aux-vars aux-vals))
+ (aver (or debug-name (neq '.anonymous. source-name)))
(cond ((not vars)
(if (optional-dispatch-keyp res)
;; Handle &KEY with no keys...
entry-vars entry-vals
nil nil nil vars supplied-p-p body aux-vars
aux-vals source-name debug-name
- post-binding-lexenv)
+ post-binding-lexenv system-lambda)
(let* ((name (or debug-name source-name))
(fun (ir1-convert-lambda-body
body (reverse default-vars)
:aux-vars aux-vars
:aux-vals aux-vals
:post-binding-lexenv post-binding-lexenv
- :debug-name (debug-name 'hairy-arg-processor name))))
+ :debug-name (debug-name 'hairy-arg-processor name)
+ :system-lambda system-lambda)))
(setf (optional-dispatch-main-entry res) fun)
(register-entry-point fun res)
(ir1-convert-hairy-args res nvars nvals nvars nvals
(rest vars) nil body aux-vars aux-vals
source-name debug-name
- nil post-binding-lexenv)))
+ nil post-binding-lexenv system-lambda)))
(t
(let* ((arg (first vars))
(info (lambda-var-arg-info arg))
entry-vars entry-vals vars supplied-p-p body
aux-vars aux-vals
source-name debug-name
- force post-binding-lexenv)))
+ force post-binding-lexenv
+ system-lambda)))
;; See GENERATE-OPTIONAL-DEFAULT-ENTRY.
(push (if (lambda-p ep)
(register-entry-point
arg nil nil (rest vars) supplied-p-p body
aux-vars aux-vals
source-name debug-name
- post-binding-lexenv))
+ post-binding-lexenv system-lambda))
(:more-context
(ir1-convert-more res default-vars default-vals
entry-vars entry-vals
nil arg (second vars) (cddr vars) supplied-p-p
body aux-vars aux-vals
source-name debug-name
- post-binding-lexenv))
+ post-binding-lexenv system-lambda))
(:keyword
(ir1-convert-more res default-vars default-vals
entry-vars entry-vals
nil nil nil vars supplied-p-p body aux-vars
aux-vals source-name debug-name
- post-binding-lexenv)))))))
+ post-binding-lexenv system-lambda)))))))
;;; This function deals with the case where we have to make an
;;; OPTIONAL-DISPATCH to represent a LAMBDA. We cons up the result and
;;; call IR1-CONVERT-HAIRY-ARGS to do the work. When it is done, we
;;; figure out the MIN-ARGS and MAX-ARGS.
(defun ir1-convert-hairy-lambda (body vars keyp allowp aux-vars aux-vals
- &key
- post-binding-lexenv
- (source-name '.anonymous.)
- (debug-name
- (debug-name '&optional-dispatch vars)))
+ &key post-binding-lexenv
+ (source-name '.anonymous.)
+ debug-name system-lambda)
(declare (list body vars aux-vars aux-vals))
+ (aver (or debug-name (neq '.anonymous. source-name)))
(let ((res (make-optional-dispatch :arglist vars
:allowp allowp
:keyp keyp
(aver-live-component *current-component*)
(push res (component-new-functionals *current-component*))
(ir1-convert-hairy-args res () () () () vars nil body aux-vars aux-vals
- source-name debug-name nil post-binding-lexenv)
+ source-name debug-name nil post-binding-lexenv
+ system-lambda)
(setf (optional-dispatch-min-args res) min)
(setf (optional-dispatch-max-args res)
(+ (1- (length (optional-dispatch-entry-points res))) min))
;;; Convert a LAMBDA form into a LAMBDA leaf or an OPTIONAL-DISPATCH leaf.
(defun ir1-convert-lambda (form &key (source-name '.anonymous.)
- debug-name maybe-add-debug-catch)
+ debug-name maybe-add-debug-catch
+ system-lambda)
(unless (consp form)
(compiler-error "A ~S was found when expecting a lambda expression:~% ~S"
(type-of form)
(compiler-error
"The lambda expression has a missing or non-list lambda list:~% ~S"
form))
-
+ (when (and system-lambda maybe-add-debug-catch)
+ (bug "Both SYSTEM-LAMBDA and MAYBE-ADD-DEBUG-CATCH specified"))
+ (unless (or debug-name (neq '.anonymous. source-name))
+ (setf debug-name (name-lambdalike form)))
(multiple-value-bind (vars keyp allow-other-keys aux-vars aux-vals)
(make-lambda-vars (cadr form))
- (multiple-value-bind (forms decls) (parse-body (cddr form))
+ (multiple-value-bind (forms decls doc) (parse-body (cddr form))
(binding* (((*lexenv* result-type post-binding-lexenv)
(process-decls decls (append aux-vars vars) nil
:binding-form-p t))
(forms (if (eq result-type *wild-type*)
forms
`((the ,result-type (progn ,@forms)))))
- (res (if (or (find-if #'lambda-var-arg-info vars) keyp)
- (ir1-convert-hairy-lambda forms vars keyp
- allow-other-keys
- aux-vars aux-vals
- :post-binding-lexenv post-binding-lexenv
- :source-name source-name
- :debug-name debug-name)
- (ir1-convert-lambda-body forms vars
- :aux-vars aux-vars
- :aux-vals aux-vals
- :post-binding-lexenv post-binding-lexenv
- :source-name source-name
- :debug-name debug-name))))
+ (*allow-instrumenting* (and (not system-lambda) *allow-instrumenting*))
+ (res (cond ((or (find-if #'lambda-var-arg-info vars) keyp)
+ (ir1-convert-hairy-lambda forms vars keyp
+ allow-other-keys
+ aux-vars aux-vals
+ :post-binding-lexenv post-binding-lexenv
+ :source-name source-name
+ :debug-name debug-name
+ :system-lambda system-lambda))
+ (t
+ (ir1-convert-lambda-body forms vars
+ :aux-vars aux-vars
+ :aux-vals aux-vals
+ :post-binding-lexenv post-binding-lexenv
+ :source-name source-name
+ :debug-name debug-name
+ :system-lambda system-lambda)))))
(setf (functional-inline-expansion res) form)
(setf (functional-arg-documentation res) (cadr form))
+ (setf (functional-documentation res) doc)
+ (when (boundp '*lambda-conversions*)
+ ;; KLUDGE: Not counting TL-XEPs is a lie, of course, but
+ ;; keeps things less confusing to users of TIME, where this
+ ;; count gets used.
+ (unless (and (consp debug-name) (eq 'tl-xep (car debug-name)))
+ (incf *lambda-conversions*)))
res))))
(defun wrap-forms-in-debug-catch (forms)
&key
(source-name '.anonymous.)
debug-name)
+ (when (and (not debug-name) (eq '.anonymous. source-name))
+ (setf debug-name (name-lambdalike thing)))
(ecase (car thing)
((lambda)
(ir1-convert-lambda thing
((named-lambda)
(let ((name (cadr thing))
(lambda-expression `(lambda ,@(cddr thing))))
- (if (legal-fun-name-p name)
- (let ((defined-fun-res (get-defined-fun name))
+ (if (and name (legal-fun-name-p name))
+ (let ((defined-fun-res (get-defined-fun name (second lambda-expression)))
(res (ir1-convert-lambda lambda-expression
:maybe-add-debug-catch t
:source-name name)))
(assert-global-function-definition-type name res)
- (setf (defined-fun-functional defined-fun-res) res)
+ (push res (defined-fun-functionals defined-fun-res))
(unless (eq (defined-fun-inlinep defined-fun-res) :notinline)
(substitute-leaf-if
(lambda (ref)
res)
(ir1-convert-lambda lambda-expression
:maybe-add-debug-catch t
- :debug-name name))))
+ :debug-name
+ (or name (name-lambdalike thing))))))
((lambda-with-lexenv)
(ir1-convert-inline-lambda thing
:source-name source-name
(source-name '.anonymous.)
debug-name
system-lambda)
+ (when (and (not debug-name) (eq '.anonymous. source-name))
+ (setf debug-name (name-lambdalike fun)))
(destructuring-bind (decls macros symbol-macros &rest body)
(if (eq (car fun) 'lambda-with-lexenv)
(cdr fun)
;; like a much more common case.
:handled-conditions (lexenv-handled-conditions *lexenv*)
:policy (lexenv-policy *lexenv*)))
- (*allow-instrumenting* (and (not system-lambda)
- *allow-instrumenting*))
(clambda (ir1-convert-lambda `(lambda ,@body)
:source-name source-name
- :debug-name debug-name)))
+ :debug-name debug-name
+ :system-lambda system-lambda)))
(setf (functional-inline-expanded clambda) t)
clambda)))
+;;; Given a lambda-list, return a FUN-TYPE object representing the signature:
+;;; return type is *, and each individual arguments type is T -- but we get
+;;; the argument counts and keywords.
+(defun ftype-from-lambda-list (lambda-list)
+ (multiple-value-bind (req opt restp rest-name keyp key-list allowp morep)
+ (parse-lambda-list lambda-list)
+ (declare (ignore rest-name))
+ (flet ((t (list)
+ (mapcar (constantly t) list)))
+ (let ((reqs (t req))
+ (opts (when opt (cons '&optional (t opt))))
+ ;; When it comes to building a type, &REST means pretty much the
+ ;; same thing as &MORE.
+ (rest (when (or morep restp) (list '&rest t)))
+ (keys (when keyp
+ (cons '&key (mapcar (lambda (spec)
+ (let ((key/var (if (consp spec)
+ (car spec)
+ spec)))
+ (list (if (consp key/var)
+ (car key/var)
+ (keywordicate key/var))
+ t)))
+ key-list))))
+ (allow (when allowp (list '&allow-other-keys))))
+ (specifier-type `(function (,@reqs ,@opts ,@rest ,@keys ,@allow) *))))))
+
;;; Get a DEFINED-FUN object for a function we are about to define. If
;;; the function has been forward referenced, then substitute for the
;;; previous references.
-(defun get-defined-fun (name)
+(defun get-defined-fun (name &optional (lambda-list nil lp))
(proclaim-as-fun-name name)
- (let ((found (find-free-fun name "shouldn't happen! (defined-fun)")))
- (note-name-defined name :function)
- (cond ((not (defined-fun-p found))
- (aver (not (info :function :inlinep name)))
- (let* ((where-from (leaf-where-from found))
- (res (make-defined-fun
- :%source-name name
- :where-from (if (eq where-from :declared)
- :declared :defined)
- :type (leaf-type found))))
- (substitute-leaf res found)
- (setf (gethash name *free-funs*) res)))
- ;; If *FREE-FUNS* has a previously converted definition
- ;; for this name, then blow it away and try again.
- ((defined-fun-functional found)
- (remhash name *free-funs*)
- (get-defined-fun name))
- (t found))))
+ (when (boundp '*free-funs*)
+ (let ((found (find-free-fun name "shouldn't happen! (defined-fun)")))
+ (note-name-defined name :function)
+ (cond ((not (defined-fun-p found))
+ (aver (not (info :function :inlinep name)))
+ (let* ((where-from (leaf-where-from found))
+ (res (make-defined-fun
+ :%source-name name
+ :where-from (if (eq where-from :declared)
+ :declared
+ :defined)
+ :type (if (eq :declared where-from)
+ (leaf-type found)
+ (if lp
+ (ftype-from-lambda-list lambda-list)
+ (specifier-type 'function))))))
+ (substitute-leaf res found)
+ (setf (gethash name *free-funs*) res)))
+ ;; If *FREE-FUNS* has a previously converted definition
+ ;; for this name, then blow it away and try again.
+ ((defined-fun-functionals found)
+ (remhash name *free-funs*)
+ (get-defined-fun name lambda-list))
+ (t found)))))
;;; Check a new global function definition for consistency with
;;; previous declaration or definition, and assert argument/result
(setf (functional-inlinep fun) inlinep)
(assert-new-definition var fun)
(setf (defined-fun-inline-expansion var) expansion)
+ ;; Associate VAR with the FUN -- and in case of an optional dispatch
+ ;; with the various entry-points. This allows XREF to know where the
+ ;; inline CLAMBDA comes from.
+ (flet ((note-inlining (f)
+ (typecase f
+ (functional
+ (setf (functional-inline-expanded f) var))
+ (cons
+ ;; Delayed entry-point.
+ (if (car f)
+ (setf (functional-inline-expanded (cdr f)) var)
+ (let ((old-thunk (cdr f)))
+ (setf (cdr f) (lambda ()
+ (let ((g (funcall old-thunk)))
+ (setf (functional-inline-expanded g) var)
+ g)))))))))
+ (note-inlining fun)
+ (when (optional-dispatch-p fun)
+ (note-inlining (optional-dispatch-main-entry fun))
+ (note-inlining (optional-dispatch-more-entry fun))
+ (mapc #'note-inlining (optional-dispatch-entry-points fun))))
;; substitute for any old references
(unless (or (not *block-compile*)
(and info
(defun %compiler-defun (name lambda-with-lexenv compile-toplevel)
(let ((defined-fun nil)) ; will be set below if we're in the compiler
(when compile-toplevel
- ;; better be in the compiler
- (aver (boundp '*lexenv*))
- (remhash name *free-funs*)
- (setf defined-fun (get-defined-fun name))
- (aver (fasl-output-p *compile-object*))
- (if (member name *fun-names-in-this-file* :test #'equal)
- (warn 'duplicate-definition :name name)
- (push name *fun-names-in-this-file*)))
+ (setf defined-fun (if lambda-with-lexenv
+ (get-defined-fun name (fifth lambda-with-lexenv))
+ (get-defined-fun name)))
+ (when (boundp '*lexenv*)
+ (remhash name *free-funs*)
+ (aver (fasl-output-p *compile-object*))
+ (if (member name *fun-names-in-this-file* :test #'equal)
+ (warn 'duplicate-definition :name name)
+ (push name *fun-names-in-this-file*))))
(become-defined-fun-name name)