cont
form
&optional
- (proxy ``(error "execution of a form compiled with errors:~% ~S"
- ',,form)))
+ (proxy ``(error 'simple-program-error
+ :format-control "execution of a form compiled with errors:~% ~S"
+ :format-arguments (list ',,form))))
&body body)
(let ((skip (gensym "SKIP")))
`(block ,skip
(values))
;;; Convert anything that looks like a special form, global function
-;;; or macro call.
+;;; or compiler-macro call.
(defun ir1-convert-global-functoid (start cont form)
(declare (type continuation start cont) (list form))
- (let* ((fun (first form))
- (translator (info :function :ir1-convert fun))
- (cmacro (info :function :compiler-macro-function fun)))
- (cond (translator (funcall translator start cont form))
- ((and cmacro
- (not (eq (info :function :inlinep fun)
- :notinline)))
- (let ((res (careful-expand-macro cmacro form)))
+ (let* ((fun-name (first form))
+ (translator (info :function :ir1-convert fun-name))
+ (cmacro-fun (sb!xc:compiler-macro-function fun-name *lexenv*)))
+ (cond (translator
+ (when cmacro-fun
+ (compiler-warn "ignoring compiler macro for special form"))
+ (funcall translator start cont form))
+ ((and cmacro-fun
+ ;; gotcha: If you look up the DEFINE-COMPILER-MACRO
+ ;; macro in the ANSI spec, you might think that
+ ;; suppressing compiler-macro expansion when NOTINLINE
+ ;; is some pre-ANSI hack. However, if you look up the
+ ;; NOTINLINE declaration, you'll find that ANSI
+ ;; requires this behavior after all.
+ (not (eq (info :function :inlinep fun-name) :notinline)))
+ (let ((res (careful-expand-macro cmacro-fun form)))
(if (eq res form)
- (ir1-convert-global-functoid-no-cmacro start cont form fun)
+ (ir1-convert-global-functoid-no-cmacro
+ start cont form fun-name)
(ir1-convert start cont res))))
(t
- (ir1-convert-global-functoid-no-cmacro start cont form fun)))))
+ (ir1-convert-global-functoid-no-cmacro start cont form fun-name)))))
;;; Handle the case of where the call was not a compiler macro, or was
;;; a compiler macro and passed.
(declaim (ftype (function (list) (values list boolean boolean list list))
make-lambda-vars))
(defun make-lambda-vars (list)
- (multiple-value-bind (required optional restp rest keyp keys allowp aux
+ (multiple-value-bind (required optional restp rest keyp keys allowp auxp aux
morep more-context more-count)
(parse-lambda-list list)
+ (declare (ignore auxp)) ; since we just iterate over AUX regardless
(collect ((vars)
(names-so-far)
(aux-vars)
(setf (node-lexenv bind) *lexenv*)
(let ((cont1 (make-continuation))
- (cont2 (make-continuation))
- (revised-body (if (policy bind
- (or (> safety
- (max speed space))
- (= safety 3)))
- ;; (Stuffing this in at IR1 level like
- ;; this is pretty crude. And it's
- ;; particularly inefficient to execute
- ;; it on *every* LAMBDA, including
- ;; LET-converted LAMBDAs. Improvements
- ;; are welcome, but meanwhile, when
- ;; SAFETY is high, it's still arguably
- ;; an improvement over the old CMU CL
- ;; approach of doing nothing (waiting
- ;; for evolution to breed careful
- ;; users:-). -- WHN)
- `((%detect-stack-exhaustion)
- ,@body)
- body)))
+ (cont2 (make-continuation)))
(continuation-starts-block cont1)
(link-node-to-previous-continuation bind cont1)
(use-continuation bind cont2)
- (ir1-convert-special-bindings cont2 result
- revised-body
+ (ir1-convert-special-bindings cont2 result body
aux-vars aux-vals (svars)))
(let ((block (continuation-block result)))
(multiple-value-bind (vars keyp allow-other-keys aux-vars aux-vals)
(make-lambda-vars (cadr form))
- (multiple-value-bind (forms decls) (sb!sys:parse-body (cddr form))
+ (multiple-value-bind (forms decls) (parse-body (cddr form))
(let* ((result-cont (make-continuation))
(*lexenv* (process-decls decls
(append aux-vars vars)
:source-name source-name
:debug-name debug-name))))
-;;; 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.
+;;; 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)
(proclaim-as-fun-name name)
(let ((found (find-free-fun name "shouldn't happen! (defined-fun)")))
(setf (functional-inlinep fun) (defined-fun-inlinep var))
(assert-new-definition var fun)
(setf (defined-fun-inline-expansion var) var-expansion)
- ;; If definitely not an interpreter stub, then substitute for any
- ;; old references.
+ ;; If definitely not an interpreter stub, then substitute for
+ ;; any old references.
(unless (or (eq (defined-fun-inlinep var) :notinline)
(not *block-compile*)
(and fun-info
projects / sbcl.git / blobdiff