(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))
(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))
+ (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)
+ (if (and name (legal-fun-name-p name))
(let ((defined-fun-res (get-defined-fun name))
(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)
- `(() () () . ,(cdr fun)))
- (let ((*lexenv* (make-lexenv
- :default (process-decls decls nil nil
- :lexenv (make-null-lexenv))
- :vars (copy-list symbol-macros)
- :funs (mapcar (lambda (x)
- `(,(car x) .
- (macro . ,(coerce (cdr x) 'function))))
- macros)
- ;; Inherit MUFFLE-CONDITIONS from the call-site lexenv
- ;; rather than the definition-site lexenv, since it seems
- ;; like a much more common case.
- :handled-conditions (lexenv-handled-conditions *lexenv*)
- :policy (lexenv-policy *lexenv*)))
- (*allow-instrumenting* (and (not system-lambda) *allow-instrumenting*)))
- (ir1-convert-lambda `(lambda ,@body)
- :source-name source-name
- :debug-name debug-name))))
+ (if (eq (car fun) 'lambda-with-lexenv)
+ (cdr fun)
+ `(() () () . ,(cdr fun)))
+ (let* ((*lexenv* (make-lexenv
+ :default (process-decls decls nil nil
+ :lexenv (make-null-lexenv))
+ :vars (copy-list symbol-macros)
+ :funs (mapcar (lambda (x)
+ `(,(car x) .
+ (macro . ,(coerce (cdr x) 'function))))
+ macros)
+ ;; Inherit MUFFLE-CONDITIONS from the call-site lexenv
+ ;; rather than the definition-site lexenv, since it seems
+ ;; like a much more common case.
+ :handled-conditions (lexenv-handled-conditions *lexenv*)
+ :policy (lexenv-policy *lexenv*)))
+ (clambda (ir1-convert-lambda `(lambda ,@body)
+ :source-name source-name
+ :debug-name debug-name
+ :system-lambda system-lambda)))
+ (setf (functional-inline-expanded clambda) t)
+ clambda)))
;;; Get a DEFINED-FUN object for a function we are about to define. If
;;; the function has been forward referenced, then substitute for the
(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)
+ ((defined-fun-functionals found)
(remhash name *free-funs*)
(get-defined-fun name))
(t found))))
projects / sbcl.git / blobdiff