ast.stg

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

/** x+=rule! when output=AST is a rule ref with list addition */
ruleRefBangAndListLabel(rule,label,elementIndex,args) ::= <<
/* ruleRefBangAndListLabel(rule,label,elementIndex,args) */
<ruleRefBang(...)>
<listLabelAST(...)>
/* End: ruleRefBangAndListLabel(rule,label,elementIndex,args) */
>>

/** x+=rule^ */
ruleRefRootAndListLabel(rule,label,elementIndex,args) ::= <<
/* ruleRefRootAndListLabel(rule,label,elementIndex,args) */
<super.ruleRef(...)>
root_<blockLevel> = ctx->adaptor->becomeRoot(ctx->adaptor, <label>.tree, root_<blockLevel>);<\n>
<listLabelAST(...)>
/* End: ruleRefRootAndListLabel(rule,label,elementIndex,args) */
>>

/** x+=rule^^ */
ruleRefRuleRootAndListLabel(rule,label,elementIndex,args) ::= <<
/* ruleRefRuleRootAndListLabel(rule,label,elementIndex,args) */
<ruleRefRuleRoot(...)>
<listLabelAST(...)>
/* End: ruleRefRuleRootAndListLabel(rule,label,elementIndex,args) */
>>

// WILDCARD AST

wildcard(label,elementIndex) ::= <<
/* wildcard(label,elementIndex) */
<super.wildcard(...)>
<if(backtracking)>if ( backtracking==0 ) {<endif>
<label>_tree = ctx->adaptor->create(ctx->adaptor, <label>);
ctx->adaptor->addChild(ctx->adaptor, root_<blockLevel>, <label>_tree);
<if(backtracking)>}<endif>
/* End: wildcard(label,elementIndex) */
>>

wildcardRoot(label,elementIndex) ::= <<
/* wildcardRoot(label,elementIndex) */
<super.wildcard(...)>
<if(backtracking)>if ( backtracking==0 ) {<endif>
<label>_tree = ctx->adaptor->create(ctx->adaptor, <label>);
root_<blockLevel> = ctx->adaptor->becomeRoot(ctx->adaptor, <label>_tree, root_<blockLevel>);
<if(backtracking)>}<endif>
/* End: wildcardRoot(label,elementIndex) */
>>

wildcardRuleRoot(label,elementIndex) ::= <<
/* wildcardRuleRoot(label,elementIndex) */
<super.wildcard(...)>
<if(backtracking)>if ( backtracking==0 ) {<endif>
<label>_tree = ctx->adaptor->create(ctx->adaptor, <label>);
root_0 = ctx->adaptor->becomeRoot(ctx->adaptor, <label>_tree, root_0);
<if(backtracking)>}<endif>
/* End: wildcardRuleRoot(label,elementIndex) */
>>

// 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) ::=
<<
/* rewriteCode(
	alts, description,
	referencedTokens,
	referencedListLabels,
	referencedRules, rewriteBlockLevel, enclosingTreeLevel, treeLevel) */
// AST REWRITE
<if(backtracking)>
if ( backtracking==0 ) <\n>
<endif>
{
	ANTLR3_UINT64	i_0	    = 0;
	<prevRuleRootRef()>.tree    = root_0;
	root_0			    = ctx->adaptor->nil(ctx->adaptor);
	<alts:rewriteAlt(); separator="else ">
}
/* End: rewriteCode(
	alts, description,
	referencedTokens,
	referencedListLabels,
	referencedRules, rewriteBlockLevel, enclosingTreeLevel, treeLevel) */
>>

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

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

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

/** 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() ::= <<
/* Start: rewriteBlockCardinalityCheck */
<if(first([referencedTokens,referencedListLabels,referencedRules]))>
/* First compute size of the lists for cardinality checking
 */
<first([referencedTokens,referencedListLabels,referencedRules]):{ANTLR3_UINT64 n_<rewriteBlockLevel> = list_<first([referencedTokens,referencedListLabels,referencedRules])> == NULL ? 0 : list_<first([referencedTokens,referencedListLabels,referencedRules])>->size(list_<first([referencedTokens,referencedListLabels,referencedRules])>);}>
/* Now check the cardinality
 */
<rest([referencedTokens,referencedListLabels,referencedRules]):{if ( list_<it>->size(list_<it>)!=n_<rewriteBlockLevel> ) fprintf(stderr, "rewrite element list '<it>' differs in size from other elements!\n");<\n>}>
<endif>
<!
   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]))>
<! No lists !>
/* Compute cardinality of optional single value labels
 */
<first(referencedRuleLabels):{label | ANTLR3_UINT64 n_<rewriteBlockLevel> = <first([referencedTokenLabels,referencedRuleLabels])>.tree == NULL ? 0 : 1; }>
<first(referencedTokenLabels):{label | ANTLR3_UINT64 n_<rewriteBlockLevel> = <first([referencedTokenLabels,referencedRuleLabels])> == NULL ? 0 : 1; }>
/* Now, check cardinality of non-list labels matches cardinality of other labels for rewrite
 */
<rest(referencedRuleLabels):{label| if ( (<label> == NULL && n_<rewriteBlockLevel> \> 0) || (<label>.tree != NULL && n_<rewriteBlockLevel> == 0) ) fprintf(stderr, "rewrite element list '<label>' differs in size from other elements!\n");}>
<rest(referencedTokenLabels):{label| if ( (<label> == NULL && n_<rewriteBlockLevel> \> 0) || (<label> != NULL && n_<rewriteBlockLevel> == 0) ) fprintf(stderr, "rewrite element list '<label>' differs in size from other elements!\n");}>
<else> <! There were some list labels !>
/* Now, ensure list labels match cardinality of lists
 */
<referencedRuleLabels:{label| if ( (<label>.tree == NULL && n_<rewriteBlockLevel> \> 0) || (<label>.tree != NULL && n_<rewriteBlockLevel> == 0) ) fprintf(stderr, "rewrite element list '<label>' differs in size from other elements!\n");}>
<referencedTokenLabels:{label| if ( (<label> == NULL && n_<rewriteBlockLevel> \> 0) || (<label> != NULL && n_<rewriteBlockLevel> == 0) ) fprintf(stderr, "rewrite element list '<label>' differs in size from other elements!\n");}>
<endif>
/* End: rewriteBlockCardinalityCheck */
>>

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; /* \<-- rewriteEmptyAlt()) */"

rewriteTree(root,children,description,enclosingTreeLevel,treeLevel) ::= <<
/* rewriteTree(root,children,description,enclosingTreeLevel,treeLevel) */
// <fileName>:<description>
{
    pANTLR3_BASE_TREE root_<treeLevel> = ctx->adaptor->nil(ctx->adaptor);
    <root:rewriteElement()>
    <children:rewriteElement()>
    ctx->adaptor->addChild(ctx->adaptor, root_<enclosingTreeLevel>, root_<treeLevel>);
}<\n>
>>

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

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

/** Gen ID */
rewriteTokenRef(token,elementIndex) ::= <<
/* rewriteTokenRef(token,elementIndex) */
// Is this a token actaully and not a tree list?
ctx->adaptor->addChildToken(ctx->adaptor, root_<treeLevel>, list_<token>->get(list_<token>, i_<rewriteBlockLevel> + 1));<\n>
/* End: rewriteTokenRef(token,elementIndex) */
>>

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

/** Gen $label ... where defined via label+=ID */
rewriteTokenListLabelRef(label,elementIndex) ::= <<
/* rewriteTokenListLabelRef(label,elementIndex) */
ctx->adaptor->addChildToken(ctx->adaptor, root_<treeLevel>, list_<label>->get(list_<label>, i_<rewriteBlockLevel> + 1));<\n>
/* Home: rewriteTokenListLabelRef(label,elementIndex) */
>>

/** Gen ^($label ...) */
rewriteTokenLabelRefRoot(label,elementIndex) ::= <<
/* rewriteTokenLabelRefRoot(label,elementIndex) */
root_<treeLevel> = ctx->adaptor->becomeRootToken(ctx->adaptor, <label>, root_<treeLevel>);<\n>
/* End: rewriteTokenLabelRefRoot(label,elementIndex) */
>>

/** Gen ^(ID ...) */
rewriteTokenRefRoot(token,elementIndex) ::= <<
/* rewriteTokenRefRoot(token,elementIndex) */
root_<treeLevel> = ctx->adaptor->becomeRootToken(ctx->adaptor, list_<token>->get(list_<token>, i_<rewriteBlockLevel> + 1), root_<treeLevel>);<\n>
/* End: rewriteTokenRefRoot(token,elementIndex) */
>>

rewriteImaginaryTokenRef(args,token,elementIndex) ::= <<
ctx->adaptor->addChild(ctx->adaptor, root_<treeLevel>, ctx->adaptor->createTypeText(ctx->adaptor, <token>, (pANTLR3_UINT8)<args; separator=", (pANTLR3_UINT8)"><if(!args)>"<token>"<endif>));<\n>
>>

rewriteImaginaryTokenRefRoot(args,token,elementIndex) ::= <<
root_<treeLevel> = ctx->adaptor->becomeRoot(ctx->adaptor, ctx->adaptor->createTypeText(ctx->adaptor, <token>, (pANTLR3_UINT8)<args; separator=", (pANTLR3_UINT8)"><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) ::= <<
/* rewriteRuleRef(rule,dup) */
<if(dup)>
ctx->adaptor->addChild(ctx->adaptor, root_<treeLevel>, ctx->adaptor->dupTree(ctx->adaptor, list_<rule>->get(list_<rule>, i_<rewriteBlockLevel>+1)));<\n>
<else>
ctx->adaptor->addChild(ctx->adaptor, root_<treeLevel>, list_<rule>->get(list_<rule>, i_<rewriteBlockLevel>+1));<\n>
<endif>
/* End: rewriteRuleRef(rule,dup) */
>>

rewriteRuleRefRoot(rule,dup) ::= <<
/* rewriteRuleRefRoot(rule,dup) */
<if(dup)>
root_<treeLevel> = list_<rule>->becomeRoot(ctx->adaptor, ctx->adaptor->dupTree(atx->adaptor, list_<rule>->get(list_<rule>, i_<rewriteBlockLevel>+1)), root_<treeLevel>);<\n>
<else>
root_<treeLevel> = list_<rule>->becomeRoot(list_<rule>->get(list_<rule>, i_<rewriteBlockLevel> + 1), root_<treeLevel>);<\n>
<endif>
/* End: rewriteRuleRefRoot(rule,dup) */
>>

rewriteNodeAction(action) ::= <<
/* rewriteNodeAction(action) */
ctx->adaptor->addChild(ctx->adaptor, root_<treeLevel>, <action>);<\n>
/* End: rewriteNodeAction(action) */
>>

rewriteNodeActionRoot(action) ::= <<
/* rewriteNodeActionRoot(action) */
root_<treeLevel> = ctx->adaptor->becomeRoot(ctx->adaptor, <action>, root_<treeLevel>);<\n>
/* End: rewriteNodeActionRoot(action) */
>>

/** Gen $ruleLabel ... where defined via ruleLabel=rule */
rewriteRuleLabelRef(label) ::= <<
/* rewriteRuleLabelRef(label) */
ctx->adaptor->addChild(ctx->adaptor, root_<treeLevel>, <label>.tree);<\n>
/* End: rewriteRuleLabelRef(label) */
>>

/** Gen $ruleLabel ... where defined via ruleLabel+=rule */
rewriteRuleListLabelRef(label) ::= <<
/* rewriteRuleListLabelRef(label) */
ctx->adaptor->addChild(ctx->adaptor, root_<treeLevel>, (pANTLR3_BASE_TREE)(list_<label>->get(list_<label>, i_<rewriteBlockLevel> + 1)));<\n>
/* End: rewriteRuleListLabelRef(label) */
>>

/** Gen ^($ruleLabel ...) where ruleLabel=rule */
rewriteRuleLabelRefRoot(label) ::= <<
/* rewriteRuleLabelRefRoot(label) */
root_<treeLevel> = ctx->adaptor->becomeRoot(ctx->adaptor, <label>.tree, root_<treeLevel>);<\n>
/* End: rewriteRuleLabelRefRoot(label) */
>>

/** Gen ^($ruleLabel ...) where ruleLabel+=rule */
rewriteRuleListLabelRefRoot(label) ::= <<
/* rewriteRuleListLabelRefRoot(label) */
root_<treeLevel> = ctx->adaptor->becomeRoot((pANTLR3_BASE_TREE)(list_<label>->get(list_<label>, i_<rewriteBlockLevel> + 1)), root_<treeLevel>);<\n>
/* End: rewriteRuleListLabelRefRoot(label) */
>>