(in-package "SB!IMPL")
+(/show0 "entering backq.lisp")
+
;;; The flags passed back by BACKQUOTIFY can be interpreted as follows:
;;;
;;; |`,|: [a] => a
(defvar *bq-dot-flag* '(|,.|))
(defvar *bq-vector-flag* '(|bqv|))
+(/show0 "backq.lisp 50")
+
;;; the actual character macro
(defun backquote-macro (stream ignore)
(declare (ignore ignore))
(%reader-error stream ",. after backquote in ~S" thing))
(values (backquotify-1 flag thing) 'list))))
+(/show0 "backq.lisp 64")
+
(defun comma-macro (stream ignore)
(declare (ignore ignore))
(unless (> *backquote-count* 0)
(cons *bq-comma-flag* (read stream t nil t))))
'list)))
+(/show0 "backq.lisp 83")
+
;;; This does the expansion from table 2.
(defun backquotify (stream code)
(cond ((atom code)
(values 'list*
(list a (backquotify-1 dflag d)))))))))))
+(/show0 "backq.lisp 139")
+
;;; This handles the <hair> cases.
(defun comma (code)
(cond ((atom code)
(values 'list* (cdr code)))
(t (values *bq-comma-flag* code))))
+(/show0 "backq.lisp 157")
+
;;; This handles table 1.
(defun backquotify-1 (flag thing)
(cond ((or (eq flag *bq-comma-flag*)
\f
;;;; magic BACKQ- versions of builtin functions
-;;; Define synonyms for the lisp functions we use, so that by using them, we
-;;; backquoted material will be recognizable to the pretty-printer.
+(/show0 "backq.lisp 184")
+
+;;; Define synonyms for the lisp functions we use, so that by using
+;;; them, the backquoted material will be recognizable to the
+;;; pretty-printer.
(macrolet ((def-frob (b-name name)
(let ((args (gensym "ARGS")))
;; FIXME: This function should be INLINE so that the lists
(def-frob backq-nconc nconc)
(def-frob backq-cons cons))
+(/show0 "backq.lisp 204")
+
(defun backq-vector (list)
(declare (list list))
(coerce list 'simple-vector))
\f
;;;; initialization
+(/show0 "backq.lisp 212")
+
;;; Install BACKQ stuff in the current *READTABLE*.
;;;
-;;; In the target Lisp, we have to wait to do this until the readtable has been
-;;; created. In the cross-compilation host Lisp, we can do this right away.
-;;; (You may ask: In the cross-compilation host, which already has its own
-;;; implementation of the backquote readmacro, why do we do this at all?
-;;; Because the cross-compilation host might -- as SBCL itself does -- express
-;;; the backquote expansion in terms of internal, nonportable functions. By
-;;; redefining backquote in terms of functions which are guaranteed to exist on
-;;; the target Lisp, we ensure that backquote expansions in code-generating
-;;; code work properly.)
+;;; In the target Lisp, we have to wait to do this until the readtable
+;;; has been created. In the cross-compilation host Lisp, we can do
+;;; this right away. (You may ask: In the cross-compilation host,
+;;; which already has its own implementation of the backquote
+;;; readmacro, why do we do this at all? Because the cross-compilation
+;;; host might -- as SBCL itself does -- express the backquote
+;;; expansion in terms of internal, nonportable functions. By
+;;; redefining backquote in terms of functions which are guaranteed to
+;;; exist on the target Lisp, we ensure that backquote expansions in
+;;; code-generating code work properly.)
(defun !backq-cold-init ()
(set-macro-character #\` #'backquote-macro)
(set-macro-character #\, #'comma-macro))
#+sb-xc-host (!backq-cold-init)
+
+(/show0 "done with backq.lisp")