`(progn
(export '(,type ,kind ,constructor))
(defclass ,type (tagged-c-type) ()
- (:documentation ,(format nil "C ~a types." what)))
+ (:documentation ,(format nil "C ~A types." what)))
(defmethod c-tagged-type-kind ((type ,type))
',keyword)
(defmethod kind-c-tagged-type ((kind (eql ',keyword)))
(let ((this-name (argument-name this))
(prev-name (argument-name prev)))
(when (string= this-name prev-name)
- (error "Duplicate keyword argument name `~A'." this-name)))))
+ (error "Duplicate keyword argument name `~A'" this-name)))))
list))
(export 'merge-keyword-lists)
(other-what (cdr other-item)))
(unless (c-type-equal-p type other-type)
(error "Type mismatch for keyword argument `~A': ~
- ~A~@[ (~A)~] doesn't match ~A~@[ (~A)~]."
+ ~A~@[ (~A)~] doesn't match ~A~@[ (~A)~]"
name
type what
other-type other-what))))))))
(disallow-keyword-functions (type)
(when (typep type 'c-keyword-function-type)
(error "Functions with keyword arguments are only ~
- allowed at top-level.")))
+ allowed at top-level")))
(star ()
;; Prefix: `*' qualifiers
((char= ch #\-)
(write-char #\_ out))
(t
- (error "Bad character in C name ~S." name))))))
+ (error "Bad character in C name ~S" name))))))
(t name)))
;;;--------------------------------------------------------------------------
(when (member candidate (sod-class-direct-superclasses class))
(setf winner candidate))))
(unless winner
- (error "SOD INTERNAL ERROR: Failed to break tie in CLOS."))
+ (error "SOD INTERNAL ERROR: Failed to break tie in CLOS"))
winner))
(defun c3-tiebreaker (candidates cpls)
(dolist (candidate candidates)
(when (member candidate cpl)
(return-from c3-tiebreaker candidate))))
- (error "SOD INTERNAL ERROR: Failed to break tie in C3."))
+ (error "SOD INTERNAL ERROR: Failed to break tie in C3"))
;;; Linearization functions.
(reduce (lambda (best this)
(cond ((funcall order best this) best)
((funcall order this best) this)
- (t (error "Unable to choose best ~A." what))))
+ (t (error "Unable to choose best ~A" what))))
items))
(defmethod guess-metaclass ((class sod-class))
(setf (codegen-vars codegen)
(cons (make-var-inst name type init) vars)))
((not (c-type-equal-p type (inst-type var)))
- (error "(Internal) Redefining type for variable ~A." name)))
+ (error "(Internal) Redefining type for variable ~A" name)))
name))
(export 'codegen)
((or #\) #\] #\})
(if (eql it delim)
(setf delim (pop stack))
- (cerror* "Unmatched `~C.'." it)))
+ (cerror* "Unmatched `~C'" it)))
;; String and character literals.
((seq ((quote (or #\" #\'))
;; Check that we've been given a method combination and make sure it
;; actually exists.
(unless comb
- (error "The `combination' property is required."))
+ (error "The `combination' property is required"))
(unless (some (lambda (method)
(let* ((specs (method-specializers method))
(message-spec (car specs))
comb))))
(generic-function-methods
#'compute-aggregating-message-kernel))
- (error "Unknown method combination `~(~A~)'." comb))
+ (error "Unknown method combination `~(~A~)'" comb))
(setf combination comb)
;; Make sure the ordering is actually valid.
(unless (member most-specific '(:first :last))
- (error "The `most_specific' property must be `first' or `last'."))
+ (error "The `most_specific' property must be `first' or `last'"))
;; Set up the function which will compute the kernel.
(let ((magic (cons nil nil))
(unless (c-type-equal-p (c-type-subtype ,type)
,want-type)
(error "Messages with `~(~A~)' combination ~
- must return `~A'."
+ must return `~A'"
,combvar ,want-type)))
(call-next-method))))
(when (consp name)
(cerror*-with-location
scanner
- "Method declarations must have function type.")
+ "Method declarations must have function type")
(setf name (cdr name)))
(parse-slot-item sub-pset base-type type name))
((consp name)
#+ecl (loop for i from 1
below (ext:argc)
collect (ext:argv i))))
- (error "Unsupported Lisp."))))))
+ (error "Unsupported Lisp"))))))
*program-name* (pathname-name (car *command-line*))))
#+cmu #:extensions
#+ecl #.(if (find-package '#:gray) '#:gray '#:si)
#+clisp #:gray))
- (error "Unsupported Lisp (can't find Gray streams).")))
+ (error "Unsupported Lisp (can't find Gray streams)")))
;; CMUCL's `extensions' package has lots of cruft. Use our cruft instead.
#+cmu (:shadowing-import-from #:sod-utilities #:symbolicate #:once-only))
The return value may later be used with `parser-restore-place'. Be
careful: all of this is happening at macro-expansion time.")
(:method (context)
- (error "Parser context ~S doesn't support rewinding." context)))
+ (error "Parser context ~S doesn't support rewinding" context)))
(export 'parser-restore-place)
(defgeneric parser-restore-place (context place)
(defun commit-peeked-place ()
"Called by `commit' not lexically within `peek'."
- (error "`commit' is not within `peek'."))
+ (error "`commit' is not within `peek'"))
(export 'commit)
(defparse commit ()
:index index))))
(last-link (charbuf-scanner-place-link place-b)))
(flet ((bad ()
- (error "Incorrect places ~S and ~S to `scanner-interval'."
+ (error "Incorrect places ~S and ~S to `scanner-interval'"
place-a place-b)))
(do ((link (charbuf-scanner-place-link place-a)
(charbuf-chain-link-next link))
(:documentation
"Capture the SCANNER's current place and return it.")
(:method (scanner)
- (error "Scanner ~S doesn't support rewinding." scanner)))
+ (error "Scanner ~S doesn't support rewinding" scanner)))
(export 'scanner-restore-place)
(defgeneric scanner-restore-place (scanner place)
(or (and (boundp '*module-type-map*)
(gethash value *module-type-map*))
(find-simple-c-type value)
- (error "Unknown type `~A'." value)))
+ (error "Unknown type `~A'" value)))
;;;--------------------------------------------------------------------------
;;; Property sets.
(:documentation
"Reports an inconsistency in the arguments passed to `merge-lists'.")
(:report (lambda (condition stream)
- (format stream "Merge inconsistency: failed to decide among ~A."
+ (format stream "Merge inconsistency: failed to decide among ~A"
(merge-error-candidates condition)))))
(export 'merge-lists)
~mdw / sod / commitdiff