1.0.20.2: Fewer XC/reader-conditional confusions

	Inspired by Josh Elasser (sbcl-devel 2008-08-29), write code
	that tries to be clever about reader conditionals in the
	cross-compiler, in order to point out when a mistake is likely.
	... and fix the extra buglet that this reveals.

make-host-1.lisp

@@ -11,6 +11,10 @@
 (setf *host-obj-prefix* "obj/from-host/")
 (load "src/cold/set-up-cold-packages.lisp")
 (load "src/cold/defun-load-or-cload-xcompiler.lisp")
+
+(set-dispatch-macro-character #\# #\+ #'she-reader)
+(set-dispatch-macro-character #\# #\- #'she-reader)
+
 (load-or-cload-xcompiler #'host-cload-stem)
 
 ;;; Let's check that the type system, and various other things, are

make-host-2.lisp

@@ -50,6 +50,9 @@
  ;; toplevel forms in the xcompiler backq.lisp file?
  (set-macro-character #\` #'sb!impl::backquote-macro)
  (set-macro-character #\, #'sb!impl::comma-macro)
+
+ (set-dispatch-macro-character #\# #\+ #'she-reader)
+ (set-dispatch-macro-character #\# #\- #'she-reader)
  ;; Control optimization policy.
  (proclaim-target-optimization)
  ;; Specify where target machinery lives.

src/code/debug-int.lisp

@@ -3384,9 +3384,9 @@ register."
  ;; sense in signaling the condition.
  (when step-info
  (let ((*step-frame*
- #+(or x86 x86-64)
+ #!+(or x86 x86-64)
  (signal-context-frame (sb!alien::alien-sap context))
- #-(or x86 x86-64)
+ #!-(or x86 x86-64)
  ;; KLUDGE: Use the first non-foreign frame as the
  ;; *STACK-TOP-HINT*. Getting the frame from the signal
  ;; context as on x86 would be cleaner, but

src/code/target-alieneval.lisp

@@ -180,10 +180,10 @@
  `(symbol-macrolet ((&auxiliary-type-definitions&
  ,(append *new-auxiliary-types*
  (auxiliary-type-definitions env))))
- #+(or x86 x86-64)
+ #!+(or x86 x86-64)
  (let ((sb!vm::*alien-stack* sb!vm::*alien-stack*))
  ,@body)
- #-(or x86 x86-64)
+ #!-(or x86 x86-64)
  ,@body)))
 
 ;;;; runtime C values that don't correspond directly to Lisp types

src/cold/shebang.lisp

@@ -61,6 +61,45 @@
 (compile 'shebang-reader)
 
 (set-dispatch-macro-character #\# #\! #'shebang-reader)
+;;; while we are at it, let us write something which helps us sanity
+;;; check our own code; it is too easy to write #+ when meaning #!+,
+;;; and such mistakes can go undetected for a while.
+;;;
+;;; ideally we wouldn't use *SHEBANG-FEATURES* but
+;;; *ALL-POSSIBLE-SHEBANG-FEATURES*, but maintaining that variable
+;;; will not be easy.
+(defun checked-feature-in-features-list-p (feature list)
+ (etypecase feature
+ (symbol (unless (member feature '(:ansi-cl :common-lisp :ieee-floating-point))
+ (when (member feature *shebang-features* :test #'eq)
+ (error "probable XC bug in host read-time conditional")))
+ (member feature list :test #'eq))
+ (cons (flet ((subfeature-in-list-p (subfeature)
+ (checked-feature-in-features-list-p subfeature list)))
+ (ecase (first feature)
+ (:or (some #'subfeature-in-list-p (rest feature)))
+ (:and (every #'subfeature-in-list-p (rest feature)))
+ (:not (let ((rest (cdr feature)))
+ (if (or (null (car rest)) (cdr rest))
+ (error "wrong number of terms in compound feature ~S"
+ feature)
+ (not (subfeature-in-list-p (second feature)))))))))))
+(compile 'checked-feature-in-features-list-p)
+
+(defun she-reader (stream sub-character infix-parameter)
+ (when infix-parameter
+ (error "illegal read syntax: #~D~C" infix-parameter sub-character))
+ (when (let* ((*package* (find-package "KEYWORD"))
+ (*read-suppress* nil)
+ (notp (eql sub-character #\-))
+ (feature (read stream)))
+ (if (checked-feature-in-features-list-p feature *features*)
+ notp
+ (not notp)))
+ (let ((*read-suppress* t))
+ (read stream t nil t)))
+ (values))
+(compile 'she-reader)
 
 ;;;; variables like *SHEBANG-FEATURES* but different
 

version.lisp-expr

@@ -17,4 +17,4 @@
 ;;; checkins which aren't released. (And occasionally for internal
 ;;; versions, especially for internal versions off the main CVS
 ;;; branch, it gets hairier, e.g. "0.pre7.14.flaky4.13".)
-"1.0.20.1"
+"1.0.20.2"