Grammar StitchTreeWalker
ANTLR-generated HTML file from C:\eclipse\data\eclipse-3.2\org.sa.rainbow.lang\src\org\sa\rainbow\stitch\parser/stitchT.g

Terence Parr, MageLang Institute
ANTLR Version 2.7.6 (2005-12-22); 1989-2005



Definition of tree parser StitchTreeWalker, which is a subclass of TreeParser.

	
	
script
		:				 #( MODULE id:IDENTIFIER  beh.createModule(#id);  imports tactics strategies ) 
		;
	
	
imports
		:				 #( IMPORTS ( importStmt )* ) 
		;
	
	
tactics
		:				 #( TACTICS ( tactic )* ) 
		;
	
	
strategies
		:				 #( STRATEGIES ( strategy )* ) 
		;
	
	
importStmt
		:				 #( i1:IMPORT_LIB s1:STRING_LIT  imp = beh.createImport(#i1, #s1);  ( importRenames )* ) 
		|				 #( i2:IMPORT_MODEL s2:STRING_LIT  imp = beh.createImport(#i2, #s2);  ( importRenames )* ) 
		|				 #( i3:IMPORT_OP s3:STRING_LIT  imp = beh.createImport(#i3, #s3);  ( importRenames )* ) 
		;
	
	
importRenames
		:				 #( AS id1:IDENTIFIER id2:IDENTIFIER ) 
		;
	
	
tactic
		:				 #( TACTIC id:IDENTIFIER  beh.beginTactic(#id);  params vars condition action effect ) 
		;
	
	
params
		:				 #( PARAM_LIST ( param )* ) 
		;
	
	
vars
		:				 #( DECL_LIST ( var )* ) 
		;
	
	
condition
		:				 #( cn:CONDITION  beh.beginConditionBlock(#cn);  ( expr )* ) 
		;
	
	
action
		:				 #( ac:ACTION  beh.beginActionBlock(#ac);  ( statement )* ) 
		;
	
	
effect
		:				 #( ef:EFFECT  beh.beginEffectBlock(#ef);  ( expr )* ) 
		;
	
	
var
		:				 #( v:VAR_DEF  beh.beginStatement(#v);  t:TYPE id:IDENTIFIER ( #( ASSIGN expr ) | ) ) 
		;
	
	
expr
		:	(					 #( EXPR expr ) 
			|	quanExpr 
			|	setExpr 
			|	assignExpr 
			|	logicalExpr 
			|	relationalExpr 
			|	arithmeticExpr 
			|	unaryExpr 
			|	idExpr 
			) 
			
		;
	
	
statement
		:	(					 #( sl:STMT_LIST  beh.beginStatement(#sl);  ( statement )* ( failHandler | ) ) 
			|	var 
			|					 #( x:EXPR  beh.beginStatement(#x);  expr  beh.endStatement();  ) 
			|	ifStmt 
			|	whileStmt 
			|	forStmt 
			|	EMPTY_STMT 
			) 
		;
	
	
strategy
		:				 #( STRATEGY id:IDENTIFIER  beh.beginStrategy(#id);  params ( strategyNode | ) ) 
		;
	
	
strategyNode
		:				 #( l:IDENTIFIER strategyCond tacticRef ( strategyBranch | DONE | ) ) 
		;
	
	
strategyCond
		:				 #( STRATEGY_COND ( #( HASH ( #( id1:IDENTIFIER ( id2:IDENTIFIER | ) ) | i:INTEGER_LIT ) ) | ) ( expr | SUCCESS | DEFAULT ) ( #( AT expr ) | ) ) 
		;
	
	
tacticRef
		:				 #( t1:IDENTIFIER exprs ( strategyExit | ) ) 
		|	DONE 
		|	NULLTACTIC 
		|				 #( DO ( v:IDENTIFIER | i:INTEGER_LIT ) t2:IDENTIFIER ) 
		;
	
	
strategyBranch
		:				 #( STRATEGY_BRANCH ( strategyNode )+ ) 
		;
	
	
exprs
		:				 #( EXPR_LIST ( expr )* ) 
		;
	
	
strategyExit
		:				 #( STRATEGY_EXITCOND expr #( AT expr ) ) 
		;
	
	
failHandler
		:				 #( f:FAIL  beh.beginStatement(#f);  ( expr statement )* ) 
		;
	
	
ifStmt
		:				 #( si:IF  beh.beginStatement(#si);  expr statement statement ) 
		;
	
	
whileStmt
		:				 #( w:WHILE  beh.beginStatement(#w);  expr statement ) 
		;
	
	
forStmt
		:				 #( f:FOR  beh.beginStatement(#f);  ( forInit  beh.markForCondition();  forCond forIter statement | forEach  beh.markForEach();  statement ) ) 
		;
	
	
forInit
		:				 #( FOR_INIT ( ( var )+ | exprs | ) ) 
		;
	
	
forCond
		:				 #( FOR_COND ( expr | ) ) 
		;
	
	
forIter
		:				 #( FOR_ITER ( exprs | ) ) 
		;
	
	
forEach
		:				 #( FOR_EACH param expr ) 
		;
	
	
param
		:				 #( PARAM t:TYPE id:IDENTIFIER ) 
		;
	
	
quanExpr
		:				 #( fa:FORALL  beh.beginQuantifiedExpression();  params expr  beh.doQuantifiedExpression();  expr ) 
		|				 #( e:EXISTS  beh.beginQuantifiedExpression();  params expr  beh.doQuantifiedExpression();  expr ) 
		|				 #( eu:EXISTS_UNIQUE  beh.beginQuantifiedExpression();  params expr  beh.doQuantifiedExpression();  expr ) 
		|				 #( s:SELECT  beh.beginQuantifiedExpression();  params expr  beh.doQuantifiedExpression();  expr ) 
		;
	
	
setExpr
		:				 #( s:SET ( expr ( expr )* | ) ) 
		;
	
	
assignExpr
		:				 #( aa:ASSIGN beh.lOp(); expr beh.rOp(); expr ) 
		;
	
	
logicalExpr
		:				 #( imp:IMPLIES beh.lOp(); expr beh.rOp(); expr ) 
		|				 #( iff:IFF beh.lOp(); expr beh.rOp(); expr ) 
		|				 #( lor:LOGICAL_OR beh.lOp(); expr beh.rOp(); expr ) 
		|				 #( lnd:LOGICAL_AND beh.lOp(); expr beh.rOp(); expr ) 
		;
	
	
relationalExpr
		:				 #( ne:NE beh.lOp(); expr beh.rOp(); expr ) 
		|				 #( eq:EQ beh.lOp(); expr beh.rOp(); expr ) 
		|				 #( lt:LT beh.lOp(); expr beh.rOp(); expr ) 
		|				 #( le:LE beh.lOp(); expr beh.rOp(); expr ) 
		|				 #( ge:GE beh.lOp(); expr beh.rOp(); expr ) 
		|				 #( gt:GT beh.lOp(); expr beh.rOp(); expr ) 
		;
	
	
arithmeticExpr
		:				 #( p:PLUS beh.lOp(); expr beh.rOp(); expr ) 
		|				 #( m:MINUS beh.lOp(); expr beh.rOp(); expr ) 
		|				 #( t:STAR beh.lOp(); expr beh.rOp(); expr ) 
		|				 #( d:SLASH beh.lOp(); expr beh.rOp(); expr ) 
		|				 #( r:MOD beh.lOp(); expr beh.rOp(); expr ) 
		;
	
	
unaryExpr
		:				 #( ic:INCR beh.lOp(); expr ) 
		|				 #( dc:DECR beh.lOp(); expr ) 
		|				 #( um:UNARY_MINUS beh.lOp(); expr ) 
		|				 #( ln:LOGICAL_NOT beh.lOp(); expr ) 
		;
	
	
idExpr
		:	IDENTIFIER 
		|	methodCall 
		|	INTEGER_LIT 
		|	FLOAT_LIT 
		|	STRING_LIT 
		|	CHAR_LIT 
		|	TRUE 
		|	FALSE 
		|	NULL 
		;
	
	
methodCall
		:				 #( mc:METHOD_CALL id:IDENTIFIER ( exprs | ) ) 
		;