org.antlr.codegen.templates.CSharp3.AST.stg Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of analytics-plugin Show documentation
Kill Bill Analytics plugin
There is a newer version: 8.1.2
/*
 * [The "BSD licence"]
 * Copyright (c) 2005-2008 Terence Parr
 * All rights reserved.
 *
 * Conversion to C#:
 * Copyright (c) 2008-2009 Sam Harwell, Pixel Mine, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
group AST;

@outputFile.imports() ::= <<
<@super.imports()>

using Antlr.Runtime.Tree;
using RewriteRuleITokenStream = Antlr.Runtime.Tree.RewriteRuleTokenStream;<\n>

>>

@genericParser.members() ::= <<
<@super.members()>

>>

parserCtorBody() ::= <<

ITreeAdaptor treeAdaptor = null;
CreateTreeAdaptor(ref treeAdaptor);
TreeAdaptor = treeAdaptor ?? new CommonTreeAdaptor();
>>

/** Add an adaptor property that knows how to build trees */
parserMembers() ::= <<
// Implement this function in your helper file to use a custom tree adaptor
partial void CreateTreeAdaptor(ref ITreeAdaptor adaptor);

private ITreeAdaptor adaptor;

public ITreeAdaptor TreeAdaptor
{
	get
	{
		return adaptor;
	}
	set
	{
		this.adaptor = value;
		.TreeAdaptor = this.adaptor;}>
	}
}
>>

@returnScope.ruleReturnInterfaces() ::= <<
, IAstRuleReturnScope\<\>
>>

@returnScope.ruleReturnMembers() ::= <<
private  _tree;
public  Tree { get { return _tree; } set { _tree = value; } }
>>

/** Add a variable to track rule's return AST */
ruleDeclarations() ::= <<

 root_0 = null;<\n>
>>

ruleLabelDefs() ::= <<

<[ruleDescriptor.tokenLabels,ruleDescriptor.wildcardTreeLabels,ruleDescriptor.wildcardTreeListLabels]
	:{ _tree=null;}; separator="\n">
 _tree=null;}; separator="\n">
Stream stream_=new RewriteRuleStream(adaptor,"token ");}; separator="\n">
=new RewriteRuleSubtreeStream(adaptor,"rule ");}; separator="\n">
>>

/** When doing auto AST construction, we must define some variables;
 *  These should be turned off if doing rewrites.  This must be a "mode"
 *  as a rule could have both rewrite and AST within the same alternative
 *  block.
 */
@alt.declarations() ::= <<



root_0 = ()adaptor.Nil();<\n>



>>

// T r a c k i n g  R u l e  E l e m e n t s

/** ID and track it for use in a rewrite rule */
tokenRefTrack(token,label,elementIndex,hetero) ::= <<
 
if (  ) stream_.Add();<\n>
>>

/** ids+=ID and track it for use in a rewrite rule; adds to ids *and*
 *  to the tracking list stream_ID for use in the rewrite.
 */
tokenRefTrackAndListLabel(token,label,elementIndex,hetero) ::= <<


>>

/** ^(ID ...) track for rewrite */
tokenRefRuleRootTrack(token,label,elementIndex,hetero) ::= <<

if (  ) stream_.Add();<\n>
>>

/** Match ^(label+=TOKEN ...) track for rewrite */
tokenRefRuleRootTrackAndListLabel(token,label,elementIndex,hetero) ::= <<


>>

/** rule when output=AST and tracking for rewrite */
ruleRefTrack(rule,label,elementIndex,args,scope) ::= <<

if (  ) stream_.Add(.Tree);
>>

/** x+=rule when output=AST and tracking for rewrite */
ruleRefTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<


>>

/** ^(rule ...) rewrite */
ruleRefRuleRootTrack(rule,label,elementIndex,args,scope) ::= <<

if (  ) stream_.Add(.Tree);
>>

/** ^(x+=rule ...) rewrite */
ruleRefRuleRootTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<


>>

// R e w r i t e

rewriteCode(
	alts, description,
	referencedElementsDeep, // ALL referenced elements to right of ->
	referencedTokenLabels,
	referencedTokenListLabels,
	referencedRuleLabels,
	referencedRuleListLabels,
	referencedWildcardLabels,
	referencedWildcardListLabels,
	rewriteBlockLevel, enclosingTreeLevel, treeLevel) ::=
<<

{
// AST REWRITE
// elements: 
// token labels: 
// rule labels: 
// token list labels: 
// rule list labels: 
// wildcard labels: <[referencedWildcardLabels,referencedWildcardListLabels]; separator=", ">

if (  ) {<\n>

.Tree = root_0;

root_0 = ()adaptor.Nil();




.Tree = ()adaptor.RulePostProcessing(root_0);
input.ReplaceChildren(adaptor.GetParent(retval.Start),
                      adaptor.GetChildIndex(retval.Start),
                      adaptor.GetChildIndex(_last),
                      retval.Tree);




.Tree = root_0;<\n>


.Tree = root_0;



}<\n>

}

>>

rewriteCodeLabels() ::= <<
Stream stream_=new RewriteRuleStream(adaptor,"token ",);};
    separator="\n"
>
Stream stream_=new RewriteRuleStream(adaptor,"token ", list_);};
    separator="\n"
>
=new RewriteRuleSubtreeStream(adaptor,"wildcard ",);};
	separator="\n"
>
=new RewriteRuleSubtreeStream(adaptor,"wildcard ",list_);};
	separator="\n"
>
=new RewriteRuleSubtreeStream(adaptor,"rule ",!=null?.Tree:null);};
    separator="\n"
>
=new RewriteRuleSubtreeStream(adaptor,"token ",list_);};
    separator="\n"
>
>>

/** Generate code for an optional rewrite block; note it uses the deep ref'd element
  *  list rather shallow like other blocks.
  */
rewriteOptionalBlock(
	alt,rewriteBlockLevel,
	referencedElementsDeep, // all nested refs
	referencedElements, // elements in immediately block; no nested blocks
	description) ::=
<<
// :
if ( .HasNext}; separator="||"> )
{
	
}
.Reset();<\n>}>
>>

rewriteClosureBlock(
	alt,rewriteBlockLevel,
	referencedElementsDeep, // all nested refs
	referencedElements, // elements in immediately block; no nested blocks
	description) ::=
<<
// :
while ( .HasNext}; separator="||"> )
{
	
}
.Reset();<\n>}>
>>

rewritePositiveClosureBlock(
	alt,rewriteBlockLevel,
	referencedElementsDeep, // all nested refs
	referencedElements, // elements in immediately block; no nested blocks
	description) ::=
<<
if ( !(.HasNext}; separator="||">) )
{
	throw new RewriteEarlyExitException();
}
while ( .HasNext}; separator="||"> )
{
	
}
.Reset();<\n>}>
>>

rewriteAlt(a) ::= <<
// 

if ()
{
	
}<\n>

{
	
}<\n>

>>

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

rewriteTree(root,children,description,enclosingTreeLevel,treeLevel) ::= <<
// :
{
 root_ = ()adaptor.Nil();


adaptor.AddChild(root_, root_);
}<\n>
>>

rewriteElementList(elements) ::= ""

rewriteElement(e) ::= <<
<@pregen()>
DebugLocation(, );

>>

/** Gen ID or ID[args] */
rewriteTokenRef(token,elementIndex,hetero,args) ::= <<
adaptor.AddChild(root_, );<\n>
>>

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

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

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

/** Gen ^($label ...) where label+=... */
rewriteTokenListLabelRefRoot ::= rewriteTokenLabelRefRoot

/** Gen ^(ID ...) or ^(ID[args] ...) */
rewriteTokenRefRoot(token,elementIndex,hetero,args) ::= <<
root_ = ()adaptor.BecomeRoot(, root_);<\n>
>>

rewriteImaginaryTokenRef(args,token,hetero,elementIndex) ::= <<
adaptor.AddChild(root_, );<\n>
>>

rewriteImaginaryTokenRefRoot(args,token,hetero,elementIndex) ::= <<
root_ = ()adaptor.BecomeRoot(, root_);<\n>
>>

/** plain -> {foo} action */
rewriteAction(action) ::= <<
root_0 = ;<\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) ::= <<
adaptor.AddChild(root_, stream_.NextTree());<\n>
>>

rewriteRuleRefRoot(rule) ::= <<
root_ = ()adaptor.BecomeRoot(stream_.NextNode(), root_);<\n>
>>

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

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

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

/** Gen $ruleLabel ... where defined via ruleLabel+=rule */
rewriteRuleListLabelRef(label) ::= <<
adaptor.AddChild(root_, stream_.NextTree());<\n>
>>

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

/** Gen ^($ruleLabel ...) where ruleLabel+=rule */
rewriteRuleListLabelRefRoot(label) ::= <<
root_ = ()adaptor.BecomeRoot(stream_.NextNode(), root_);<\n>
>>

rewriteWildcardLabelRef(label) ::= <<
adaptor.AddChild(root_, stream_.NextTree());<\n>
>>

createImaginaryNode(tokenType,hetero,args) ::= <<


new (, )

()adaptor.Create(, "")

>>

createRewriteNodeFromElement(token,hetero,args) ::= <<

new (stream_.NextToken(), )

 
adaptor.Create(, )

stream_.NextNode()


>>