anchor.diff:  					  (unless (null *transform-term*)
   					    (print-current-term))))
   	                       (values))
  +	   ((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))
   	   ((done)             (finish-transform-session))
   
  +	   ((proc p) (when (cl-user::sw argstr)
  +		       (let ((val (cdr (Specware::evaluateUnitId cl-user::*last-unit-Id-_loaded*))))
  +			 (if (or (null val) (not (eq (car val) ':|Spec|)))
  +			     (format t "Not a spec!")
  +			     (let ((spc (cdr val)))
  +			       (process-transform-shell-command 'undo "all")
  +			       (setq *transform-spec* spc)
  +			       (format t "Restarting Transformation Shell.")))))
  +		      (values))
   	   ;; Possibly useful commands from the standard shell
  -	   ((proc p)  (cl-user::sw     argstr) (values))
   	   (show      (cl-user::show   argstr) (values))
   	   (showx     (cl-user::showx  argstr) (values))
   	   (lgen-lisp (cl-user::swll   argstr) (values))
  
positive.code: 				   ("abstract-cse" . "Abstract Common Sub-Expressions")
  				   ("cse" . "Abstract Common Sub-Expressions")
  				   ("pc"   . "Print current expression")
  				   ("undo" . "[n] Undo n levels (1 with no argument)")
  				   ("done" . "Print script and return to normal shell")
  				   ))
  
negative.code: (defpackage :SWShell)
  (in-package :SWShell)
  
  (defvar *transform-help-strings* '(("at" . "[op] Focuses on definition of op")
  				   ("simplify" . "[rules] Applies rewriting simplifier with supplied rules.")
  				   ("fold" . "[op] folds first occurrence of definition of op")
  				   ("unfold" . "[op] unfolds first occurrence of op")
  				   ("lr" . "[thm] Applies theorem as a rewrite in left-to-right direction")
  				   ("rl" . "[thm] Applies theorem as a rewrite in right-to-left direction")
  				   ("simp-standard" . "Applies standard simplifier")
  