@@ -25,47 +25,52 @@

 (defgeneric print-format-modifiers (command stream)

   (:method ((command format-string-command) s)

-   ; TODO: format here causes inconsistent behavior :p

+     ;; TODO: format here causes inconsistent behavior :p

      (mapl (lambda (x)

              (princ (car x) s)

              (when (cdr x) (princ #\, s)))

            (modifiers command))))

 (defgeneric print-format-representation (command stream)

-  (:method ((commands list) s)

-   (dolist (command commands)

-     (print-format-representation command s)))

-  (:method ((literal character) s)

-   (princ literal s))

-  (:method ((literal string) s)

-   (princ literal s))

-

-  (:method :around ((command format-string-command) s)

-   (princ #\~ s)

-   (call-next-method))

-  (:method :before ((command format-string-command) s)

-   (when (colon-p command)

-     (princ #\: s))

-   (when (at-p command)

-     (princ #\@ s)))

-

-  (:method :before ((command simple-format-string-command) s)

-   (print-format-modifiers command s))

-  (:method ((command simple-format-string-command) s)

-   (princ (format-char command) s))

-

-  (:method :before ((command compound-format-string-command) s)

-   (print-format-modifiers command s))

-  (:method ((command compound-format-string-command) s)

-   (princ (start-char command) s)

-   (print-format-representation (contents command) s)

-   (princ #\~ s)

-   (princ (end-char command) s))

-

   (:documentation "Prints the appropriate control sequence to the stream passed in

                    The :before method will print the Tilde."))

-; TODO: should this be a generic function?

+(defmethod ((commands list) s)

+  (dolist (command commands)

+    (print-format-representation command s)))

+

+(defmethod ((literal character) s)

+  (princ literal s))

+

+(defmethod ((literal string) s)

+  (princ literal s))

+

+(defmethod :around ((command format-string-command) s)

+  (princ #\~ s)

+  (call-next-method))

+

+(defmethod :before ((command format-string-command) s)

+  (when (colon-p command)

+    (princ #\: s))

+  (when (at-p command)

+    (princ #\@ s)))

+

+(defmethod :before ((command simple-format-string-command) s)

+  (print-format-modifiers command s))

+

+(defmethod ((command simple-format-string-command) s)

+  (princ (format-char command) s))

+

+(defmethod :before ((command compound-format-string-command) s)

+  (print-format-modifiers command s))

+

+(defmethod ((command compound-format-string-command) s)

+  (princ (start-char command) s)

+  (print-format-representation (contents command) s)

+  (princ #\~ s)

+  (princ (end-char command) s))

+

+;;; TODO: should this be a generic function?

 (defun convert-modifier (modifier)

   (flet ((validate-modifier (modifier)

            (when (member (elt (string modifier) 0) '(#\: #\@ #\,))

@@ -115,7 +120,7 @@

       *format-stream*)))

 (defun %define-format-char (name format-char closing-char &key at-p colon-p)

-  ; TODO: implement closing-char when we implement the block constructs.

+  ;; TODO: implement closing-char when we implement the block constructs.

   (declare (ignore closing-char))

   (setf (gethash (intern (string name) :keyword)

                  *format-string-registry*)

@@ -134,19 +139,15 @@

                                          :at-p ,at-p

                                          :colon-p ,colon-p)))

-; ('compound-format-string-command :start-char #\{ :end-char #\})

-

 (defmacro define-compound-format-chars (&body specs)

-  (list*

-    'progn

-    (loop for spec in specs

-        collect `(define-compound-format-char ,@spec))))

+  `(progn

+     ,@(loop for spec in specs

+             collect `(define-compound-format-char ,@spec))))

 (defmacro define-simple-format-chars (&body specs)

-  (list*

-    'progn

-    (loop for spec in specs

-        collect `(define-simple-format-char ,@spec))))

+  `(progn

+     ,@(loop for spec in specs

+             collect `(define-simple-format-char ,@spec))))

 (defmacro define-format-chars (&body body)

   `(macrolet ((:simple (name (char) &key at-p colon-p)

@@ -181,7 +182,7 @@

 (define-format-chars

-  ; Iteration characters.

+  ;; Iteration characters.

   (:compounds

     (:map (#\{ #\}))

     (:rest (#\{ #\}) :at-p t)

@@ -192,7 +193,7 @@

     (:aprest (#\{ #\}) :at-p t :colon-p t)

     (:apply-rest (#\{ #\}) :at-p t :colon-p t))

-  ; Alignment characters.

+  ;; Alignment characters.

   (:compounds

     (:spread (#\< #\>))

@@ -205,7 +206,7 @@

     (:cjust (#\< #\>) :at-p t :colon-p t)

     (:center (#\< #\>) :at-p t :colon-p t))

-  ; Case printing characters.

+  ;; Case printing characters.

   (:compounds

     (:lowercase (#\( #\)))

     (:uppercase (#\( #\)) :at-p t :colon-p t)