anchor.diff:  
              ((lisp l)  (if (null argstr)
                             (format t "Error: ~a requires an argument" *raw-command*)
  -                        (with-break-possibility (lisp-value (multiple-value-list (eval (read-from-string argstr)))))))
  +                          (with-break-possibility (lisp-value (multiple-value-list (eval (read-from-string argstr)))))))
              (cl        (with-break-possibility (cl-user::cl argstr)))
              (ld        (with-break-possibility (cl-user::ld argstr)))
              (cf        (cl-user::cf argstr))
  
positive.code: ;; Other systems (e.g. prism or accord) may use related functions...
  (defun process-sw-shell-command (command argstr)
    (cond ((and (consp command) (null argstr))
          (lisp-value (multiple-value-list (eval command))))
        ((symbolp command)
         (case command
           (transform (let* ((spec-uid (cl-user::norm-unitid-str argstr))
                             (val (cdr (Specware::evaluateUnitId (or spec-uid cl-user::*last-unit-Id-_loaded*)))))
                        (if (or (null val) (not (eq (car val) ':|Spec|)))
                            (format t "Not a spec!")
                            (let ((spc (cdr val)))
                              (when spec-uid (setq cl-user::*last-unit-Id-_loaded* spec-uid))
                              (initialize-transform-session spc)
                              (setq *current-command-processor* 'process-transform-shell-command)
                              (format t "Entering Transformation Construction Shell")))
                        (values)))
           (help      (let ((cl-user::*sw-help-strings*
                             (append *sw-shell-help-strings*
                                     (if *developer?*
                                         *sw-shell-dev-help-strings*
                                         '()))))
                        (cl-user::sw-help argstr) ; refers to cl-user::*sw-help-strings*
                        ))
           (cd        (if (null argstr)
                          (princ (Specware::current-directory))
                          (Specware::cd argstr))
                      (values))
           (pwd       (princ (Specware::current-directory)) (values))
           ((dir ls)       (cl-user::ls     (or argstr "")))
           (dirr      (cl-user::dirr   (or argstr "")))
           (path      (cl-user::swpath argstr))
           ((proc p)  (cl-user::sw     argstr) (values))
           ((reproc rp)  (let ((cl-user::*force-reprocess-of-unit* t)) (cl-user::sw     argstr)) (values))
           (show      (cl-user::show     argstr) (values))
           (showx     (cl-user::showx    argstr) (values))
           (showdeps  (cl-user::showdeps argstr) (values))
           (showimports  (cl-user::showimports argstr) (values))
           (showdata  (cl-user::showdata argstr) (values))
           (cinit     (cl-user::sw-init))
           ((gen-lisp gen-l)  (cl-user::swl argstr) (values))
           ((gen-lisp-top gen-lt)  (let ((cl-user::*slicing-lisp?* t)) (cl-user::swl argstr)) (values))
           (lgen-lisp (cl-user::swll   argstr) (values))
           (gen-c     (cl-user::swc    argstr) (values))
           (gen-c-thin (cl-user::gen-c-thin    argstr) (values))
           (make      (if (null argstr) (cl-user::make) (cl-user::make argstr)))
           (gen-java  (cl-user::swj    argstr) (values))
           ((obligations oblig obligs)
            (cl-user::show   (concatenate 'string "obligations "
                                            (if (null argstr)
                                                cl-user::*last-unit-Id-_loaded*
                                                (cl-user::norm-unitid-str argstr))))
             (values))
            ((gen-obligations gen-oblig gen-obligs)
             (let ((TypeObligations::generateTerminationConditions? nil)
                   (TypeObligations::generateExhaustivityConditions? t)
                    (Simplify::simplifyUsingSubtypes? t)
                   (Prover::treatNatSpecially? nil)
                    (Utilities::namedTypesRaised? t)
                   (uid (if (not (null argstr))
                            argstr
                            (if (not (null cl-user::*last-unit-Id-_loaded*))
                                cl-user::*last-unit-Id-_loaded*
                                (progn (format t "No previous unit processed~%")
                                       nil)))))
               (unless (null uid)
                 (setq cl-user::*last-unit-Id-_loaded* uid)
                 (IsaTermPrinter::printUIDtoThyFile-2 uid t))))
             ((gen-haskell gen-h)
             (let ((uid (if (not (null argstr))
                            argstr
                            (if (not (null cl-user::*last-unit-Id-_loaded*))
                                cl-user::*last-unit-Id-_loaded*
                                (progn (format t "No previous unit processed~%")
                                       nil)))))
               (unless (null uid)
                 (setq cl-user::*last-unit-Id-_loaded* uid)
                 (Haskell::printUIDtoHaskellFile-3 uid nil t))))
             ((gen-haskell-top gen-ht)
              (let ((uid (if (not (null argstr))
                             argstr
  
negative.code:                                     (funcall command com-argstr)))
                                (format t "Unknown command: ~a." command)))))
             ((trace-rewrites trr) (setq MetaSlangRewriter::traceRewriting 2)
              (format t "Rewrite tracing turned on.")
              (values))
             ((untrace-rewrites untrr) (setq MetaSlangRewriter::traceRewriting 0)
              (format t "Rewrite tracing turned off.")
              (values))
             ;;      (bash      (cl-user::bash argstr))
             ;;
             (t
              (format t "Unknown command `~a'. Type `help' to see available commands."
  