anchor.diff:  		       (not (null keys)))
   		  `(if (eql ,variable ,keys)
   		       (progn ,@forms)
  -		       ,(expand-e/ccase-clauses (cdr clauses) variable final))
  +		       ,(expand-e/ccase-clauses (cdr clauses) variable final name))
   		  `(if (or ,@(eql-ify keys variable))
   		       (progn ,@forms)
  -		       ,(expand-e/ccase-clauses (cdr clauses) variable final))))))))
  +		       ,(expand-e/ccase-clauses (cdr clauses) variable final name))))))))
   
   ;;; For ECASE, the default is to signal a type error. 
   (defmacro ecase (keyform &rest clauses)
     (let* ((variable (gensym))
  -	 (keys (collect-e/ccase-keys clauses))
  +	 (keys (collect-e/ccase-keys clauses 'ecase))
   	 (final `(error 'ecase-type-error
  +			:name 'ecase
   			:datum ,variable
   			:expected-type '(member ,@keys))))
       `(let ((,variable ,keyform))
  -       ,(expand-e/ccase-clauses clauses variable final))))
  +       ,(expand-e/ccase-clauses clauses variable final 'ecase))))
   
   ;;; This function is does the same thing as
   ;;; (mapcar #'list vars vals), but since we are not
  
positive.code: 	     (list keys)
  	     (if (not (proper-list-p keys))
  		 (error 'malformed-keys
  			:keys keys)
  		 keys)))
         (collect-e/ccase-keys (cdr clauses)))))
  
  ;;; Expand a list of clauses for ECASE or CCASE.  We turn the clauses
  ;;; into nested IFs, where the innermost form (final) depends on
  ;;; whether we use ecase or ccase.  We check that the list of clauses
  ;;; is a proper list, and that each clause is a proper list.
  (defun expand-e/ccase-clauses (clauses variable final)
    (if (null clauses)
        final
        (if (not (consp clauses))
  	  (error 'malformed-case-clauses
  		 :clauses clauses)
  	  (let ((clause (car clauses)))
  	    (unless (and (proper-list-p clause)
  			 (not (null clause)))
  	      (error 'malformed-case-clause
  		     :clause clause))
  	    (let ((keys (car clause))
  		  (forms (cdr clause)))
  
negative.code:       'nil
        (if (not (consp clauses))
  	  (error 'malformed-case-clauses
  		 :name 'case
  		 :clauses clauses)
  	  (let ((clause (car clauses)))
  	    (unless (and (proper-list-p clause)
  			 (not (null clause)))
  	      (error 'malformed-case-clause
  		     :name 'case
  		     :clause clause))
  	    (if (or (eq (car clause) 'otherwise)
  		    (eq (car clause) t))
  		(if (null (cdr clauses))
  		    `(progn ,@(cdr clause))
  		    (error 'otherwise-clause-not-last
  			   :name 'case
  			   :clauses (cdr clauses)))
  		;; it is a normal clause
  		(let ((keys (car clause))
  