anchor.diff:             (loop for statement in body-statements do
                    (progn (newline-and-indent)
                           (ps-print statement)
  -                        (write-char #\;)))
  +                        (psw #\;)))
              (decf *indent-level*)))
  -    (write-string "switch (")
  -    (ps-print test)
  -    (write-string ") {")
  +    (psw "switch (") (ps-print test) (psw ") {")
       (loop for (val body-block) in clauses
             for body-statements = (third body-block)
             do (progn (newline-and-indent)
                       (if (eql val 'default)
  -                        (progn (write-string "default: ")
  +                        (progn (psw "default: ")
                                  (print-body-statements body-statements))
  -                        (progn (write-string "case ")
  +                        (progn (psw "case ")
                                  (ps-print val)
  -                               (write-char #\:)
  +                               (psw #\:)
                                  (print-body-statements body-statements)))))
  -    (write-char #\})))
  +    (psw #\})))
   
   (defprinter js-try (body-block &key catch finally)
  -  (write-string "try ")
  +  (psw "try ")
     (ps-print body-block)
     (when catch
  -    (write-string " catch (")
  -    (write-string (js-translate-symbol (first catch)))
  -    (write-string ") ")
  +    (psw " catch (") (psw (js-translate-symbol (first catch))) (psw ") ")
       (ps-print (second catch)))
     (when finally
  -    (write-string " finally ")
  +    (psw " finally ")
       (ps-print finally)))
   
   ;;; regex
  
positive.code:   (if (or (numberp object) (and (consp object) (member (car object) '(js-lambda js-object operator js-expression-if))))
        (parenthesize-print object)
        (ps-print object))
    (write-string (js-translate-symbol method))
    (write-char #\()
    (print-comma-list args)
    (write-char #\)))
  
  (defprinter js-block (statement-p statements)
    (if statement-p
        (progn (write-char #\{)
               (incf *indent-level*)
               (loop for statement in statements
                     do (progn (newline-and-indent)
                               (ps-print statement)
                               (write-char #\;)))
               (decf *indent-level*)
               (newline-and-indent)
               (write-char #\}))
        (progn (write-char #\()
               (loop for (statement . rest) on statements
                     with after = ", "
                     unless rest do (setf after "")
                     do (progn (ps-print statement)
                               (write-string after)))
               (write-char #\)))))
  
  (defprinter js-lambda (args body)
    (print-fun-def nil args body))
  
negative.code: (defparameter *indent-num-space* 4)
  
  (defun newline-and-indent ()
    (when (fresh-line *ps-output-stream*)
      (loop repeat (* *indent-level* *indent-num-space*)
            do (psw #\Space))))
  
  ;;; string literals
  (defvar *js-quote-char* #\'
  