0.7.13.15:
[sbcl.git] / src / compiler / compiler-error.lisp
1 ;;;; the bare essentials of compiler error handling
2 ;;;;
3 ;;;; (Logically, this might belong in early-c.lisp, since it's stuff
4 ;;;; which might as well be visible to all compiler code. However,
5 ;;;; physically its DEFINE-CONDITION forms depend on the condition
6 ;;;; system being set up before it can be cold loaded, so we keep it
7 ;;;; in this separate, loaded-later file instead of in early-c.lisp.)
8
9 ;;;; This software is part of the SBCL system. See the README file for
10 ;;;; more information.
11 ;;;;
12 ;;;; This software is derived from the CMU CL system, which was
13 ;;;; written at Carnegie Mellon University and released into the
14 ;;;; public domain. The software is in the public domain and is
15 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
16 ;;;; files for more information.
17
18 (in-package "SB!C")
19
20 ;;;; error-handling definitions which are easy to define early and
21 ;;;; which are nice to have visible everywhere
22
23 ;;; a function that is called to unwind out of COMPILER-ERROR
24 (declaim (type (function () nil) *compiler-error-bailout*))
25 (defvar *compiler-error-bailout*
26   (lambda () (error "COMPILER-ERROR with no bailout")))
27
28 ;;; an application programmer's error caught by the compiler
29 ;;;
30 ;;; We want a separate condition for application programmer errors so
31 ;;; that we can distinguish them from system programming errors (bugs
32 ;;; in SBCL itself). Application programmer errors should be caught
33 ;;; and turned into diagnostic output and a FAILURE-P return value
34 ;;; from COMPILE or COMPILE-FILE. Bugs in SBCL itself throw us into
35 ;;; the debugger.
36 (define-condition compiler-error (simple-error) ())
37
38 ;;; Signal the appropriate condition. COMPILER-ERROR calls the bailout
39 ;;; function so that it never returns (but compilation continues).
40 ;;; COMPILER-ABORT falls through to the default error handling, so
41 ;;; compilation terminates. 
42 (declaim (ftype (function (string &rest t) nil) compiler-error compiler-abort))
43 (declaim (ftype (function (string &rest t) (values))
44                 compiler-warning compiler-style-warning))
45 (defun compiler-abort (format-string &rest format-args)
46   (error 'compiler-error
47          :format-control format-string
48          :format-arguments format-args))
49 (defun compiler-error (format-string &rest format-args)
50   (cerror "Replace form with call to ERROR."
51           'compiler-error
52           :format-control format-string
53           :format-arguments format-args)
54   (funcall *compiler-error-bailout*)
55   (bug "Control returned from *COMPILER-ERROR-BAILOUT*."))
56 (defun compiler-warn (format-string &rest format-args)
57   (apply #'warn format-string format-args)
58   (values))
59 (defun compiler-style-warn (format-string &rest format-args)
60   (apply #'style-warn format-string format-args)
61   (values))
62
63 ;;; the condition of COMPILE-FILE being unable to READ from the
64 ;;; source file
65 ;;;
66 ;;; This is not a COMPILER-ERROR, since we don't try to recover from
67 ;;; it and keep chugging along, but instead immediately bail out of
68 ;;; the entire COMPILE-FILE.
69 ;;;
70 ;;; (The old CMU CL code did try to recover from this condition, but
71 ;;; the code for doing that was messy and didn't always work right.
72 ;;; Since in Common Lisp the simple act of reading and compiling code
73 ;;; (even without ever loading the compiled result) can have side
74 ;;; effects, it's a little scary to go on reading code when you're
75 ;;; deeply confused, so we violate what'd otherwise be good compiler
76 ;;; practice by not trying to recover from this error and bailing out
77 ;;; instead.)
78 (define-condition input-error-in-compile-file (error)
79   (;; the original error which was trapped to produce this condition
80    (error :reader input-error-in-compile-file-error
81           :initarg :error)
82    ;; the position where the bad READ began, or NIL if unavailable,
83    ;; redundant, or irrelevant
84    (position :reader input-error-in-compile-file-position
85              :initarg :position
86              :initform nil))
87   (:report
88    (lambda (condition stream)
89      (format stream
90              "~@<~S failure in ~S~@[ at character ~W~]: ~2I~_~A~:>"
91              'read
92              'compile-file
93              (input-error-in-compile-file-position condition)
94              (input-error-in-compile-file-error condition)))))