application ::=
	<spaces> $< <name>:prod <argument>*:args <spaces> $>
		=> [ `(apply ',(intern (string-upcase prod)) ,@args)]
argument ::=
	~$> <hostLanguageTinyExpression>
ocharacter ::=
	<spaces> $$ <ochar>:x => [ x ]
expr ::=
	<expr4>:x (<token '|'> <expr4>)*:xs => [ `(or ,x ,@xs) ]
expr1 ::=

	<application>
|	<semanticAction>
|	<semanticPredicate>
|	( <okeyword 'nil'>	| <okeyword 'true'>	| <okeyword 'false'>
	| <onumber>			| <ostring>			| <ocharacter>
	| <osymbol>													):x	=> [`(apply 'exactly ,x)]
|	<token '"'> (~$" <ochar>)*:cs $"										=> 
	[ `(and ,@(loop for c in cs collect `(apply 'exactly ,c)) `(action ,(string cs))) ]
|	<token '('> <expr>:x <token ')'>										=> [x]
|	<token '{'> <token '}'>						    						=> ['(form (lambda () t))]
|	<token '{'> <expr>:x <token '}'>										=> [`(form ,x)]
expr2 ::=

	<token '~'> <expr2>:x	=> [(list 'not x)]
|	<token '&'> <expr1>:x	=> [(list 'not (list 'not x))]
|	<expr1>
expr3 ::=

	<expr2>:r
		(	<token '*'> ![ (list 'many r)]:r
		|	<token '+'> ![ (list 'many1 r)]:r
		|	<empty>						)
		(	$: <name>:n ![ (pushnew (intern (string-upcase n)) (locals o))] ![`(assign ,n ,r)]:r
		|	<empty>													)	=> [r]
|	<token ':'> <name>:n ![ (pushnew (intern (string-upcase n)) (locals o))] => [`(assign ,n (apply 'anything))]
expr4 ::=

	<expr3>*:xs => [`(and ,@xs)]
hostLanguageExpression ::=

	((~$] <anything>)*):expr => [ (coerce expr 'string) ]
hostLanguageTinyExpression ::=

	<spaces> $' (~$' <anything>)*:xs $' => [ (coerce xs 'string) ]
	| <spaces> <letter>+:xs => [ (intern (string-upcase (coerce xs 'string))) ]
	| <lispexpr>
lispexpr ::=
	(<lisplist> | <lispatom>):x  => [ x ]
lispatom ::=
	<spaces> (<lispoperator> | <onumber> | <name>)
lispoperator ::=
	$> | $< | $+ | $! | $= | $- | $_  
lisplist ::=
	<spaces> $( <spaces> $) => [ nil ]
	| <spaces> $( (<lisplist> | <lispatom>):x (<ospace>+ (<lisplist> | <lispatom>))*:xs <spaces> $) => [ (cons x xs) ]
okeyword :xs ::=

	<spaces> <seq xs> ~(<letter> | <digit>)	=> [xs]
name ::=

	<spaces> <letter>:x (<letter> | <digit>)*:xs => [ (concatenate 'string (string x) (coerce xs 'string))]
onumber ::=

	<spaces> <digit>+:ip
		(	$. <digit>+:fp	=> [(format nil "~A.~A" ip fp)] 
		|	<empty>			=> [ (read-from-string (coerce ip 'string)) ])
production ::=

	&(<name>:name)
		<productionPart name>:x
		(<token ';'> <productionPart name>)*:xs
		<spaces> <end>
		=> [`(prod ,name ,(locals o) (or ,x ,@xs))]
productionPart :requiredName ::=

	<name>:name ?[(equal name requiredName)]
		<expr4>:body
		(	<token '::='> <expr>:rhs	=> [`(and ,body ,rhs)]
		|	<empty>					=> [body]			  )
semanticAction ::=

	<token '!['> <hostLanguageExpression>:r <token ']'>				=> [(list 'action r)]
|	<token '=>'> <token '['> <hostLanguageExpression>:r	<token ']'>	=> [(list 'action r)]

semanticPredicate ::=

	<token '?['> <hostLanguageExpression>:r <token ']'>	=> [(list 'pred r)]
ostring ::=

	<spaces> $' (~$' <ochar>)*:s $' => [(coerce  s 'string)]
osymbol ::=

	<spaces> $#
		(	<name>
		|	<ostring>:s => [ `(subseq ,s 1)] ):n
		=> [ `(quote ,(intern (string-upcase (coerce n 'string)))) ]
token :xs ::=

	<spaces> <seq xs>