anchor.diff:  						  (list 1 . 2)))
   					     `(:anyof
   					       ((:tuple (1 ,elt) ,sep (2 (:REPEAT ,@(rest pattern))))
  -						(list 1 . 2)))))))
  +						(list 1 . 2)))))
  +					 s-p-d
  +					 o-s))
   	   )
  -       (let* ((new-rule (build-parser-rule-aux parser name (first pattern)))
  -	      (semantics     (second pattern))
  -	      (keyword-args  (rest (rest pattern)))
  -	      (precedence    (getf keyword-args :PRECEDENCE    +default-precedence+))
  -	      (documentation (getf keyword-args :DOCUMENTATION nil)))
  -	 (add-parser-rule-semantics     new-rule semantics)
  -	 (add-parser-rule-precedence    new-rule precedence)
  -	 (add-parser-rule-documentation new-rule documentation)
  -	 new-rule)))))
  +	 (let* ((new-rule (build-parser-rule-aux parser name (first pattern) s-p-d o-s))
  +		(semantics     (second pattern))
  +		(keyword-args  (rest (rest pattern)))
  +		(precedence    (getf keyword-args :PRECEDENCE    +default-precedence+))
  +		(documentation (getf keyword-args :DOCUMENTATION nil)))
  +	   (add-parser-rule-semantics     new-rule semantics)
  +	   (add-parser-rule-precedence    new-rule precedence)
  +	   (add-parser-rule-documentation new-rule documentation)
  +	   new-rule)))))
   
   ;;; ====================
   
  
positive.code: 
  ;;; ============================================================================
  
  (defun add-parser-main-rule (parser name parent-names pattern semantics precedence documentation)
    (debugging-comment "--------------------------------------------------------------------------------")
    (debugging-comment "Adding rule ~S" name)
    (let ((rule-name
  	 (cond ((null pattern)
  		(let ((newrule (make-parser-atomic-rule :name name)))
  		  (install-parser-rule parser newrule)
  		  name))
  	       ((and (consp pattern) (or (numberp (first pattern))
  					 (eq (first pattern) :optional)))
  		(build-parser-rule parser name `(:TUPLE ,pattern)))
  	       (t
  		(build-parser-rule parser name pattern)))))
      (when (null rule-name)
        (warn "Ignoring rule ~S, because pattern begins with :optional: ~S"
  	    name 
  	    pattern)
        (return-from add-parser-main-rule nil))
      (let ((rule (maybe-find-parser-rule parser rule-name)))
        (unless (null rule)
  	(setf (parser-rule-main-rule? rule) t)
  	(add-parser-rule-semantics     rule semantics)
  	(add-parser-rule-precedence    rule precedence)
  	(add-parser-rule-documentation rule documentation)
  	))
      (dolist (parent-name parent-names)
        (extend-anyof-rule parser parent-name rule-name))
      rule-name))
  
  ;;; ============================================================================
  
  (defun build-parser-rule (parser name pattern)
    (let ((newrule (build-parser-rule-aux parser name pattern)))
      (cond ((symbolp newrule)
  	   newrule)
  	  (t
  	   (install-parser-rule parser newrule)
  	   (parser-rule-name newrule)))))
  
  (defun build-parser-rule-aux (parser name pattern)
    (debugging-comment "Build rule ~30S  from  ~A" name (format nil "~S" pattern))
    (etypecase pattern ; cannot use (ecase (type-of pattern) ...) since 'STRING won't match '(SIMPLE-ARRAY CHARACTER (3)) ,etc.
      (string (build-parser-keyword-rule parser pattern)) ; ignore name
      (symbol (build-parser-id-rule name pattern))
  
negative.code: 						 `(:anyof 
  						   ((:tuple (1 (:optional (:REPEAT ,@(rest pattern))))) 
  						    (if (eq '1 :unspecified) '() (list . 1)))
  						   )
  						 s-p-d
  						 (list t '())))
  			     (rule (gethash rulename (parser-ht-name-to-rule parser))))
  			(debugging-comment "Rule ~S is now optional: ~S." rulename rule)
  			rulename))
             (:REPEAT+  (build-parser-rule parser name 
  					 `(:anyof
  					   ((:tuple (1 (:REPEAT ,@(rest pattern))))
  					    (list . 1)))
  					 s-p-d
  					 o-s))
  	   (:REPEAT++ (build-parser-rule parser name 
  					 (let ((elt (second pattern))
  					       (sep (third  pattern)))
  