codegen.g

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

		}
		}

    |   #( w:WILDCARD (as5:ast_suffix)? )
        {
		code = getWildcardST(#w,#as5,label);
		/*
		if ( label!=null ) {
		    code.setAttribute("label", label);
		}
		*/
		code.setAttribute("elementIndex", ((TokenWithIndex)#w.getToken()).getIndex());
		}

    |	code=set[label]
    ;

ast_suffix
	:	ROOT
	|	RULEROOT
	|	BANG
	;

set[String label] returns [StringTemplate code=null]
	:   #( s:SET (setElement)+ ( ast:ast_suffix )? )
        {
        // TODO: make this work with ast_suffix
        code = getTokenElementST("matchSet", "set", #s, #ast, label);
		code.setAttribute("elementIndex", ((TokenWithIndex)#s.getToken()).getIndex());
		if ( grammar.type!=Grammar.LEXER ) {
			generator.generateLocalFOLLOW(#s,"set",currentRuleName);
        }
        code.setAttribute("s", generator.genSetExpr(templates,#s.getSetValue(),1,false));
		/*
		if ( label!=null ) {
		    code.setAttribute("label", label);
		}
		*/
        }
    ;

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));
		currentBlockST = code;
	}
}
}
	:	(
			{rewriteRuleRefs = new HashSet();}
			#( r:REWRITE (pred:SEMPRED)? alt=rewrite_alternative )
			{
            rewriteBlockNestingLevel = OUTER_REWRITE_NESTING_LEVEL;
			List predChunks = null;
			if ( #pred!=null ) {
				//predText = #pred.getText();
        		#pred.outerAltNum = this.outerAltNum;
        		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
            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]

    |   #(  n:NOT
            (  c:CHAR_LITERAL
            |  s:STRING_LITERAL
            |  t:TOKEN_REF
            |  #( st:SET (rewrite_setElement)+ )
            )
         )

    |   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);
    		}
    		else {
    			// we found a ref to the same rule in the same -> rewrite
    			code.setAttribute("dup", Boolean.valueOf(true));
    		}
			currentBlockST.setAttribute("referencedRules", 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 ) {
	        #arg.outerAltNum = this.outerAltNum;
			List args = generator.translateArgAction(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
    	}
    	else {
    		// only track this reference if it's valid
			if ( !imaginary ) {
				currentBlockST.setAttribute("referencedTokens", tok);
			}
		}
    	}

    |	code=rewrite_set

    |	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;
			String refListAttrName = null;
			switch ( pair.type ) {
				case Grammar.TOKEN_LABEL :
					stName = "rewriteTokenLabelRef";
					refListAttrName = "referencedTokenLabels";
					break;
				case Grammar.RULE_LABEL :
					stName = "rewriteRuleLabelRef";
					refListAttrName = "referencedRuleLabels";
					break;
				case Grammar.TOKEN_LIST_LABEL :
					stName = "rewriteTokenListLabelRef";
					refListAttrName = "referencedListLabels";
					break;
				case Grammar.RULE_LIST_LABEL :
					stName = "rewriteRuleListLabelRef";
					refListAttrName = "referencedListLabels";
					break;
			}
			if ( isRoot ) {
				stName += "Root";
			}
			code = templates.getInstanceOf(stName);
			code.setAttribute("label", labelName);
			if ( refListAttrName!=null ) {
				currentBlockST.setAttribute(refListAttrName, #LABEL.getText());
			}
		}
    	}

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

rewrite_set returns [StringTemplate code=null]
	:   #( s:SET (rewrite_setElement)+ )
    ;

rewrite_setElement
    :   c:CHAR_LITERAL
    |   t:TOKEN_REF
    |   s:STRING_LITERAL
    ;

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
		   		   {
				   #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
   		{
        #act.outerAltNum = this.outerAltNum;
   		code=templates.getInstanceOf("rewriteAction");
   		code.setAttribute("action",
   						  generator.translateAction(currentRuleName,#act));
   		}
	;