1.0.48.31: WITH-LOCKED-SYSTEM-TABLE

[sbcl.git] / src / code / late-format.lisp

diff --git a/src/code/late-format.lisp b/src/code/late-format.lisp
index 6369024..9b339c6 100644 (file)
--- a/src/code/late-format.lisp
+++ b/src/code/late-format.lisp
@@ -237,11 +237,13 @@
                    :offset ,(cdr arg)))
                 args))
         (return `(lambda (stream &optional ,@args &rest args)
+                   (declare (ignorable stream))
                    ,guts
                    args))))
     (let ((*orig-args-available* t)
           (*only-simple-args* nil))
       `(lambda (stream &rest orig-args)
+         (declare (ignorable stream))
          (let ((args orig-args))
            ,(expand-control-string control-string)
            args)))))
@@ -277,8 +279,7 @@
             (let ((char (format-directive-character directive)))
               (typecase char
                 (base-char
-                 (aref *format-directive-expanders* (char-code char)))
-                (character nil))))
+                 (aref *format-directive-expanders* (sb!xc:char-code char))))))
            (*default-format-error-offset*
             (1- (format-directive-end directive))))
        (declare (type (or null function) expander))
@@ -304,7 +305,7 @@
       `(,*expander-next-arg-macro*
         ,*default-format-error-control-string*
         ,(or offset *default-format-error-offset*))
-      (let ((symbol (gensym "FORMAT-ARG-")))
+      (let ((symbol (sb!xc:gensym "FORMAT-ARG")))
         (push (cons symbol (or offset *default-format-error-offset*))
               *simple-args*)
         symbol)))
@@ -313,34 +314,32 @@
   (once-only ((params params))
     (if specs
         (collect ((expander-bindings) (runtime-bindings))
-                 (dolist (spec specs)
-                   (destructuring-bind (var default) spec
-                     (let ((symbol (gensym)))
-                       (expander-bindings
-                        `(,var ',symbol))
-                       (runtime-bindings
-                        `(list ',symbol
-                               (let* ((param-and-offset (pop ,params))
-                                      (offset (car param-and-offset))
-                                      (param (cdr param-and-offset)))
-                                 (case param
-                                   (:arg `(or ,(expand-next-arg offset)
-                                              ,,default))
-                                   (:remaining
-                                    (setf *only-simple-args* nil)
-                                    '(length args))
-                                   ((nil) ,default)
-                                   (t param))))))))
-                 `(let ,(expander-bindings)
-                    `(let ,(list ,@(runtime-bindings))
-                       ,@(if ,params
-                             (error
-                              'format-error
-                              :complaint
-                              "too many parameters, expected no more than ~W"
-                              :args (list ,(length specs))
-                              :offset (caar ,params)))
-                       ,,@body)))
+          (dolist (spec specs)
+            (destructuring-bind (var default) spec
+              (let ((symbol (sb!xc:gensym "FVAR")))
+                (expander-bindings
+                 `(,var ',symbol))
+                (runtime-bindings
+                 `(list ',symbol
+                   (let* ((param-and-offset (pop ,params))
+                          (offset (car param-and-offset))
+                          (param (cdr param-and-offset)))
+                     (case param
+                       (:arg `(or ,(expand-next-arg offset) ,,default))
+                       (:remaining
+                        (setf *only-simple-args* nil)
+                        '(length args))
+                       ((nil) ,default)
+                       (t param))))))))
+          `(let ,(expander-bindings)
+            `(let ,(list ,@(runtime-bindings))
+              ,@(if ,params
+                    (error
+                     'format-error
+                     :complaint "too many parameters, expected no more than ~W"
+                     :args (list ,(length specs))
+                     :offset (caar ,params)))
+              ,,@body)))
         `(progn
            (when ,params
              (error 'format-error
@@ -350,13 +349,13 @@
 \f
 ;;;; format directive machinery
 
-;;; FIXME: only used in this file, could be SB!XC:DEFMACRO in EVAL-WHEN
-(defmacro def-complex-format-directive (char lambda-list &body body)
+(eval-when (:compile-toplevel :execute)
+(#+sb-xc-host defmacro #-sb-xc-host sb!xc:defmacro def-complex-format-directive (char lambda-list &body body)
   (let ((defun-name (intern (format nil
                                     "~:@(~:C~)-FORMAT-DIRECTIVE-EXPANDER"
                                     char)))
-        (directive (gensym))
-        (directives (if lambda-list (car (last lambda-list)) (gensym))))
+        (directive (sb!xc:gensym "DIRECTIVE"))
+        (directives (if lambda-list (car (last lambda-list)) (sb!xc:gensym "DIRECTIVES"))))
     `(progn
        (defun ,defun-name (,directive ,directives)
          ,@(if lambda-list
@@ -370,9 +369,8 @@
                  ,@body)))
        (%set-format-directive-expander ,char #',defun-name))))
 
-;;; FIXME: only used in this file, could be SB!XC:DEFMACRO in EVAL-WHEN
-(defmacro def-format-directive (char lambda-list &body body)
-  (let ((directives (gensym))
+(#+sb-xc-host defmacro #-sb-xc-host sb!xc:defmacro def-format-directive (char lambda-list &body body)
+  (let ((directives (sb!xc:gensym "DIRECTIVES"))
         (declarations nil)
         (body-without-decls body))
     (loop
@@ -385,17 +383,18 @@
        ,@declarations
        (values (progn ,@body-without-decls)
                ,directives))))
+) ; EVAL-WHEN
 
 (eval-when (#-sb-xc :compile-toplevel :load-toplevel :execute)
 
 (defun %set-format-directive-expander (char fn)
-  (setf (aref *format-directive-expanders* (char-code (char-upcase char))) fn)
+  (let ((code (sb!xc:char-code (char-upcase char))))
+    (setf (aref *format-directive-expanders* code) fn))
   char)
 
 (defun %set-format-directive-interpreter (char fn)
-  (setf (aref *format-directive-interpreters*
-              (char-code (char-upcase char)))
-        fn)
+  (let ((code (sb!xc:char-code (char-upcase char))))
+    (setf (aref *format-directive-interpreters* code) fn))
   char)
 
 (defun find-directive (directives kind stop-at-semi)
@@ -481,8 +480,10 @@
         `(format-print-integer stream ,(expand-next-arg) ,colonp ,atsignp
                                ,base ,mincol ,padchar ,commachar
                                ,commainterval))
-      `(write ,(expand-next-arg) :stream stream :base ,base :radix nil
-              :escape nil)))
+      `(let ((*print-base* ,base)
+             (*print-radix* nil)
+             (*print-escape* nil))
+         (output-object ,(expand-next-arg) stream))))
 
 (def-format-directive #\D (colonp atsignp params)
   (expand-format-integer 10 colonp atsignp params))
@@ -501,7 +502,7 @@
       ((base nil) (mincol 0) (padchar #\space) (commachar #\,)
        (commainterval 3))
       params
-    (let ((n-arg (gensym)))
+    (let ((n-arg (sb!xc:gensym "ARG")))
       `(let ((,n-arg ,(expand-next-arg)))
          (if ,base
              (format-print-integer stream ,n-arg ,colonp ,atsignp
@@ -1245,7 +1246,7 @@
     (collect ((param-names) (bindings))
       (dolist (param-and-offset params)
         (let ((param (cdr param-and-offset)))
-          (let ((param-name (gensym)))
+          (let ((param-name (sb!xc:gensym "PARAM")))
             (param-names param-name)
             (bindings `(,param-name
                         ,(case param