anchor.diff:        (format *ps-output-stream* (concatenate 'string slash "~A" slash) regex))))
   
   (defprinter js-return (value)
  -  (write-sequence "return " *ps-output-stream*)
  -  (ps-print value))
  +  (psw "return ") (ps-print value))
   
   ;;; conditional compilation
   (defprinter cc-if (test body-forms)
  -  (write-string "/*@if ")
  +  (psw "/*@if ")
     (ps-print test)
     (incf *indent-level*)
     (dolist (form body-forms)
  -    (newline-and-indent)    
  -    (ps-print form)
  -    (write-char #\;))
  +    (newline-and-indent) (ps-print form) (psw #\;))
     (decf *indent-level*)
     (newline-and-indent)
  -  (write-string "@end @*/"))
  +  (psw "@end @*/"))
   
   (defprinter js-instanceof (value type)
  -  (write-char #\()
  -  (ps-print value)
  -  (write-string " instanceof ")
  -  (ps-print type)
  -  (write-char #\)))
  +  (psw #\() (ps-print value) (psw " instanceof ") (ps-print type) (psw #\)))
   
   (defprinter js-named-operator (op value)
     (format *ps-output-stream* "~(~A~) " op)
  
positive.code:            (loop for statement in body-statements do
                   (progn (newline-and-indent)
                          (ps-print statement)
                          (write-char #\;)))
             (decf *indent-level*)))
      (write-string "switch (")
      (ps-print test)
      (write-string ") {")
      (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: ")
                                 (print-body-statements body-statements))
                          (progn (write-string "case ")
                                 (ps-print val)
                                 (write-char #\:)
                                 (print-body-statements body-statements)))))
      (write-char #\})))
  
  (defprinter js-try (body-block &key catch finally)
    (write-string "try ")
    (ps-print body-block)
    (when catch
      (write-string " catch (")
      (write-string (js-translate-symbol (first catch)))
      (write-string ") ")
      (ps-print (second catch)))
    (when finally
      (write-string " finally ")
      (ps-print finally)))
  
  ;;; regex
  
negative.code: (defmethod parenscript-print (ps-form &optional *ps-output-stream*)
    (setf *indent-level* 0)
    (flet ((print-ps (form)
             (if (and (listp form) (eql 'js-block (car form))) ;; ignore top-level block
                 (loop for (statement . remaining) on (third form) do
                       (ps-print statement) (psw ";") (when remaining (psw #\Newline)))
                 (ps-print form))))
      (if *ps-output-stream*
          (print-ps ps-form)
          (with-output-to-string (*ps-output-stream*)
            (print-ps ps-form)))))
  
  (defun psw (obj) ;; parenscript-write
    (cond ((stringp obj) (write-string obj *ps-output-stream*))
          ((characterp obj) (write-char obj *ps-output-stream*))
          (t (princ obj *ps-output-stream*))))    
  
  (defgeneric ps-print% (special-form-name special-form-args))
  
  