anchor.diff:    (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 #\)))
  +  (psw (js-translate-symbol method))
  +  (psw #\() (print-comma-delimited-list args) (psw #\)))
   
   (defprinter js-block (statement-p statements)
     (if statement-p
  -      (progn (write-char #\{)
  +      (progn (psw #\{)
                (incf *indent-level*)
  -             (loop for statement in statements
  -                   do (progn (newline-and-indent)
  -                             (ps-print statement)
  -                             (write-char #\;)))
  +             (dolist (statement statements)
  +               (newline-and-indent) (ps-print statement) (psw #\;))
                (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 #\)))))
  +             (psw #\}))
  +      (progn (psw #\()
  +             (loop for (statement . remaining) on statements do
  +                   (ps-print statement) (when remaining (psw ", ")))
  +             (psw #\)))))
   
   (defprinter js-lambda (args body)
     (print-fun-def nil args body))
  
positive.code:     (t op)))
  
  (defun parenthesize-print (ps-form)
    (write-char #\()
    (ps-print ps-form)
    (write-char #\)))
  
  (defprinter operator (op args)
    (loop for (arg . rest) on args
          with precedence = (op-precedence op)
          with op-string = (format nil " ~A " op)
          unless rest do (setf op-string "")
          do (progn (if (>= (expression-precedence arg) precedence)
                        (parenthesize-print arg)
                        (ps-print arg))
                    (write-string op-string))))
  
  (defprinter unary-operator (op arg &key prefix)
    (when prefix
      (write-string op))
    (if (and (listp arg) (eql 'operator (car arg)))
        (parenthesize-print arg)
        (ps-print arg))
    (unless prefix
      (write-string op)))
  
  ;;; function and method calls
  (defprinter js-funcall (fun-designator args)
    (cond ((member (car fun-designator) '(js-variable js-aref js-slot-value))
           (ps-print fun-designator))
          ((eql 'js-lambda (car fun-designator))
           (write-char #\()
           (ps-print fun-designator)
           (write-char #\)))
          ((eql 'js-funcall (car fun-designator))
           (ps-print fun-designator)))
    (write-char #\()
    (print-comma-list args)
    (write-char #\)))
  
  (defprinter js-method-call (method object args)
    ;; TODO: this may not be the best way to add ()'s around lambdas
  
negative.code: (defmethod ps-print ((string string))
    (flet ((lisp-special-char-to-js (lisp-char)
             (car (rassoc lisp-char *js-lisp-escaped-chars*))))
      (psw *js-quote-char*)
      (loop for char across string
            for code = (char-code char)
            for special = (lisp-special-char-to-js char)
            do (cond (special (psw #\\)
                              (psw special))
                     ((or (<= code #x1f) (>= code #x80))
                      (format *ps-output-stream* "\\u~4,'0x" code))
                     (t (psw char)))
            finally (psw *js-quote-char*))))
  
  (defmethod ps-print ((number number))
    (format *ps-output-stream* (if (integerp number) "~S" "~F") number))
  