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: 
  (defun print-fun-def (name args body-block)
    (format *ps-output-stream* "function ~:[~;~A~](" name (js-translate-symbol name))
    (loop for (arg . rest) on args
          with after = ", "
          unless rest do (setf after "")
          do (progn (write-string (js-translate-symbol arg))
                    (write-string after))
          finally (write-string ") "))
    (ps-print body-block))
  
  ;;; object creation
  (defprinter js-object (slot-defs)
    (write-string "{ ")
    (loop for ((slot-name slot-value) . rest) on slot-defs
          with after = ", "
          unless rest do (setf after "")
          do (progn (if (and (listp slot-name) (eql 'script-quote (car slot-name)) (symbolp (second slot-name)))
                        (write-string (js-translate-symbol (second slot-name)))
                        (ps-print slot-name))
                    (write-string " : ")
                    (ps-print slot-value)
                    (write-string after)))
    (write-string " }"))
  
  (defprinter js-slot-value (obj slot)
    (if (and (listp obj) (member (car obj) '(js-expression-if)))
        (parenthesize-print obj)
        (ps-print obj))
    (if (and (listp slot) (eql 'script-quote (car slot)))
        (progn (write-char #\.)
               (if (symbolp (second slot))
                   (write-string (js-translate-symbol (second slot)))
                   (ps-print slot)))
        (progn (write-char #\[)
               (ps-print slot)
               (write-char #\]))))
  
  ;;; cond
  (defprinter js-cond-statement (clauses)
    (loop for (test body-block) in clauses
          for start = "if (" then " else if ("
          do (progn (if (equalp test "true")
                        (write-string " else ")
                        (progn (write-string start)
                               (ps-print test)
                               (write-string ") ")))
                    (ps-print body-block))))
  
  (defprinter js-statement-if (test then-block else-block)
    (write-string "if (")
    (ps-print test)
    (write-string ") ")
    (ps-print then-block)
    (when else-block
        (write-string " else ")
        (ps-print else-block)))
  
  (defprinter js-expression-if (test then else)
    (ps-print test)
    (write-string " ? ")
    (if (>= (expression-precedence then) (op-precedence 'js-expression-if))
        (parenthesize-print then)
        (ps-print then))
    (write-string " : ")
    (if (>= (expression-precedence else) (op-precedence 'js-expression-if))
        (parenthesize-print else)
        (ps-print else)))
  
  (defprinter js-assign (lhs rhs)
    (ps-print lhs)
    (write-string " = ")
    (ps-print rhs))
  
  (defprinter js-defvar (var-name &rest var-value)
    (write-string "var ")
    (write-string (js-translate-symbol var-name))
    (when var-value
      (write-string " = ")
      (ps-print (car var-value))))
  
  ;;; iteration
  (defprinter js-for (vars steps test body-block)
    (write-string "for (")
    (loop for ((var-name . var-init) . rest) on vars
          for decl = "var " then ""
          with after = ", "
          unless rest do (setf after "")
          do (progn (write-string decl)
                    (write-string (js-translate-symbol var-name))
                    (write-string " = ")
                    (ps-print var-init)
                    (write-string after)))
    (write-string "; ")
    (ps-print test)
    (write-string "; ")
    (loop for ((var-name . nil) . rest) on vars
          for step in steps
          with after = ", "
          unless rest do (setf after "")
          do (progn (write-string (js-translate-symbol var-name))
                    (write-string " = ")
                    (ps-print step)
                    (write-string after)))
    (write-string ") ")
    (ps-print body-block))
  
  (defprinter js-for-each (var object body-block)
    (write-string "for (var ")
    (write-string (js-translate-symbol var))
    (write-string " in ")
    (ps-print object)
    (write-string ") ")
    (ps-print body-block))
  
  (defprinter js-while (test body-block)
    (write-string "while (")
    (ps-print test)
    (write-string ") ")
    (ps-print body-block))
  
  (defprinter js-with (expression body-block)
    (write-string "with (")
    (ps-print expression)
    (write-string ") ")
    (ps-print body-block))
  
  (defprinter js-switch (test clauses)
  
negative.code:       (format *ps-output-stream* (concatenate 'string slash "~A" slash) regex))))
  
  (defprinter js-return (value)
    (psw "return ") (ps-print value))
  
  ;;; conditional compilation
  (defprinter cc-if (test body-forms)
    (psw "/*@if ")
    (ps-print test)
    (incf *indent-level*)
    (dolist (form body-forms)
      (newline-and-indent) (ps-print form) (psw #\;))
    (decf *indent-level*)
    (newline-and-indent)
    (psw "@end @*/"))
  
  (defprinter js-instanceof (value type)
    (psw #\() (ps-print value) (psw " instanceof ") (ps-print type) (psw #\)))
  
  (defprinter js-named-operator (op value)
    (format *ps-output-stream* "~(~A~) " op)
  