org.antlr.codegen.templates.CSharp2.CSharp2.stg Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of antlr Show documentation
The ANTLR 3 tool.
There is a newer version: 3.5.3
/*
 * [The "BSD license"]
 * Copyright (c) 2007-2008 Johannes Luber
 * Copyright (c) 2005-2007 Kunle Odutola
 * Copyright (c) 2011 Sam Harwell
 * Copyright (c) 2011 Terence Parr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

csharpVisibilityMap ::= [
	"private":"private",
	"protected":"protected",
	"public":"public",
	"fragment":"private",
	default:"private"
]

/** The overall file structure of a recognizer; stores methods for rules
 *  and cyclic DFAs plus support code.
 */
outputFile(	LEXER,PARSER,TREE_PARSER, actionScope, actions,
			docComment, recognizer,
			name, tokens, tokenNames, rules, cyclicDFAs,
			bitsets, buildTemplate, buildAST, rewriteMode, profile,
			backtracking, synpreds, memoize, numRules,
			fileName, ANTLRVersion, generatedTimestamp, trace,
			scopes, superClass, literals) ::=
<<
//------------------------------------------------------------------------------
// \
//     This code was generated by a tool.
//     ANTLR Version: 
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// \
//------------------------------------------------------------------------------

// $ANTLR   


#define ANTLR_TRACE

<@debugPreprocessor()>
// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 168, 219
// Unreachable code detected.
#pragma warning disable 162
// Missing XML comment for publicly visible type or member 'Type_or_Member'
#pragma warning disable 1591



<@imports>
using System.Collections.Generic;
using Antlr.Runtime;
using Antlr.Runtime.Misc;

using Antlr.Runtime.Tree;
using RewriteRuleITokenStream = Antlr.Runtime.Tree.RewriteRuleTokenStream;

using ConditionalAttribute = System.Diagnostics.ConditionalAttribute;
<@end>

namespace 
{





} // namespace 

>>

lexerInputStreamType() ::= <<

>>

lexer(grammar, name, tokens, scopes, rules, numRules, filterMode, labelType="CommonToken",
      superClass={Antlr.Runtime.Lexer}) ::= <<
[System.CodeDom.Compiler.GeneratedCode("ANTLR", "")]
[System.CLSCompliant(false)]
 partial class  : <@superClassName><@end>
{
	=;}; separator="\n">
	}>
	

    // delegates
     ;}; separator="\n">
    // delegators
     ;}; separator="\n">
     gParent;}>

	 ()
	{
		OnCreated();
	}

	 ( input }> )
		: this(input, new RecognizerSharedState()}>)
	{
	}

	 ( input, RecognizerSharedState state }>)
		: base(input, state)
	{


		state.ruleMemo = new System.Collections.Generic.Dictionary\[+1];<\n>


		 = new (input, this.state}>, this);}; separator="\n">
		 = ;}; separator="\n">
		;}>

		OnCreated();
	}
	public override string GrammarFileName { get { return ""; } }

	private static readonly bool[] decisionCanBacktrack = new bool[0];


	public override  CharStream
	{
		get
		{
			return base.CharStream;
		}
		set
		{
			base.CharStream = value;
			 = new (input, state}>, this);}; separator="\n">
			 = ;}; separator="\n">
			;}>
		}
	}


	public override void SetState(RecognizerSharedState state)
	{
		base.SetState(state);
		.SetState(state);}; separator="\n">
	}




	


	[Conditional("ANTLR_TRACE")]
	protected virtual void OnCreated() {}
	[Conditional("ANTLR_TRACE")]
	protected virtual void EnterRule(string ruleName, int ruleIndex) {}
	[Conditional("ANTLR_TRACE")]
	protected virtual void LeaveRule(string ruleName, int ruleIndex) {}

    

	

	#region DFA
	 dfa;}; separator="\n">

	protected override void InitDFAs()
	{
		base.InitDFAs();
		 = new DFA(this, SpecialStateTransition);}; separator="\n">
	}

	 
	#endregion

}
>>

/** A override of Lexer.nextToken() that backtracks over mTokens() looking
 *  for matches.  No error can be generated upon error; just rewind, consume
 *  a token and then try again.  backtracking needs to be set as well.
 *  Make rule memoization happen only at levels above 1 as we start mTokens
 *  at backtracking==1.
 */
filteringNextToken() ::= <<
public override IToken NextToken()
{
	while (true)
	{
		if (input.LA(1) == CharStreamConstants.EndOfFile)
		{
			IToken eof = new CommonToken((ICharStream)input, CharStreamConstants.EndOfFile, TokenChannels.Default, input.Index, input.Index);
			eof.Line = Line;
			eof.CharPositionInLine = CharPositionInLine;
			return eof;
		}
		state.token = null;
		state.channel = TokenChannels.Default;
		state.tokenStartCharIndex = input.Index;
		state.tokenStartCharPositionInLine = input.CharPositionInLine;
		state.tokenStartLine = input.Line;
		state.text = null;
		try
		{
			int m = input.Mark();
			state.backtracking=1;
			state.failed=false;
			mTokens();
			state.backtracking=0;
			
			if (state.failed)
			{
				input.Rewind(m);
				input.Consume();
			}
			else
			{
				Emit();
				return state.token;
			}
		}
		catch (RecognitionException re)
		{
			// shouldn't happen in backtracking mode, but...
			ReportError(re);
			Recover(re);
		}
	}
}

public override void Memoize(IIntStream input, int ruleIndex, int ruleStartIndex)
{
	if (state.backtracking > 1)
		base.Memoize(input, ruleIndex, ruleStartIndex);
}

public override bool AlreadyParsedRule(IIntStream input, int ruleIndex)
{
	if (state.backtracking > 1)
		return base.AlreadyParsedRule(input, ruleIndex);

	return false;
}
>>

actionGate() ::= "state.backtracking == 0"

filteringActionGate() ::= "state.backtracking == 1"

/** How to generate a parser */
genericParser(grammar, name, scopes, tokens, tokenNames, rules, numRules,
              bitsets, inputStreamType, superClass,
              labelType, members, rewriteElementType,
              filterMode, ASTLabelType="object") ::= <<
[System.CodeDom.Compiler.GeneratedCode("ANTLR", "")]
[System.CLSCompliant(false)]
 partial class  : <@superClassName><@end>
{

	internal static readonly string[] tokenNames = new string[] {
		"\", "\", "\", "\", 
	};

	=;}; separator="\n">


	// delegates
	 ;}; separator="\n">


	// delegators
	 ;}; separator="\n">
	 gParent;}>



	public override void SetState(RecognizerSharedState state)
	{
		base.SetState(state);
		.SetState(state);}; separator="\n">
	}


	public override void SetTreeNodeStream(ITreeNodeStream input)
	{
		base.SetTreeNodeStream(input);
		.SetTreeNodeStream(input);}; separator="\n">
	}



	}>
	<@members()>

	public override string[] TokenNames { get { return .tokenNames; } }
	public override string GrammarFileName { get { return ""; } }

	

	[Conditional("ANTLR_TRACE")]
	protected virtual void OnCreated() {}
	[Conditional("ANTLR_TRACE")]
	protected virtual void EnterRule(string ruleName, int ruleIndex) {}
	[Conditional("ANTLR_TRACE")]
	protected virtual void LeaveRule(string ruleName, int ruleIndex) {}

	#region Rules
	
	#endregion Rules



	#region Delegated rules
  () { return .(}; separator=", ">); \}}; separator="\n">
	#endregion Delegated rules


	


	#region DFA
	 dfa;}; separator="\n">

	protected override void InitDFAs()
	{
		base.InitDFAs();
		 = new DFA( this, SpecialStateTransition );}; separator="\n">
	}

	
	#endregion DFA



	#region Follow sets
	private static class Follow
	{
		_in_}, words64=it.bits)>}; separator="\n">
	}
	#endregion Follow sets

}
>>

@genericParser.members() ::= <<
#if ANTLR_DEBUG
private static readonly bool[] decisionCanBacktrack =
	new bool[]
	{
		false, // invalid decision
		}; wrap="\n", separator=", ">
	};
#else
private static readonly bool[] decisionCanBacktrack = new bool[0];
#endif

 ( input }>)
	: this(input, new RecognizerSharedState()}>)
{
}
 ( input, RecognizerSharedState state }>)
	: base(input, state)
{

	 = new (input, state}>, this);}; separator="\n">


	 = .;}; separator="\n">


	;}>

	
	OnCreated();
}
>>

// imported grammars are 'public' (can't be internal because their return scope classes must be accessible)
parserModifier(grammar, actions) ::= <<
public
>>

parserCtorBody() ::= <<


this.state.ruleMemo = new System.Collections.Generic.Dictionary\[+1];<\n>


 = ;}; separator="\n">
>>

parser(grammar, name, scopes, tokens, tokenNames, rules, numRules, bitsets,
       ASTLabelType="object", superClass={Antlr.Runtime.Parser}, labelType="IToken",
       members={}) ::= <<

>>

/** How to generate a tree parser; same as parser except the input
 *  stream is a different type.
 */
treeParser(grammar, name, scopes, tokens, tokenNames, globalAction, rules,
           numRules, bitsets, filterMode, labelType={}, ASTLabelType="object",
           superClass={Antlr.Runtime.Tree.TreeRewriterTreeFilterTreeParser},
           members={}) ::= <<

>>

/** A simpler version of a rule template that is specific to the imaginary
 *  rules created for syntactic predicates.  As they never have return values
 *  nor parameters etc..., just give simplest possible method.  Don't do
 *  any of the normal memoization stuff in here either; it's a waste.
 *  As predicates cannot be inlined into the invoking rule, they need to
 *  be in a rule by themselves.
 */
synpredRule(ruleName, ruleDescriptor, block, description, nakedBlock) ::=
<<
[Conditional("ANTLR_TRACE")]
protected virtual void EnterRule__fragment() {}
[Conditional("ANTLR_TRACE")]
protected virtual void LeaveRule__fragment() {}

// $ANTLR start 
 void _fragment()
{
	
	EnterRule__fragment();
	EnterRule("_fragment", );
	TraceIn("_fragment", );
	try
	{
		
	}
	finally
	{
		TraceOut("_fragment", );
		LeaveRule("_fragment", );
		LeaveRule__fragment();
	}
}
// $ANTLR end 
>>

insertLexerSynpreds(synpreds) ::= <<

>>

insertSynpreds(synpreds) ::= <<

#region Synpreds
private bool EvaluatePredicate(System.Action fragment)
{
	bool success = false;
	state.backtracking++;
	<@start()>
	try { DebugBeginBacktrack(state.backtracking);
	int start = input.Mark();
	try
	{
		fragment();
	}
	catch ( RecognitionException re )
	{
		System.Console.Error.WriteLine("impossible: "+re);
	}
	success = !state.failed;
	input.Rewind(start);
	} finally { DebugEndBacktrack(state.backtracking, success); }
	<@stop()>
	state.backtracking--;
	state.failed=false;
	return success;
}
#endregion Synpreds

>>

ruleMemoization(name) ::= <<

if (state.backtracking > 0 && AlreadyParsedRule(input, )) {  }

>>

/** How to test for failure and return from rule */
checkRuleBacktrackFailure() ::= <<
if (state.failed) 
>>

/** This rule has failed, exit indicating failure during backtrack */
ruleBacktrackFailure() ::= <<
if (state.backtracking>0) {state.failed=true; }
>>

ruleWrapperMap ::= [
	"bottomup":{},
	"topdown":{},
	default:""
]

ruleWrapperBottomup() ::= <<

protected override IAstRuleReturnScopevoid Bottomup() { return bottomup(); }

>>

ruleWrapperTopdown() ::= <<

protected override IAstRuleReturnScopevoid Topdown() { return topdown(); }

>>

/** How to generate code for a rule.  This includes any return type
 *  data aggregates required for multiple return values.
 */
rule(ruleName,ruleDescriptor,block,emptyRule,description,exceptions,finally,memoize) ::= <<



[Conditional("ANTLR_TRACE")]
protected virtual void EnterRule_() {}
[Conditional("ANTLR_TRACE")]
protected virtual void LeaveRule_() {}

// $ANTLR start ""
// :
[GrammarRule("")]
  ()
{
	EnterRule_();
	EnterRule("", );
	TraceIn("", );
    
    
    
    
	try { DebugEnterRule(GrammarFileName, "");
	DebugLocation(, );
	<@preamble()>
	try
	{
		
		
		
		<(ruleDescriptor.actions.after):execAction()>
	}

	<\n>}>



	

	catch (RecognitionException re)
	{
		ReportError(re);
		Recover(input,re);
	<@setErrorReturnValue()>
	}



	finally
	{
		TraceOut("", );
		LeaveRule("", );
		LeaveRule_();
        
        
        
    }
 	DebugLocation(, );
	} finally { DebugExitRule(GrammarFileName, ""); }
	<@postamble()>
	<\n>
}
// $ANTLR end ""
>>

// imported grammars need to have internal rules
ruleModifier(grammar,ruleDescriptor) ::= <<
internal
>>

// imported grammars need to have public return scopes
returnScopeModifier(grammar,ruleDescriptor) ::= <<
public
>>

catch(decl,action) ::= <<
catch ()
{
	
}
>>

ruleDeclarations() ::= <<

 retval = new ();
retval.Start = ()input.LT(1);

  = ;
}>


int _StartIndex = input.Index;

>>

ruleScopeSetUp() ::= <<
_stack.Push(new _scope());_scopeInit(_stack.Peek());}; separator="\n">
_stack.Push(new _scope());_scopeInit(_stack.Peek());}; separator="\n">
>>

ruleScopeCleanUp() ::= <<
_scopeAfter(_stack.Peek());_stack.Pop();}; separator="\n">
_scopeAfter(_stack.Peek());_stack.Pop();}; separator="\n">
>>

ruleLabelDefs() ::= <<
<[ruleDescriptor.tokenLabels,ruleDescriptor.tokenListLabels,ruleDescriptor.wildcardTreeLabels,ruleDescriptor.wildcardTreeListLabels]
    :{it|  = default();}; separator="\n"
>
\> list_ = null;}; separator="\n"
>
<[ruleDescriptor.ruleListLabels,ruleDescriptor.wildcardTreeListLabels]
    :{it|List\<\> list_ = null;}; separator="\n"
>


>>

lexerRuleLabelDefs() ::= <<
<[ruleDescriptor.tokenLabels,
  ruleDescriptor.tokenListLabels,
  ruleDescriptor.ruleLabels]
    :{it|  = default();}; separator="\n"
>
<[ruleDescriptor.charListLabels,
  ruleDescriptor.charLabels]
	:{it|int  = 0;}; separator="\n"
>
<[ruleDescriptor.tokenListLabels,
  ruleDescriptor.ruleListLabels]
    :{it|List\<\> list_ = null;}; separator="\n"
>
 list_ = null;}; separator="\n"
>
>>

returnFromRule() ::= <%
return



 

 retval



;
%>

ruleCleanUp() ::= <<


retval.Stop = ()input.LT(-1);


>>

memoize() ::= <<


if (state.backtracking > 0) { Memoize(input, , _StartIndex); }


>>

/** How to generate a rule in the lexer; naked blocks are used for
 *  fragment rules.
 */
lexerRule(ruleName,nakedBlock,ruleDescriptor,block,memoize) ::= <<

[Conditional("ANTLR_TRACE")]
protected virtual void EnterRule_() {}
[Conditional("ANTLR_TRACE")]
protected virtual void LeaveRule_() {}

// $ANTLR start ""
[GrammarRule("")]
 void m()
{
	EnterRule_();
	EnterRule("", );
	TraceIn("", );
    
    
		try
		{

		
		
		
		

		int _type = ;
		int _channel = DefaultTokenChannel;
		
		
		
		
		
		state.type = _type;
		state.channel = _channel;
		<(ruleDescriptor.actions.after):execAction()>

	}
	finally
	{
		TraceOut("", );
		LeaveRule("", );
		LeaveRule_();
        
        
    }
}
// $ANTLR end ""
>>

/** How to generate code for the implicitly-defined lexer grammar rule
 *  that chooses between lexer rules.
 */
tokensRule(ruleName,nakedBlock,args,block,ruleDescriptor) ::= <<

public override void mTokens()
{
	<\n>
}
>>

// S U B R U L E S

/** A (...) subrule with multiple alternatives */
block(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
// :
int alt=;

<@predecision()>
try { DebugEnterSubRule();
try { DebugEnterDecision(, decisionCanBacktrack[]);

} finally { DebugExitDecision(); }
<@postdecision()>
<@prebranch()>
switch (alt)
{
}>
}
} finally { DebugExitSubRule(); }
<@postbranch()>
>>

/** A rule block with multiple alternatives */
ruleBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
// :
int alt=;

<@predecision()>
try { DebugEnterDecision(, decisionCanBacktrack[]);

} finally { DebugExitDecision(); }
<@postdecision()>
switch (alt)
{
}>
}
>>

ruleBlockSingleAlt(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,description) ::= <<
// :

<@prealt()>
DebugEnterAlt(1);

<@postalt()>
>>

/** A special case of a (...) subrule with a single alternative */
blockSingleAlt(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,description) ::= <<
// :

<@prealt()>
DebugEnterAlt(1);

<@postalt()>
>>

/** A (..)+ block with 1 or more alternatives */
positiveClosureBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
// :
int cnt=0;

<@preloop()>
try { DebugEnterSubRule();
while (true)
{
	int alt=;
	<@predecision()>
	try { DebugEnterDecision(, decisionCanBacktrack[]);
	
	} finally { DebugExitDecision(); }
	<@postdecision()>
	switch (alt)
	{
	}>
	default:
		if (cnt >= 1)
			goto loop;

		
		EarlyExitException eee = new EarlyExitException( , input );
		DebugRecognitionException(eee);
		<@earlyExitException()>
		throw eee;
	}
	cnt++;
}
loop:
	;

} finally { DebugExitSubRule(); }
<@postloop()>
>>

positiveClosureBlockSingleAlt ::= positiveClosureBlock

/** A (..)* block with 1 or more alternatives */
closureBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
// :

<@preloop()>
try { DebugEnterSubRule();
while (true)
{
	int alt=;
	<@predecision()>
	try { DebugEnterDecision(, decisionCanBacktrack[]);
	
	} finally { DebugExitDecision(); }
	<@postdecision()>
	switch ( alt )
	{
	}>
	default:
		goto loop;
	}
}

loop:
	;

} finally { DebugExitSubRule(); }
<@postloop()>
>>

closureBlockSingleAlt ::= closureBlock

/** Optional blocks (x)? are translated to (x|) by before code generation
 *  so we can just use the normal block template
 */
optionalBlock ::= block

optionalBlockSingleAlt ::= block

/** A case in a switch that jumps to an alternative given the alternative
 *  number.  A DFA predicts the alternative and then a simple switch
 *  does the jump to the code that actually matches that alternative.
 */
altSwitchCase(altNum,alt) ::= <<
case :
	<@prealt()>
	DebugEnterAlt();
	
	break;<\n>
>>

/** An alternative is just a list of elements; at outermost level */
alt(elements,altNum,description,autoAST,outerAlt,treeLevel,rew) ::= <<
// :
{
<@declarations()>


<@cleanup()>
}
>>

/** What to emit when there is no rewrite.  For auto build
 *  mode, does nothing.
 */
noRewrite(rewriteBlockLevel, treeLevel) ::= ""

// E L E M E N T S

/** Dump the elements one per line */
element(it) ::= <%
<@prematch()>
DebugLocation(, );<\n>
<\n>
%>

/** match a token optionally with a label in front */
tokenRef(token,label,elementIndex,terminalOptions={}) ::= <<
=()Match(input,,Follow.__in_); 
>>

/** ids+=ID */
tokenRefAndListLabel(token,label,elementIndex,terminalOptions={}) ::= <<


>>

listLabelElem(label,elem,elemType) ::= <<
if (list_==null) list_=new List\<}>\>();
list_.Add();<\n>
>>

/** match a character */
charRef(char,label) ::= <<

 = input.LA(1);<\n>

Match(); 
>>

/** match a character range */
charRangeRef(a,b,label) ::= <<

 = input.LA(1);<\n>

MatchRange(,); 
>>

/** For now, sets are interval tests and must be tested inline */
matchSet(s,label,elementIndex,postmatchCode="",terminalOptions={}) ::= <<



if ()
{
	input.Consume();
	
	state.errorRecovery=false;state.failed=false;
}
else
{
	
	MismatchedSetException mse = new MismatchedSetException(null,input);
	DebugRecognitionException(mse);
	<@mismatchedSetException()>

	Recover(mse);
	throw mse;

	throw mse;
	);
	!>

}<\n>
>>

matchSetUnchecked(s,label,elementIndex,postmatchCode=false) ::= <%

<\n>

input.Consume();<\n>

<\n>

state.errorRecovery=false;state.failed=false;
%>

matchSetLabel() ::= <%

= input.LA(1);

=()input.LT(1);

%>

matchRuleBlockSet ::= matchSet

matchSetAndListLabel(s,label,elementIndex,postmatchCode) ::= <<


>>

/** Match a string literal */
lexerStringRef(string,label,elementIndex) ::= <%

int Start = CharIndex;<\n>
Match(); <\n>
int StartLine = Line;<\n>
int StartCharPos = CharPositionInLine;<\n>
 = new (input, TokenTypes.Invalid, TokenChannels.Default, Start, CharIndex-1);<\n>
.Line = StartLine;<\n>
.CharPositionInLine = StartCharPos;

Match(); <\n>

%>

wildcard(token,label,elementIndex,terminalOptions={}) ::= <<

=()input.LT(1);<\n>

MatchAny(input); 
>>

wildcardAndListLabel(token,label,elementIndex,terminalOptions={}) ::= <<


>>

/** Match . wildcard in lexer */
wildcardChar(label, elementIndex) ::= <<

 = input.LA(1);<\n>

MatchAny(); 
>>

wildcardCharListLabel(label, elementIndex) ::= <<


>>

/** Match a rule reference by invoking it possibly with arguments
 *  and a return value or values.  The 'rule' argument was the
 *  target rule name, but now is type Rule, whose toString is
 *  same: the rule name.  Now though you can access full rule
 *  descriptor stuff.
 */
ruleRef(rule,label,elementIndex,args,scope) ::= <<
PushFollow(Follow.__in_);
=.();
PopFollow();

>>

/** ids+=r */
ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<

},...)>
>>

/** A lexer rule reference.
 *
 *  The 'rule' argument was the target rule name, but now
 *  is type Rule, whose toString is same: the rule name.
 *  Now though you can access full rule descriptor stuff.
 */
lexerRuleRef(rule,label,args,elementIndex,scope) ::= <%

int Start = CharIndex;<\n>
int StartLine = Line;<\n>
int StartCharPos = CharPositionInLine;<\n>
.m(); <\n>
 = new (input, TokenTypes.Invalid, TokenChannels.Default, Start, CharIndex-1);<\n>
.Line = StartLine;<\n>
.CharPositionInLine = StartCharPos;

.m(); 

%>

/** i+=INT in lexer */
lexerRuleRefAndListLabel(rule,label,args,elementIndex,scope) ::= <<


>>

/** EOF in the lexer */
lexerMatchEOF(label,elementIndex) ::= <%

int Start = CharIndex;<\n>
int StartLine = Line;<\n>
int StartCharPos = CharPositionInLine;<\n>
Match(EOF); <\n>
  = new (input, EOF, TokenChannels.Default, Start, CharIndex-1);<\n>
.Line = StartLine;<\n>
.CharPositionInLine = StartCharPos;

Match(EOF); 

%>

// used for left-recursive rules
recRuleDefArg()                       ::= "int "
recRuleArg()                          ::= "_p"
recRuleAltPredicate(ruleName,opPrec)  ::= " \<= "
recRuleSetResultAction()              ::= "root_0=$_primary.tree;"
recRuleSetReturnAction(src,name)      ::= "$=$.;"

/** match ^(root children) in tree parser */
tree(root, actionsAfterRoot, children, nullableChildList,
     enclosingTreeLevel, treeLevel) ::= <<



if (input.LA(1) == TokenTypes.Down)
{
	Match(input, TokenTypes.Down, null); 
	
	Match(input, TokenTypes.Up, null); 
}

Match(input, TokenTypes.Down, null); 

Match(input, TokenTypes.Up, null); 

>>

/** Every predicate is used as a validating predicate (even when it is
 *  also hoisted into a prediction expression).
 */
validateSemanticPredicate(pred,description) ::= <<
if (!())
{
	
	throw new FailedPredicateException(input, "", "");
}
>>

// F i x e d  D F A  (if-then-else)

dfaState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
int LA_ = input.LA();<\n>


else
{

	alt = ;

	
	NoViableAltException nvae = new NoViableAltException("", , , input, );
	DebugRecognitionException(nvae);
	<@noViableAltException()>
	throw nvae;

}

>>

/** Same as a normal DFA state except that we don't examine lookahead
 *  for the bypass alternative.  It delays error detection but this
 *  is faster, smaller, and more what people expect.  For (X)? people
 *  expect "if ( LA(1)==X ) match(X);" and that's it.
 */
dfaOptionalBlockState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
int LA_ = input.LA();<\n>

>>

/** A DFA state that is actually the loopback decision of a closure
 *  loop.  If end-of-token (EOT) predicts any of the targets then it
 *  should act like a default clause (i.e., no error can be generated).
 *  This is used only in the lexer so that for ('a')* on the end of a rule
 *  anything other than 'a' predicts exiting.
 */
dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
int LA_ = input.LA();<\n>
<\n>


alt = ;

else
{
	alt = ;
}<\n>


>>

/** An accept state indicates a unique alternative has been predicted */
dfaAcceptState(alt) ::= "alt = ;"

/** A simple edge with an expression.  If the expression is satisfied,
 *  enter to the target state.  To handle gated productions, we may
 *  have to evaluate some predicates for this edge.
 */
dfaEdge(labelExpr, targetState, predicates) ::= <<
if (() && ())
{
	
}
>>

// F i x e d  D F A  (switch case)

/** A DFA state where a SWITCH may be generated.  The code generator
 *  decides if this is possible: CodeGenerator.canGenerateSwitch().
 */
dfaStateSwitch(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
switch (input.LA())
{

default:

	alt=;
	break;<\n>

	{
		
		NoViableAltException nvae = new NoViableAltException("", , , input, );
		DebugRecognitionException(nvae);
		<@noViableAltException()>
		throw nvae;
	}

}<\n>
>>

dfaOptionalBlockStateSwitch(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
switch (input.LA())
{

}<\n>
>>

dfaLoopbackStateSwitch(k, edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
switch (input.LA())
{


default:
	alt=;
	break;<\n>

}<\n>
>>

dfaEdgeSwitch(labels, targetState) ::= <<
:}; separator="\n">
	{
	
	}
	break;
>>

// C y c l i c  D F A

/** The code to initiate execution of a cyclic DFA; this is used
 *  in the rule to predict an alt just like the fixed DFA case.
 *  The  attribute is inherited via the parser, lexer, ...
 */
dfaDecision(decisionNumber,description) ::= <<
try
{
	alt = dfa.Predict(input);
}
catch (NoViableAltException nvae)
{
	DebugRecognitionException(nvae);
	throw;
}
>>

/* Dump DFA tables as run-length-encoded Strings of octal values.
 * Can't use hex as compiler translates them before compilation.
 * These strings are split into multiple, concatenated strings.
 * Java puts them back together at compile time thankfully.
 * Java cannot handle large static arrays, so we're stuck with this
 * encode/decode approach.  See analysis and runtime DFA for
 * the encoding methods.
 */
cyclicDFA(dfa) ::= <<
private class DFA : DFA
{
	private const string DFA_eotS =
		"";
	private const string DFA_eofS =
		"";
	private const string DFA_minS =
		"";
	private const string DFA_maxS =
		"";
	private const string DFA_acceptS =
		"";
	private const string DFA_specialS =
		"}>";
	private static readonly string[] DFA_transitionS =
		{
			"}; separator=",\n">
		};

	private static readonly short[] DFA_eot = DFA.UnpackEncodedString(DFA_eotS);
	private static readonly short[] DFA_eof = DFA.UnpackEncodedString(DFA_eofS);
	private static readonly char[] DFA_min = DFA.UnpackEncodedStringToUnsignedChars(DFA_minS);
	private static readonly char[] DFA_max = DFA.UnpackEncodedStringToUnsignedChars(DFA_maxS);
	private static readonly short[] DFA_accept = DFA.UnpackEncodedString(DFA_acceptS);
	private static readonly short[] DFA_special = DFA.UnpackEncodedString(DFA_specialS);
	private static readonly short[][] DFA_transition;

	static DFA()
	{
		int numStates = DFA_transitionS.Length;
		DFA_transition = new short[numStates][];
		for ( int i=0; i \< numStates; i++ )
		{
			DFA_transition[i] = DFA.UnpackEncodedString(DFA_transitionS[i]);
		}
	}

	public DFA( BaseRecognizer recognizer, SpecialStateTransitionHandler specialStateTransition )

		: base(specialStateTransition)

	{
		this.recognizer = recognizer;
		this.decisionNumber = ;
		this.eot = DFA_eot;
		this.eof = DFA_eof;
		this.min = DFA_min;
		this.max = DFA_max;
		this.accept = DFA_accept;
		this.special = DFA_special;
		this.transition = DFA_transition;
	}

	public override string Description { get { return ""; } }

	public override void Error(NoViableAltException nvae)
	{
		DebugRecognitionException(nvae);
	}
}<\n>

private int SpecialStateTransition(DFA dfa, int s, IIntStream _input)
{
	
	IIntStream input = _input;
	
	
	ITokenStream input = (ITokenStream)_input;
	
	
	ITreeNodeStream input = (ITreeNodeStream)_input;
	
	int _s = s;
	s = -1;
	
	int LA_1 = input.LA(1);
	int index_1 = input.Index;
	switch (_s)
	{
	:
	}; separator="\n">

	default:
		break;
	}

	if (s >= 0)
		return s;


	if (state.backtracking > 0) {state.failed=true; return -1;}

	NoViableAltException nvae = new NoViableAltException(dfa.Description, , _s, input);
	dfa.Error(nvae);
	throw nvae;
}

>>

/** A state in a cyclic DFA; it's a special state and part of a big switch on
 *  state.
 */
cyclicDFAState(decisionNumber,stateNumber,edges,needErrorClause,semPredState) ::= <<
{

	
	input.Rewind();

	

	
	input.Seek(index_1);

	break;
}
>>

/** Just like a fixed DFA edge, test the lookahead and indicate what
 *  state to jump to next if successful.
 */
cyclicDFAEdge(labelExpr, targetStateNumber, edgeNumber, predicates) ::= <<
if (() && ()) {s = ;}<\n>
>>

/** An edge pointing at end-of-token; essentially matches any char;
 *  always jump to the target.
 */
eotDFAEdge(targetStateNumber,edgeNumber, predicates) ::= <<
s = ;<\n>
>>


// D F A  E X P R E S S I O N S

andPredicates(left,right) ::= "(&&)"

orPredicates(operands) ::= "()"

notPredicate(pred) ::= "!()"

evalPredicate(pred,description) ::= "()"

evalSynPredicate(pred,description) ::= "EvaluatePredicate(_fragment)"

lookaheadTest(atom,k,atomAsInt) ::= "LA_=="

/** Sometimes a lookahead test cannot assume that LA(k) is in a temp variable
 *  somewhere.  Must ask for the lookahead directly.
 */
isolatedLookaheadTest(atom,k,atomAsInt) ::= "input.LA()=="

lookaheadRangeTest(lower,upper,k,rangeNumber,lowerAsInt,upperAsInt) ::= <%
(LA_ && LA_)
%>

isolatedLookaheadRangeTest(lower,upper,k,rangeNumber,lowerAsInt,upperAsInt) ::= "(input.LA() && input.LA())"

le() ::= "\<="
ge() ::= ">="

setTest(ranges) ::= <<

>>

// A T T R I B U T E S

attributeScope(scope) ::= <<


protected sealed partial class _scope
{
	;}; separator="\n">
}

protected void _scopeInit( _scope scope )
{
	
}

protected virtual void _scopeInit( _scope scope ) {}


protected void _scopeAfter( _scope scope )
{
	
}

protected virtual void _scopeAfter( _scope scope ) {}

protected readonly ListStack\<_scope> _stack = new ListStack\<_scope>();


>>

globalAttributeScope(scope) ::= <<

>>

ruleAttributeScope(scope) ::= <<

>>

returnStructName(it) ::= "_return"

returnType(ruleDescriptor) ::= <%

	.

	

	

	void

%>

/** Generate the C# type associated with a single or multiple return
 *  values.
 */
ruleLabelType(referencedRule) ::= <%

	

	

	void

%>

delegateName(it) ::= <<
g
>>

/** Using a type to init value map, try to init a type; if not in table
 *  must be an object, default value is "null".
 */
initValue(typeName) ::= <<
default()
>>

/** Define a rule label including default value */
ruleLabelDef(label) ::= <%
  = ;
%>

/** Define a return struct for a rule if the code needs to access its
 *  start/stop tokens, tree stuff, attributes, ...  Leave a hole for
 *  subgroups to stick in members.
 */
returnScope(scope) ::= <<

 sealed partial class  : <@ruleReturnInterfaces()>
{
	;}; separator="\n">
	<@ruleReturnMembers()>
}

>>

ruleReturnBaseType() ::= <%
TreeParserRuleReturnScope\<>
%>

@returnScope.ruleReturnMembers() ::= <<
>>

parameterScope(scope) ::= <<
}; separator=", ">
>>

parameterAttributeRef(attr) ::= <<

>>

parameterSetAttributeRef(attr,expr) ::= <<
 =;
>>

scopeAttributeRef(scope,attr,index,negIndex) ::= <%

_stack[_stack.Count -  - 1].


_stack[].

_stack.Peek().


%>

scopeSetAttributeRef(scope,attr,expr,index,negIndex) ::= <%

_stack[_stack.Count -  - 1]. = ;


_stack[]. = ;

_stack.Peek(). = ;


%>

/** $x is either global scope or x is rule with dynamic scope; refers
 *  to stack itself not top of stack.  This is useful for predicates
 *  like {$function.Count>0 && $function::name.Equals("foo")}?
 */
isolatedDynamicScopeRef(scope) ::= "_stack"

/** reference an attribute of rule; might only have single return value */
ruleLabelRef(referencedRule,scope,attr) ::= <%

(!=null?(()).:)



%>

returnAttributeRef(ruleDescriptor,attr) ::= <%

retval.



%>

returnSetAttributeRef(ruleDescriptor,attr,expr) ::= <%

retval. =;

 =;

%>

/** How to translate $tokenLabel */
tokenLabelRef(label) ::= ""

/** ids+=ID {$ids} or e+=expr {$e} */
listLabelRef(label) ::= "list_"


// not sure the next are the right approach

tokenLabelPropertyRef_text(scope,attr) ::= "(!=null?.Text:default(string))"
tokenLabelPropertyRef_type(scope,attr) ::= "(!=null?.Type:0)"
tokenLabelPropertyRef_line(scope,attr) ::= "(!=null?.Line:0)"
tokenLabelPropertyRef_pos(scope,attr) ::= "(!=null?.CharPositionInLine:0)"
tokenLabelPropertyRef_channel(scope,attr) ::= "(!=null?.Channel:0)"
tokenLabelPropertyRef_index(scope,attr) ::= "(!=null?.TokenIndex:0)"
tokenLabelPropertyRef_tree(scope,attr) ::= "_tree"
tokenLabelPropertyRef_int(scope,attr) ::= "(!=null?int.Parse(.Text):0)"

ruleLabelPropertyRef_start(scope,attr) ::= "(!=null?(().Start):default())"
ruleLabelPropertyRef_stop(scope,attr) ::= "(!=null?(().Stop):default())"
ruleLabelPropertyRef_tree(scope,attr) ::= "(!=null?(().Tree):default())"
ruleLabelPropertyRef_text(scope,attr) ::= <%

(!=null?(input.TokenStream.ToString(
  input.TreeAdaptor.GetTokenStartIndex(.Start),
  input.TreeAdaptor.GetTokenStopIndex(.Start))):default(string))

(!=null?input.ToString(.Start,.Stop):default(string))

%>

ruleLabelPropertyRef_st(scope,attr) ::= "(!=null?.Template:null)"

/** Isolated $RULE ref ok in lexer as it's a Token */
lexerRuleLabel(label) ::= ""

lexerRuleLabelPropertyRef_type(scope,attr) ::=
    "(!=null?.Type:0)"

lexerRuleLabelPropertyRef_line(scope,attr) ::=
    "(!=null?.Line:0)"

lexerRuleLabelPropertyRef_pos(scope,attr) ::=
    "(!=null?.CharPositionInLine:-1)"

lexerRuleLabelPropertyRef_channel(scope,attr) ::=
    "(!=null?.Channel:0)"

lexerRuleLabelPropertyRef_index(scope,attr) ::=
    "(!=null?.TokenIndex:0)"

lexerRuleLabelPropertyRef_text(scope,attr) ::=
    "(!=null?.Text:default(string))"

lexerRuleLabelPropertyRef_int(scope,attr) ::=
    "(!=null?int.Parse(.Text):0)"

// Somebody may ref $template or $tree or $stop within a rule:
rulePropertyRef_start(scope,attr) ::= "retval.Start"
rulePropertyRef_stop(scope,attr) ::= "retval.Stop"
rulePropertyRef_tree(scope,attr) ::= "retval.Tree"
rulePropertyRef_text(scope,attr) ::= <%

input.TokenStream.ToString(
  input.TreeAdaptor.GetTokenStartIndex(retval.Start),
  input.TreeAdaptor.GetTokenStopIndex(retval.Start))

input.ToString(retval.Start,input.LT(-1))

%>
rulePropertyRef_st(scope,attr) ::= "retval.Template"

lexerRulePropertyRef_text(scope,attr) ::= "Text"
lexerRulePropertyRef_type(scope,attr) ::= "_type"
lexerRulePropertyRef_line(scope,attr) ::= "state.tokenStartLine"
lexerRulePropertyRef_pos(scope,attr) ::= "state.tokenStartCharPositionInLine"
lexerRulePropertyRef_index(scope,attr) ::= "-1" // undefined token index in lexer
lexerRulePropertyRef_channel(scope,attr) ::= "_channel"
lexerRulePropertyRef_start(scope,attr) ::= "state.tokenStartCharIndex"
lexerRulePropertyRef_stop(scope,attr) ::= "(CharIndex-1)"
lexerRulePropertyRef_int(scope,attr) ::= "int.Parse(.Text)"

// setting $st and $tree is allowed in local rule. everything else
// is flagged as error
ruleSetPropertyRef_tree(scope,attr,expr) ::= "retval.Tree = ;"
ruleSetPropertyRef_st(scope,attr,expr) ::= "retval.Template =;"

/** How to execute an action (only when not backtracking) */
execAction(action) ::= <%

if ()<\n>
{<\n>
<@indentedAction()><\n>
}



%>

@execAction.indentedAction() ::= <<
	
>>

/** How to always execute an action even when backtracking */
execForcedAction(action) ::= ""

// M I S C (properties, etc...)

bitset(name, words64) ::= <<
public static readonly BitSet  = new BitSet(new ulong[]{UL};separator=",">});
>>

codeFileExtension() ::= ".cs"

true_value() ::= "true"
false_value() ::= "false"

isTrue ::= [
	"true" : true,
	default : false
]