+;;;; 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)
+ "~@<This is probably a bug in SBCL itself. (Alternatively, ~
+ SBCL might have been corrupted by bad user code, e.g. by an ~
+ undefined Lisp operation like ~S, or by stray pointers from ~
+ alien code or from unsafe Lisp code; or there might be a bug ~
+ in the OS or hardware that SBCL is running on.) If it seems to ~
+ be a bug in SBCL itself, the maintainers would like to know ~
+ about it. Bug reports are welcome on the SBCL ~
+ mailing lists, which you can find at ~
+ <http://sbcl.sourceforge.net/>.~:@>"
+ '((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 (simple-error) ())
+
+\f
+;;; (: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)
+ (:amop
+ (format stream "AMOP")
+ (format stream ", ")
+ (destructuring-bind (type data) (cdr reference)
+ (ecase type
+ (:generic-function (format stream "Generic Function ~S" data))
+ (:section (format stream "Section ~{~D~^.~}" data)))))
+ (: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))
+ (:function (format stream "Function ~S" data)))))
+ ;; FIXME: other documents (e.g. CLIM, 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 (and *print-condition-references*
+ (reference-condition-references o))
+ (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 for ~S found in ~
+ one file.~@:>"
+ (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
+ "~@<The constant ~S is being redefined (from ~S to ~S)~@:>"
+ (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 "~~@<Lock on package ~A violated when ~A.~~:@>"
+ (package-name (package-error-package condition))
+ control)
+ (package-error-format-arguments condition))
+ (format stream "~@<Lock on package ~A violated.~:@>"
+ (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
+
+(define-condition undefined-alien-error (error) ()
+ (:report
+ (lambda (condition stream)
+ (declare (ignore condition))
+ (format stream "Attempt to access an undefined alien value."))))
+\f