CL-USER> (defparser *test-parser*
	     expression
	   (open-paren symbol close-paren comma)
	   ((expression    -> function-call
			   -> symbol)
	    (function-call -> symbol open-paren argument-list close-paren)
	    (argument-list -> argument-list comma expression
			      (:call (lambda (args c expr)
				      (cons args expr)))
			   -> expression)))

CL-USER> (parser-lr (make-pcre-lexer "foo(bar,baz,xenu(elron))"
				     '((symbol "(?i)[a-z][a-z0-9_]*")
				       (open-paren "\\(")
				       (close-paren "\\)")
				       (comma ",")
				       (whitespace "[	 ]+")))
			   *test-parser*)

("foo" "(" (("bar" . "baz") "xenu" "(" "elron" ")") ")")

(fucc:defparser *css-parser* 
    stylesheet
  (space ident percent length number ems emx angle time freq
         string includes dashmatch
         hash page-sym media-sym
         import-sym important uri 
         |}| |{| |:| |;| |.| |,| |(| |)| |[| |]| |/| + - |>| |*| |=| |@|)

  ((stylesheet	-> s (:* import) (:var css-rules (:* (:or ruleset media page)))
                (:do (identity css-rules)))
   (s		-> (:* space))
   (import	-> import-sym s (:or string uri) s
                (:* medium ) s |;| s )
   (media	->  media-sym s (:list medium comma) { s (:* ruleset) } s 
                (:do nil))
   (medium	-> ident s)
   (page	-> page-sym s (:maybe pseudo-page) s { s 
                (:list declaration colon) } s (:do nil))
   (pseudo-page	-> |:| ident )
   (operator	-> |/| s
                -> |,| s
                -> )
   (combinator	-> + s
                -> |>| s
                -> (:+ space))
   (unary-operator -> (:or + -))
   (ruleset	-> (:var sel (:list selector comma)) s
                { s (:var par (:list declaration colon)) } s
                (:do (list sel (apply #'append par))))
   (colon	-> |;| s)
   (comma	-> |,| s)
   (selector	-> (:list simple-selector combinator))
   (simple-selector -> (:var name element-name) (:var pairs 
                                                      (:* (:or hash class 
                                                               attrib pseudo)))
                    (:do (append (list name) (flatten pairs)))
                    -> (:var pairs
                             (:+ (:or hash class attrib pseudo)))
                    (:do (append (list nil) (flatten pairs))))
   (class	-> |.| (:var id ident) (:do (list :class id)))
   (element-name -> (:var ele (:or ident |*|))
                 (:do (intern (string-upcase ele) :keyword)))
   (attrib	-> |[| s (:var key ident) s 
                (:var val (:maybe (:or |=| includes dashmatch ) s
                                  (:or ident string) s))
                |]|
                (:do (list (intern (string-upcase key) 'keyword)
                           (third val))))
   (pseudo	-> |:| (:or ident pseudo-func) (:do (list :nouse t)))
   (pseudo-func -> ident |(| s (:maybe ident) s |)|)
   (declaration	-> (:var key property) |:| s (:var vals expr) (:maybe prio)
                (:do (list (intern (string-upcase key) 'keyword) 
                           (if (= (length vals) 1) (first vals) vals)))
                -> )
   (prio	-> important s)
   (property	-> (:var id ident) s (:do (identity id)))
   (expr	-> (:list term operator))
   (term	-> (:var minus (:maybe unary-operator))
                (:var val (:or number percent length ems emx angle time freq)) s
                (:do (if (eql minus '-)
                         (identity (CL:- val)) 
                         (identity val)))
                -> (:var minus (:maybe unary-operator))
                (:var val number) s
                (:do (if (eql minus '-)
                       (cons (first val) (CL:- (second val)))
                       (identity val)))
                -> (:var val (:or string ident uri)) s (:do (identity val))
                -> (:or hexcolor function))
   (function	-> ident |(| s expr |)| (:*))
   (hexcolor	-> hash s)))