codegen.g

antlr最新版本V3源代码

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

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

    |   w:WILDCARD
        {
		code = getWildcardST(#w,astSuffix,labelText);
		code.setAttribute("elementIndex", ((TokenWithIndex)#w.getToken()).getIndex());
		}

    |	code=set[label,astSuffix]
    ;

ast_suffix
	:	ROOT
	|	BANG
	;


set[GrammarAST label, GrammarAST astSuffix] returns [StringTemplate code=null]
{
String labelText=null;
if ( label!=null ) {
    labelText = label.getText();
}
}
	:   s:BLOCK // only care that it's a BLOCK with setValue!=null
        {
        code = getTokenElementST("matchSet", "set", #s, astSuffix, labelText);
        int i = ((TokenWithIndex)#s.getToken()).getIndex();
		code.setAttribute("elementIndex", i);
		if ( grammar.type!=Grammar.LEXER ) {
			generator.generateLocalFOLLOW(#s,"set",currentRuleName,i);
        }
        code.setAttribute("s", generator.genSetExpr(templates,#s.getSetValue(),1,false));
        }
    ;

setElement
    :   c:CHAR_LITERAL
    |   t:TOKEN_REF
    |   s:STRING_LITERAL
    |	#(CHAR_RANGE c1:CHAR_LITERAL c2:CHAR_LITERAL)
    ;

// REWRITE stuff

rewrite returns [StringTemplate code=null]
{
StringTemplate alt;
if ( #rewrite.getType()==REWRITE ) {
	if ( generator.grammar.buildTemplate() ) {
		code = templates.getInstanceOf("rewriteTemplate");
	}
	else {
		code = templates.getInstanceOf("rewriteCode");
		code.setAttribute("treeLevel", Utils.integer(OUTER_REWRITE_NESTING_LEVEL));
		code.setAttribute("rewriteBlockLevel", Utils.integer(OUTER_REWRITE_NESTING_LEVEL));
        code.setAttribute("referencedElementsDeep",
                          getTokenTypesAsTargetLabels(#rewrite.rewriteRefsDeep));
        Set<String> tokenLabels =
            grammar.getLabels(#rewrite.rewriteRefsDeep, Grammar.TOKEN_LABEL);
        Set<String> tokenListLabels =
            grammar.getLabels(#rewrite.rewriteRefsDeep, Grammar.TOKEN_LIST_LABEL);
        Set<String> ruleLabels =
            grammar.getLabels(#rewrite.rewriteRefsDeep, Grammar.RULE_LABEL);
        Set<String> ruleListLabels =
            grammar.getLabels(#rewrite.rewriteRefsDeep, Grammar.RULE_LIST_LABEL);
        // just in case they ref $r for "previous value", make a stream
        // from retval.tree
        StringTemplate retvalST = templates.getInstanceOf("prevRuleRootRef");
        ruleLabels.add(retvalST.toString());
        code.setAttribute("referencedTokenLabels", tokenLabels);
        code.setAttribute("referencedTokenListLabels", tokenListLabels);
        code.setAttribute("referencedRuleLabels", ruleLabels);
        code.setAttribute("referencedRuleListLabels", ruleListLabels);
	}
}
}
	:	(
			{rewriteRuleRefs = new HashSet();}
			#( r:REWRITE (pred:SEMPRED)? alt=rewrite_alternative )
			{
            rewriteBlockNestingLevel = OUTER_REWRITE_NESTING_LEVEL;
			List predChunks = null;
			if ( #pred!=null ) {
				//predText = #pred.getText();
        		predChunks = generator.translateAction(currentRuleName,#pred);
			}
			String description =
			    grammar.grammarTreeToString(#r,false);
			description = generator.target.getTargetStringLiteralFromString(description);
			code.setAttribute("alts.{pred,alt,description}",
							  predChunks,
							  alt,
							  description);
			pred=null;
			}
		)*
	;

rewrite_block[String blockTemplateName] returns [StringTemplate code=null]
{
rewriteBlockNestingLevel++;
code = templates.getInstanceOf(blockTemplateName);
StringTemplate save_currentBlockST = currentBlockST;
currentBlockST = code;
code.setAttribute("rewriteBlockLevel", rewriteBlockNestingLevel);
StringTemplate alt=null;
}
    :   #(  BLOCK
            {
            currentBlockST.setAttribute("referencedElementsDeep",
                getTokenTypesAsTargetLabels(#BLOCK.rewriteRefsDeep));
            currentBlockST.setAttribute("referencedElements",
                getTokenTypesAsTargetLabels(#BLOCK.rewriteRefsShallow));
            }
            alt=rewrite_alternative
            EOB
         )
    	{
    	code.setAttribute("alt", alt);
    	rewriteBlockNestingLevel--;
    	currentBlockST = save_currentBlockST;
    	}
    ;

rewrite_alternative
	returns [StringTemplate code=null]
{
StringTemplate el,st;
}
    :   {generator.grammar.buildAST()}?
    	#(	a:ALT {code=templates.getInstanceOf("rewriteElementList");}
			(	(	{GrammarAST elAST=(GrammarAST)_t;}
    				el=rewrite_element
					{code.setAttribute("elements.{el,line,pos}",
					 					el,
    							  		Utils.integer(elAST.getLine()),
    							  		Utils.integer(elAST.getColumn())
					 					);
					}
				)+
    		|	EPSILON
    			{code.setAttribute("elements.{el,line,pos}",
    							   templates.getInstanceOf("rewriteEmptyAlt"),
    							   Utils.integer(#a.getLine()),
    							   Utils.integer(#a.getColumn())
					 			   );
				}
    		)
    		EOA
    	 )
    |	{generator.grammar.buildTemplate()}? code=rewrite_template
    ;

rewrite_element returns [StringTemplate code=null]
{
    IntSet elements=null;
    GrammarAST ast = null;
}
    :   code=rewrite_atom[false]

    |   code=rewrite_ebnf

    |   code=rewrite_tree
    ;

rewrite_ebnf returns [StringTemplate code=null]
    :   #( OPTIONAL code=rewrite_block["rewriteOptionalBlock"] )
		{
		String description = grammar.grammarTreeToString(#rewrite_ebnf, false);
		description = generator.target.getTargetStringLiteralFromString(description);
		code.setAttribute("description", description);
		}
    |   #( CLOSURE code=rewrite_block["rewriteClosureBlock"] )
		{
		String description = grammar.grammarTreeToString(#rewrite_ebnf, false);
		description = generator.target.getTargetStringLiteralFromString(description);
		code.setAttribute("description", description);
		}
    |   #( POSITIVE_CLOSURE code=rewrite_block["rewritePositiveClosureBlock"] )
		{
		String description = grammar.grammarTreeToString(#rewrite_ebnf, false);
		description = generator.target.getTargetStringLiteralFromString(description);
		code.setAttribute("description", description);
		}
    ;

rewrite_tree returns [StringTemplate code=templates.getInstanceOf("rewriteTree")]
{
rewriteTreeNestingLevel++;
code.setAttribute("treeLevel", rewriteTreeNestingLevel);
code.setAttribute("enclosingTreeLevel", rewriteTreeNestingLevel-1);
StringTemplate r, el;
GrammarAST elAST=null;
}
	:   #(	TREE_BEGIN {elAST=(GrammarAST)_t;}
			r=rewrite_atom[true]
			{code.setAttribute("root.{el,line,pos}",
							   r,
							   Utils.integer(elAST.getLine()),
							   Utils.integer(elAST.getColumn())
							  );
			}
			( {elAST=(GrammarAST)_t;}
			  el=rewrite_element
			  {
			  code.setAttribute("children.{el,line,pos}",
							    el,
							    Utils.integer(elAST.getLine()),
							    Utils.integer(elAST.getColumn())
							    );
			  }
			)*
		)
		{
		String description = grammar.grammarTreeToString(#rewrite_tree, false);
		description = generator.target.getTargetStringLiteralFromString(description);
		code.setAttribute("description", description);
    	rewriteTreeNestingLevel--;
		}
    ;

rewrite_atom[boolean isRoot] returns [StringTemplate code=null]
    :   r:RULE_REF
    	{
    	String ruleRefName = #r.getText();
    	String stName = "rewriteRuleRef";
    	if ( isRoot ) {
    		stName += "Root";
    	}
    	code = templates.getInstanceOf(stName);
    	code.setAttribute("rule", ruleRefName);
    	if ( grammar.getRule(ruleRefName)==null ) {
			ErrorManager.grammarError(ErrorManager.MSG_UNDEFINED_RULE_REF,
									  grammar,
									  ((GrammarAST)(#r)).getToken(),
									  ruleRefName);
    		code = new StringTemplate(); // blank; no code gen
    	}
    	else if ( grammar.getRule(currentRuleName)
    			     .getRuleRefsInAlt(ruleRefName,outerAltNum)==null )
		{
			ErrorManager.grammarError(ErrorManager.MSG_REWRITE_ELEMENT_NOT_PRESENT_ON_LHS,
									  grammar,
									  ((GrammarAST)(#r)).getToken(),
									  ruleRefName);
    		code = new StringTemplate(); // blank; no code gen
    	}
    	else {
    		// track all rule refs as we must copy 2nd ref to rule and beyond
    		if ( !rewriteRuleRefs.contains(ruleRefName) ) {
	    		rewriteRuleRefs.add(ruleRefName);
    		}
		}
    	}

    |   ( #(TOKEN_REF (arg:ARG_ACTION)?) | CHAR_LITERAL | STRING_LITERAL )
    	{
    	String tokenName = #rewrite_atom.getText();
    	String stName = "rewriteTokenRef";
    	Rule rule = grammar.getRule(currentRuleName);
    	Set tokenRefsInAlt = rule.getTokenRefsInAlt(outerAltNum);
    	boolean imaginary = !tokenRefsInAlt.contains(tokenName);
    	if ( imaginary ) {
    		stName = "rewriteImaginaryTokenRef";
    	}
    	if ( isRoot ) {
    		stName += "Root";
    	}
    	code = templates.getInstanceOf(stName);
    	if ( #arg!=null ) {
			List args = generator.translateAction(currentRuleName,#arg);
			code.setAttribute("args", args);
    	}
		code.setAttribute("elementIndex", ((TokenWithIndex)#rewrite_atom.getToken()).getIndex());
		int ttype = grammar.getTokenType(tokenName);
		String tok = generator.getTokenTypeAsTargetLabel(ttype);
    	code.setAttribute("token", tok);
    	if ( grammar.getTokenType(tokenName)==Label.INVALID ) {
			ErrorManager.grammarError(ErrorManager.MSG_UNDEFINED_TOKEN_REF_IN_REWRITE,
									  grammar,
									  ((GrammarAST)(#rewrite_atom)).getToken(),
									  tokenName);
    		code = new StringTemplate(); // blank; no code gen
    	}
    	}

    |	LABEL
    	{
    	String labelName = #LABEL.getText();
    	Rule rule = grammar.getRule(currentRuleName);
    	Grammar.LabelElementPair pair = rule.getLabel(labelName);
    	if ( labelName.equals(currentRuleName) ) {
    		// special case; ref to old value via $rule
    		StringTemplate labelST = templates.getInstanceOf("prevRuleRootRef");
    		code = templates.getInstanceOf("rewriteRuleLabelRef"+(isRoot?"Root":""));
    		code.setAttribute("label", labelST);
    	}
    	else if ( pair==null ) {
			ErrorManager.grammarError(ErrorManager.MSG_UNDEFINED_LABEL_REF_IN_REWRITE,
									  grammar,
									  ((GrammarAST)(#LABEL)).getToken(),
									  labelName);
			code = new StringTemplate();
    	}
    	else {
			String stName = null;
			switch ( pair.type ) {
				case Grammar.TOKEN_LABEL :
					stName = "rewriteTokenLabelRef";
					break;
				case Grammar.RULE_LABEL :
					stName = "rewriteRuleLabelRef";
					break;
				case Grammar.TOKEN_LIST_LABEL :
					stName = "rewriteTokenListLabelRef";
					break;
				case Grammar.RULE_LIST_LABEL :
					stName = "rewriteRuleListLabelRef";
					break;
			}
			if ( isRoot ) {
				stName += "Root";
			}
			code = templates.getInstanceOf(stName);
			code.setAttribute("label", labelName);
		}
    	}

    |   ACTION
        {
        // actions in rewrite rules yield a tree object
        String actText = #ACTION.getText();
        List chunks = generator.translateAction(currentRuleName,#ACTION);
		code = templates.getInstanceOf("rewriteNodeAction"+(isRoot?"Root":""));
		code.setAttribute("action", chunks);
        }
    ;

rewrite_template returns [StringTemplate code=null]
    :	#( ALT EPSILON EOA ) {code=templates.getInstanceOf("rewriteEmptyTemplate");}
   	|	#( TEMPLATE (id:ID|ind:ACTION)
		   {
		   if ( #id!=null && #id.getText().equals("template") ) {
		   		code = templates.getInstanceOf("rewriteInlineTemplate");
		   }
		   else if ( #id!=null ) {
		   		code = templates.getInstanceOf("rewriteExternalTemplate");
		   		code.setAttribute("name", #id.getText());
		   }
		   else if ( #ind!=null ) { // must be %({expr})(args)
		   		code = templates.getInstanceOf("rewriteIndirectTemplate");
				List chunks=generator.translateAction(currentRuleName,#ind);
		   		code.setAttribute("expr", chunks);
		   }
		   }
	       #( ARGLIST
	       	  ( #( ARG arg:ID a:ACTION
		   		   {
                   // must set alt num here rather than in define.g
                   // because actions like %foo(name={$ID.text}) aren't
                   // broken up yet into trees.
				   #a.outerAltNum = this.outerAltNum;
		   		   List chunks = generator.translateAction(currentRuleName,#a);
		   		   code.setAttribute("args.{name,value}", #arg.getText(), chunks);
		   		   }
	             )
	          )*
	        )
		   ( DOUBLE_QUOTE_STRING_LITERAL
             {
             String sl = #DOUBLE_QUOTE_STRING_LITERAL.getText();
			 String t = sl.substring(1,sl.length()-1); // strip quotes
			 t = generator.target.getTargetStringLiteralFromString(t);
             code.setAttribute("template",t);
             }
		   | DOUBLE_ANGLE_STRING_LITERAL
             {
             String sl = #DOUBLE_ANGLE_STRING_LITERAL.getText();
			 String t = sl.substring(2,sl.length()-2); // strip double angle quotes
			 t = generator.target.getTargetStringLiteralFromString(t);
             code.setAttribute("template",t);
             }
		   )?
	     )

	|	act:ACTION
   		{
        // set alt num for same reason as ARGLIST above
        #act.outerAltNum = this.outerAltNum;
   		code=templates.getInstanceOf("rewriteAction");
   		code.setAttribute("action",
   						  generator.translateAction(currentRuleName,#act));
   		}
	;