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

Go to download
Show more of this group Show more artifacts with this name
Show all versions of antlr-complete Show documentation
Complete distribution for ANTLR 3
There is a newer version: 3.5.3
/*
 * [The "BSD license"]
 * Copyright (c) 2007-2008 Johannes Luber
 * Copyright (c) 2005-2007 Kunle Odutola
 * Copyright (c) 2011 Sam Harwell
 * Copyright (c) 2011 Terence Parr
 * 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.
 */

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



using Antlr.Runtime.Tree;
using RewriteRuleITokenStream = Antlr.Runtime.Tree.RewriteRuleTokenStream;

>>

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

>>

parserCtorBody() ::= <%
<\n>
TreeAdaptor = 

	

	new ()

;
%>

/** Add an adaptor property that knows how to build trees */
parserMembers() ::= <<
private  adaptor;

public  TreeAdaptor
{
	get
	{
		return adaptor;
	}

	set
	{
		this.adaptor = value;
		.TreeAdaptor = this.adaptor;}>
	}
}
>>

treeAdaptorType() ::= <<

>>

ruleReturnBaseType() ::= <%
AstTreeParserRuleReturnScope\<, >
%>

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

 root_0 = default();<\n>
>>

ruleLabelDefs() ::= <<

<[ruleDescriptor.tokenLabels,ruleDescriptor.wildcardTreeLabels,ruleDescriptor.wildcardTreeListLabels]
	:{it| _tree = default();}; separator="\n">
 _tree = default();}; 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();



>>

// 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,terminalOptions={}) ::= <<
 
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,terminalOptions={}) ::= <<


>>

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

if () stream_.Add();
>>

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


>>

/** 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) ::= <<

.Tree},elemType=ASTLabelType,...)>
>>

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

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

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

.Tree},elemType=ASTLabelType,...)>
>>

// 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) ::= <<
<\n>{
// AST REWRITE
// elements: 
// token labels: 
// rule labels: 
// token list labels: 
// rule list labels: 
// wildcard labels: <[referencedWildcardLabels,referencedWildcardListLabels]; separator=", ">

if () {

.Tree = root_0;

root_0 = ()adaptor.Nil();



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



.Tree = root_0;


}

}

>>

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 ()
{
	
}

{
	
}

>>

/** 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(, );<\n>

%>

/** Gen ID or ID[args] */
rewriteTokenRef(token,elementIndex,args,terminalOptions={}) ::= <<
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,args,terminalOptions={}) ::= <<
root_ = ()adaptor.BecomeRoot(, root_);<\n>
>>

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

rewriteImaginaryTokenRefRoot(args,token,elementIndex,terminalOptions={}) ::= <<
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,args,terminalOptions={}) ::= <%


new (, )

()adaptor.Create(, "")

%>

createRewriteNodeFromElement(token,args,terminalOptions={}) ::= <%

new (stream_.NextToken(), )

 
adaptor.Create(, )

stream_.NextNode()


%>