+ "unexpected end of file on ~S ~A"
+ (stream-error-stream condition)
+ (reader-eof-error-context condition)))))
+
+(define-condition reader-impossible-number-error (simple-reader-error)
+ ((error :reader reader-impossible-number-error-error :initarg :error))
+ (:report
+ (lambda (condition stream)
+ (let ((error-stream (stream-error-stream condition)))
+ (format stream
+ "READER-ERROR ~@[at ~W ~]on ~S:~%~?~%Original error: ~A"
+ (file-position-or-nil-for-error error-stream) error-stream
+ (simple-condition-format-control condition)
+ (simple-condition-format-arguments condition)
+ (reader-impossible-number-error-error condition))))))
+
+(define-condition standard-readtable-modified-error (reference-condition error)
+ ((operation :initarg :operation :reader standard-readtable-modified-operation))
+ (:report (lambda (condition stream)
+ (format stream "~S would modify the standard readtable."
+ (standard-readtable-modified-operation condition))))
+ (:default-initargs :references `((:ansi-cl :section (2 1 1 2))
+ (:ansi-cl :glossary "standard readtable"))))
+
+(define-condition standard-pprint-dispatch-table-modified-error
+ (reference-condition error)
+ ((operation :initarg :operation
+ :reader standard-pprint-dispatch-table-modified-operation))
+ (:report (lambda (condition stream)
+ (format stream "~S would modify the standard pprint dispatch table."
+ (standard-pprint-dispatch-table-modified-operation
+ condition))))
+ (:default-initargs
+ :references `((:ansi-cl :glossary "standard pprint dispatch table"))))
+
+(define-condition timeout (serious-condition)
+ ((seconds :initarg :seconds :initform nil :reader timeout-seconds))
+ (:report (lambda (condition stream)
+ (format stream "Timeout occurred~@[ after ~A seconds~]."
+ (timeout-seconds condition)))))
+
+(define-condition io-timeout (stream-error timeout)
+ ((direction :reader io-timeout-direction :initarg :direction))
+ (:report
+ (lambda (condition stream)
+ (declare (type stream stream))
+ (format stream
+ "I/O timeout while doing ~(~A~) on ~S."
+ (io-timeout-direction condition)
+ (stream-error-stream condition)))))
+
+(define-condition deadline-timeout (timeout) ()
+ (:report (lambda (condition stream)
+ (format stream "A deadline was reached after ~A seconds."
+ (timeout-seconds condition)))))
+
+(define-condition declaration-type-conflict-error (reference-condition
+ simple-error)
+ ()
+ (:default-initargs
+ :format-control "symbol ~S cannot be both the name of a type and the name of a declaration"
+ :references (list '(:ansi-cl :section (3 8 21)))))
+
+;;; Single stepping conditions
+
+(define-condition step-condition ()
+ ((form :initarg :form :reader step-condition-form))
+
+ #!+sb-doc
+ (:documentation "Common base class of single-stepping conditions.
+STEP-CONDITION-FORM holds a string representation of the form being
+stepped."))
+
+#!+sb-doc
+(setf (fdocumentation 'step-condition-form 'function)
+ "Form associated with the STEP-CONDITION.")
+
+(define-condition step-form-condition (step-condition)
+ ((args :initarg :args :reader step-condition-args))
+ (:report
+ (lambda (condition stream)
+ (let ((*print-circle* t)
+ (*print-pretty* t)
+ (*print-readably* nil))
+ (format stream
+ "Evaluating call:~%~< ~@;~A~:>~%~
+ ~:[With arguments:~%~{ ~S~%~}~;With unknown arguments~]~%"
+ (list (step-condition-form condition))
+ (eq (step-condition-args condition) :unknown)
+ (step-condition-args condition)))))
+ #!+sb-doc
+ (:documentation "Condition signalled by code compiled with
+single-stepping information when about to execute a form.
+STEP-CONDITION-FORM holds the form, STEP-CONDITION-PATHNAME holds the
+pathname of the original file or NIL, and STEP-CONDITION-SOURCE-PATH
+holds the source-path to the original form within that file or NIL.
+Associated with this condition are always the restarts STEP-INTO,
+STEP-NEXT, and STEP-CONTINUE."))
+
+(define-condition step-result-condition (step-condition)
+ ((result :initarg :result :reader step-condition-result)))
+
+#!+sb-doc
+(setf (fdocumentation 'step-condition-result 'function)
+ "Return values associated with STEP-VALUES-CONDITION as a list,
+or the variable value associated with STEP-VARIABLE-CONDITION.")
+
+(define-condition step-values-condition (step-result-condition)
+ ()
+ #!+sb-doc
+ (:documentation "Condition signalled by code compiled with
+single-stepping information after executing a form.
+STEP-CONDITION-FORM holds the form, and STEP-CONDITION-RESULT holds
+the values returned by the form as a list. No associated restarts."))
+
+(define-condition step-finished-condition (step-condition)
+ ()
+ (:report
+ (lambda (condition stream)
+ (declare (ignore condition))
+ (format stream "Returning from STEP")))
+ #!+sb-doc
+ (:documentation "Condition signaled when STEP returns."))
+\f
+;;; A knob for muffling warnings, mostly for use while loading files.
+(defvar *muffled-warnings* 'uninteresting-redefinition
+ "A type that ought to specify a subtype of WARNING. Whenever a
+warning is signaled, if the warning if of this type and is not
+handled by any other handler, it will be muffled.")
+\f
+;;; Various STYLE-WARNING signaled in the system.
+;; For the moment, we're only getting into the details for function
+;; redefinitions, but other redefinitions could be done later
+;; (e.g. methods).
+(define-condition redefinition-warning (style-warning)
+ ((name
+ :initarg :name
+ :reader redefinition-warning-name)
+ (new-location
+ :initarg :new-location
+ :reader redefinition-warning-new-location)))
+
+(define-condition function-redefinition-warning (redefinition-warning)
+ ((new-function
+ :initarg :new-function
+ :reader function-redefinition-warning-new-function)))
+
+(define-condition redefinition-with-defun (function-redefinition-warning)
+ ()
+ (:report (lambda (warning stream)
+ (format stream "redefining ~/sb-impl::print-symbol-with-prefix/ ~
+ in DEFUN"
+ (redefinition-warning-name warning)))))
+
+(define-condition redefinition-with-defmacro (function-redefinition-warning)
+ ()
+ (:report (lambda (warning stream)
+ (format stream "redefining ~/sb-impl::print-symbol-with-prefix/ ~
+ in DEFMACRO"
+ (redefinition-warning-name warning)))))
+
+(define-condition redefinition-with-defgeneric (redefinition-warning)
+ ()
+ (:report (lambda (warning stream)
+ (format stream "redefining ~/sb-impl::print-symbol-with-prefix/ ~
+ in DEFGENERIC"
+ (redefinition-warning-name warning)))))
+
+(define-condition redefinition-with-defmethod (redefinition-warning)
+ ((qualifiers :initarg :qualifiers
+ :reader redefinition-with-defmethod-qualifiers)
+ (specializers :initarg :specializers
+ :reader redefinition-with-defmethod-specializers)
+ (new-location :initarg :new-location
+ :reader redefinition-with-defmethod-new-location)
+ (old-method :initarg :old-method
+ :reader redefinition-with-defmethod-old-method))
+ (:report (lambda (warning stream)
+ (format stream "redefining ~S~{ ~S~} ~S in DEFMETHOD"
+ (redefinition-warning-name warning)
+ (redefinition-with-defmethod-qualifiers warning)
+ (redefinition-with-defmethod-specializers warning)))))
+
+;;;; Deciding which redefinitions are "interesting".
+
+(defun function-file-namestring (function)
+ #!+sb-eval
+ (when (typep function 'sb!eval:interpreted-function)
+ (return-from function-file-namestring
+ (sb!c:definition-source-location-namestring
+ (sb!eval:interpreted-function-source-location function))))
+ (let* ((fun (sb!kernel:%fun-fun function))
+ (code (sb!kernel:fun-code-header fun))
+ (debug-info (sb!kernel:%code-debug-info code))
+ (debug-source (when debug-info
+ (sb!c::debug-info-source debug-info)))
+ (namestring (when debug-source
+ (sb!c::debug-source-namestring debug-source))))
+ namestring))
+
+(defun interesting-function-redefinition-warning-p (warning old)
+ (let ((new (function-redefinition-warning-new-function warning))
+ (source-location (redefinition-warning-new-location warning)))
+ (or
+ ;; Compiled->Interpreted is interesting.
+ (and (typep old 'compiled-function)
+ (typep new '(not compiled-function)))
+ ;; FIN->Regular is interesting.
+ (and (typep old 'funcallable-instance)
+ (typep new '(not funcallable-instance)))
+ ;; Different file or unknown location is interesting.
+ (let* ((old-namestring (function-file-namestring old))
+ (new-namestring
+ (or (function-file-namestring new)
+ (when source-location
+ (sb!c::definition-source-location-namestring source-location)))))
+ (and (or (not old-namestring)
+ (not new-namestring)
+ (not (string= old-namestring new-namestring))))))))
+
+(defun uninteresting-ordinary-function-redefinition-p (warning)
+ (and
+ ;; There's garbage in various places when the first DEFUN runs in
+ ;; cold-init.
+ sb!kernel::*cold-init-complete-p*
+ (typep warning 'redefinition-with-defun)
+ ;; Shared logic.
+ (let ((name (redefinition-warning-name warning)))
+ (not (interesting-function-redefinition-warning-p
+ warning (or (fdefinition name) (macro-function name)))))))
+
+(defun uninteresting-macro-redefinition-p (warning)
+ (and
+ (typep warning 'redefinition-with-defmacro)
+ ;; Shared logic.
+ (let ((name (redefinition-warning-name warning)))
+ (not (interesting-function-redefinition-warning-p
+ warning (or (macro-function name) (fdefinition name)))))))
+
+(defun uninteresting-generic-function-redefinition-p (warning)
+ (and
+ (typep warning 'redefinition-with-defgeneric)
+ ;; Can't use the shared logic above, since GF's don't get a "new"
+ ;; definition -- rather the FIN-FUNCTION is set.
+ (let* ((name (redefinition-warning-name warning))
+ (old (fdefinition name))
+ (old-location (when (typep old 'generic-function)
+ (sb!pcl::definition-source old)))
+ (old-namestring (when old-location
+ (sb!c:definition-source-location-namestring old-location)))
+ (new-location (redefinition-warning-new-location warning))
+ (new-namestring (when new-location
+ (sb!c:definition-source-location-namestring new-location))))
+ (and old-namestring
+ new-namestring
+ (string= old-namestring new-namestring)))))
+
+(defun uninteresting-method-redefinition-p (warning)
+ (and
+ (typep warning 'redefinition-with-defmethod)
+ ;; Can't use the shared logic above, since GF's don't get a "new"
+ ;; definition -- rather the FIN-FUNCTION is set.
+ (let* ((old-method (redefinition-with-defmethod-old-method warning))
+ (old-location (sb!pcl::definition-source old-method))
+ (old-namestring (when old-location
+ (sb!c:definition-source-location-namestring old-location)))
+ (new-location (redefinition-warning-new-location warning))
+ (new-namestring (when new-location
+ (sb!c:definition-source-location-namestring new-location))))
+ (and new-namestring
+ old-namestring
+ (string= new-namestring old-namestring)))))
+
+(deftype uninteresting-redefinition ()
+ '(or (satisfies uninteresting-ordinary-function-redefinition-p)
+ (satisfies uninteresting-macro-redefinition-p)
+ (satisfies uninteresting-generic-function-redefinition-p)
+ (satisfies uninteresting-method-redefinition-p)))
+
+(define-condition redefinition-with-deftransform (redefinition-warning)
+ ((transform :initarg :transform
+ :reader redefinition-with-deftransform-transform))
+ (:report (lambda (warning stream)
+ (format stream "Overwriting ~S"
+ (redefinition-with-deftransform-transform warning)))))
+\f
+;;; Various other STYLE-WARNINGS
+(define-condition dubious-asterisks-around-variable-name
+ (style-warning simple-condition)
+ ()
+ (:report (lambda (warning stream)
+ (format stream "~@?, even though the name follows~@
+the usual naming convention (names like *FOO*) for special variables"
+ (simple-condition-format-control warning)
+ (simple-condition-format-arguments warning)))))
+
+(define-condition asterisks-around-lexical-variable-name
+ (dubious-asterisks-around-variable-name)
+ ())
+
+(define-condition asterisks-around-constant-variable-name
+ (dubious-asterisks-around-variable-name)
+ ())
+
+;; We call this UNDEFINED-ALIEN-STYLE-WARNING because there are some
+;; subclasses of ERROR above having to do with undefined aliens.
+(define-condition undefined-alien-style-warning (style-warning)
+ ((symbol :initarg :symbol :reader undefined-alien-symbol))
+ (:report (lambda (warning stream)
+ (format stream "Undefined alien: ~S"
+ (undefined-alien-symbol warning)))))
+
+#!+sb-eval
+(define-condition lexical-environment-too-complex (style-warning)
+ ((form :initarg :form :reader lexical-environment-too-complex-form)
+ (lexenv :initarg :lexenv :reader lexical-environment-too-complex-lexenv))
+ (:report (lambda (warning stream)
+ (format stream
+ "~@<Native lexical environment too complex for ~
+ SB-EVAL to evaluate ~S, falling back to ~
+ SIMPLE-EVAL-IN-LEXENV. Lexenv: ~S~:@>"
+ (lexical-environment-too-complex-form warning)
+ (lexical-environment-too-complex-lexenv warning)))))
+
+;; Although this has -ERROR- in the name, it's just a STYLE-WARNING.
+(define-condition character-decoding-error-in-comment (style-warning)
+ ((stream :initarg :stream :reader decoding-error-in-comment-stream)
+ (position :initarg :position :reader decoding-error-in-comment-position))
+ (:report (lambda (warning stream)
+ (format stream
+ "Character decoding error in a ~A-comment at ~
+ position ~A reading source stream ~A, ~
+ resyncing."
+ (decoding-error-in-comment-macro warning)
+ (decoding-error-in-comment-position warning)
+ (decoding-error-in-comment-stream warning)))))
+
+(define-condition character-decoding-error-in-macro-char-comment
+ (character-decoding-error-in-comment)
+ ((char :initform #\; :initarg :char
+ :reader character-decoding-error-in-macro-char-comment-char)))
+
+(define-condition character-decoding-error-in-dispatch-macro-char-comment
+ (character-decoding-error-in-comment)
+ ;; ANSI doesn't give a way for a reader function invoked by a
+ ;; dispatch macro character to determine which dispatch character
+ ;; was used, so if a user wants to signal one of these from a custom
+ ;; comment reader, he'll have to supply the :DISP-CHAR himself.
+ ((disp-char :initform #\# :initarg :disp-char
+ :reader character-decoding-error-in-macro-char-comment-disp-char)
+ (sub-char :initarg :sub-char
+ :reader character-decoding-error-in-macro-char-comment-sub-char)))
+
+(defun decoding-error-in-comment-macro (warning)
+ (etypecase warning
+ (character-decoding-error-in-macro-char-comment
+ (character-decoding-error-in-macro-char-comment-char warning))
+ (character-decoding-error-in-dispatch-macro-char-comment
+ (format
+ nil "~C~C"
+ (character-decoding-error-in-macro-char-comment-disp-char warning)
+ (character-decoding-error-in-macro-char-comment-sub-char warning)))))
+
+(define-condition deprecated-eval-when-situations (style-warning)
+ ((situations :initarg :situations
+ :reader deprecated-eval-when-situations-situations))
+ (:report (lambda (warning stream)
+ (format stream "using deprecated EVAL-WHEN situation names~{ ~S~}"
+ (deprecated-eval-when-situations-situations warning)))))
+
+(define-condition proclamation-mismatch (style-warning)
+ ((name :initarg :name :reader proclamation-mismatch-name)
+ (old :initarg :old :reader proclamation-mismatch-old)
+ (new :initarg :new :reader proclamation-mismatch-new)))
+
+(define-condition type-proclamation-mismatch (proclamation-mismatch)
+ ()
+ (:report (lambda (warning stream)
+ (format stream
+ "The new TYPE proclamation~% ~S for ~S does not ~
+ match the old TYPE proclamation ~S"
+ (proclamation-mismatch-new warning)
+ (proclamation-mismatch-name warning)
+ (proclamation-mismatch-old warning)))))
+
+(define-condition ftype-proclamation-mismatch (proclamation-mismatch)
+ ()
+ (:report (lambda (warning stream)
+ (format stream
+ "The new FTYPE proclamation~% ~S for ~S does not ~
+ match the old FTYPE proclamation ~S"
+ (proclamation-mismatch-new warning)
+ (proclamation-mismatch-name warning)
+ (proclamation-mismatch-old warning)))))
+\f
+;;;; deprecation conditions
+
+(define-condition deprecation-condition ()
+ ((name :initarg :name :reader deprecated-name)
+ (replacement :initarg :replacement :reader deprecated-name-replacement)
+ (since :initarg :since :reader deprecated-since)
+ (runtime-error :initarg :runtime-error :reader deprecated-name-runtime-error)))
+
+(def!method print-object ((condition deprecation-condition) stream)
+ (let ((*package* (find-package :keyword)))
+ (if *print-escape*
+ (print-unreadable-object (condition stream :type t)
+ (format stream "~S is deprecated~@[, use ~S~]"
+ (deprecated-name condition)
+ (deprecated-name-replacement condition)))
+ (format stream "~@<~S has been deprecated as of SBCL ~A~
+ ~@[, use ~S instead~].~:@>"
+ (deprecated-name condition)
+ (deprecated-since condition)
+ (deprecated-name-replacement condition)))))
+
+(define-condition early-deprecation-warning (style-warning deprecation-condition)
+ ())
+
+(def!method print-object :after ((warning early-deprecation-warning) stream)
+ (unless *print-escape*
+ (let ((*package* (find-package :keyword)))
+ (format stream "~%~@<~:@_In future SBCL versions ~S will signal a full warning ~
+ at compile-time.~:@>"
+ (deprecated-name warning)))))
+
+(define-condition late-deprecation-warning (warning deprecation-condition)
+ ())
+
+(def!method print-object :after ((warning late-deprecation-warning) stream)
+ (unless *print-escape*
+ (when (deprecated-name-runtime-error warning)
+ (let ((*package* (find-package :keyword)))
+ (format stream "~%~@<~:@_In future SBCL versions ~S will signal a runtime error.~:@>"
+ (deprecated-name warning))))))
+
+(define-condition final-deprecation-warning (warning deprecation-condition)
+ ())
+
+(def!method print-object :after ((warning final-deprecation-warning) stream)
+ (unless *print-escape*
+ (when (deprecated-name-runtime-error warning)
+ (let ((*package* (find-package :keyword)))
+ (format stream "~%~@<~:@_An error will be signaled at runtime for ~S.~:@>"
+ (deprecated-name warning))))))
+
+(define-condition deprecation-error (error deprecation-condition)
+ ())