anchor.diff:  
   #+mcl
   (let ((ccl::*warn-if-redefine-kernel* nil))
  -(defun ccl::check-toplevel-command (form)
  -  (let* ((cmd (if (consp form) (car form) form))
  -         (args (if (consp form) (cdr form))))
  -    (if (keywordp cmd)
  -      (dolist (g ccl::*active-toplevel-commands*
  -		 (cl::invoke-command-interactive cmd))
  -	(when
  -	    (let* ((pair (assoc cmd (cdr g))))
  -	      (if pair 
  -		(progn (apply (cadr pair) args)
  -		       t)))
  -	  (return t))))))
  -)
  +  (defun ccl::check-toplevel-command (form)
  +    (let* ((cmd (if (consp form) (car form) form))
  +	   (args (if (consp form) (cdr form))))
  +      (if (keywordp cmd)
  +	  (dolist (g ccl::*active-toplevel-commands*
  +		     (cl::invoke-command-interactive cmd))
  +	    (when (let* ((pair (assoc cmd (cdr g))))
  +		    (if pair 
  +			(progn (apply (cadr pair) args)
  +			       t)))
  +	      (return t))))))
  +  )
   
   #+allegro
   (top-level:alias ("ls" :string) (&optional (str ""))
  
positive.code: 
  #+allegro
  (top-level:alias
   ("swj-config") ()
   (let* (
         (pkgname (format nil "~A" JGEN::packageName))
         (bdir (format nil "~A" JGEN::baseDir))
         (ops (format nil "~A" JGEN::publicOps))
         (pops (if (string= ops "")
  		(concatenate 'string "\"" ops "\"")
  	      "none")
  	    )
         )
     (progn
      (format t ";;; package name   [change with :swj-config-pkg]:         \"~A\"~%" pkgname)
      (format t ";;; base directory [change with :swj-config-dir]:         \"~A\"~%" bdir)
      (format t ";;; public ops     [change with :swj-config-make-public]: ~A~%" ops)
      (if (not (string= pkgname "default"))
  	(let* (
  	       (ppath (map 'string #'(lambda(c) (if (eq c #\.) #\/ c)) pkgname))
  	       (dir (concatenate 'string bdir "/" ppath "/"))
  	       )
  	  (format t ";;; Java file(s) will be written into directory \"~A\"~%" dir)
  	  ) ()))))
  
  ;;; --------------------------------------------------------------------------------
  
  (defun swc (x &optional y)
     (Specware::evaluateCGen_fromLisp-2 x (if y (cons :|Some| y)
  					  '(:|None|))))
  #+allegro
  (top-level:alias ("swc" :case-sensitive) (&optional &rest args)
     (let ((r-args (if (not (null args))
  		     args
  		   *last-swc-args*)))
     (if r-args
         (progn (setq *last-swc-args* args)
  	      (funcall 'swc (string (first r-args))
  		       (if (not (null (second r-args)))
  			   (string (second r-args)) nil)))
       (format t "No previous unit evaluated~%"))))
  
  #+allegro
  (top-level:alias ("wiz" :case-sensitive) (&optional (b nil b?))
     (if b? (princ (setq SpecCalc::specwareWizard? b))
            (princ SpecCalc::specwareWizard?)))
  
  ;; When the following boolean is true, then the System.debug function will
  ;; take the user into the Lisp debugger.
  (defvar System-spec::specwareDebug? nil)
  (defun swdbg (&optional (b nil b?))
    (if b? (princ (setq System-spec::specwareDebug?
  		      (and b (not (equal b "nil")))))
  
negative.code: (defpackage :SpecCalc)
  (defpackage :JGen)
  ;; Toplevel Lisp aliases for Specware
  
  (defparameter *sw-help-strings*
    '(("dir" . "List files in current directory")
      ("list" . "List loaded units")
      ("ls" . "List files in current directory")
      ("set-base" . "Set base library unit id")
      ("show" . "Show unit")
      ("show-base-unit-id" . "Show base library unit id")
      ("sw" . "Process unit")
      ("sw-help" . "Help for specware commands")
      ("sw-init" . "Clear Spec cache")
      ("swc" . "Generate C code for unit")
      ("swe" . "Evaluate specware term")
      ("swe-spec" . "Set spec context for :swe command")
      ("swj" . "Generate Java code for unit")
      ("swj-config" . "Show configuration parameters for Java generation")
      ("swj-config-dir" . "Set base directory to be used by :swj")
      ("swj-config-make-public" . "Set public names to be used by :swj")
      ("swj-config-pkg" . "Set package name to be used by :swj")
      ("swj-config-reset" . "Restore default configuration parameters for Java generation")
      ("swl" . "Generate Lisp code for unit")
      ("swll" . "Generate Lisp code for local definition of unit, and compile and load")
      ("swpath" . "Query (no arg) or set SWPATH"))
    )
  
  (defun sw-help (command)
  