# 2010: I'm not sure what the following means.

#
# Local commit:
# 		-clears reparse flags underneath
# 		-must be possible to backtrack after
# Global commit (revertOn)
# 		-clears all reparse flags
# 		-must be possible to backtrack after
# Global commit (!revertOn)
# 		-clears all reparse flags
# 		-clears all 'parsed' reverse code
# 		-clears all reverse code
# 		-clears all alg structures
#

# This test shows that a global commit with revertOn correctly does not clear
# 'parsed' items because it must entertain the possibility of backtracking.

lex start
{
	ignore /[\t\n ]+/
	literal '^', '|', '-', ',', ':', '!', '?', '.'
	literal '(', ')', '{', '}', '*', '&', '+'

	literal '--', ':>', ':>>', '<:', '->', '**'

	token word /[a-zA-Z_][a-zA-Z0-9_]*/
	token uint /[0-9]+/
}


def expression [term expression_op*]

def expression_op
	['|' term]
|	['&' term]
|	['-' term]
|	['--' term]

def term [factor_rep term_rest]

# This list is done manually to get shortest match.
def term_rest
	[]
|	[term_op term_rest]

def term_op
	[factor_rep]
|	['.' factor_rep]
|	[':>' factor_rep]
|	[':>>' factor_rep]
|	['<:' factor_rep]

def factor_rep 
	[factor_neg factor_rep_op*]

def factor_rep_op
	['*']
|	['**']
|	['?']
|	['+']
|	['{' factor_rep_num '}']
|	['{' ',' factor_rep_num '}']
|	['{' factor_rep_num ',' '}']
|	['{' factor_rep_num ',' factor_rep_num '}']

def factor_rep_num [uint]

def factor_neg 
	['!' factor_neg]
|	['^' factor_neg]
|	[factor]

def factor 
	[alphabet_num]
|	[word]
|	['(' expression ')']

def alphabet_num 
	[uint]

global i: int

def suint
	i: int
	[uint]
	{
		#lhs.i = 0
		#i = 1
		#lhs = construct suint "1"
	}

def sub
	[suint* '*']

token item
	S: sub
	/[0-9]+/
	{
		M: str = input.pull(match_length)
		S: sub = parse_stop sub(input)
		input.push( make_token( typeid<item> M S ) )
	}

token EOL /'\n'/

def stuff
	[item* '!' EOL]
|	[sub]

S: stuff = parse stuff( stdin  )
print_xml( S )