diff options
Diffstat (limited to 'tool/src/main/resources/org/antlr/codegen/templates/Delphi/ASTParser.stg')
| -rw-r--r-- | tool/src/main/resources/org/antlr/codegen/templates/Delphi/ASTParser.stg | 220 |
1 files changed, 220 insertions, 0 deletions
diff --git a/tool/src/main/resources/org/antlr/codegen/templates/Delphi/ASTParser.stg b/tool/src/main/resources/org/antlr/codegen/templates/Delphi/ASTParser.stg new file mode 100644 index 0000000..f95a4fa --- /dev/null +++ b/tool/src/main/resources/org/antlr/codegen/templates/Delphi/ASTParser.stg @@ -0,0 +1,220 @@ +/* + [The "BSD license"] + Copyright (c) 2008 Erik van Bilsen + Copyright (c) 2007-2008 Johannes Luber + Copyright (c) 2005-2007 Kunle Odutola + Copyright (c) 2005-2006 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. + */ +group ASTParser; + +@rule.setErrorReturnValue() ::= << +RetVal.Tree := Adaptor.ErrorNode(Input, RetVal.Start as IToken, + Input.LT(-1), RE) as I<ASTLabelType>; +>> + +// TOKEN AST STUFF + +/** ID and output=AST */ +tokenRef(token,label,elementIndex,terminalOptions) ::= << +<super.tokenRef(...)> +<if(backtracking)> +if (State.Backtracking = 0) then +begin<\n> +<endif> +<label>_tree := <createNodeFromToken(...)>; +Adaptor.AddChild(Root[0], <label>_tree); +<if(backtracking)> +end; +<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 (State.Backtracking = 0) then +begin +<endif> +<label>_tree := <createNodeFromToken(...)>; +Root[0] := Adaptor.BecomeRoot(<label>_tree, Root[0]) as I<ASTLabelType>; +<if(backtracking)> +end; +<endif> +>> + +/** ids+=ID! and output=AST */ +tokenRefBangAndListLabel(token,label,elementIndex,terminalOptions) ::= << +<tokenRefBang(...)> +<listLabel(elem=label,...)> +>> + +/** label+=TOKEN when output=AST but not rewrite alt */ +tokenRefAndListLabel(token,label,elementIndex,terminalOptions) ::= << +<tokenRef(...)> +<listLabel(elem=label,...)> +>> + +/** Match label+=TOKEN^ when output=AST but not rewrite alt */ +tokenRefRuleRootAndListLabel(token,label,terminalOptions,elementIndex) ::= << +<tokenRefRuleRoot(...)> +<listLabel(elem=label,...)> +>> + +// 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 (State.Backtracking = 0) then <endif>Adaptor.AddChild(Root[0], <createNodeFromToken(...)>);})> +>> + +matchRuleBlockSet(s,label,terminalOptions,elementIndex,postmatchCode,treeLevel="0") ::= << +<matchSet(...)> +>> + +matchSetBang(s,label,elementIndex,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> := Input.LT(1) as I<labelType>;<\n> +<endif> +<super.matchSet(..., postmatchCode={<if(backtracking)>if (State.Backtracking = 0) then <endif>Root[0] := Adaptor.BecomeRoot(<createNodeFromToken(...)>, Root[0]) as I<ASTLabelType>;})> +>> + +// RULE REF AST + +/** rule when output=AST */ +ruleRef(rule,label,elementIndex,args,scope) ::= << +<super.ruleRef(...)> +<if(backtracking)>if (State.Backtracking = 0) then <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 (State.Backtracking = 0) then <endif>Root[0] := Adaptor.BecomeRoot(<label>.Tree, Root[0]) as I<ASTLabelType>; +>> + +/** x+=rule when output=AST */ +ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= << +<ruleRef(...)> +<listLabel(elem=label+".Tree",...)> +>> + +/** x+=rule! when output=AST is a rule ref with list addition */ +ruleRefBangAndListLabel(rule,label,elementIndex,args,scope) ::= << +<ruleRefBang(...)> +<listLabel(elem=label+".Tree",...)> +>> + +/** x+=rule^ */ +ruleRefRuleRootAndListLabel(rule,label,elementIndex,args,scope) ::= << +<ruleRefRuleRoot(...)> +<listLabel(elem=label+".Tree",...)> +>> + +// WILDCARD AST + +wildcard(label,elementIndex) ::= << +<super.wildcard(...)> +<if(backtracking)> +if (State.Backtracking = 0) then +begin +<endif> + <label>_tree := Adaptor.CreateNode(<label>) as I<ASTLabelType>; + Adaptor.AddChild(Root[0], <label>_tree); +<if(backtracking)> +end; +<endif> +>> + +wildcardBang(label,elementIndex) ::= "<super.wildcard(...)>" + +wildcardRuleRoot(label,elementIndex) ::= << +<super.wildcard(...)> +<if(backtracking)> +if (State.Backtracking = 0) then +begin +<endif> + <label>_tree := Adaptor.CreateNode(<label>) as I<ASTLabelType>; + Root[0] := Adaptor.BecomeRoot(<label>_tree, Root[0]) as I<ASTLabelType>; +<if(backtracking)> +end; +<endif> +>> + +createNodeFromToken(label,terminalOptions) ::= << +<if(terminalOptions.node)> +T<terminalOptions.node>.Create(<label>) <! new MethodNode(IDLabel) !> +<else> +Adaptor.CreateNode(<label>) as I<ASTLabelType> +<endif> +>> + +ruleCleanUp() ::= << +<super.ruleCleanUp()> +<if(backtracking)> +if (State.Backtracking = 0) then +begin<\n> +<endif> +RetVal.Tree := Adaptor.RulePostProcessing(Root[0]) as I<ASTLabelType>; +<if(!TREE_PARSER)> +Adaptor.SetTokenBoundaries(RetVal.Tree, RetVal.Start as IToken, RetVal.Stop as IToken); +<endif> +<if(backtracking)> +<\n>end; +<endif> +>> |