anchor.diff:             (match-token *lexer* '<identifier>)))))
   
   
  -
   (defun <number_literal> ()
  -  (seq #'numberp))
  +  (alt #'numberp #'idl-fixed-p))
   
   (defun <character_literal> ()
     (seq #'characterp))
  
positive.code: 
  ;;;; Constant Declaration
  
  (defun <const_dcl> (&aux type name value)
    (seq "const" 
         (-> (<const_type>) type)
         (-> (<identifier>) name)
         "=" 
         (-> (<const_exp>) value)
         (action (named-create *container* #'op:create_constant name
                               type 
                               (corba:any :any-typecode (op:type type)
                                          :any-value value)))))
  
  (defun <const_type> ()
    (alt
     (seq "fixed")                    ; FIXME: ???
     (<simple_type_spec> :disallow-kind '(:tk_struct :tk_union))))
  
  
  
  
negative.code:                     (seq "<<" (-> (<add_expr>) y) (action (setq x (<< x y))))))
           (action x))))
  
  
  (defmethod add ((n1 cons) (n2 cons))
    ;; Assume fixed
    (multiple-value-bind (d1 s1 m1) (idl-fixed-values n1)
      (multiple-value-bind (d2 s2 m2) (idl-fixed-values n2)
        (make-idl-fixed (+ (max (- d1 s1) (- d2 s2)) (max s1 s2) 1)
                        (max s1 s2)
                        (+ m1 m2)))))
    
  (defmethod add (n1 n2)
    (+ n1 n2))
  
  (defmethod sub ((n1 cons) (n2 cons))
    (multiple-value-bind (d1 s1 m1) (idl-fixed-values n1)
      (multiple-value-bind (d2 s2 m2) (idl-fixed-values n2)
        (make-idl-fixed (+ (max (- d1 s1) (- d2 s2)) (max s1 s2) 1)
                        (max s1 s2)
                        (- m1 m2)))))
  
  (defmethod sub (n1 n2)
    (- n1 n2))
  
  
  (defun <add_expr> nil
    (let (x y)
      (seq (-> (<mult_expr>) x)
           (seq* (alt (seq "+" (-> (<mult_expr>) y) (action (setq x (add x y))))
                      (seq "-" (-> (<mult_expr>) y) (action (setq x (sub x y))))))
           (action x))))
  
  (defun <mult_expr> nil
  