X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Fcondition.lisp;h=f4621466c2fe6f97ccafacd4be03f97c2e016c8e;hb=fea8ea02847ddc0864546a02480fb3e97d6fa318;hp=699bb231705e326c44558fb9008e5a97db308426;hpb=25422d88edd9bf712206aee5143a4f952981b4d5;p=sbcl.git
diff --git a/src/code/condition.lisp b/src/code/condition.lisp
index 699bb23..f462146 100644
--- a/src/code/condition.lisp
+++ b/src/code/condition.lisp
@@ -266,7 +266,6 @@
(return nil)))
(setf (getf (condition-assigned-slots res) (condition-slot-name hslot))
(find-slot-default class hslot))))
-
res))
;;;; DEFINE-CONDITION
@@ -274,47 +273,49 @@
(eval-when (:compile-toplevel :load-toplevel :execute)
(defun %compiler-define-condition (name direct-supers layout
all-readers all-writers)
- (sb!xc:proclaim `(ftype (function (t) t) ,@all-readers))
- (sb!xc:proclaim `(ftype (function (t t) t) ,@all-writers))
- (multiple-value-bind (class old-layout)
- (insured-find-classoid name
- #'condition-classoid-p
- #'make-condition-classoid)
- (setf (layout-classoid layout) class)
- (setf (classoid-direct-superclasses class)
- (mapcar #'find-classoid direct-supers))
- (cond ((not old-layout)
- (register-layout layout))
- ((not *type-system-initialized*)
- (setf (layout-classoid old-layout) class)
- (setq layout old-layout)
- (unless (eq (classoid-layout class) layout)
+ (with-single-package-locked-error
+ (:symbol name "defining ~A as a condition")
+ (sb!xc:proclaim `(ftype (function (t) t) ,@all-readers))
+ (sb!xc:proclaim `(ftype (function (t t) t) ,@all-writers))
+ (multiple-value-bind (class old-layout)
+ (insured-find-classoid name
+ #'condition-classoid-p
+ #'make-condition-classoid)
+ (setf (layout-classoid layout) class)
+ (setf (classoid-direct-superclasses class)
+ (mapcar #'find-classoid direct-supers))
+ (cond ((not old-layout)
+ (register-layout layout))
+ ((not *type-system-initialized*)
+ (setf (layout-classoid old-layout) class)
+ (setq layout old-layout)
+ (unless (eq (classoid-layout class) layout)
+ (register-layout layout)))
+ ((redefine-layout-warning "current"
+ old-layout
+ "new"
+ (layout-length layout)
+ (layout-inherits layout)
+ (layout-depthoid layout))
+ (register-layout layout :invalidate t))
+ ((not (classoid-layout class))
(register-layout layout)))
- ((redefine-layout-warning "current"
- old-layout
- "new"
- (layout-length layout)
- (layout-inherits layout)
- (layout-depthoid layout))
- (register-layout layout :invalidate t))
- ((not (classoid-layout class))
- (register-layout layout)))
-
- (setf (layout-info layout)
- (locally
- ;; KLUDGE: There's a FIND-CLASS DEFTRANSFORM for constant class
- ;; names which creates fast but non-cold-loadable, non-compact
- ;; code. In this context, we'd rather have compact, cold-loadable
- ;; code. -- WHN 19990928
- (declare (notinline find-classoid))
- (layout-info (classoid-layout (find-classoid 'condition)))))
-
- (setf (find-classoid name) class)
-
- ;; Initialize CPL slot.
- (setf (condition-classoid-cpl class)
- (remove-if-not #'condition-classoid-p
- (std-compute-class-precedence-list class))))
+
+ (setf (layout-info layout)
+ (locally
+ ;; KLUDGE: There's a FIND-CLASS DEFTRANSFORM for constant class
+ ;; names which creates fast but non-cold-loadable, non-compact
+ ;; code. In this context, we'd rather have compact, cold-loadable
+ ;; code. -- WHN 19990928
+ (declare (notinline find-classoid))
+ (layout-info (classoid-layout (find-classoid 'condition)))))
+
+ (setf (find-classoid name) class)
+
+ ;; Initialize CPL slot.
+ (setf (condition-classoid-cpl class)
+ (remove-if-not #'condition-classoid-p
+ (std-compute-class-precedence-list class)))))
(values))
) ; EVAL-WHEN
@@ -369,49 +370,51 @@
(defun %define-condition (name parent-types layout slots documentation
report default-initargs all-readers all-writers)
- (%compiler-define-condition name parent-types layout all-readers all-writers)
- (let ((class (find-classoid name)))
- (setf (condition-classoid-slots class) slots)
- (setf (condition-classoid-report class) report)
- (setf (condition-classoid-default-initargs class) default-initargs)
- (setf (fdocumentation name 'type) documentation)
-
- (dolist (slot slots)
-
- ;; Set up reader and writer functions.
- (let ((slot-name (condition-slot-name slot)))
- (dolist (reader (condition-slot-readers slot))
- (install-condition-slot-reader reader name slot-name))
- (dolist (writer (condition-slot-writers slot))
- (install-condition-slot-writer writer name slot-name))))
-
- ;; Compute effective slots and set up the class and hairy slots
- ;; (subsets of the effective slots.)
- (let ((eslots (compute-effective-slots class))
- (e-def-initargs
- (reduce #'append
- (mapcar #'condition-classoid-default-initargs
+ (with-single-package-locked-error
+ (:symbol name "defining ~A as a condition")
+ (%compiler-define-condition name parent-types layout all-readers all-writers)
+ (let ((class (find-classoid name)))
+ (setf (condition-classoid-slots class) slots)
+ (setf (condition-classoid-report class) report)
+ (setf (condition-classoid-default-initargs class) default-initargs)
+ (setf (fdocumentation name 'type) documentation)
+
+ (dolist (slot slots)
+
+ ;; Set up reader and writer functions.
+ (let ((slot-name (condition-slot-name slot)))
+ (dolist (reader (condition-slot-readers slot))
+ (install-condition-slot-reader reader name slot-name))
+ (dolist (writer (condition-slot-writers slot))
+ (install-condition-slot-writer writer name slot-name))))
+
+ ;; Compute effective slots and set up the class and hairy slots
+ ;; (subsets of the effective slots.)
+ (let ((eslots (compute-effective-slots class))
+ (e-def-initargs
+ (reduce #'append
+ (mapcar #'condition-classoid-default-initargs
(condition-classoid-cpl class)))))
- (dolist (slot eslots)
- (ecase (condition-slot-allocation slot)
- (:class
- (unless (condition-slot-cell slot)
- (setf (condition-slot-cell slot)
- (list (if (condition-slot-initform-p slot)
- (let ((initform (condition-slot-initform slot)))
- (if (functionp initform)
- (funcall initform)
- initform))
- *empty-condition-slot*))))
- (push slot (condition-classoid-class-slots class)))
- ((:instance nil)
- (setf (condition-slot-allocation slot) :instance)
- (when (or (functionp (condition-slot-initform slot))
- (dolist (initarg (condition-slot-initargs slot) nil)
- (when (functionp (getf e-def-initargs initarg))
- (return t))))
- (push slot (condition-classoid-hairy-slots class))))))))
- name)
+ (dolist (slot eslots)
+ (ecase (condition-slot-allocation slot)
+ (:class
+ (unless (condition-slot-cell slot)
+ (setf (condition-slot-cell slot)
+ (list (if (condition-slot-initform-p slot)
+ (let ((initform (condition-slot-initform slot)))
+ (if (functionp initform)
+ (funcall initform)
+ initform))
+ *empty-condition-slot*))))
+ (push slot (condition-classoid-class-slots class)))
+ ((:instance nil)
+ (setf (condition-slot-allocation slot) :instance)
+ (when (or (functionp (condition-slot-initform slot))
+ (dolist (initarg (condition-slot-initargs slot) nil)
+ (when (functionp (getf e-def-initargs initarg))
+ (return t))))
+ (push slot (condition-classoid-hairy-slots class))))))))
+ name))
(defmacro define-condition (name (&rest parent-types) (&rest slot-specs)
&body options)
@@ -554,6 +557,25 @@
(condition-actual-initargs condition)
(condition-assigned-slots condition))))
+;;;; MAKE-LOAD-FORM equivalent for conditions.
+
+;;; We need this to be able to dump arbitrary encapsulated conditions
+;;; with MAKE-LOAD-FORM for COMPILED-PROGRAM-ERRORs. Unfortunately
+;;; ANSI specifies that MAKE-LOAD-FORM for conditions should signal an
+;;; error, despite the fact that it also specifies that the
+;;; file-compiler should use MAKE-LOAD-FORM for conditions. Bah.
+;;; Badness results if this is called before PCL is in place. Unlike
+;;; real make-load-form we return just a single form, so that it can
+;;; easily be embedded in the surrounding condition.
+(defun make-condition-load-form (condition &optional env)
+ (with-unique-names (instance)
+ (multiple-value-bind (create init)
+ (make-load-form-saving-slots condition :environment env)
+ (let ((fixed-init (subst instance condition init)))
+ `(let ((,instance ,create))
+ ,fixed-init
+ ,instance)))))
+
;;;; various CONDITIONs specified by ANSI
(define-condition serious-condition (condition) ())
@@ -583,6 +605,9 @@
(define-condition simple-error (simple-condition error) ())
+;;; not specified by ANSI, but too useful not to have around.
+(define-condition simple-style-warning (simple-condition style-warning) ())
+
(define-condition storage-condition (serious-condition) ())
(define-condition type-error (error)
@@ -717,12 +742,232 @@
(reader-error-format-control condition)
(reader-error-format-arguments condition)))))))
+;;;; special SBCL extension conditions
+
+;;; an error apparently caused by a bug in SBCL itself
+;;;
+;;; Note that we don't make any serious effort to use this condition
+;;; for *all* errors in SBCL itself. E.g. type errors and array
+;;; indexing errors can occur in functions called from SBCL code, and
+;;; will just end up as ordinary TYPE-ERROR or invalid index error,
+;;; because the signalling code has no good way to know that the
+;;; underlying problem is a bug in SBCL. But in the fairly common case
+;;; that the signalling code does know that it's found a bug in SBCL,
+;;; this condition is appropriate, reusing boilerplate and helping
+;;; users to recognize it as an SBCL bug.
+(define-condition bug (simple-error)
+ ()
+ (:report
+ (lambda (condition stream)
+ (format stream
+ "~@< ~? ~:@_~?~:>"
+ (simple-condition-format-control condition)
+ (simple-condition-format-arguments condition)
+ "~@.~:@>"
+ '((fmakunbound 'compile))))))
+
+;;; a condition for use in stubs for operations which aren't supported
+;;; on some platforms
+;;;
+;;; E.g. in sbcl-0.7.0.5, it might be appropriate to do something like
+;;; #-(or freebsd linux)
+;;; (defun load-foreign (&rest rest)
+;;; (error 'unsupported-operator :name 'load-foreign))
+;;; #+(or freebsd linux)
+;;; (defun load-foreign ... actual definition ...)
+;;; By signalling a standard condition in this case, we make it
+;;; possible for test code to distinguish between (1) intentionally
+;;; unimplemented and (2) unintentionally just screwed up somehow.
+;;; (Before this condition was defined, test code tried to deal with
+;;; this by checking for FBOUNDP, but that didn't work reliably. In
+;;; sbcl-0.7.0, a a package screwup left the definition of
+;;; LOAD-FOREIGN in the wrong package, so it was unFBOUNDP even on
+;;; architectures where it was supposed to be supported, and the
+;;; regression tests cheerfully passed because they assumed that
+;;; unFBOUNDPness meant they were running on an system which didn't
+;;; support the extension.)
+(define-condition unsupported-operator (cell-error) ()
+ (:report
+ (lambda (condition stream)
+ (format stream
+ "unsupported on this platform (OS, CPU, whatever): ~S"
+ (cell-error-name condition)))))
+
+;;; (:ansi-cl :function remove)
+;;; (:ansi-cl :section (a b c))
+;;; (:ansi-cl :glossary "similar")
+;;;
+;;; (:sbcl :node "...")
+;;; (:sbcl :variable *ed-functions*)
+;;;
+;;; FIXME: this is not the right place for this.
+(defun print-reference (reference stream)
+ (ecase (car reference)
+ (:ansi-cl
+ (format stream "The ANSI Standard")
+ (format stream ", ")
+ (destructuring-bind (type data) (cdr reference)
+ (ecase type
+ (:function (format stream "Function ~S" data))
+ (:special-operator (format stream "Special Operator ~S" data))
+ (:macro (format stream "Macro ~S" data))
+ (:section (format stream "Section ~{~D~^.~}" data))
+ (:glossary (format stream "Glossary entry for ~S" data))
+ (:issue (format stream "writeup for Issue ~A" data)))))
+ (:sbcl
+ (format stream "The SBCL Manual")
+ (format stream ", ")
+ (destructuring-bind (type data) (cdr reference)
+ (ecase type
+ (:node (format stream "Node ~S" data))
+ (:variable (format stream "Variable ~S" data)))))
+ ;; FIXME: other documents (e.g. AMOP, Franz documentation :-)
+ ))
+(define-condition reference-condition ()
+ ((references :initarg :references :reader reference-condition-references)))
+(defvar *print-condition-references* t)
+(def!method print-object :around ((o reference-condition) s)
+ (call-next-method)
+ (unless (or *print-escape* *print-readably*)
+ (when *print-condition-references*
+ (format s "~&See also:~%")
+ (pprint-logical-block (s nil :per-line-prefix " ")
+ (do* ((rs (reference-condition-references o) (cdr rs))
+ (r (car rs) (car rs)))
+ ((null rs))
+ (print-reference r s)
+ (unless (null (cdr rs))
+ (terpri s)))))))
+
+(define-condition duplicate-definition (reference-condition warning)
+ ((name :initarg :name :reader duplicate-definition-name))
+ (:report (lambda (c s)
+ (format s "~@"
+ (duplicate-definition-name c))))
+ (:default-initargs :references (list '(:ansi-cl :section (3 2 2 3)))))
+
+(define-condition package-at-variance (reference-condition simple-warning)
+ ()
+ (:default-initargs :references (list '(:ansi-cl :macro defpackage))))
+
+(define-condition defconstant-uneql (reference-condition error)
+ ((name :initarg :name :reader defconstant-uneql-name)
+ (old-value :initarg :old-value :reader defconstant-uneql-old-value)
+ (new-value :initarg :new-value :reader defconstant-uneql-new-value))
+ (:report
+ (lambda (condition stream)
+ (format stream
+ "~@"
+ (defconstant-uneql-name condition)
+ (defconstant-uneql-old-value condition)
+ (defconstant-uneql-new-value condition))))
+ (:default-initargs :references (list '(:ansi-cl :macro defconstant)
+ '(:sbcl :node "Idiosyncrasies"))))
+
+(define-condition array-initial-element-mismatch
+ (reference-condition simple-warning)
+ ()
+ (:default-initargs
+ :references (list
+ '(:ansi-cl :function make-array)
+ '(:ansi-cl :function sb!xc:upgraded-array-element-type))))
+
+(define-condition displaced-to-array-too-small-error
+ (reference-condition simple-error)
+ ()
+ (:default-initargs
+ :references (list '(:ansi-cl :function adjust-array))))
+
+(define-condition type-warning (reference-condition simple-warning)
+ ()
+ (:default-initargs :references (list '(:sbcl :node "Handling of Types"))))
+
+(define-condition local-argument-mismatch (reference-condition simple-warning)
+ ()
+ (:default-initargs :references (list '(:ansi-cl :section (3 2 2 3)))))
+
+(define-condition format-args-mismatch (reference-condition)
+ ()
+ (:default-initargs :references (list '(:ansi-cl :section (22 3 10 2)))))
+
+(define-condition format-too-few-args-warning
+ (format-args-mismatch simple-warning)
+ ())
+(define-condition format-too-many-args-warning
+ (format-args-mismatch simple-style-warning)
+ ())
+
+(define-condition extension-failure (reference-condition simple-error)
+ ())
+
+#!+sb-package-locks
+(progn
+
+(define-condition package-lock-violation (reference-condition package-error)
+ ((format-control :initform nil :initarg :format-control
+ :reader package-error-format-control)
+ (format-arguments :initform nil :initarg :format-arguments
+ :reader package-error-format-arguments))
+ (:report
+ (lambda (condition stream)
+ (let ((control (package-error-format-control condition)))
+ (if control
+ (apply #'format stream
+ (format nil "~~@"
+ (package-name (package-error-package condition))
+ control)
+ (package-error-format-arguments condition))
+ (format stream "~@"
+ (package-name (package-error-package condition)))))))
+ ;; no :default-initargs -- reference-stuff provided by the
+ ;; signalling form in target-package.lisp
+ #!+sb-doc
+ (:documentation
+ "Subtype of CL:PACKAGE-ERROR. A subtype of this error is signalled
+when a package-lock is violated."))
+
+(define-condition package-locked-error (package-lock-violation) ()
+ #!+sb-doc
+ (:documentation
+ "Subtype of SB-EXT:PACKAGE-LOCK-VIOLATION. An error of this type is
+signalled when an operation on a package violates a package lock."))
+
+(define-condition symbol-package-locked-error (package-lock-violation)
+ ((symbol :initarg :symbol :reader package-locked-error-symbol))
+ #!+sb-doc
+ (:documentation
+ "Subtype of SB-EXT:PACKAGE-LOCK-VIOLATION. An error of this type is
+signalled when an operation on a symbol violates a package lock. The
+symbol that caused the violation is accessed by the function
+SB-EXT:PACKAGE-LOCKED-ERROR-SYMBOL."))
+
+) ; progn
+
;;;; various other (not specified by ANSI) CONDITIONs
;;;;
;;;; These might logically belong in other files; they're here, after
;;;; setup of CONDITION machinery, only because that makes it easier to
;;;; get cold init to work.
+(define-condition encapsulated-condition (condition)
+ ((condition :initarg :condition :reader encapsulated-condition)))
+
+;;; This comes to play if we have multiple levels of encapsulated
+;;; errors and we need to dump them with MAKE-CONDITION-LOAD-FORM.
+;;; Should not see much/any use, but better to have it.
+(def!method make-load-form ((condition encapsulated-condition) &optional env)
+ `(make-condition 'encapsulated-condition
+ :condition ,(make-condition-load-form (encapsulated-condition condition) env)))
+
(define-condition values-type-error (type-error)
()
(:report
@@ -765,7 +1010,7 @@
"The index ~S is too large."
(type-error-datum condition)))))
-(define-condition bounding-indices-bad-error (type-error)
+(define-condition bounding-indices-bad-error (reference-condition type-error)
((object :reader bounding-indices-bad-object :initarg :object))
(:report
(lambda (condition stream)
@@ -776,21 +1021,31 @@
(etypecase object
(sequence
(format stream
- "The bounding indices ~S and ~S are bad for a sequence of length ~S."
+ "The bounding indices ~S and ~S are bad ~
+ for a sequence of length ~S."
start end (length object)))
(array
;; from WITH-ARRAY-DATA
(format stream
- "The START and END parameters ~S and ~S are bad for an array of total size ~S."
- start end (array-total-size object))))))))
-
-(define-condition nil-array-accessed-error (type-error)
+ "The START and END parameters ~S and ~S are ~
+ bad for an array of total size ~S."
+ start end (array-total-size object)))))))
+ (:default-initargs
+ :references
+ (list '(:ansi-cl :glossary "bounding index designator")
+ '(:ansi-cl :issue "SUBSEQ-OUT-OF-BOUNDS:IS-AN-ERROR"))))
+
+(define-condition nil-array-accessed-error (reference-condition type-error)
()
(:report (lambda (condition stream)
(declare (ignore condition))
(format stream
"An attempt to access an array of element-type ~
- NIL was made. Congratulations!"))))
+ NIL was made. Congratulations!")))
+ (:default-initargs
+ :references (list '(:ansi-cl :function sb!xc:upgraded-array-element-type)
+ '(:ansi-cl :section (15 1 2 1))
+ '(:ansi-cl :section (15 1 2 2)))))
(define-condition io-timeout (stream-error)
((direction :reader io-timeout-direction :initarg :direction))
@@ -840,82 +1095,7 @@
(reader-error-format-arguments condition)
(reader-impossible-number-error-error condition))))))
-(define-condition sb!ext::timeout (serious-condition) ())
-
-(define-condition defconstant-uneql (error)
- ((name :initarg :name :reader defconstant-uneql-name)
- (old-value :initarg :old-value :reader defconstant-uneql-old-value)
- (new-value :initarg :new-value :reader defconstant-uneql-new-value))
- (:report
- (lambda (condition stream)
- (format stream
- "~@"
- (defconstant-uneql-name condition)
- (defconstant-uneql-old-value condition)
- (defconstant-uneql-new-value condition)))))
-
-;;;; special SBCL extension conditions
-
-;;; an error apparently caused by a bug in SBCL itself
-;;;
-;;; Note that we don't make any serious effort to use this condition
-;;; for *all* errors in SBCL itself. E.g. type errors and array
-;;; indexing errors can occur in functions called from SBCL code, and
-;;; will just end up as ordinary TYPE-ERROR or invalid index error,
-;;; because the signalling code has no good way to know that the
-;;; underlying problem is a bug in SBCL. But in the fairly common case
-;;; that the signalling code does know that it's found a bug in SBCL,
-;;; this condition is appropriate, reusing boilerplate and helping
-;;; users to recognize it as an SBCL bug.
-(define-condition bug (simple-error)
- ()
- (:report
- (lambda (condition stream)
- (format stream
- "~@< ~? ~:@_~?~:>"
- (simple-condition-format-control condition)
- (simple-condition-format-arguments condition)
- "~@.~:@>"
- '((fmakunbound 'compile))))))
-(defun bug (format-control &rest format-arguments)
- (error 'bug
- :format-control format-control
- :format-arguments format-arguments))
-
-;;; a condition for use in stubs for operations which aren't supported
-;;; on some platforms
-;;;
-;;; E.g. in sbcl-0.7.0.5, it might be appropriate to do something like
-;;; #-(or freebsd linux)
-;;; (defun load-foreign (&rest rest)
-;;; (error 'unsupported-operator :name 'load-foreign))
-;;; #+(or freebsd linux)
-;;; (defun load-foreign ... actual definition ...)
-;;; By signalling a standard condition in this case, we make it
-;;; possible for test code to distinguish between (1) intentionally
-;;; unimplemented and (2) unintentionally just screwed up somehow.
-;;; (Before this condition was defined, test code tried to deal with
-;;; this by checking for FBOUNDP, but that didn't work reliably. In
-;;; sbcl-0.7.0, a a package screwup left the definition of
-;;; LOAD-FOREIGN in the wrong package, so it was unFBOUNDP even on
-;;; architectures where it was supposed to be supported, and the
-;;; regression tests cheerfully passed because they assumed that
-;;; unFBOUNDPness meant they were running on an system which didn't
-;;; support the extension.)
-(define-condition unsupported-operator (cell-error) ()
- (:report
- (lambda (condition stream)
- (format stream
- "unsupported on this platform (OS, CPU, whatever): ~S"
- (cell-error-name condition)))))
+(define-condition timeout (serious-condition) ())
;;;; restart definitions