(t
(compiler-warn
"~@<The ~(~A~) ~S is undefined, and its name is ~
- reserved by ANSI CL so that even if it it were ~
+ reserved by ANSI CL so that even if it were ~
defined later, the code doing so would not be ~
portable.~:@>"
kind name)))
(maybe-mumble "control ")
(control-analyze component #'make-ir2-block)
- (when (ir2-component-values-receivers (component-info component))
+ (when (or (ir2-component-values-receivers (component-info component))
+ (component-dx-lvars component))
(maybe-mumble "stack ")
(stack-analyze component)
;; Assign BLOCK-NUMBER for any cleanup blocks introduced by
;;; A FILE-INFO structure holds all the source information for a
;;; given file.
-(defstruct (file-info (:copier nil))
+(def!struct (file-info (:copier nil))
;; If a file, the truename of the corresponding source file. If from
;; a Lisp form, :LISP. If from a stream, :STREAM.
(name (missing-arg) :type (or pathname (member :lisp :stream)))
;;; The SOURCE-INFO structure provides a handle on all the source
;;; information for an entire compilation.
-(defstruct (source-info
- #-no-ansi-print-object
- (:print-object (lambda (s stream)
- (print-unreadable-object (s stream :type t))))
- (:copier nil))
+(def!struct (source-info
+ #-no-ansi-print-object
+ (:print-object (lambda (s stream)
+ (print-unreadable-object (s stream :type t))))
+ (:copier nil))
;; the UT that compilation started at
(start-time (get-universal-time) :type unsigned-byte)
;; the FILE-INFO structure for this compilation
(handler-case (read stream nil stream)
(reader-error (condition)
(error 'input-error-in-compile-file
- :error condition
+ :condition condition
;; We don't need to supply :POSITION here because
;; READER-ERRORs already know their position in the file.
))
;; file in the middle of something it's trying to read.
(end-of-file (condition)
(error 'input-error-in-compile-file
- :error condition
+ :condition condition
;; We need to supply :POSITION here because the END-OF-FILE
;; condition doesn't carry the position that the user
;; probably cares about, where the failed READ began.
(defun convert-and-maybe-compile (form path)
(declare (list path))
(let* ((*lexenv* (make-lexenv :policy *policy*
- :handled-conditions *handled-conditions*))
+ :handled-conditions *handled-conditions*
+ :disabled-package-locks *disabled-package-locks*))
(tll (ir1-toplevel form path nil)))
(cond ((eq *block-compile* t) (push tll *toplevel-lambdas*))
(t (compile-toplevel (list tll) nil)))))
;; issue a warning instead of silently screwing up.
(*policy* (lexenv-policy *lexenv*))
;; This is probably also a hack
- (*handled-conditions* (lexenv-handled-conditions *lexenv*)))
+ (*handled-conditions* (lexenv-handled-conditions *lexenv*))
+ ;; ditto
+ (*disabled-package-locks* (lexenv-disabled-package-locks *lexenv*)))
(process-toplevel-progn forms path compile-time-too))))
;;; Parse an EVAL-WHEN situations list, returning three flags,
(when name
(legal-fun-name-or-type-error name))
(let* ((*lexenv* (make-lexenv :policy *policy*
- :handled-conditions *handled-conditions*))
+ :handled-conditions *handled-conditions*
+ :disabled-package-locks *disabled-package-locks*))
(fun (make-functional-from-toplevel-lambda lambda-expression
:name name
:path path)))
(catch 'process-toplevel-form-error-abort
(let* ((path (or (gethash form *source-paths*) (cons form path)))
(*compiler-error-bailout*
- (lambda ()
+ (lambda (&optional condition)
(convert-and-maybe-compile
- `(error 'simple-program-error
- :format-control "execution of a form compiled with errors:~% ~S"
- :format-arguments (list ',form))
+ (make-compiler-error-form condition form)
path)
(throw 'process-toplevel-form-error-abort nil))))
((macrolet)
(funcall-in-macrolet-lexenv
magic
- (lambda (&key funs)
+ (lambda (&key funs prepend)
(declare (ignore funs))
+ (aver (null prepend))
(process-toplevel-locally body
path
compile-time-too))
((symbol-macrolet)
(funcall-in-symbol-macrolet-lexenv
magic
- (lambda (&key vars)
+ (lambda (&key vars prepend)
+ (aver (null prepend))
(process-toplevel-locally body
path
compile-time-too
(*policy* *policy*)
(*handled-conditions* *handled-conditions*)
+ (*disabled-package-locks* *disabled-package-locks*)
(*lexenv* (make-null-lexenv))
(*block-compile* *block-compile-arg*)
(*source-info* info)
;; Some errors are sufficiently bewildering that we just fail
;; immediately, without trying to recover and compile more of
;; the input file.
- (input-error-in-compile-file (condition)
+ (fatal-compiler-error (condition)
+ (signal condition)
(format *error-output*
- "~@<compilation aborted because of input error: ~2I~_~A~:>"
+ "~@<compilation aborted because of fatal error: ~2I~_~A~:>"
condition)
(values nil t t)))))
(throw 'pending-init circular-ref)))
(multiple-value-bind (creation-form init-form)
(handler-case
- (sb!xc:make-load-form constant (make-null-lexenv))
+ (sb!xc:make-load-form constant (make-null-lexenv))
(error (condition)
- (compiler-error "(while making load form for ~S)~%~A"
- constant
- condition)))
+ (compiler-error condition)))
(case creation-form
(:sb-just-dump-it-normally
(fasl-validate-structure constant *compile-object*)