ast.stg

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

adaptor.AddChild(root_<blockLevel>, <label>_tree);
<if(backtracking)>}<endif>
>>

wildcardRoot(label,elementIndex) ::= <<
<super.wildcard(...)>
<if(backtracking)>if ( backtracking==0 ) {<endif>
<label>_tree = (<ASTLabelType>)adaptor.Create(<label>);
root_<blockLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<label>_tree, root_<blockLevel>);
<if(backtracking)>}<endif>
>>

wildcardRuleRoot(label,elementIndex) ::= <<
<super.wildcard(...)>
<if(backtracking)>if ( backtracking==0 ) {<endif>
<label>_tree = (<ASTLabelType>)adaptor.Create(<label>);
root_0 = (<ASTLabelType>)adaptor.BecomeRoot(<label>_tree, root_0);
<if(backtracking)>}<endif>
>>

// ugh, am i really missing the combinations for Track and ListLabel?
// there's got to be a better way

// R e w r i t e

rewriteCode(
	alts, description,
	referencedTokens,
	referencedListLabels,
	referencedRules,
	referencedTokenLabels,
	referencedRuleLabels,
	rewriteBlockLevel, enclosingTreeLevel, treeLevel) ::=
<<

// AST REWRITE
<if(backtracking)>
if ( backtracking==0 ) {<\n>
<endif>
int i_0 = 0;
<prevRuleRootRef()>.tree = root_0;
root_0 = (<ASTLabelType>)adaptor.GetNilNode();
<alts:rewriteAlt(); separator="else ">
<if(backtracking)>
}
<endif>
>>

rewriteOptionalBlock(
	alt,rewriteBlockLevel,
	referencedTokens,
	referencedListLabels,
	referencedRules,
	referencedTokenLabels,
	referencedRuleLabels,
	description) ::=
<<
// <fileName>:<description>
{
<rewriteBlockCardinalityCheck()>
if ( n_<rewriteBlockLevel> > 1 ) throw new InvalidOperationException("<first([referencedTokens,referencedListLabels,referencedRules])> list has > 1 elements");
if ( n_<rewriteBlockLevel>==1 ) {
    int i_<rewriteBlockLevel> = 0;
    <alt>
    }
}<\n>
>>

rewriteClosureBlock(
	alt,rewriteBlockLevel,
	referencedTokens,
	referencedListLabels,
	referencedRules,
	referencedTokenLabels,
	referencedRuleLabels,
	description) ::=
<<
// <fileName>:<description>
{
<rewriteBlockCardinalityCheck()>
for (int i_<rewriteBlockLevel>=0; i_<rewriteBlockLevel>\<n_<rewriteBlockLevel>; i_<rewriteBlockLevel>++) {
    <alt>
}
}<\n>
>>

rewritePositiveClosureBlock(
	alt,rewriteBlockLevel,
	referencedTokens,
	referencedListLabels,
	referencedRules,
	referencedTokenLabels,
	referencedRuleLabels,
	description) ::=
<<
// <fileName>:<description>
{
<rewriteBlockCardinalityCheck()>
if ( n_<rewriteBlockLevel>==0 ) throw new InvalidOperationException("Must have more than one element for (...)+ loops");
for (int i_<rewriteBlockLevel>=0; i_<rewriteBlockLevel>\<n_<rewriteBlockLevel>; i_<rewriteBlockLevel>++) {
    <alt>
}
}<\n>
>>

/** Elements referenced in rewrite loops/optional blocks must have
 *  the same size.  Factor this out from rewriteXXXBlock rules.  This
 *  deals both with the lists of stuff and single element labels like id=ID.
 *  The n_xxx var is always defined to either first list_ var or single-value 
 *  label.
 */
rewriteBlockCardinalityCheck() ::= <<
<!
	First compute size of lists of stuff
!>
<first([referencedTokens,referencedListLabels,referencedRules]):{int n_<rewriteBlockLevel> = list_<first([referencedTokens,referencedListLabels,referencedRules])> == null ? 0 : list_<first([referencedTokens,referencedListLabels,referencedRules])>.Count;}>
<!
	Then, check cardinality against first size
!>
<rest([referencedTokens,referencedListLabels,referencedRules]):{if ( list_<it>.Count!=n_<rewriteBlockLevel> ) throw new InvalidOperationException("rewrite element <it> list differs in size from other elements");<\n>}>
<!
   Now generate checks for non-list labels
!>
<!
   If no lists above, then we need to define n to be 0 or 1 depending on presence
   of single-value labels
!>
<if(!first([referencedTokens,referencedListLabels,referencedRules]))>
<first([referencedTokenLabels,referencedRuleLabels]):{label |
int n_<rewriteBlockLevel> = (<first([referencedTokenLabels,referencedRuleLabels])>==null) ? 0 : 1;
}>
<!
	Now, gen checks to ensure non-list labels match cardinality of other labels
!>
<rest([referencedTokenLabels,referencedRuleLabels]):{label|
if ( (<label>==null && n_<rewriteBlockLevel>\>0) || (<label>!=null && n_<rewriteBlockLevel>==0) ) throw new InvalidOperationException("rewrite element <label> list differs in size from other elements");
}>

<else> <! there were some list labels !>

<! Now, gen checks to ensure non-list labels match cardinality of lists !>
<[referencedTokenLabels,referencedRuleLabels]:{label|
if ( (<label>==null && n_<rewriteBlockLevel>\>0) || (<label>!=null && n_<rewriteBlockLevel>==0) ) throw new InvalidOperationException("rewrite element <label> list differs in size from other elements");
}>
<endif>
>>

rewriteAlt(a) ::= <<
// <a.description>
<if(a.pred)>
if (<a.pred>)
{
    <a.alt>
}<\n>
<else>
{
    <a.alt>
}<\n>
<endif>
>>

/** For empty rewrites: "r : ... -> ;" */
rewriteEmptyAlt() ::= "root_0 = null;"

rewriteTree(root,children,description,enclosingTreeLevel,treeLevel) ::= <<
// <fileName>:<description>
{
<ASTLabelType> root_<treeLevel> = (<ASTLabelType>)adaptor.GetNilNode();
<root:rewriteElement()>
<children:rewriteElement()>
adaptor.AddChild(root_<enclosingTreeLevel>, root_<treeLevel>);
}<\n>
>>

rewriteElementList(elements) ::= "<elements:rewriteElement()>"

rewriteElement(e) ::= <<
<@pregen()>
<e.el>
>>

/** Gen ID */
rewriteTokenRef(token,elementIndex) ::= <<
adaptor.AddChild(root_<treeLevel>, (<labelType>)list_<token>[i_<rewriteBlockLevel>]);<\n>
>>

/** Gen $label ... where defined via label=ID */
rewriteTokenLabelRef(label,elementIndex) ::= <<
adaptor.AddChild(root_<treeLevel>, <label>);<\n>
>>

/** Gen $label ... where defined via label+=ID */
rewriteTokenListLabelRef(label,elementIndex) ::= <<
adaptor.AddChild(root_<treeLevel>, (<labelType>)list_<label>[i_<rewriteBlockLevel>]);<\n>
>>

/** Gen ^($label ...) */
rewriteTokenLabelRefRoot(label,elementIndex) ::= <<
root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<label>, root_<treeLevel>);<\n>
>>

/** Gen ^(ID ...) */
rewriteTokenRefRoot(token,elementIndex) ::= <<
root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot((<labelType>)list_<token>[i_<rewriteBlockLevel>], root_<treeLevel>);<\n>
>>

rewriteImaginaryTokenRef(args,token,elementIndex) ::= <<
adaptor.AddChild(root_<treeLevel>, adaptor.Create(<token>, <args; separator=", "><if(!args)>"<token>"<endif>));<\n>
>>

rewriteImaginaryTokenRefRoot(args,token,elementIndex) ::= <<
root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(adaptor.Create(<token>, <args; separator=", "><if(!args)>"<token>"<endif>), root_<treeLevel>);<\n>
>>

/** plain -> {foo} action */
rewriteAction(action) ::= <<
root_0 = <action>;<\n>
>>

/** What is the name of the previous value of this rule's root tree?  This
 *  let's us refer to $rule to mean previous value.  I am reusing the
 *  variable 'tree' sitting in retval struct to hold the value of root_0 right
 *  before I set it during rewrites.  The assign will be to retval.Tree.
 */
prevRuleRootRef() ::= "retval"

rewriteRuleRef(rule,dup) ::= <<
<if(dup)>
adaptor.AddChild(root_<treeLevel>, adaptor.DupTree(list_<rule>[i_<rewriteBlockLevel>]));<\n>
<else>
adaptor.AddChild(root_<treeLevel>, list_<rule>[i_<rewriteBlockLevel>]);<\n>
<endif>
>>

rewriteRuleRefRoot(rule,dup) ::= <<
<if(dup)>
root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(adaptor.DupTree(list_<rule>[i_<rewriteBlockLevel>]), root_<treeLevel>);<\n>
<else>
root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(list_<rule>[i_<rewriteBlockLevel>], root_<treeLevel>);<\n>
<endif>
>>

rewriteNodeAction(action) ::= <<
adaptor.AddChild(root_<treeLevel>, <action>);<\n>
>>

rewriteNodeActionRoot(action) ::= <<
root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<action>, root_<treeLevel>);<\n>
>>

/** Gen $ruleLabel ... where defined via ruleLabel=rule */
rewriteRuleLabelRef(label) ::= <<
adaptor.AddChild(root_<treeLevel>, <label>.Tree);<\n>
>>

/** Gen $ruleLabel ... where defined via ruleLabel+=rule */
rewriteRuleListLabelRef(label) ::= <<
adaptor.AddChild(root_<treeLevel>, ((<if(TREE_PARSER)>Tree<else>Parser<endif>RuleReturnScope)list_<label>[i_<rewriteBlockLevel>]).Tree);<\n>
>>

/** Gen ^($ruleLabel ...) where ruleLabel=rule */
rewriteRuleLabelRefRoot(label) ::= <<
root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<label>.Tree, root_<treeLevel>);<\n>
>>

/** Gen ^($ruleLabel ...) where ruleLabel+=rule */
rewriteRuleListLabelRefRoot(label) ::= <<
root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(((<if(TREE_PARSER)>Tree<else>Parser<endif>RuleReturnScope)list_<label>[i_<rewriteBlockLevel>]).Tree, root_<treeLevel>);<\n>
>>