Init
This commit is contained in:
Kevin Krüger
430
packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/AST.stg
vendored
Normal file
430
packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/AST.stg
vendored
Normal file
@@ -0,0 +1,430 @@
|
||||
/*
|
||||
* [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()>
|
||||
|
||||
<if(!TREE_PARSER)>
|
||||
<! tree parser would already have imported !>
|
||||
using Antlr.Runtime.Tree;
|
||||
using RewriteRuleITokenStream = Antlr.Runtime.Tree.RewriteRuleTokenStream;
|
||||
<endif>
|
||||
>>
|
||||
|
||||
@genericParser.members() ::= <<
|
||||
<@super.members()>
|
||||
<parserMembers()>
|
||||
>>
|
||||
|
||||
parserCtorBody() ::= <%
|
||||
<super.parserCtorBody()><\n>
|
||||
TreeAdaptor =
|
||||
<if(actions.(actionScope).treeAdaptorInitializer)>
|
||||
<actions.(actionScope).treeAdaptorInitializer>
|
||||
<else>
|
||||
new <actions.(actionScope).treeAdaptorType; null="CommonTreeAdaptor">()
|
||||
<end>
|
||||
;
|
||||
%>
|
||||
|
||||
/** Add an adaptor property that knows how to build trees */
|
||||
parserMembers() ::= <<
|
||||
private <treeAdaptorType()> adaptor;
|
||||
|
||||
public <treeAdaptorType()> TreeAdaptor
|
||||
{
|
||||
get
|
||||
{
|
||||
return adaptor;
|
||||
}
|
||||
|
||||
set
|
||||
{
|
||||
this.adaptor = value;
|
||||
<grammar.directDelegates:{g|<g:delegateName()>.TreeAdaptor = this.adaptor;}>
|
||||
}
|
||||
}
|
||||
>>
|
||||
|
||||
treeAdaptorType() ::= <<
|
||||
<actions.(actionScope).treeAdaptorType; null="ITreeAdaptor">
|
||||
>>
|
||||
|
||||
ruleReturnBaseType() ::= <%
|
||||
Ast<if(TREE_PARSER)>Tree<else>Parser<endif>RuleReturnScope\<<ASTLabelType>, <labelType>>
|
||||
%>
|
||||
|
||||
/** Add a variable to track rule's return AST */
|
||||
ruleDeclarations() ::= <<
|
||||
<super.ruleDeclarations()>
|
||||
<ASTLabelType> root_0 = default(<ASTLabelType>);<\n>
|
||||
>>
|
||||
|
||||
ruleLabelDefs() ::= <<
|
||||
<super.ruleLabelDefs()>
|
||||
<[ruleDescriptor.tokenLabels,ruleDescriptor.wildcardTreeLabels,ruleDescriptor.wildcardTreeListLabels]
|
||||
:{it|<ASTLabelType> <it.label.text>_tree = default(<ASTLabelType>);}; separator="\n">
|
||||
<ruleDescriptor.tokenListLabels:{it|<ASTLabelType> <it.label.text>_tree = default(<ASTLabelType>);}; separator="\n">
|
||||
<ruleDescriptor.allTokenRefsInAltsWithRewrites
|
||||
:{it|RewriteRule<rewriteElementType>Stream stream_<it>=new RewriteRule<rewriteElementType>Stream(adaptor,"token <it>");}; separator="\n">
|
||||
<ruleDescriptor.allRuleRefsInAltsWithRewrites
|
||||
:{it|RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"rule <it>");}; 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() ::= <<
|
||||
<if(autoAST)>
|
||||
<if(outerAlt)>
|
||||
<if(!rewriteMode)>
|
||||
root_0 = (<ASTLabelType>)adaptor.Nil();
|
||||
<endif>
|
||||
<endif>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
// 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) ::= <<
|
||||
<tokenRefBang(...)> <! Track implies no auto AST construction!>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>stream_<token>.Add(<label>);<\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) ::= <<
|
||||
<tokenRefTrack(...)>
|
||||
<listLabelElem(elem=label,elemType=labelType,...)>
|
||||
>>
|
||||
|
||||
/** ^(ID ...) track for rewrite */
|
||||
tokenRefRuleRootTrack(token,label,elementIndex,terminalOptions) ::= <<
|
||||
<tokenRefBang(...)>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>stream_<token>.Add(<label>);
|
||||
>>
|
||||
|
||||
/** Match ^(label+=TOKEN ...) track for rewrite */
|
||||
tokenRefRuleRootTrackAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
|
||||
<tokenRefRuleRootTrack(...)>
|
||||
<listLabelElem(elem=label,elemType=labelType,...)>
|
||||
>>
|
||||
|
||||
/** rule when output=AST and tracking for rewrite */
|
||||
ruleRefTrack(rule,label,elementIndex,args,scope) ::= <<
|
||||
<super.ruleRef(...)>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>stream_<rule.name>.Add(<label>.Tree);
|
||||
>>
|
||||
|
||||
/** x+=rule when output=AST and tracking for rewrite */
|
||||
ruleRefTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<
|
||||
<ruleRefTrack(...)>
|
||||
<listLabelElem(elem={<label>.Tree},elemType=ASTLabelType,...)>
|
||||
>>
|
||||
|
||||
/** ^(rule ...) rewrite */
|
||||
ruleRefRuleRootTrack(rule,label,elementIndex,args,scope) ::= <<
|
||||
<ruleRefRuleRoot(...)>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>stream_<rule>.Add(<label>.Tree);
|
||||
>>
|
||||
|
||||
/** ^(x+=rule ...) rewrite */
|
||||
ruleRefRuleRootTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<
|
||||
<ruleRefRuleRootTrack(...)>
|
||||
<listLabelElem(elem={<label>.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: <referencedElementsDeep; separator=", ">
|
||||
// token labels: <referencedTokenLabels; separator=", ">
|
||||
// rule labels: <referencedRuleLabels; separator=", ">
|
||||
// token list labels: <referencedTokenListLabels; separator=", ">
|
||||
// rule list labels: <referencedRuleListLabels; separator=", ">
|
||||
// wildcard labels: <[referencedWildcardLabels,referencedWildcardListLabels]; separator=", ">
|
||||
<if(backtracking)>
|
||||
if (<actions.(actionScope).synpredgate>) {
|
||||
<endif>
|
||||
<prevRuleRootRef()>.Tree = root_0;
|
||||
<rewriteCodeLabels()>
|
||||
root_0 = (<ASTLabelType>)adaptor.Nil();
|
||||
<alts:rewriteAlt(); separator="else ">
|
||||
<! if tree parser and rewrite=true !>
|
||||
<if(TREE_PARSER&&rewriteMode)>
|
||||
<prevRuleRootRef()>.Tree = (<ASTLabelType>)adaptor.RulePostProcessing(root_0);
|
||||
if (<prevRuleRootRef()>.Tree != null)
|
||||
input.ReplaceChildren(adaptor.GetParent(retval.Start), adaptor.GetChildIndex(retval.Start), adaptor.GetChildIndex(_last), retval.Tree);
|
||||
<endif>
|
||||
<! if parser or tree-parser && rewrite!=true, we need to set result !>
|
||||
<if(!TREE_PARSER||!rewriteMode)>
|
||||
<prevRuleRootRef()>.Tree = root_0;
|
||||
<endif>
|
||||
<if(backtracking)>
|
||||
}
|
||||
<endif>
|
||||
}
|
||||
|
||||
>>
|
||||
|
||||
rewriteCodeLabels() ::= <<
|
||||
<referencedTokenLabels
|
||||
:{it|RewriteRule<rewriteElementType>Stream stream_<it>=new RewriteRule<rewriteElementType>Stream(adaptor,"token <it>",<it>);};
|
||||
separator="\n"
|
||||
>
|
||||
<referencedTokenListLabels
|
||||
:{it|RewriteRule<rewriteElementType>Stream stream_<it>=new RewriteRule<rewriteElementType>Stream(adaptor,"token <it>", list_<it>);};
|
||||
separator="\n"
|
||||
>
|
||||
<referencedWildcardLabels
|
||||
:{it|RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"wildcard <it>",<it>);};
|
||||
separator="\n"
|
||||
>
|
||||
<referencedWildcardListLabels
|
||||
:{it|RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"wildcard <it>",list_<it>);};
|
||||
separator="\n"
|
||||
>
|
||||
<referencedRuleLabels
|
||||
:{it|RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"rule <it>",<it>!=null?<it>.Tree:null);};
|
||||
separator="\n"
|
||||
>
|
||||
<referencedRuleListLabels
|
||||
:{it|RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"token <it>",list_<it>);};
|
||||
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) ::=
|
||||
<<
|
||||
// <fileName>:<description>
|
||||
if (<referencedElementsDeep:{el | stream_<el>.HasNext}; separator="||">)
|
||||
{
|
||||
<alt>
|
||||
}
|
||||
<referencedElementsDeep:{el | stream_<el>.Reset();<\n>}>
|
||||
>>
|
||||
|
||||
rewriteClosureBlock(
|
||||
alt,rewriteBlockLevel,
|
||||
referencedElementsDeep, // all nested refs
|
||||
referencedElements, // elements in immediately block; no nested blocks
|
||||
description) ::=
|
||||
<<
|
||||
// <fileName>:<description>
|
||||
while ( <referencedElements:{el | stream_<el>.HasNext}; separator="||"> )
|
||||
{
|
||||
<alt>
|
||||
}
|
||||
<referencedElements:{el | stream_<el>.Reset();<\n>}>
|
||||
>>
|
||||
|
||||
rewritePositiveClosureBlock(
|
||||
alt,rewriteBlockLevel,
|
||||
referencedElementsDeep, // all nested refs
|
||||
referencedElements, // elements in immediately block; no nested blocks
|
||||
description) ::=
|
||||
<<
|
||||
if (!(<referencedElements:{el | stream_<el>.HasNext}; separator="||">))
|
||||
{
|
||||
throw new RewriteEarlyExitException();
|
||||
}
|
||||
while ( <referencedElements:{el | stream_<el>.HasNext}; separator="||"> )
|
||||
{
|
||||
<alt>
|
||||
}
|
||||
<referencedElements:{el | stream_<el>.Reset();<\n>}>
|
||||
>>
|
||||
|
||||
rewriteAlt(a) ::= <<
|
||||
// <a.description>
|
||||
<if(a.pred)>
|
||||
if (<a.pred>)
|
||||
{
|
||||
<a.alt>
|
||||
}
|
||||
<else>
|
||||
{
|
||||
<a.alt>
|
||||
}
|
||||
<endif>
|
||||
>>
|
||||
|
||||
/** For empty rewrites: "r : ... -> ;" */
|
||||
rewriteEmptyAlt() ::= "root_0 = null;"
|
||||
|
||||
rewriteTree(root,children,description,enclosingTreeLevel,treeLevel) ::= <<
|
||||
// <fileName>:<description>
|
||||
{
|
||||
<ASTLabelType> root_<treeLevel> = (<ASTLabelType>)adaptor.Nil();
|
||||
<root:rewriteElement()>
|
||||
<children:rewriteElement()>
|
||||
adaptor.AddChild(root_<enclosingTreeLevel>, root_<treeLevel>);
|
||||
}<\n>
|
||||
>>
|
||||
|
||||
rewriteElementList(elements) ::= "<elements:rewriteElement()>"
|
||||
|
||||
rewriteElement(e) ::= <%
|
||||
<@pregen()>
|
||||
DebugLocation(<e.line>, <e.pos>);<\n>
|
||||
<e.el>
|
||||
%>
|
||||
|
||||
/** Gen ID or ID[args] */
|
||||
rewriteTokenRef(token,elementIndex,terminalOptions,args) ::= <<
|
||||
adaptor.AddChild(root_<treeLevel>, <createRewriteNodeFromElement(...)>);<\n>
|
||||
>>
|
||||
|
||||
/** Gen $label ... where defined via label=ID */
|
||||
rewriteTokenLabelRef(label,elementIndex) ::= <<
|
||||
adaptor.AddChild(root_<treeLevel>, stream_<label>.NextNode());<\n>
|
||||
>>
|
||||
|
||||
/** Gen $label ... where defined via label+=ID */
|
||||
rewriteTokenListLabelRef(label,elementIndex) ::= <<
|
||||
adaptor.AddChild(root_<treeLevel>, stream_<label>.NextNode());<\n>
|
||||
>>
|
||||
|
||||
/** Gen ^($label ...) */
|
||||
rewriteTokenLabelRefRoot(label,elementIndex) ::= <<
|
||||
root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(stream_<label>.NextNode(), root_<treeLevel>);<\n>
|
||||
>>
|
||||
|
||||
/** Gen ^($label ...) where label+=... */
|
||||
rewriteTokenListLabelRefRoot ::= rewriteTokenLabelRefRoot
|
||||
|
||||
/** Gen ^(ID ...) or ^(ID[args] ...) */
|
||||
rewriteTokenRefRoot(token,elementIndex,terminalOptions,args) ::= <<
|
||||
root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<createRewriteNodeFromElement(...)>, root_<treeLevel>);<\n>
|
||||
>>
|
||||
|
||||
rewriteImaginaryTokenRef(args,token,terminalOptions,elementIndex) ::= <<
|
||||
adaptor.AddChild(root_<treeLevel>, <createImaginaryNode(tokenType=token, ...)>);<\n>
|
||||
>>
|
||||
|
||||
rewriteImaginaryTokenRefRoot(args,token,terminalOptions,elementIndex) ::= <<
|
||||
root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<createImaginaryNode(tokenType=token, ...)>, 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) ::= <<
|
||||
adaptor.AddChild(root_<treeLevel>, stream_<rule>.NextTree());<\n>
|
||||
>>
|
||||
|
||||
rewriteRuleRefRoot(rule) ::= <<
|
||||
root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(stream_<rule>.NextNode(), root_<treeLevel>);<\n>
|
||||
>>
|
||||
|
||||
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>, stream_<label>.NextTree());<\n>
|
||||
>>
|
||||
|
||||
/** Gen $ruleLabel ... where defined via ruleLabel+=rule */
|
||||
rewriteRuleListLabelRef(label) ::= <<
|
||||
adaptor.AddChild(root_<treeLevel>, stream_<label>.NextTree());<\n>
|
||||
>>
|
||||
|
||||
/** Gen ^($ruleLabel ...) where ruleLabel=rule */
|
||||
rewriteRuleLabelRefRoot(label) ::= <<
|
||||
root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(stream_<label>.NextNode(), root_<treeLevel>);<\n>
|
||||
>>
|
||||
|
||||
/** Gen ^($ruleLabel ...) where ruleLabel+=rule */
|
||||
rewriteRuleListLabelRefRoot(label) ::= <<
|
||||
root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(stream_<label>.NextNode(), root_<treeLevel>);<\n>
|
||||
>>
|
||||
|
||||
rewriteWildcardLabelRef(label) ::= <<
|
||||
adaptor.AddChild(root_<treeLevel>, stream_<label>.NextTree());<\n>
|
||||
>>
|
||||
|
||||
createImaginaryNode(tokenType,terminalOptions,args) ::= <%
|
||||
<if(terminalOptions.node)>
|
||||
<! new MethodNode(IDLabel, args) !>
|
||||
new <terminalOptions.node>(<tokenType><if(args)>, <args; separator=", "><endif>)
|
||||
<else>
|
||||
(<ASTLabelType>)adaptor.Create(<tokenType>, <args; separator=", "><if(!args)>"<tokenType>"<endif>)
|
||||
<endif>
|
||||
%>
|
||||
|
||||
createRewriteNodeFromElement(token,terminalOptions,args) ::= <%
|
||||
<if(terminalOptions.node)>
|
||||
new <terminalOptions.node>(stream_<token>.NextToken()<if(args)>, <args; separator=", "><endif>)
|
||||
<else>
|
||||
<if(args)> <! must create new node from old !>
|
||||
adaptor.Create(<token>, <args; separator=", ">)
|
||||
<else>
|
||||
stream_<token>.NextNode()
|
||||
<endif>
|
||||
<endif>
|
||||
%>
|
||||
94
packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ASTDbg.stg
vendored
Normal file
94
packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ASTDbg.stg
vendored
Normal file
@@ -0,0 +1,94 @@
|
||||
/*
|
||||
* [The "BSD license"]
|
||||
* Copyright (c) 2007-2008 Johannes Luber
|
||||
* Copyright (c) 2005-2007 Kunle Odutola
|
||||
* Copyright (c) 2005 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.
|
||||
*/
|
||||
|
||||
/** Template overrides to add debugging to AST stuff. Dynamic inheritance
|
||||
* hierarchy is set up as ASTDbg : AST : Dbg : Java by code generator.
|
||||
*/
|
||||
|
||||
parserMembers() ::= <<
|
||||
protected DebugTreeAdaptor adaptor;
|
||||
|
||||
public ITreeAdaptor TreeAdaptor
|
||||
{
|
||||
get
|
||||
{
|
||||
return adaptor;
|
||||
}
|
||||
set
|
||||
{
|
||||
<if(grammar.grammarIsRoot)>
|
||||
this.adaptor = new DebugTreeAdaptor(dbg,adaptor);
|
||||
<else>
|
||||
this.adaptor = (DebugTreeAdaptor)adaptor; // delegator sends dbg adaptor
|
||||
<endif><\n>
|
||||
<grammar.directDelegates:{g|<g:delegateName()>.TreeAdaptor = this.adaptor;}>
|
||||
}
|
||||
}<\n>
|
||||
>>
|
||||
|
||||
parserCtorBody() ::= <<
|
||||
<super.parserCtorBody()>
|
||||
>>
|
||||
|
||||
createListenerAndHandshake() ::= <<
|
||||
DebugEventSocketProxy proxy = new DebugEventSocketProxy( this, port, <if(TREE_PARSER)>input.TreeAdaptor<else>adaptor<endif> );
|
||||
DebugListener = proxy;
|
||||
<inputStreamType> = new Debug<inputStreamType>( input, proxy );
|
||||
try
|
||||
{
|
||||
proxy.Handshake();
|
||||
}
|
||||
catch ( IOException ioe )
|
||||
{
|
||||
ReportError( ioe );
|
||||
}
|
||||
>>
|
||||
|
||||
@ctorForRootGrammar.finally() ::= <<
|
||||
ITreeAdaptor adap = new CommonTreeAdaptor();
|
||||
TreeAdaptor = adap;
|
||||
proxy.TreeAdaptor = adap;
|
||||
>>
|
||||
|
||||
@ctorForProfilingRootGrammar.finally() ::=<<
|
||||
ITreeAdaptor adap = new CommonTreeAdaptor();
|
||||
TreeAdaptor = adap;
|
||||
>>
|
||||
|
||||
@ctorForPredefinedListener.superClassRef() ::= ": base( input, dbg )"
|
||||
|
||||
@ctorForPredefinedListener.finally() ::=<<
|
||||
<if(grammar.grammarIsRoot)><! don't create new adaptor for delegates !>
|
||||
ITreeAdaptor adap = new CommonTreeAdaptor();
|
||||
TreeAdaptor = adap;<\n>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
//@rewriteElement.pregen() ::= "dbg.Location( <e.line>, <e.pos> );"
|
||||
192
packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ASTParser.stg
vendored
Normal file
192
packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ASTParser.stg
vendored
Normal file
@@ -0,0 +1,192 @@
|
||||
/*
|
||||
* [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.
|
||||
*/
|
||||
|
||||
/** Templates for building ASTs during normal parsing.
|
||||
*
|
||||
* Deal with many combinations. Dimensions are:
|
||||
* Auto build or rewrite
|
||||
* no label, label, list label (label/no-label handled together)
|
||||
* child, root
|
||||
* token, set, rule, wildcard
|
||||
*
|
||||
* The situation is not too bad as rewrite (->) usage makes ^ and !
|
||||
* invalid. There is no huge explosion of combinations.
|
||||
*/
|
||||
|
||||
@rule.setErrorReturnValue() ::= <<
|
||||
retval.Tree = (<ASTLabelType>)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
|
||||
<! System.out.WriteLine("<ruleName> returns "+((CommonTree)retval.tree).toStringTree()); !>
|
||||
>>
|
||||
|
||||
// TOKEN AST STUFF
|
||||
|
||||
/** ID and output=AST */
|
||||
tokenRef(token,label,elementIndex,terminalOptions) ::= <<
|
||||
<super.tokenRef(...)>
|
||||
<if(backtracking)>if (state.backtracking == 0) {<endif>
|
||||
<label>_tree = <createNodeFromToken(...)>;
|
||||
adaptor.AddChild(root_0, <label>_tree);
|
||||
<if(backtracking)>}<endif>
|
||||
>>
|
||||
|
||||
/** ID! and output=AST (same as plain tokenRef) */
|
||||
tokenRefBang(token,label,elementIndex) ::= "<super.tokenRef(...)>"
|
||||
|
||||
/** ID^ and output=AST */
|
||||
tokenRefRuleRoot(token,label,elementIndex,terminalOptions) ::= <<
|
||||
<super.tokenRef(...)>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
|
||||
<label>_tree = <createNodeFromToken(...)>;
|
||||
root_0 = (<ASTLabelType>)adaptor.BecomeRoot(<label>_tree, root_0);
|
||||
<if(backtracking)>}<endif>
|
||||
>>
|
||||
|
||||
/** ids+=ID! and output=AST */
|
||||
tokenRefBangAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
|
||||
<tokenRefBang(...)>
|
||||
<listLabelElem(elem=label,elemType=labelType,...)>
|
||||
>>
|
||||
|
||||
/** label+=TOKEN when output=AST but not rewrite alt */
|
||||
tokenRefAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
|
||||
<tokenRef(...)>
|
||||
<listLabelElem(elem=label,elemType=labelType,...)>
|
||||
>>
|
||||
|
||||
/** Match label+=TOKEN^ when output=AST but not rewrite alt */
|
||||
tokenRefRuleRootAndListLabel(token,label,terminalOptions,elementIndex) ::= <<
|
||||
<tokenRefRuleRoot(...)>
|
||||
<listLabelElem(elem=label,elemType=labelType,...)>
|
||||
>>
|
||||
|
||||
// SET AST
|
||||
|
||||
// the match set stuff is interesting in that it uses an argument list
|
||||
// to pass code to the default matchSet; another possible way to alter
|
||||
// inherited code. I don't use the region stuff because I need to pass
|
||||
// different chunks depending on the operator. I don't like making
|
||||
// the template name have the operator as the number of templates gets
|
||||
// large but this is the most flexible--this is as opposed to having
|
||||
// the code generator call matchSet then add root code or ruleroot code
|
||||
// plus list label plus ... The combinations might require complicated
|
||||
// rather than just added on code. Investigate that refactoring when
|
||||
// I have more time.
|
||||
|
||||
matchSet(s,label,terminalOptions,elementIndex,postmatchCode) ::= <<
|
||||
<super.matchSet(postmatchCode={<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>adaptor.AddChild(root_0, <createNodeFromToken(...)>);}, ...)>
|
||||
>>
|
||||
|
||||
matchRuleBlockSet(s,label,terminalOptions,elementIndex,postmatchCode,treeLevel="0") ::= <<
|
||||
<matchSet(...)>
|
||||
>>
|
||||
|
||||
matchSetBang(s,label,elementIndex,terminalOptions,postmatchCode) ::= "<super.matchSet(...)>"
|
||||
|
||||
// note there is no matchSetTrack because -> rewrites force sets to be
|
||||
// plain old blocks of alts: (A|B|...|C)
|
||||
|
||||
matchSetRuleRoot(s,label,terminalOptions,elementIndex,debug) ::= <<
|
||||
<if(label)>
|
||||
<label>=(<labelType>)input.LT(1);
|
||||
<endif>
|
||||
<super.matchSet(postmatchCode={<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>root_0 = (<ASTLabelType>)adaptor.BecomeRoot(<createNodeFromToken(...)>, root_0);}, ...)>
|
||||
>>
|
||||
|
||||
// RULE REF AST
|
||||
|
||||
/** rule when output=AST */
|
||||
ruleRef(rule,label,elementIndex,args,scope) ::= <<
|
||||
<super.ruleRef(...)>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>adaptor.AddChild(root_0, <label>.Tree);
|
||||
>>
|
||||
|
||||
/** rule! is same as normal rule ref */
|
||||
ruleRefBang(rule,label,elementIndex,args,scope) ::= "<super.ruleRef(...)>"
|
||||
|
||||
/** rule^ */
|
||||
ruleRefRuleRoot(rule,label,elementIndex,args,scope) ::= <<
|
||||
<super.ruleRef(...)>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>root_0 = (<ASTLabelType>)adaptor.BecomeRoot(<label>.Tree, root_0);
|
||||
>>
|
||||
|
||||
/** x+=rule when output=AST */
|
||||
ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<
|
||||
<ruleRef(...)>
|
||||
<listLabelElem(elem={<label>.Tree},elemType=ASTLabelType,...)>
|
||||
>>
|
||||
|
||||
/** x+=rule! when output=AST is a rule ref with list addition */
|
||||
ruleRefBangAndListLabel(rule,label,elementIndex,args,scope) ::= <<
|
||||
<ruleRefBang(...)>
|
||||
<listLabelElem(elem={<label>.Tree},elemType=ASTLabelType,...)>
|
||||
>>
|
||||
|
||||
/** x+=rule^ */
|
||||
ruleRefRuleRootAndListLabel(rule,label,elementIndex,args,scope) ::= <<
|
||||
<ruleRefRuleRoot(...)>
|
||||
<listLabelElem(elem={<label>.Tree},elemType=ASTLabelType,...)>
|
||||
>>
|
||||
|
||||
// WILDCARD AST
|
||||
|
||||
wildcard(token,label,elementIndex,terminalOptions) ::= <<
|
||||
<super.wildcard(...)>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
|
||||
<label>_tree = (<ASTLabelType>)adaptor.Create(<label>);
|
||||
adaptor.AddChild(root_0, <label>_tree);
|
||||
<if(backtracking)>}<endif>
|
||||
>>
|
||||
|
||||
wildcardBang(label,elementIndex) ::= "<super.wildcard(...)>"
|
||||
|
||||
wildcardRuleRoot(token,label,elementIndex,terminalOptions) ::= <<
|
||||
<super.wildcard(...)>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
|
||||
<label>_tree = (<ASTLabelType>)adaptor.Create(<label>);
|
||||
root_0 = (<ASTLabelType>)adaptor.BecomeRoot(<label>_tree, root_0);
|
||||
<if(backtracking)>}<endif>
|
||||
>>
|
||||
|
||||
createNodeFromToken(label,terminalOptions) ::= <%
|
||||
<if(terminalOptions.node)>
|
||||
new <terminalOptions.node>(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>)
|
||||
<else>
|
||||
(<ASTLabelType>)adaptor.Create(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>)
|
||||
<endif>
|
||||
%>
|
||||
|
||||
ruleCleanUp() ::= <<
|
||||
<super.ruleCleanUp()>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
|
||||
retval.Tree = (<ASTLabelType>)adaptor.RulePostProcessing(root_0);
|
||||
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
|
||||
<if(backtracking)>}<endif>
|
||||
>>
|
||||
380
packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ASTTreeParser.stg
vendored
Normal file
380
packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ASTTreeParser.stg
vendored
Normal file
@@ -0,0 +1,380 @@
|
||||
/*
|
||||
* [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.
|
||||
*/
|
||||
|
||||
/** Templates for building ASTs during tree parsing.
|
||||
*
|
||||
* Deal with many combinations. Dimensions are:
|
||||
* Auto build or rewrite
|
||||
* no label, label, list label (label/no-label handled together)
|
||||
* child, root
|
||||
* token, set, rule, wildcard
|
||||
*
|
||||
* Each combination has its own template except that label/no label
|
||||
* is combined into tokenRef, ruleRef, ...
|
||||
*/
|
||||
|
||||
/** Add a variable to track last element matched */
|
||||
ruleDeclarations() ::= <<
|
||||
<super.ruleDeclarations()>
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
<ASTLabelType> _first_0 = default(<ASTLabelType>);
|
||||
<ASTLabelType> _last = default(<ASTLabelType>);
|
||||
<endif>
|
||||
>>
|
||||
|
||||
/** What to emit when there is no rewrite rule. For auto build
|
||||
* mode, does nothing.
|
||||
*/
|
||||
noRewrite(rewriteBlockLevel, treeLevel) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
|
||||
<if(rewriteMode)>
|
||||
retval.Tree = (<ASTLabelType>)_first_0;
|
||||
if (adaptor.GetParent(retval.Tree)!=null && adaptor.IsNil(adaptor.GetParent(retval.Tree)))
|
||||
retval.Tree = (<ASTLabelType>)adaptor.GetParent(retval.Tree);
|
||||
<endif>
|
||||
<if(backtracking)>}<endif>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
/** match ^(root children) in tree parser; override here to
|
||||
* add tree construction actions.
|
||||
*/
|
||||
tree(root, actionsAfterRoot, children, nullableChildList,
|
||||
enclosingTreeLevel, treeLevel) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
_last = (<ASTLabelType>)input.LT(1);
|
||||
{
|
||||
<ASTLabelType> _save_last_<treeLevel> = _last;
|
||||
<ASTLabelType> _first_<treeLevel> = default(<ASTLabelType>);
|
||||
<if(!rewriteMode)>
|
||||
<ASTLabelType> root_<treeLevel> = (<ASTLabelType>)adaptor.Nil();
|
||||
<endif>
|
||||
<root:element()>
|
||||
<if(rewriteMode)>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>)<endif>
|
||||
<if(root.el.rule)>
|
||||
if (_first_<enclosingTreeLevel> == null) _first_<enclosingTreeLevel> = <root.el.label>.Tree;
|
||||
<else>
|
||||
if (_first_<enclosingTreeLevel> == null) _first_<enclosingTreeLevel> = <root.el.label>;
|
||||
<endif>
|
||||
<endif>
|
||||
<actionsAfterRoot:element()>
|
||||
<if(nullableChildList)>
|
||||
if (input.LA(1) == TokenTypes.Down) {
|
||||
Match(input, TokenTypes.Down, null); <checkRuleBacktrackFailure()>
|
||||
<children:element()>
|
||||
Match(input, TokenTypes.Up, null); <checkRuleBacktrackFailure()>
|
||||
}
|
||||
<else>
|
||||
Match(input, TokenTypes.Down, null); <checkRuleBacktrackFailure()>
|
||||
<children:element()>
|
||||
Match(input, TokenTypes.Up, null); <checkRuleBacktrackFailure()>
|
||||
<endif>
|
||||
<if(!rewriteMode)>
|
||||
adaptor.AddChild(root_<enclosingTreeLevel>, root_<treeLevel>);
|
||||
<endif>
|
||||
_last = _save_last_<treeLevel>;
|
||||
}
|
||||
<else>
|
||||
<super.tree(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
// TOKEN AST STUFF
|
||||
|
||||
/** ID! and output=AST (same as plain tokenRef) 'cept add
|
||||
* setting of _last
|
||||
*/
|
||||
tokenRefBang(token,label,elementIndex,terminalOptions) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
_last = (<ASTLabelType>)input.LT(1);
|
||||
<super.tokenRef(...)>
|
||||
<else>
|
||||
<super.tokenRefBang(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
/** ID auto construct */
|
||||
tokenRef(token,label,elementIndex,terminalOptions) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
_last = (<ASTLabelType>)input.LT(1);
|
||||
<super.tokenRef(...)>
|
||||
<if(!rewriteMode)>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
|
||||
<if(terminalOptions.node)>
|
||||
<label>_tree = new <terminalOptions.node>(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
|
||||
<else>
|
||||
<label>_tree = (<ASTLabelType>)adaptor.DupNode(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
|
||||
<endif><\n>
|
||||
adaptor.AddChild(root_<treeLevel>, <label>_tree);
|
||||
<if(backtracking)>}<endif>
|
||||
<else> <! rewrite mode !>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>)<endif>
|
||||
if (_first_<treeLevel> == null) _first_<treeLevel> = <label>;
|
||||
<endif>
|
||||
<else>
|
||||
<super.tokenRef(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
/** label+=TOKEN auto construct */
|
||||
tokenRefAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
<tokenRef(...)>
|
||||
<listLabelElem(elem=label,...)>
|
||||
<else>
|
||||
<super.tokenRefAndListLabel(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
/** ^(ID ...) auto construct */
|
||||
tokenRefRuleRoot(token,label,elementIndex,terminalOptions) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
_last = (<ASTLabelType>)input.LT(1);
|
||||
<super.tokenRef(...)>
|
||||
<if(!rewriteMode)>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
|
||||
<if(terminalOptions.node)>
|
||||
<label>_tree = new <terminalOptions.node>(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
|
||||
<else>
|
||||
<label>_tree = (<ASTLabelType>)adaptor.DupNode(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
|
||||
<endif><\n>
|
||||
root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<label>_tree, root_<treeLevel>);
|
||||
<if(backtracking)>}<endif>
|
||||
<endif>
|
||||
<else>
|
||||
<super.tokenRefRuleRoot(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
/** Match ^(label+=TOKEN ...) auto construct */
|
||||
tokenRefRuleRootAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
<tokenRefRuleRoot(...)>
|
||||
<listLabelElem(elem=label,...)>
|
||||
<else>
|
||||
<super.tokenRefRuleRootAndListLabel(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
/** Match . wildcard and auto dup the node/subtree */
|
||||
wildcard(token,label,elementIndex,terminalOptions) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
_last = (<ASTLabelType>)input.LT(1);
|
||||
<super.wildcard(...)>
|
||||
<if(!rewriteMode)>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
|
||||
<label>_tree = (<ASTLabelType>)adaptor.DupTree(<label>);
|
||||
adaptor.AddChild(root_<treeLevel>, <label>_tree);
|
||||
<if(backtracking)>}<endif>
|
||||
<else> <! rewrite mode !>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>)<endif>
|
||||
if (_first_<treeLevel> == null) _first_<treeLevel> = <label>;
|
||||
<endif>
|
||||
<else>
|
||||
<super.wildcard(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
// SET AST
|
||||
|
||||
matchSet(s,label,terminalOptions,elementIndex,postmatchCode) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
_last = (<ASTLabelType>)input.LT(1);
|
||||
<super.matchSet(postmatchCode={
|
||||
<if(!rewriteMode)>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
|
||||
<if(terminalOptions.node)>
|
||||
<label>_tree = new <terminalOptions.node>(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
|
||||
<else>
|
||||
<label>_tree = (<ASTLabelType>)adaptor.DupNode(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
|
||||
<endif><\n>
|
||||
adaptor.AddChild(root_<treeLevel>, <label>_tree);
|
||||
<if(backtracking)>\}<endif>
|
||||
<endif>
|
||||
}, ...
|
||||
)>
|
||||
<else>
|
||||
<super.matchSet(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
matchRuleBlockSet(s,label,terminalOptions,elementIndex,postmatchCode,treeLevel="0") ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
<matchSet(...)>
|
||||
<noRewrite(...)> <! set return tree !>
|
||||
<else>
|
||||
<super.matchRuleBlockSet(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
matchSetBang(s,label,terminalOptions,elementIndex,postmatchCode) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
_last = (<ASTLabelType>)input.LT(1);
|
||||
<super.matchSet(...)>
|
||||
<else>
|
||||
<super.matchSetBang(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
matchSetRuleRoot(s,label,terminalOptions,elementIndex,debug) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
<super.matchSet(postmatchCode={
|
||||
<if(!rewriteMode)>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
|
||||
<if(terminalOptions.node)>
|
||||
<label>_tree = new <terminalOptions.node>(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
|
||||
<else>
|
||||
<label>_tree = (<ASTLabelType>)adaptor.DupNode(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
|
||||
<endif><\n>
|
||||
root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<label>_tree, root_<treeLevel>);
|
||||
<if(backtracking)>\}<endif>
|
||||
<endif>
|
||||
}, ...
|
||||
)>
|
||||
<else>
|
||||
<super.matchSetRuleRoot(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
// RULE REF AST
|
||||
|
||||
/** rule auto construct */
|
||||
ruleRef(rule,label,elementIndex,args,scope) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
_last = (<ASTLabelType>)input.LT(1);
|
||||
<super.ruleRef(...)>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>)<endif>
|
||||
<if(!rewriteMode)>
|
||||
adaptor.AddChild(root_<treeLevel>, <label>.Tree);
|
||||
<else> <! rewrite mode !>
|
||||
if (_first_<treeLevel> == null) _first_<treeLevel> = <label>.Tree;
|
||||
<endif>
|
||||
<else>
|
||||
<super.ruleRef(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
/** x+=rule auto construct */
|
||||
ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
<ruleRef(...)>
|
||||
<listLabelElem(elem={<label>.Tree},...)>
|
||||
<else>
|
||||
<super.ruleRefAndListLabel(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
/** ^(rule ...) auto construct */
|
||||
ruleRefRuleRoot(rule,label,elementIndex,args,scope) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
_last = (<ASTLabelType>)input.LT(1);
|
||||
<super.ruleRef(...)>
|
||||
<if(!rewriteMode)>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<label>.Tree, root_<treeLevel>);
|
||||
<endif>
|
||||
<else>
|
||||
<super.ruleRefRuleRoot(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
/** ^(x+=rule ...) auto construct */
|
||||
ruleRefRuleRootAndListLabel(rule,label,elementIndex,args,scope) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
<ruleRefRuleRoot(...)>
|
||||
<listLabelElem(elem={<label>.Tree},...)>
|
||||
<else>
|
||||
<super.ruleRefRuleRootAndListLabel(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
/** rule when output=AST and tracking for rewrite */
|
||||
ruleRefTrack(rule,label,elementIndex,args,scope) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
_last = (<ASTLabelType>)input.LT(1);
|
||||
<super.ruleRefTrack(...)>
|
||||
<else>
|
||||
<super.ruleRefTrack(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
/** x+=rule when output=AST and tracking for rewrite */
|
||||
ruleRefTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
_last = (<ASTLabelType>)input.LT(1);
|
||||
<super.ruleRefTrackAndListLabel(...)>
|
||||
<else>
|
||||
<super.ruleRefTrackAndListLabel(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
/** ^(rule ...) rewrite */
|
||||
ruleRefRuleRootTrack(rule,label,elementIndex,args,scope) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
_last = (<ASTLabelType>)input.LT(1);
|
||||
<super.ruleRefRootTrack(...)>
|
||||
<else>
|
||||
<super.ruleRefRuleRootTrack(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
/** ^(x+=rule ...) rewrite */
|
||||
ruleRefRuleRootTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
_last = (<ASTLabelType>)input.LT(1);
|
||||
<super.ruleRefRuleRootTrackAndListLabel(...)>
|
||||
<else>
|
||||
<super.ruleRefRuleRootTrackAndListLabel(...)>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
/** Streams for token refs are tree nodes now; override to
|
||||
* change NextToken to NextNode.
|
||||
*/
|
||||
createRewriteNodeFromElement(token,terminalOptions,args) ::= <%
|
||||
<if(terminalOptions.node)>
|
||||
new <terminalOptions.node>(<if(terminalOptions.type)><terminalOptions.type>,<endif>stream_<token>.NextNode())
|
||||
<else>
|
||||
stream_<token>.NextNode()
|
||||
<endif>
|
||||
%>
|
||||
|
||||
ruleCleanUp() ::= <<
|
||||
<super.ruleCleanUp()>
|
||||
<if(!ruleDescriptor.isSynPred)>
|
||||
<if(!rewriteMode)>
|
||||
<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
|
||||
retval.Tree = (<ASTLabelType>)adaptor.RulePostProcessing(root_0);
|
||||
<if(backtracking)>}<endif>
|
||||
<endif>
|
||||
<endif>
|
||||
>>
|
||||
1765
packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/CSharp2.stg
vendored
Normal file
1765
packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/CSharp2.stg
vendored
Normal file
File diff suppressed because it is too large
Load Diff
313
packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/Dbg.stg
vendored
Normal file
313
packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/Dbg.stg
vendored
Normal file
@@ -0,0 +1,313 @@
|
||||
/*
|
||||
* [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.
|
||||
*/
|
||||
/** Template overrides to add debugging to normal Java output;
|
||||
* If ASTs are built, then you'll also get ASTDbg.stg loaded.
|
||||
*/
|
||||
|
||||
@outputFile.debugPreprocessor() ::= "#define ANTLR_DEBUG"
|
||||
|
||||
@outputFile.imports() ::= <<
|
||||
<@super.imports()>
|
||||
using Antlr.Runtime.Debug;
|
||||
using IOException = System.IO.IOException;
|
||||
>>
|
||||
|
||||
@genericParser.members() ::= <<
|
||||
<if(grammar.grammarIsRoot)>
|
||||
public static readonly string[] ruleNames =
|
||||
new string[]
|
||||
{
|
||||
"invalidRule", <grammar.allImportedRules:{rST | "<rST.name>"}; wrap="\n ", separator=", ">
|
||||
};<\n>
|
||||
<endif>
|
||||
<if(grammar.grammarIsRoot)><! grammar imports other grammar(s) !>
|
||||
int ruleLevel = 0;
|
||||
public virtual int RuleLevel { get { return ruleLevel; } }
|
||||
public virtual void IncRuleLevel() { ruleLevel++; }
|
||||
public virtual void DecRuleLevel() { ruleLevel--; }
|
||||
<if(profile)>
|
||||
<ctorForProfilingRootGrammar()>
|
||||
<else>
|
||||
<ctorForRootGrammar()>
|
||||
<endif>
|
||||
<ctorForPredefinedListener()>
|
||||
<else><! imported grammar !>
|
||||
public int RuleLevel { get { return <grammar.delegators:{g| <g:delegateName()>}>.RuleLevel; } }
|
||||
public void IncRuleLevel() { <grammar.delegators:{g| <g:delegateName()>}>.IncRuleLevel(); }
|
||||
public void DecRuleLevel() { <grammar.delegators:{g| <g:delegateName()>}>.DecRuleLevel(); }
|
||||
<ctorForDelegateGrammar()>
|
||||
<endif>
|
||||
<if(profile)>
|
||||
public override bool AlreadyParsedRule( IIntStream input, int ruleIndex )
|
||||
{
|
||||
int stopIndex = GetRuleMemoization(ruleIndex, input.Index);
|
||||
((Profiler)dbg).ExamineRuleMemoization(input, ruleIndex, stopIndex, <grammar.composite.rootGrammar.recognizerName>.ruleNames[ruleIndex]);
|
||||
return base.AlreadyParsedRule(input, ruleIndex);
|
||||
}<\n>
|
||||
public override void Memoize( IIntStream input, int ruleIndex, int ruleStartIndex )
|
||||
{
|
||||
((Profiler)dbg).Memoize(input, ruleIndex, ruleStartIndex, <grammar.composite.rootGrammar.recognizerName>.ruleNames[ruleIndex]);
|
||||
base.Memoize(input, ruleIndex, ruleStartIndex);
|
||||
}<\n>
|
||||
<endif>
|
||||
protected virtual bool EvalPredicate( bool result, string predicate )
|
||||
{
|
||||
dbg.SemanticPredicate( result, predicate );
|
||||
return result;
|
||||
}<\n>
|
||||
>>
|
||||
|
||||
ctorForRootGrammar() ::= <<
|
||||
<! bug: can't use <@super.members()> cut-n-paste instead !>
|
||||
<! Same except we add port number and profile stuff if root grammar !>
|
||||
<actions.(actionScope).ctorModifier; null="public"> <name>( <inputStreamType> input )
|
||||
: this( input, DebugEventSocketProxy.DefaultDebuggerPort, new RecognizerSharedState() )
|
||||
{
|
||||
}
|
||||
<actions.(actionScope).ctorModifier; null="public"> <name>( <inputStreamType> input, int port, RecognizerSharedState state )
|
||||
: base( input, state )
|
||||
{
|
||||
<createListenerAndHandshake()>
|
||||
<grammar.directDelegates:{g|<g:delegateName()> = new <g.recognizerName>( input, dbg, this.state, this<grammar.delegators:{g|, <g:delegateName()>}> );}; separator="\n">
|
||||
<parserCtorBody()>
|
||||
<@finally()>
|
||||
}<\n>
|
||||
>>
|
||||
|
||||
ctorForProfilingRootGrammar() ::= <<
|
||||
<! bug: can't use <@super.members()> cut-n-paste instead !>
|
||||
<actions.(actionScope).ctorModifier; null="public"> <name>( <inputStreamType> input )
|
||||
: this( input, new Profiler(null), new RecognizerSharedState() )
|
||||
{
|
||||
}
|
||||
<actions.(actionScope).ctorModifier; null="public"> <name>( <inputStreamType> input, IDebugEventListener dbg, RecognizerSharedState state )
|
||||
: base( input, dbg, state )
|
||||
{
|
||||
Profiler p = (Profiler)dbg;
|
||||
p.setParser(this);
|
||||
<grammar.directDelegates:
|
||||
{g|<g:delegateName()> = new <g.recognizerName>( input, dbg, this.state, this<grammar.delegators:{g|, <g:delegateName()>}> );}; separator="\n">
|
||||
<parserCtorBody()>
|
||||
<@finally()>
|
||||
}
|
||||
<\n>
|
||||
>>
|
||||
|
||||
/** Basically we don't want to set any dbg listeners are root will have it. */
|
||||
ctorForDelegateGrammar() ::= <<
|
||||
<actions.(actionScope).ctorModifier; null="public"> <name>( <inputStreamType> input, IDebugEventListener dbg, RecognizerSharedState state<grammar.delegators:{g|, <g.recognizerName> <g:delegateName()>}> )
|
||||
: base( input, dbg, state )
|
||||
{
|
||||
<grammar.directDelegates:
|
||||
{g|<g:delegateName()> = new <g.recognizerName>( input, this, this.state<grammar.delegators:{g|, <g:delegateName()>}> );}; separator="\n">
|
||||
<parserCtorBody()>
|
||||
}<\n>
|
||||
>>
|
||||
|
||||
ctorForPredefinedListener() ::= <<
|
||||
<actions.(actionScope).ctorModifier; null="public"> <name>( <inputStreamType> input, IDebugEventListener dbg )
|
||||
<@superClassRef>: base( input, dbg, new RecognizerSharedState() )<@end>
|
||||
{
|
||||
<if(profile)>
|
||||
Profiler p = (Profiler)dbg;
|
||||
p.setParser(this);
|
||||
<endif>
|
||||
<grammar.directDelegates:{g|<g:delegateName()> = new <g.recognizerName>(input, dbg, this.state, this<grammar.delegators:{g|, <g:delegateName()>}>);}; separator="\n">
|
||||
<parserCtorBody()>
|
||||
<@finally()>
|
||||
}<\n>
|
||||
>>
|
||||
|
||||
createListenerAndHandshake() ::= <<
|
||||
<if(TREE_PARSER)>
|
||||
DebugEventSocketProxy proxy = new DebugEventSocketProxy( this, port, input.TreeAdaptor );<\n>
|
||||
<else>
|
||||
DebugEventSocketProxy proxy = new DebugEventSocketProxy( this, port, null );<\n>
|
||||
<endif>
|
||||
DebugListener = proxy;
|
||||
try
|
||||
{
|
||||
proxy.Handshake();
|
||||
}
|
||||
catch ( IOException ioe )
|
||||
{
|
||||
ReportError( ioe );
|
||||
}
|
||||
>>
|
||||
|
||||
@genericParser.superClassName() ::= "Debug<@super.superClassName()>"
|
||||
|
||||
/*
|
||||
* Many of the following rules were merged into CSharp2.stg.
|
||||
*/
|
||||
|
||||
@rule.preamble() ::= <<
|
||||
if (RuleLevel == 0)
|
||||
DebugListener.Commence();
|
||||
IncRuleLevel();
|
||||
>>
|
||||
//@rule.preamble() ::= <<
|
||||
//try
|
||||
//{
|
||||
// dbg.EnterRule( GrammarFileName, "<ruleName>" );
|
||||
// if ( RuleLevel == 0 )
|
||||
// {
|
||||
// dbg.Commence();
|
||||
// }
|
||||
// IncRuleLevel();
|
||||
// dbg.Location( <ruleDescriptor.tree.line>, <ruleDescriptor.tree.charPositionInLine> );<\n>
|
||||
//>>
|
||||
|
||||
@rule.postamble() ::= <<
|
||||
DecRuleLevel();
|
||||
if (RuleLevel == 0)
|
||||
DebugListener.Terminate();
|
||||
>>
|
||||
//@rule.postamble() ::= <<
|
||||
//dbg.Location(<ruleDescriptor.EORNode.line>, <ruleDescriptor.EORNode.charPositionInLine>);<\n>
|
||||
//}
|
||||
//finally
|
||||
//{
|
||||
// dbg.ExitRule( GrammarFileName, "<ruleName>" );
|
||||
// DecRuleLevel();
|
||||
// if ( RuleLevel == 0 )
|
||||
// {
|
||||
// dbg.Terminate();
|
||||
// }
|
||||
//}<\n>
|
||||
//>>
|
||||
|
||||
//@insertSynpreds.start() ::= "dbg.BeginBacktrack( state.backtracking );"
|
||||
//@insertSynpreds.stop() ::= "dbg.EndBacktrack( state.backtracking, success );"
|
||||
|
||||
// Common debug event triggers used by region overrides below
|
||||
|
||||
//enterSubRule() ::= <<
|
||||
//try
|
||||
//{
|
||||
// dbg.EnterSubRule( <decisionNumber> );<\n>
|
||||
//>>
|
||||
|
||||
//exitSubRule() ::= <<
|
||||
//}
|
||||
//finally
|
||||
//{
|
||||
// dbg.ExitSubRule( <decisionNumber> );
|
||||
//}<\n>
|
||||
//>>
|
||||
|
||||
//enterDecision() ::= <<
|
||||
//try
|
||||
//{
|
||||
// dbg.EnterDecision( <decisionNumber> );<\n>
|
||||
//>>
|
||||
|
||||
//exitDecision() ::= <<
|
||||
//}
|
||||
//finally
|
||||
//{
|
||||
// dbg.ExitDecision( <decisionNumber> );
|
||||
//}<\n>
|
||||
//>>
|
||||
|
||||
//enterAlt(n) ::= "dbg.EnterAlt( <n> );<\n>"
|
||||
|
||||
// Region overrides that tell various constructs to add debugging triggers
|
||||
|
||||
//@block.predecision() ::= "<enterSubRule()><enterDecision()>"
|
||||
|
||||
//@block.postdecision() ::= "<exitDecision()>"
|
||||
|
||||
//@block.postbranch() ::= "<exitSubRule()>"
|
||||
|
||||
//@ruleBlock.predecision() ::= "<enterDecision()>"
|
||||
|
||||
//@ruleBlock.postdecision() ::= "<exitDecision()>"
|
||||
|
||||
//@ruleBlockSingleAlt.prealt() ::= "<enterAlt(n=\"1\")>"
|
||||
|
||||
//@blockSingleAlt.prealt() ::= "<enterAlt(n=\"1\")>"
|
||||
|
||||
//@positiveClosureBlock.preloop() ::= "<enterSubRule()>"
|
||||
|
||||
//@positiveClosureBlock.postloop() ::= "<exitSubRule()>"
|
||||
|
||||
//@positiveClosureBlock.predecision() ::= "<enterDecision()>"
|
||||
|
||||
//@positiveClosureBlock.postdecision() ::= "<exitDecision()>"
|
||||
|
||||
//@positiveClosureBlock.earlyExitException() ::=
|
||||
// "dbg.RecognitionException( eee<decisionNumber> );<\n>"
|
||||
|
||||
//@closureBlock.preloop() ::= "<enterSubRule()>"
|
||||
|
||||
//@closureBlock.postloop() ::= "<exitSubRule()>"
|
||||
|
||||
//@closureBlock.predecision() ::= "<enterDecision()>"
|
||||
|
||||
//@closureBlock.postdecision() ::= "<exitDecision()>"
|
||||
|
||||
//@altSwitchCase.prealt() ::= "<enterAlt(n=i)>"
|
||||
|
||||
//@element.prematch() ::=
|
||||
// "dbg.Location( <it.line>, <it.pos> );"
|
||||
|
||||
//@matchSet.mismatchedSetException() ::=
|
||||
// "dbg.RecognitionException( mse );"
|
||||
|
||||
//@dfaState.noViableAltException() ::= "dbg.RecognitionException( nvae );"
|
||||
|
||||
//@dfaStateSwitch.noViableAltException() ::= "dbg.RecognitionException( nvae );"
|
||||
|
||||
//dfaDecision(decisionNumber,description) ::= <<
|
||||
//try
|
||||
//{
|
||||
// isCyclicDecision = true;
|
||||
// <super.dfaDecision(...)>
|
||||
//}
|
||||
//catch ( NoViableAltException nvae )
|
||||
//{
|
||||
// dbg.RecognitionException( nvae );
|
||||
// throw nvae;
|
||||
//}
|
||||
//>>
|
||||
|
||||
//@cyclicDFA.errorMethod() ::= <<
|
||||
//public override void Error( NoViableAltException nvae )
|
||||
//{
|
||||
// ((DebugParser)recognizer).dbg.RecognitionException( nvae );
|
||||
//}
|
||||
//>>
|
||||
|
||||
/** Force predicate validation to trigger an event */
|
||||
evalPredicate(pred,description) ::= <<
|
||||
EvalPredicate(<pred>, "<description>")
|
||||
>>
|
||||
171
packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ST.stg
vendored
Normal file
171
packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ST.stg
vendored
Normal file
@@ -0,0 +1,171 @@
|
||||
/*
|
||||
* [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.
|
||||
*/
|
||||
/** Template subgroup to add template rewrite output
|
||||
* If debugging, then you'll also get STDbg.stg loaded.
|
||||
*/
|
||||
|
||||
@outputFile.imports() ::= <<
|
||||
<@super.imports()>
|
||||
using Antlr.StringTemplate;
|
||||
using Antlr.StringTemplate.Language;
|
||||
<if(!backtracking)>
|
||||
using Hashtable = System.Collections.Hashtable;
|
||||
<endif>
|
||||
|
||||
>>
|
||||
|
||||
/** Add this to each rule's return value struct */
|
||||
@returnScope.ruleReturnMembers() ::= <<
|
||||
private StringTemplate _st;
|
||||
public StringTemplate Template { get { return _st; } set { _st = value; } }
|
||||
public override string ToString() { return (Template==null) ? string.Empty : Template.ToString(); }
|
||||
>>
|
||||
|
||||
@genericParser.members() ::= <<
|
||||
<@super.members()>
|
||||
protected StringTemplateGroup templateLib = new StringTemplateGroup("<name>Templates", typeof(AngleBracketTemplateLexer) );
|
||||
|
||||
public StringTemplateGroup TemplateLib
|
||||
{
|
||||
get { return this.templateLib; }
|
||||
set { this.templateLib = value; }
|
||||
}
|
||||
|
||||
/// \<summary> Allows convenient multi-value initialization:
|
||||
/// "new STAttrMap().Add(...).Add(...)"
|
||||
/// \</summary>
|
||||
protected class STAttrMap : Hashtable
|
||||
{
|
||||
public STAttrMap Add(string attrName, object value)
|
||||
{
|
||||
base.Add(attrName, value);
|
||||
return this;
|
||||
}
|
||||
public STAttrMap Add(string attrName, int value)
|
||||
{
|
||||
base.Add(attrName, value);
|
||||
return this;
|
||||
}
|
||||
}
|
||||
>>
|
||||
|
||||
/** x+=rule when output=template */
|
||||
ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<
|
||||
<ruleRef(...)>
|
||||
<listLabel(elem=label+".Template",...)>
|
||||
>>
|
||||
|
||||
rewriteTemplate(alts) ::= <<
|
||||
|
||||
// TEMPLATE REWRITE
|
||||
<if(backtracking)>
|
||||
if ( <actions.(actionScope).synpredgate> )
|
||||
{
|
||||
<alts:rewriteTemplateAlt(); separator="else ">
|
||||
<if(rewriteMode)><replaceTextInLine()><endif>
|
||||
}
|
||||
<else>
|
||||
<alts:rewriteTemplateAlt(); separator="else ">
|
||||
<if(rewriteMode)><replaceTextInLine()><endif>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
replaceTextInLine() ::= <<
|
||||
<if(TREE_PARSER)>
|
||||
((TokenRewriteStream)input.TokenStream).Replace(
|
||||
input.TreeAdaptor.GetTokenStartIndex(retval.Start),
|
||||
input.TreeAdaptor.GetTokenStopIndex(retval.Start),
|
||||
retval.Template);
|
||||
<else>
|
||||
((TokenRewriteStream)input).Replace(
|
||||
((IToken)retval.Start).TokenIndex,
|
||||
input.LT(-1).TokenIndex,
|
||||
retval.Template);
|
||||
<endif>
|
||||
>>
|
||||
|
||||
rewriteTemplateAlt() ::= <<
|
||||
// <it.description>
|
||||
<if(it.pred)>
|
||||
if (<it.pred>) {
|
||||
retval.Template = <it.alt>;
|
||||
}<\n>
|
||||
<else>
|
||||
{
|
||||
retval.Template = <it.alt>;
|
||||
}<\n>
|
||||
<endif>
|
||||
>>
|
||||
|
||||
rewriteEmptyTemplate(alts) ::= <<
|
||||
null;
|
||||
>>
|
||||
|
||||
/** Invoke a template with a set of attribute name/value pairs.
|
||||
* Set the value of the rule's template *after* having set
|
||||
* the attributes because the rule's template might be used as
|
||||
* an attribute to build a bigger template; you get a self-embedded
|
||||
* template.
|
||||
*/
|
||||
rewriteExternalTemplate(name,args) ::= <<
|
||||
templateLib.GetInstanceOf("<name>"<if(args)>,
|
||||
new STAttrMap()<args:{a | .Add("<a.name>", <a.value>)}>
|
||||
<endif>)
|
||||
>>
|
||||
|
||||
/** expr is a string expression that says what template to load */
|
||||
rewriteIndirectTemplate(expr,args) ::= <<
|
||||
templateLib.GetInstanceOf(<expr><if(args)>,
|
||||
new STAttrMap()<args:{a | .Add("<a.name>", <a.value>)}>
|
||||
<endif>)
|
||||
>>
|
||||
|
||||
/** Invoke an inline template with a set of attribute name/value pairs */
|
||||
rewriteInlineTemplate(args, template) ::= <<
|
||||
new StringTemplate(templateLib, "<template>"<if(args)>,
|
||||
new STAttrMap()<args:{a | .Add("<a.name>", <a.value>)}>
|
||||
<endif>)
|
||||
>>
|
||||
|
||||
/** plain -> {foo} action */
|
||||
rewriteAction(action) ::= <<
|
||||
<action>
|
||||
>>
|
||||
|
||||
/** An action has %st.attrName=expr; or %{st}.attrName=expr; */
|
||||
actionSetAttribute(st,attrName,expr) ::= <<
|
||||
(<st>).SetAttribute("<attrName>",<expr>);
|
||||
>>
|
||||
|
||||
/** Translate %{stringExpr} */
|
||||
actionStringConstructor(stringExpr) ::= <<
|
||||
new StringTemplate(templateLib,<stringExpr>)
|
||||
>>
|
||||
Reference in New Issue
Block a user