codegen.g

antlr最新版本V3源代码

				code.setAttribute("initAction", initAction);
			}
        }
		templates = saveGroup;
        }
    ;

modifier
	:	"protected"
	|	"public"
	|	"private"
	|	"fragment"
	;

ruleScopeSpec
 	:	#( "scope" (ACTION)? ( ID )* )
 	;

block[String blockTemplateName, DFA dfa]
     returns [StringTemplate code=null]
{
    StringTemplate decision = null;
    if ( dfa!=null ) {
        code = templates.getInstanceOf(blockTemplateName);
        decision = generator.genLookaheadDecision(recognizerST,dfa);
        code.setAttribute("decision", decision);
        code.setAttribute("decisionNumber", dfa.getDecisionNumber());
		code.setAttribute("maxK",dfa.getMaxLookaheadDepth());
		code.setAttribute("maxAlt",dfa.getNumberOfAlts());
    }
    else {
        code = templates.getInstanceOf(blockTemplateName+"SingleAlt");
    }
    blockNestingLevel++;
    code.setAttribute("blockLevel", blockNestingLevel);
    code.setAttribute("enclosingBlockLevel", blockNestingLevel-1);
    StringTemplate alt = null;
    StringTemplate rew = null;
    StringTemplate sb = null;
    GrammarAST r = null;
    int altNum = 1;
	if ( this.blockNestingLevel==RULE_BLOCK_NESTING_LEVEL ) {
        this.outerAltNum=1;
    }
}
    :   {#block.getSetValue()!=null}? sb=setBlock
        {
            code.setAttribute("alts",sb);
            blockNestingLevel--;
        }

    |   #(  BLOCK
    	    ( OPTIONS )? // ignore
            ( alt=alternative {r=(GrammarAST)_t;} rew=rewrite
              {
              if ( this.blockNestingLevel==RULE_BLOCK_NESTING_LEVEL ) {
              	this.outerAltNum++;
              }
              // add the rewrite code as just another element in the alt :)
    		  if ( rew!=null ) {
    		  	alt.setAttribute("elements.{el,line,pos}",
    		  		rew, Utils.integer(r.getLine()), Utils.integer(r.getColumn()));
    		  }
    		  // add this alt to the list of alts for this block
              code.setAttribute("alts",alt);
              alt.setAttribute("altNum", Utils.integer(altNum));
              alt.setAttribute("outerAlt",
                  Boolean.valueOf(blockNestingLevel==RULE_BLOCK_NESTING_LEVEL));
              altNum++;
              }
            )+
            EOB
         )
    	{blockNestingLevel--;}
    ;

setBlock returns [StringTemplate code=null]
{
if ( blockNestingLevel==RULE_BLOCK_NESTING_LEVEL && grammar.buildAST() ) {
    Rule r = grammar.getRule(currentRuleName);
    currentAltHasASTRewrite = r.hasRewrite(outerAltNum);
    if ( currentAltHasASTRewrite ) {
        r.trackTokenReferenceInAlt(#setBlock, outerAltNum);
    }
}
}
    :   s:BLOCK
        {
        StringTemplate setcode =
            getTokenElementST("matchSet", "set", #s, null, null);
        int i = ((TokenWithIndex)#s.getToken()).getIndex();
		setcode.setAttribute("elementIndex", i);
		if ( grammar.type!=Grammar.LEXER ) {
			generator.generateLocalFOLLOW(#s,"set",currentRuleName,i);
        }
        setcode.setAttribute("s",
            generator.genSetExpr(templates,#s.getSetValue(),1,false));
        StringTemplate altcode=templates.getInstanceOf("alt");
		altcode.setAttribute("elements.{el,line,pos}",
						     setcode,
                             Utils.integer(#s.getLine()),
                             Utils.integer(#s.getColumn())
                            );
        altcode.setAttribute("altNum", Utils.integer(1));
        altcode.setAttribute("outerAlt",
           Boolean.valueOf(blockNestingLevel==RULE_BLOCK_NESTING_LEVEL));
        if ( !currentAltHasASTRewrite && grammar.buildAST() ) {
            altcode.setAttribute("autoAST", Boolean.valueOf(true));
        }
        code = altcode;
        }
    ;

exceptionGroup[StringTemplate ruleST]
	:	( exceptionHandler[ruleST] )+ (finallyClause[ruleST])?
	|   finallyClause[ruleST]
    ;

exceptionHandler[StringTemplate ruleST]
    :    #("catch" ARG_ACTION ACTION)
    	{
    	List chunks = generator.translateAction(currentRuleName,#ACTION);
    	ruleST.setAttribute("exceptions.{decl,action}",#ARG_ACTION.getText(),chunks);
    	}
    ;

finallyClause[StringTemplate ruleST]
    :    #("finally" ACTION)
    	{
    	List chunks = generator.translateAction(currentRuleName,#ACTION);
    	ruleST.setAttribute("finally",chunks);
    	}
    ;

alternative returns [StringTemplate code=templates.getInstanceOf("alt")]
{
/*
// TODO: can we use Rule.altsWithRewrites???
if ( blockNestingLevel==RULE_BLOCK_NESTING_LEVEL ) {
	GrammarAST aRewriteNode = #alternative.findFirstType(REWRITE);
	if ( grammar.buildAST() &&
		 (aRewriteNode!=null||
		 (#alternative.getNextSibling()!=null &&
		  #alternative.getNextSibling().getType()==REWRITE)) )
	{
		currentAltHasASTRewrite = true;
	}
	else {
		currentAltHasASTRewrite = false;
	}
}
*/
if ( blockNestingLevel==RULE_BLOCK_NESTING_LEVEL && grammar.buildAST() ) {
    Rule r = grammar.getRule(currentRuleName);
    currentAltHasASTRewrite = r.hasRewrite(outerAltNum);
}
String description = grammar.grammarTreeToString(#alternative, false);
description = generator.target.getTargetStringLiteralFromString(description);
code.setAttribute("description", description);
if ( !currentAltHasASTRewrite && grammar.buildAST() ) {
	code.setAttribute("autoAST", Boolean.valueOf(true));
}
StringTemplate e;
}
    :   #(	a:ALT
    		(	{GrammarAST elAST=(GrammarAST)_t;}
    			e=element[null,null]
    			{
    			if ( e!=null ) {
					code.setAttribute("elements.{el,line,pos}",
									  e,
									  Utils.integer(elAST.getLine()),
									  Utils.integer(elAST.getColumn())
									 );
    			}
    			}
    		)+
    		EOA
    	 )
    ;

element[GrammarAST label, GrammarAST astSuffix] returns [StringTemplate code=null]
{
    IntSet elements=null;
    GrammarAST ast = null;
}
    :   #(ROOT code=element[label,#ROOT])

    |   #(BANG code=element[label,#BANG])

    |   #( n:NOT code=notElement[#n, label, astSuffix] )

    |	#( ASSIGN alabel:ID code=element[#alabel,astSuffix] )

    |	#( PLUS_ASSIGN label2:ID code=element[#label2,astSuffix] )

    |   #(CHAR_RANGE a:CHAR_LITERAL b:CHAR_LITERAL)
        {code = templates.getInstanceOf("charRangeRef");
		 String low =
		 	generator.target.getTargetCharLiteralFromANTLRCharLiteral(generator,a.getText());
		 String high =
		 	generator.target.getTargetCharLiteralFromANTLRCharLiteral(generator,b.getText());
         code.setAttribute("a", low);
         code.setAttribute("b", high);
         if ( label!=null ) {
             code.setAttribute("label", label.getText());
         }
        }

    |   {#element.getSetValue()==null}? code=ebnf

    |   code=atom[label, astSuffix]

    |   code=tree

    |   code=element_action

    |   (sp:SEMPRED|gsp:GATED_SEMPRED {#sp=#gsp;})
        {
        code = templates.getInstanceOf("validateSemanticPredicate");
        code.setAttribute("pred", generator.translateAction(currentRuleName,#sp));
		String description =
			generator.target.getTargetStringLiteralFromString(#sp.getText());
		code.setAttribute("description", description);
        }

    |	SYN_SEMPRED // used only in lookahead; don't generate validating pred

    |	BACKTRACK_SEMPRED

    |   EPSILON
    ;

element_action returns [StringTemplate code=null]
    :   act:ACTION
        {
        code = templates.getInstanceOf("execAction");
        code.setAttribute("action", generator.translateAction(currentRuleName,#act));
        }
    ;

notElement[GrammarAST n, GrammarAST label, GrammarAST astSuffix]
returns [StringTemplate code=null]
{
    IntSet elements=null;
    String labelText = null;
    if ( label!=null ) {
        labelText = label.getText();
    }
}
    :   (assign_c:CHAR_LITERAL
        {
        int ttype=0;
        if ( grammar.type==Grammar.LEXER ) {
            ttype = Grammar.getCharValueFromGrammarCharLiteral(assign_c.getText());
        }
        else {
            ttype = grammar.getTokenType(assign_c.getText());
        }
        elements = grammar.complement(ttype);
        }
    |   assign_s:STRING_LITERAL
        {
        int ttype=0;
        if ( grammar.type==Grammar.LEXER ) {
            // TODO: error!
        }
        else {
            ttype = grammar.getTokenType(assign_s.getText());
        }
        elements = grammar.complement(ttype);
        }
    |   assign_t:TOKEN_REF
        {
        int ttype = grammar.getTokenType(assign_t.getText());
        elements = grammar.complement(ttype);
        }
    |   assign_st:BLOCK
        {
        elements = assign_st.getSetValue();
        elements = grammar.complement(elements);
        }
        )
        {
        code = getTokenElementST("matchSet",
                                 "set",
                                 (GrammarAST)n.getFirstChild(),
                                 astSuffix,
                                 labelText);
        code.setAttribute("s",generator.genSetExpr(templates,elements,1,false));
        int i = ((TokenWithIndex)n.getToken()).getIndex();
        code.setAttribute("elementIndex", i);
        if ( grammar.type!=Grammar.LEXER ) {
            generator.generateLocalFOLLOW(n,"set",currentRuleName,i);
        }
        }
    ;

ebnf returns [StringTemplate code=null]
{
    DFA dfa=null;
    GrammarAST b = (GrammarAST)#ebnf.getFirstChild();
    GrammarAST eob = (GrammarAST)#b.getLastChild(); // loops will use EOB DFA
}
    :   (	{dfa = #ebnf.getLookaheadDFA();}
			code=block["block", dfa]
		|   {dfa = #ebnf.getLookaheadDFA();}
			#( OPTIONAL code=block["optionalBlock", dfa] )
		|   {dfa = #eob.getLookaheadDFA();}
			#( CLOSURE code=block["closureBlock", dfa] )
		|   {dfa = #eob.getLookaheadDFA();}
			#( POSITIVE_CLOSURE code=block["positiveClosureBlock", dfa] )
		)
		{
		String description = grammar.grammarTreeToString(#ebnf, false);
		description = generator.target.getTargetStringLiteralFromString(description);
    	code.setAttribute("description", description);
    	}
    ;

tree returns [StringTemplate code=templates.getInstanceOf("tree")]
{
StringTemplate el=null, act=null;
GrammarAST elAST=null, actAST=null;
NFAState afterDOWN = (NFAState)tree_AST_in.NFATreeDownState.transition(0).target;
LookaheadSet s = grammar.LOOK(afterDOWN);
if ( s.member(Label.UP) ) {
	// nullable child list if we can see the UP as the next token
	// we need an "if ( input.LA(1)==Token.DOWN )" gate around
	// the child list.
	code.setAttribute("nullableChildList", "true");
}
}
    :   #( TREE_BEGIN {elAST=(GrammarAST)_t;}
    	   el=element[null,null]
           {
           code.setAttribute("root.{el,line,pos}",
							  el,
							  Utils.integer(elAST.getLine()),
							  Utils.integer(elAST.getColumn())
							  );
           }
           // push all the immediately-following actions out before children
           // so actions aren't guarded by the "if (input.LA(1)==Token.DOWN)"
           // guard in generated code.
           (    options {greedy=true;}:
                {actAST=(GrammarAST)_t;}
                act=element_action
                {
                code.setAttribute("actionsAfterRoot.{el,line,pos}",
                                  act,
                                  Utils.integer(actAST.getLine()),
                                  Utils.integer(actAST.getColumn())
                );
                }
           )*
           ( {elAST=(GrammarAST)_t;}
    		 el=element[null,null]
           	 {
			 code.setAttribute("children.{el,line,pos}",
							  el,
							  Utils.integer(elAST.getLine()),
							  Utils.integer(elAST.getColumn())
							  );
			 }
           )*
         )
    ;

atom[GrammarAST label, GrammarAST astSuffix] 
    returns [StringTemplate code=null]
{
String labelText=null;
if ( label!=null ) {
    labelText = label.getText();
}
}
    :   #( r:RULE_REF (rarg:ARG_ACTION)? )
        {
        grammar.checkRuleReference(#r, #rarg, currentRuleName);
        Rule rdef = grammar.getRule(#r.getText());
        // don't insert label=r() if $label.attr not used, no ret value, ...
        if ( !rdef.getHasReturnValue() ) {
            labelText = null;
        }
        code = getRuleElementST("ruleRef", #r.getText(), #r, astSuffix, labelText);
		code.setAttribute("rule", r.getText());

		if ( #rarg!=null ) {
			List args = generator.translateAction(currentRuleName,#rarg);
			code.setAttribute("args", args);
		}
        int i = ((TokenWithIndex)r.getToken()).getIndex();
		code.setAttribute("elementIndex", i);
		generator.generateLocalFOLLOW(#r,#r.getText(),currentRuleName,i);
		#r.code = code;
        }

    |   #( t:TOKEN_REF (targ:ARG_ACTION)? )
        {
           grammar.checkRuleReference(#t, #targ, currentRuleName);
		   if ( grammar.type==Grammar.LEXER ) {
				if ( grammar.getTokenType(t.getText())==Label.EOF ) {
					code = templates.getInstanceOf("lexerMatchEOF");
				}
			    else {
					code = templates.getInstanceOf("lexerRuleRef");
                    if ( isListLabel(labelText) ) {
                        code = templates.getInstanceOf("lexerRuleRefAndListLabel");
                    }
					code.setAttribute("rule", t.getText());
					if ( #targ!=null ) {
						List args = generator.translateAction(currentRuleName,#targ);
						code.setAttribute("args", args);
					}
				}
                int i = ((TokenWithIndex)#t.getToken()).getIndex();
			    code.setAttribute("elementIndex", i);
			    if ( label!=null ) code.setAttribute("label", labelText);
		   }
		   else {
				code = getTokenElementST("tokenRef", #t.getText(), #t, astSuffix, labelText);
				String tokenLabel =
				   generator.getTokenTypeAsTargetLabel(grammar.getTokenType(t.getText()));
				code.setAttribute("token",tokenLabel);
                int i = ((TokenWithIndex)#t.getToken()).getIndex();
			    code.setAttribute("elementIndex", i);
			    generator.generateLocalFOLLOW(#t,tokenLabel,currentRuleName,i);
		   }
		   #t.code = code;
		}

    |   c:CHAR_LITERAL
        {