codegen.g

ANTLR(ANother Tool for Language Recognition)它是这样的一种工具

			if ( initAction!=null ) {
				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;
    GrammarAST r = null;
    int altNum = 1;
	if ( this.blockNestingLevel==RULE_BLOCK_NESTING_LEVEL ) {this.outerAltNum=1;}
}
    :   #(  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--;}
    ;

exceptionGroup[StringTemplate ruleST]
	:	( exceptionSpec[ruleST] )+  // we only handle one group now
    ;

exceptionSpec[StringTemplate ruleST]
    :   #("exception" ( ARG_ACTION )? ( exceptionHandler[ruleST] )*)
    ;

exceptionHandler[StringTemplate ruleST]
    :    #("catch" ARG_ACTION ACTION)
    	{
    	List chunks = generator.translateAction(currentRuleName,#ACTION);
    	ruleST.setAttribute("exceptions.{decl,action}",#ARG_ACTION.getText(),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;
	}
}
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
    			{
    			if ( e!=null ) {
					code.setAttribute("elements.{el,line,pos}",
									  e,
									  Utils.integer(elAST.getLine()),
									  Utils.integer(elAST.getColumn())
									 );
    			}
    			}
    		)+
    		EOA
    	 )
    ;

element returns [StringTemplate code=null]
{
    IntSet elements=null;
    GrammarAST ast = null;
}
    :   code=atom[null]
    |   #(  n:NOT
            (  #( c:CHAR_LITERAL (ast1:ast_suffix)? )
	           {
	            int ttype=0;
     			if ( grammar.type==Grammar.LEXER ) {
        			ttype = Grammar.getCharValueFromGrammarCharLiteral(c.getText());
     			}
     			else {
        			ttype = grammar.getTokenType(c.getText());
        		}
	            elements = grammar.complement(ttype);
	            ast = #ast1;
	           }
            |  #( s:STRING_LITERAL (ast2:ast_suffix)? )
	           {
	            int ttype=0;
     			if ( grammar.type==Grammar.LEXER ) {
        			// TODO: error!
     			}
     			else {
        			ttype = grammar.getTokenType(s.getText());
        		}
	            elements = grammar.complement(ttype);
	            ast = #ast2;
	           }
            |  #( t:TOKEN_REF (ast3:ast_suffix)? )
	           {
	           int ttype = grammar.getTokenType(t.getText());
	           elements = grammar.complement(ttype);
	           ast = #ast3;
	           }
            |  #( st:SET (setElement)+ (ast4:ast_suffix)? )
               {
               // SETs are not precomplemented by buildnfa.g like
               // simple elements.
               elements = st.getSetValue();
	           ast = #ast4;
               }
            )
            {
            code = getTokenElementST("matchSet",
                        "set",
                        (GrammarAST)#n.getFirstChild(),
                        ast,
                        null);
            code.setAttribute("s", generator.genSetExpr(templates,elements,1,false));
		 	code.setAttribute("elementIndex", ((TokenWithIndex)#n.getToken()).getIndex());
			if ( grammar.type!=Grammar.LEXER ) {
		 		generator.generateLocalFOLLOW(#n,"set",currentRuleName);
        	}
            }
         )

    |   #(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);
        }

    |	#(ASSIGN label:ID (#(assign_n:NOT
    		( assign_c:CHAR_LITERAL (assign_ast1:ast_suffix)?
	           {
	            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);
	            ast = #assign_ast1;
	           }
            |  assign_s:STRING_LITERAL (assign_ast2:ast_suffix)?
	           {
	            int ttype=0;
     			if ( grammar.type==Grammar.LEXER ) {
        			// TODO: error!
     			}
     			else {
        			ttype = grammar.getTokenType(assign_s.getText());
        		}
	            elements = grammar.complement(ttype);
	            ast = #assign_ast2;
	           }
            |  assign_t:TOKEN_REF (assign_ast3:ast_suffix)?
	           {
	           int ttype = grammar.getTokenType(assign_t.getText());
	           elements = grammar.complement(ttype);
	           ast = #assign_ast3;
	           }
            |  assign_st:SET (setElement)+ (assign_ast4:ast_suffix)?
               {
               // SETs are not precomplemented by buildnfa.g like
               // simple elements.
               elements = st.getSetValue();
	           ast = #assign_ast4;
               }
            )
            {
            code = getTokenElementST("matchSet",
                        "set",
                        (GrammarAST)#assign_n.getFirstChild(),
                        ast,
                        #label.getText());
            code.setAttribute("s", generator.genSetExpr(templates,elements,1,false));
		 	code.setAttribute("elementIndex", ((TokenWithIndex)#assign_n.getToken()).getIndex());
			if ( grammar.type!=Grammar.LEXER ) {
		 		generator.generateLocalFOLLOW(#assign_n,"set",currentRuleName);
        	}
            }
            )
    	|code=atom[#label.getText()]))

    |	#(	PLUS_ASSIGN label2:ID code=atom[#label2.getText()]
         )

    |   code=ebnf
    |   code=tree

    |   act:ACTION
        {
        #act.outerAltNum = this.outerAltNum;
        code = templates.getInstanceOf("execAction");
        code.setAttribute("action", generator.translateAction(currentRuleName,#act));
        }

    |   (sp:SEMPRED|gsp:GATED_SEMPRED {#sp=#gsp;})
        {
        code = templates.getInstanceOf("validateSemanticPredicate");
        #sp.outerAltNum = this.outerAltNum;
        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

    |   EPSILON
    ;

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;
GrammarAST elAST=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
           {
           code.setAttribute("root.{el,line,pos}",
							  el,
							  Utils.integer(elAST.getLine()),
							  Utils.integer(elAST.getColumn())
							  );
           }
           ( {elAST=(GrammarAST)_t;}
    		 el=element
           	 {
			 code.setAttribute("children.{el,line,pos}",
							  el,
							  Utils.integer(elAST.getLine()),
							  Utils.integer(elAST.getColumn())
							  );
			 }
           )*
         )
    ;

atom[String label] returns [StringTemplate code=null]
    :   #( r:RULE_REF (rarg:ARG_ACTION)? (as1:ast_suffix)? )
        {
        grammar.checkRuleReference(#r, #rarg, currentRuleName);
        code = getRuleElementST("ruleRef", #r.getText(), #r, #as1, label);
		code.setAttribute("rule", r.getText());

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

    |   #( t:TOKEN_REF (targ:ARG_ACTION)? (as2:ast_suffix)? )
        {
           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");
					code.setAttribute("rule", t.getText());
					if ( #targ!=null ) {
						#targ.outerAltNum = this.outerAltNum;
						List args = generator.translateArgAction(currentRuleName,#targ);
						code.setAttribute("args", args);
					}
				}
			    if ( label!=null ) code.setAttribute("label", label);
		   }
		   else {
				code = getTokenElementST("tokenRef", #t.getText(), #t, #as2, label);
				String tokenLabel =
				   generator.getTokenTypeAsTargetLabel(grammar.getTokenType(t.getText()));
				code.setAttribute("token",tokenLabel);
			    code.setAttribute("elementIndex", ((TokenWithIndex)#t.getToken()).getIndex());
			    generator.generateLocalFOLLOW(#t,tokenLabel,currentRuleName);
		   }
		   #t.code = code;
		}

    |   #( c:CHAR_LITERAL (as3:ast_suffix)? )
        {
		if ( grammar.type==Grammar.LEXER ) {
			code = templates.getInstanceOf("charRef");
			code.setAttribute("char",
			   generator.target.getTargetCharLiteralFromANTLRCharLiteral(generator,c.getText()));
			if ( label!=null ) {
				code.setAttribute("label", label);
			}
		}
		else { // else it's a token type reference
			code = getTokenElementST("tokenRef", "char_literal", #c, #as3, label);
			String tokenLabel = generator.getTokenTypeAsTargetLabel(grammar.getTokenType(c.getText()));
			code.setAttribute("token",tokenLabel);
			code.setAttribute("elementIndex",
							  ((TokenWithIndex)#c.getToken()).getIndex());
			generator.generateLocalFOLLOW(#c,tokenLabel,currentRuleName);
		}
        }

    |   #( s:STRING_LITERAL (as4:ast_suffix)? )
        {
		if ( grammar.type==Grammar.LEXER ) {
			code = templates.getInstanceOf("lexerStringRef");
			code.setAttribute("string",
			   generator.target.getTargetStringLiteralFromANTLRStringLiteral(generator,s.getText()));
			if ( label!=null ) {
				code.setAttribute("label", label);
			}
		}
		else { // else it's a token type reference
			code = getTokenElementST("tokenRef", "string_literal", #s, #as4, label);
			String tokenLabel =
			   generator.getTokenTypeAsTargetLabel(grammar.getTokenType(#s.getText()));
			code.setAttribute("token",tokenLabel);
			code.setAttribute("elementIndex", ((TokenWithIndex)#s.getToken()).getIndex());
			generator.generateLocalFOLLOW(#s,tokenLabel,currentRuleName);