From 07161bffe74109cd7c26bc3080cdab81dfd541ca Mon Sep 17 00:00:00 2001 From: parrt Date: Sat, 2 Jul 2011 16:04:56 -0800 Subject: [PATCH] major reorg to get rewrites in there [git-p4: depot-paths = "//depot/code/antlr4/main/": change = 8821] --- .../v4/runtime/tree/BaseTreeAdaptor.java | 4 +- .../antlr/v4/runtime/tree/TreeAdaptor.java | 2 +- tool/playground/T.g | 2 +- .../v4/tool/templates/codegen/Java/Java.stg | 17 ++- .../v4/codegen/BlankOutputModelFactory.java | 106 ++++++++++++++++++ .../v4/codegen/CodeGeneratorExtension.java | 10 +- .../v4/codegen/DefaultOutputModelFactory.java | 68 +---------- .../v4/codegen/OutputModelController.java | 71 +++++++----- .../antlr/v4/codegen/OutputModelFactory.java | 23 ++-- .../antlr/v4/codegen/ParserASTExtension.java | 30 ++++- .../org/antlr/v4/codegen/ParserFactory.java | 39 ++++--- .../org/antlr/v4/codegen/SourceGenTriggers.g | 54 +++++---- tool/src/org/antlr/v4/codegen/Target.java | 12 +- .../org/antlr/v4/codegen/model/AltBlock.java | 2 +- .../org/antlr/v4/codegen/model/Choice.java | 4 +- .../{CodeBlock.java => CodeBlockForAlt.java} | 10 +- .../antlr/v4/codegen/model/LL1AltBlock.java | 2 +- .../org/antlr/v4/codegen/model/LL1Choice.java | 2 +- .../org/antlr/v4/codegen/model/LL1Loop.java | 2 +- .../v4/codegen/model/LL1OptionalBlock.java | 2 +- .../model/LL1OptionalBlockSingleAlt.java | 2 +- .../antlr/v4/codegen/model/LL1PlusBlock.java | 2 +- .../codegen/model/LL1PlusBlockSingleAlt.java | 2 +- .../antlr/v4/codegen/model/LL1StarBlock.java | 2 +- .../codegen/model/LL1StarBlockSingleAlt.java | 2 +- tool/src/org/antlr/v4/codegen/model/Loop.java | 2 +- .../antlr/v4/codegen/model/OptionalBlock.java | 2 +- .../org/antlr/v4/codegen/model/PlusBlock.java | 2 +- .../org/antlr/v4/codegen/model/Rewrite.java | 43 +++++++ .../org/antlr/v4/codegen/model/StarBlock.java | 2 +- .../v4/codegen/model/ast/RewriteRuleRef.java | 40 +++++++ .../v4/codegen/model/ast/RewriteTokenRef.java | 40 +++++++ ...rackElement.java => TrackRuleElement.java} | 8 +- .../codegen/model/ast/TrackTokenElement.java | 42 +++++++ .../v4/codegen/model/ast/TreeRewrite.java | 41 +++++++ 35 files changed, 511 insertions(+), 183 deletions(-) create mode 100644 tool/src/org/antlr/v4/codegen/BlankOutputModelFactory.java rename tool/src/org/antlr/v4/codegen/model/{CodeBlock.java => CodeBlockForAlt.java} (81%) create mode 100644 tool/src/org/antlr/v4/codegen/model/Rewrite.java create mode 100644 tool/src/org/antlr/v4/codegen/model/ast/RewriteRuleRef.java create mode 100644 tool/src/org/antlr/v4/codegen/model/ast/RewriteTokenRef.java rename tool/src/org/antlr/v4/codegen/model/ast/{TrackElement.java => TrackRuleElement.java} (87%) create mode 100644 tool/src/org/antlr/v4/codegen/model/ast/TrackTokenElement.java create mode 100644 tool/src/org/antlr/v4/codegen/model/ast/TreeRewrite.java diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/BaseTreeAdaptor.java b/runtime/Java/src/org/antlr/v4/runtime/tree/BaseTreeAdaptor.java index 7284bced4..571d82af5 100644 --- a/runtime/Java/src/org/antlr/v4/runtime/tree/BaseTreeAdaptor.java +++ b/runtime/Java/src/org/antlr/v4/runtime/tree/BaseTreeAdaptor.java @@ -52,8 +52,8 @@ public abstract class BaseTreeAdaptor implements TreeAdaptor { public List getChildren(Object root) { return ((Tree)root).getChildren(); } */ - public List createElementList() { - return new ArrayList(5); + public List createElementList() { + return new ArrayList(3); } // END v4 stuff diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/TreeAdaptor.java b/runtime/Java/src/org/antlr/v4/runtime/tree/TreeAdaptor.java index f700bf032..935f2169f 100644 --- a/runtime/Java/src/org/antlr/v4/runtime/tree/TreeAdaptor.java +++ b/runtime/Java/src/org/antlr/v4/runtime/tree/TreeAdaptor.java @@ -51,7 +51,7 @@ public interface TreeAdaptor { //public List getChildren(Object root); /** Used to track elements to left of -> for use in rewrite */ - public List createElementList(); + public List createElementList(); // END new v4 stuff diff --git a/tool/playground/T.g b/tool/playground/T.g index 24b79e5d8..3c214e923 100644 --- a/tool/playground/T.g +++ b/tool/playground/T.g @@ -1,7 +1,7 @@ grammar T; options {output=AST;} tokens {I;} -a : A b -> A b ; +a : A b ';' -> A b ';' ; b : B ; diff --git a/tool/resources/org/antlr/v4/tool/templates/codegen/Java/Java.stg b/tool/resources/org/antlr/v4/tool/templates/codegen/Java/Java.stg index f2e054149..eb93994da 100644 --- a/tool/resources/org/antlr/v4/tool/templates/codegen/Java/Java.stg +++ b/tool/resources/org/antlr/v4/tool/templates/codegen/Java/Java.stg @@ -121,7 +121,7 @@ public QStack\<\> _stk = new QStack\<> -CodeBlock(c, ops) ::= << +CodeBlockForAlt(c, ops) ::= << >> @@ -353,7 +353,7 @@ public static class extends ParserRuleContext { AttributeDecl(d) ::= "" -/** If we don't know location of label def, use this template */ +/** If we don't know location of label def x, use this template */ labelref(x) ::= "_localctx." // AST stuff (TODO: separate?) @@ -371,9 +371,18 @@ _localctx.tree = _root0; _adaptor.setTokenBoundaries(_localctx.tree, _localctx.start, _localctx.stop); >> -ElementListDecl(d) ::= "List = new ArrayList(5);" +ElementListDecl(d) ::= "List\ = _adaptor.createElementList();" ElementListName(elemName) ::= "_track_" -TrackElement(e) ::= "_track_.add();" +TrackRuleElement(e) ::= ".add();" +TrackTokenElement(e) ::= ".add(_adaptor.create());" + +TreeRewrite(tr, ops) ::= << +// rewrite: ... + +>> + +RewriteTokenRef(t) ::= "/* tokenref */" +RewriteRuleRef(r) ::= "/* ruleref */" /* BitSetDecl(b) ::= << diff --git a/tool/src/org/antlr/v4/codegen/BlankOutputModelFactory.java b/tool/src/org/antlr/v4/codegen/BlankOutputModelFactory.java new file mode 100644 index 000000000..3589b3b7c --- /dev/null +++ b/tool/src/org/antlr/v4/codegen/BlankOutputModelFactory.java @@ -0,0 +1,106 @@ +/* + [The "BSD license"] + 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. + */ + +package org.antlr.v4.codegen; + +import org.antlr.v4.codegen.model.*; +import org.antlr.v4.codegen.model.ast.TreeRewrite; +import org.antlr.v4.runtime.misc.IntervalSet; +import org.antlr.v4.tool.*; + +import java.util.List; + +public abstract class BlankOutputModelFactory implements OutputModelFactory { + public ParserFile parserFile(String fileName) { return null; } + + public Parser parser(ParserFile file) { return null; } + + public RuleFunction rule(Rule r) { return null; } + + public List rulePostamble(RuleFunction function, Rule r) { return null; } + + public LexerFile lexerFile(String fileName) { return null; } + + public Lexer lexer(LexerFile file) { return null; } + + // ALTERNATIVES / ELEMENTS + + public CodeBlockForAlt alternative(List elems) { return null; } + + public CodeBlockForAlt epsilon() { return null; } + + public List ruleRef(GrammarAST ID, GrammarAST label, GrammarAST args) { return null; } + + public List tokenRef(GrammarAST ID, GrammarAST label, GrammarAST args) { return null; } + + public List stringRef(GrammarAST ID, GrammarAST label) { return tokenRef(ID, label, null); } + + // ACTIONS + + public List action(GrammarAST ast) { return null; } + + public List forcedAction(GrammarAST ast) { return null; } + + public List sempred(GrammarAST ast) { return null; } + + // AST OPS + + public List rootToken(List ops) { return ops; } + + public List rootRule(List ops) { return ops; } + + // AST REWRITES + + public TreeRewrite treeRewrite(List ops) { return null; } + + public List rewrite_ruleRef(GrammarAST ID) { return null; } + + public List rewrite_tokenRef(GrammarAST ID) { return null; } + + public List rewrite_stringRef(GrammarAST ID) { return rewrite_tokenRef(ID); } + + // BLOCKS + + public Choice getChoiceBlock(BlockAST blkAST, List alts) { return null; } + + public Choice getEBNFBlock(GrammarAST ebnfRoot, List alts) { return null; } + + public Choice getLL1ChoiceBlock(BlockAST blkAST, List alts) { return null; } + + public Choice getLLStarChoiceBlock(BlockAST blkAST, List alts) { return null; } + + public Choice getLL1EBNFBlock(GrammarAST ebnfRoot, List alts) { return null; } + + public Choice getLLStarEBNFBlock(GrammarAST ebnfRoot, List alts) { return null; } + + public List getLL1Test(IntervalSet look, GrammarAST blkAST) { return null; } + + public boolean needsImplicitLabel(GrammarAST ID, LabeledOp op) { return false; } +} + diff --git a/tool/src/org/antlr/v4/codegen/CodeGeneratorExtension.java b/tool/src/org/antlr/v4/codegen/CodeGeneratorExtension.java index dbb789361..391f40de1 100644 --- a/tool/src/org/antlr/v4/codegen/CodeGeneratorExtension.java +++ b/tool/src/org/antlr/v4/codegen/CodeGeneratorExtension.java @@ -31,6 +31,7 @@ package org.antlr.v4.codegen; import org.antlr.v4.codegen.model.*; +import org.antlr.v4.codegen.model.ast.TreeRewrite; import org.antlr.v4.tool.GrammarAST; import java.util.List; @@ -55,7 +56,9 @@ public class CodeGeneratorExtension { public List rulePostamble(List ops) { return ops; } - public List alternative(List ops) { return ops; } + public CodeBlockForAlt alternative(CodeBlockForAlt blk) { return blk; } + + public CodeBlockForAlt epsilon(CodeBlockForAlt blk) { return blk; } public List ruleRef(List ops) { return ops; } @@ -63,7 +66,6 @@ public class CodeGeneratorExtension { public List stringRef(List ops) { return ops; } - public List epsilon(List ops) { return ops; } // ACTIONS @@ -85,10 +87,14 @@ public class CodeGeneratorExtension { // AST REWRITEs + public TreeRewrite treeRewrite(TreeRewrite code) { return code; } + public List rewrite_ruleRef(List ops) { return ops; } public List rewrite_tokenRef(List ops) { return ops; } + public List rewrite_stringRef(List ops) { return ops; } + // BLOCKS public List getChoiceBlock(List ops) { return ops; } diff --git a/tool/src/org/antlr/v4/codegen/DefaultOutputModelFactory.java b/tool/src/org/antlr/v4/codegen/DefaultOutputModelFactory.java index 9aa91ac3d..33fdaa913 100644 --- a/tool/src/org/antlr/v4/codegen/DefaultOutputModelFactory.java +++ b/tool/src/org/antlr/v4/codegen/DefaultOutputModelFactory.java @@ -30,7 +30,6 @@ package org.antlr.v4.codegen; import org.antlr.v4.codegen.model.*; -import org.antlr.v4.runtime.misc.IntervalSet; import org.antlr.v4.tool.*; import java.util.*; @@ -40,7 +39,7 @@ import java.util.*; * objects such as RuleFunction that surround elements in rule * functions. */ -public abstract class DefaultOutputModelFactory implements OutputModelFactory { +public abstract class DefaultOutputModelFactory extends BlankOutputModelFactory { // Interface to outside world public Grammar g; public CodeGenerator gen; @@ -60,71 +59,6 @@ public abstract class DefaultOutputModelFactory implements OutputModelFactory { public CodeGenerator getGenerator() { return gen; } - public ParserFile parserFile(String fileName) { return null; } - - public Parser parser(ParserFile file) { return null; } - - public RuleFunction rule(Rule r) { return null; } - - public List rulePostamble(RuleFunction function, Rule r) { return null; } - - public LexerFile lexerFile(String fileName) { return null; } - - public Lexer lexer(LexerFile file) { return null; } - - // ALTERNATIVES / ELEMENTS - - public List alternative(List elems) { return null; } - - public List ruleRef(GrammarAST ID, GrammarAST label, GrammarAST args) { return null; } - - public List tokenRef(GrammarAST ID, GrammarAST label, GrammarAST args) { return null; } - - public List stringRef(GrammarAST ID, GrammarAST label) { return null; } - - public List epsilon() { return null; } - - // ACTIONS - - public List action(GrammarAST ast) { return null; } - - public List forcedAction(GrammarAST ast) { return null; } - - public List sempred(GrammarAST ast) { return null; } - - // AST OPS - - public List rootToken(List ops) { return ops; } - - public List rootRule(List ops) { return ops; } - - // AST REWRITES - - public List rewrite_ruleRef(GrammarAST ID) { return null; } - - public List rewrite_tokenRef(GrammarAST ID) { return null; } - - // BLOCKS - - public List getChoiceBlock(BlockAST blkAST, List alts) { return null; } - - public List getEBNFBlock(GrammarAST ebnfRoot, List alts) { return null; } - - public List getLL1ChoiceBlock(BlockAST blkAST, List alts) { return null; } - - public List getLLStarChoiceBlock(BlockAST blkAST, List alts) { return null; } - - public List getLL1EBNFBlock(GrammarAST ebnfRoot, List alts) { return null; } - - public List getLLStarEBNFBlock(GrammarAST ebnfRoot, List alts) { return null; } - - public List getLL1Test(IntervalSet look, GrammarAST blkAST) { return null; } - - public boolean needsImplicitLabel(GrammarAST ID, LabeledOp op) { return false; } - - - // SET CONTEXT - public OutputModelObject getRoot() { return root; } public void setRoot(OutputModelObject root) { this.root = root; } diff --git a/tool/src/org/antlr/v4/codegen/OutputModelController.java b/tool/src/org/antlr/v4/codegen/OutputModelController.java index 3437c1a7f..921f11322 100644 --- a/tool/src/org/antlr/v4/codegen/OutputModelController.java +++ b/tool/src/org/antlr/v4/codegen/OutputModelController.java @@ -31,6 +31,7 @@ package org.antlr.v4.codegen; import org.antlr.runtime.tree.*; import org.antlr.v4.codegen.model.*; +import org.antlr.v4.codegen.model.ast.TreeRewrite; import org.antlr.v4.parse.*; import org.antlr.v4.runtime.misc.IntervalSet; import org.antlr.v4.tool.*; @@ -76,7 +77,7 @@ public class OutputModelController implements OutputModelFactory { CommonTreeNodeStream nodes = new CommonTreeNodeStream(adaptor,blk); SourceGenTriggers genTriggers = new SourceGenTriggers(nodes, this); try { - function.code = genTriggers.block(null,null); // walk AST of rule alts/elements + function.code = DefaultOutputModelFactory.list(genTriggers.block(null, null)); // walk AST of rule alts/elements } catch (Exception e){ e.printStackTrace(System.err); @@ -138,10 +139,10 @@ public class OutputModelController implements OutputModelFactory { public CodeGenerator getGenerator() { return delegate.getGenerator(); } - public List alternative(List elems) { - List ops = delegate.alternative(elems); - for (CodeGeneratorExtension ext : extensions) ops = ext.alternative(ops); - return ops; + public CodeBlockForAlt alternative(List elems) { + CodeBlockForAlt code = delegate.alternative(elems); + for (CodeGeneratorExtension ext : extensions) code = ext.alternative(code); + return code; } public List ruleRef(GrammarAST ID, GrammarAST label, GrammarAST args) { @@ -178,10 +179,10 @@ public class OutputModelController implements OutputModelFactory { return ops; } - public List epsilon() { - List ops = delegate.epsilon(); - for (CodeGeneratorExtension ext : extensions) ops = ext.epsilon(ops); - return ops; + public CodeBlockForAlt epsilon() { + CodeBlockForAlt blk = delegate.epsilon(); + for (CodeGeneratorExtension ext : extensions) blk = ext.epsilon(blk); + return blk; } public List action(GrammarAST ast) { @@ -214,40 +215,46 @@ public class OutputModelController implements OutputModelFactory { return ops; } - public List getChoiceBlock(BlockAST blkAST, List alts) { - List ops = delegate.getChoiceBlock(blkAST, alts); + public Choice getChoiceBlock(BlockAST blkAST, List alts) { + Choice c = delegate.getChoiceBlock(blkAST, alts); + List ops = DefaultOutputModelFactory.list(c); for (CodeGeneratorExtension ext : extensions) ops = ext.getChoiceBlock(ops); - return ops; + return c; } - public List getEBNFBlock(GrammarAST ebnfRoot, List alts) { - List ops = delegate.getEBNFBlock(ebnfRoot, alts); + public Choice getEBNFBlock(GrammarAST ebnfRoot, List alts) { + Choice c = delegate.getEBNFBlock(ebnfRoot, alts); + List ops = DefaultOutputModelFactory.list(c); for (CodeGeneratorExtension ext : extensions) ops = ext.getEBNFBlock(ops); - return ops; + return c; } - public List getLL1ChoiceBlock(BlockAST blkAST, List alts) { - List ops = delegate.getLL1ChoiceBlock(blkAST, alts); + public Choice getLL1ChoiceBlock(BlockAST blkAST, List alts) { + Choice c = delegate.getLL1ChoiceBlock(blkAST, alts); + List ops = DefaultOutputModelFactory.list(c); for (CodeGeneratorExtension ext : extensions) ops = ext.getLL1ChoiceBlock(ops); - return ops; + return c; } - public List getLLStarChoiceBlock(BlockAST blkAST, List alts) { - List ops = delegate.getLLStarChoiceBlock(blkAST, alts); + public Choice getLLStarChoiceBlock(BlockAST blkAST, List alts) { + Choice c = delegate.getLLStarChoiceBlock(blkAST, alts); + List ops = DefaultOutputModelFactory.list(c); for (CodeGeneratorExtension ext : extensions) ops = ext.getLLStarChoiceBlock(ops); - return ops; + return c; } - public List getLL1EBNFBlock(GrammarAST ebnfRoot, List alts) { - List ops = delegate.getLL1EBNFBlock(ebnfRoot, alts); + public Choice getLL1EBNFBlock(GrammarAST ebnfRoot, List alts) { + Choice c = delegate.getLL1EBNFBlock(ebnfRoot, alts); + List ops = DefaultOutputModelFactory.list(c); for (CodeGeneratorExtension ext : extensions) ops = ext.getLL1EBNFBlock(ops); - return ops; + return c; } - public List getLLStarEBNFBlock(GrammarAST ebnfRoot, List alts) { - List ops = delegate.getLLStarEBNFBlock(ebnfRoot, alts); + public Choice getLLStarEBNFBlock(GrammarAST ebnfRoot, List alts) { + Choice c = delegate.getLLStarEBNFBlock(ebnfRoot, alts); + List ops = DefaultOutputModelFactory.list(c); for (CodeGeneratorExtension ext : extensions) ops = ext.getLLStarEBNFBlock(ops); - return ops; + return c; } public List getLL1Test(IntervalSet look, GrammarAST blkAST) { @@ -262,6 +269,14 @@ public class OutputModelController implements OutputModelFactory { return needs; } + // REWRITES + + public TreeRewrite treeRewrite(List ops) { + TreeRewrite r = delegate.treeRewrite(ops); + for (CodeGeneratorExtension ext : extensions) r = ext.treeRewrite(r); + return r; + } + public List rewrite_ruleRef(GrammarAST ID) { List ops = delegate.rewrite_ruleRef(ID); for (CodeGeneratorExtension ext : extensions) ops = ext.rewrite_ruleRef(ops); @@ -274,6 +289,8 @@ public class OutputModelController implements OutputModelFactory { return ops; } + public List rewrite_stringRef(GrammarAST ID) { return rewrite_tokenRef(ID); } + public OutputModelObject getRoot() { return delegate.getRoot(); } public void setRoot(OutputModelObject root) { delegate.setRoot(root); } diff --git a/tool/src/org/antlr/v4/codegen/OutputModelFactory.java b/tool/src/org/antlr/v4/codegen/OutputModelFactory.java index cd83c76c1..e93883d65 100644 --- a/tool/src/org/antlr/v4/codegen/OutputModelFactory.java +++ b/tool/src/org/antlr/v4/codegen/OutputModelFactory.java @@ -30,6 +30,7 @@ package org.antlr.v4.codegen; import org.antlr.v4.codegen.model.*; +import org.antlr.v4.codegen.model.ast.TreeRewrite; import org.antlr.v4.runtime.misc.IntervalSet; import org.antlr.v4.tool.*; @@ -54,7 +55,9 @@ public interface OutputModelFactory { // ELEMENT TRIGGERS - List alternative(List elems); + CodeBlockForAlt alternative(List elems); + + CodeBlockForAlt epsilon(); List ruleRef(GrammarAST ID, GrammarAST label, GrammarAST args); @@ -62,8 +65,6 @@ public interface OutputModelFactory { List stringRef(GrammarAST ID, GrammarAST label); - List epsilon(); - List action(GrammarAST ast); List forcedAction(GrammarAST ast); @@ -74,17 +75,17 @@ public interface OutputModelFactory { List rootRule(List ops); - List getChoiceBlock(BlockAST blkAST, List alts); + Choice getChoiceBlock(BlockAST blkAST, List alts); - List getEBNFBlock(GrammarAST ebnfRoot, List alts); + Choice getEBNFBlock(GrammarAST ebnfRoot, List alts); - List getLL1ChoiceBlock(BlockAST blkAST, List alts); + Choice getLL1ChoiceBlock(BlockAST blkAST, List alts); - List getLLStarChoiceBlock(BlockAST blkAST, List alts); + Choice getLLStarChoiceBlock(BlockAST blkAST, List alts); - List getLL1EBNFBlock(GrammarAST ebnfRoot, List alts); + Choice getLL1EBNFBlock(GrammarAST ebnfRoot, List alts); - List getLLStarEBNFBlock(GrammarAST ebnfRoot, List alts); + Choice getLLStarEBNFBlock(GrammarAST ebnfRoot, List alts); List getLL1Test(IntervalSet look, GrammarAST blkAST); @@ -92,10 +93,14 @@ public interface OutputModelFactory { // AST REWRITE TRIGGERS + TreeRewrite treeRewrite(List ops); + List rewrite_ruleRef(GrammarAST ID); List rewrite_tokenRef(GrammarAST ID); + List rewrite_stringRef(GrammarAST ID); + // CONTEXT MANIPULATION OutputModelObject getRoot(); diff --git a/tool/src/org/antlr/v4/codegen/ParserASTExtension.java b/tool/src/org/antlr/v4/codegen/ParserASTExtension.java index 2509503a9..7f77c1313 100644 --- a/tool/src/org/antlr/v4/codegen/ParserASTExtension.java +++ b/tool/src/org/antlr/v4/codegen/ParserASTExtension.java @@ -82,12 +82,15 @@ public class ParserASTExtension extends CodeGeneratorExtension { @Override public List leafRule(List ops) { + InvokeRule invokeOp = (InvokeRule)Utils.find(ops, InvokeRule.class); Alternative alt = factory.getCurrentAlt(); if ( alt.hasRewrite() ) { - return ops; + RuleFunction rf = factory.getCurrentRule(); + rf.addLocalDecl(new ElementListDecl(factory, invokeOp.ast)); + TrackRuleElement t = new TrackRuleElement(factory, invokeOp.ast, invokeOp); + return DefaultOutputModelFactory.list(ops, t); } else { - InvokeRule invokeOp = (InvokeRule)Utils.find(ops, InvokeRule.class); SrcOp treeOp = new AddRuleLeaf(factory, invokeOp.ast, invokeOp); return DefaultOutputModelFactory.list(ops, treeOp); } @@ -100,7 +103,7 @@ public class ParserASTExtension extends CodeGeneratorExtension { if ( alt.hasRewrite() ) { RuleFunction rf = factory.getCurrentRule(); rf.addLocalDecl(new ElementListDecl(factory, matchOp.ast)); - TrackElement t = new TrackElement(factory, matchOp.ast, matchOp); + TrackTokenElement t = new TrackTokenElement(factory, matchOp.ast, matchOp); return DefaultOutputModelFactory.list(ops, t); } else { @@ -109,8 +112,29 @@ public class ParserASTExtension extends CodeGeneratorExtension { } } + @Override + public List stringRef(List ops) { return leafToken(ops); } + @Override public boolean needsImplicitLabel(GrammarAST ID, LabeledOp op) { return op.getLabels().size()==0 && factory.getGrammar().hasASTOption(); } + + // REWRITES + + + @Override + public List rewrite_ruleRef(List ops) { + return super.rewrite_ruleRef(ops); + } + + @Override + public List rewrite_tokenRef(List ops) { + return super.rewrite_tokenRef(ops); + } + + @Override + public List rewrite_stringRef(List ops) { + return super.rewrite_stringRef(ops); + } } diff --git a/tool/src/org/antlr/v4/codegen/ParserFactory.java b/tool/src/org/antlr/v4/codegen/ParserFactory.java index a0b887be7..8c26fc894 100644 --- a/tool/src/org/antlr/v4/codegen/ParserFactory.java +++ b/tool/src/org/antlr/v4/codegen/ParserFactory.java @@ -31,6 +31,7 @@ package org.antlr.v4.codegen; import org.antlr.v4.analysis.AnalysisPipeline; import org.antlr.v4.codegen.model.*; +import org.antlr.v4.codegen.model.ast.*; import org.antlr.v4.codegen.model.decl.*; import org.antlr.v4.parse.ANTLRParser; import org.antlr.v4.runtime.atn.*; @@ -55,9 +56,9 @@ public class ParserFactory extends DefaultOutputModelFactory { return new RuleFunction(this, r); } - public List epsilon() { return list(new CodeBlock(this)); } + public CodeBlockForAlt epsilon() { return new CodeBlockForAlt(this); } - public List alternative(List elems) { return list(new CodeBlock(this, elems)); } + public CodeBlockForAlt alternative(List elems) { return new CodeBlockForAlt(this, elems); } public List action(GrammarAST ast) { return list(new Action(this, ast)); } @@ -81,11 +82,7 @@ public class ParserFactory extends DefaultOutputModelFactory { return list(matchOp, listLabelOp); } - public List stringRef(GrammarAST ID, GrammarAST label) { - return tokenRef(ID, label, null); - } - - public List getChoiceBlock(BlockAST blkAST, List alts) { + public Choice getChoiceBlock(BlockAST blkAST, List alts) { int decision = ((DecisionState)blkAST.atnState).decision; if ( AnalysisPipeline.disjoint(g.decisionLOOK.get(decision)) ) { return getLL1ChoiceBlock(blkAST, alts); @@ -95,7 +92,7 @@ public class ParserFactory extends DefaultOutputModelFactory { } } - public List getEBNFBlock(GrammarAST ebnfRoot, List alts) { + public Choice getEBNFBlock(GrammarAST ebnfRoot, List alts) { int decision; if ( ebnfRoot.getType()==ANTLRParser.POSITIVE_CLOSURE ) { decision = ((PlusBlockStartState)ebnfRoot.atnState).loopBackState.decision; @@ -114,15 +111,15 @@ public class ParserFactory extends DefaultOutputModelFactory { } } - public List getLL1ChoiceBlock(BlockAST blkAST, List alts) { - return list(new LL1AltBlock(this, blkAST, alts)); + public Choice getLL1ChoiceBlock(BlockAST blkAST, List alts) { + return new LL1AltBlock(this, blkAST, alts); } - public List getLLStarChoiceBlock(BlockAST blkAST, List alts) { - return list(new AltBlock(this, blkAST, alts)); + public Choice getLLStarChoiceBlock(BlockAST blkAST, List alts) { + return new AltBlock(this, blkAST, alts); } - public List getLL1EBNFBlock(GrammarAST ebnfRoot, List alts) { + public Choice getLL1EBNFBlock(GrammarAST ebnfRoot, List alts) { int ebnf = 0; if ( ebnfRoot!=null ) ebnf = ebnfRoot.getType(); Choice c = null; @@ -140,10 +137,10 @@ public class ParserFactory extends DefaultOutputModelFactory { else c = new LL1PlusBlock(this, ebnfRoot, alts); break; } - return list(c); + return c; } - public List getLLStarEBNFBlock(GrammarAST ebnfRoot, List alts) { + public Choice getLLStarEBNFBlock(GrammarAST ebnfRoot, List alts) { int ebnf = 0; if ( ebnfRoot!=null ) ebnf = ebnfRoot.getType(); Choice c = null; @@ -158,7 +155,7 @@ public class ParserFactory extends DefaultOutputModelFactory { c = new PlusBlock(this, ebnfRoot, alts); break; } - return list(c); + return c; } public List getLL1Test(IntervalSet look, GrammarAST blkAST) { @@ -173,12 +170,18 @@ public class ParserFactory extends DefaultOutputModelFactory { // AST REWRITE + + @Override + public TreeRewrite treeRewrite(List ops) { + return new TreeRewrite(this, ops); + } + public List rewrite_ruleRef(GrammarAST ID) { - return null; + return list(new RewriteRuleRef(this, ID)); } public List rewrite_tokenRef(GrammarAST ID) { - return null; + return list(new RewriteTokenRef(this, ID)); } // support diff --git a/tool/src/org/antlr/v4/codegen/SourceGenTriggers.g b/tool/src/org/antlr/v4/codegen/SourceGenTriggers.g index 9f121876d..9927ca6fb 100644 --- a/tool/src/org/antlr/v4/codegen/SourceGenTriggers.g +++ b/tool/src/org/antlr/v4/codegen/SourceGenTriggers.g @@ -25,35 +25,41 @@ import java.util.HashMap; dummy : block[null, null] ; -block[GrammarAST label, GrammarAST ebnfRoot] returns [List omos] +block[GrammarAST label, GrammarAST ebnfRoot] returns [List omos] : ^( blk=BLOCK (^(OPTIONS .+))? - {List alts = new ArrayList();} - ( alternative {alts.addAll($alternative.omos);} )+ + {List alts = new ArrayList();} + ( alternative {alts.add($alternative.altCodeBlock);} )+ ) { if ( alts.size()==1 && ebnfRoot==null) return alts; if ( ebnfRoot==null ) { - $omos = factory.getChoiceBlock((BlockAST)$blk, alts); + $omos = DefaultOutputModelFactory.list(factory.getChoiceBlock((BlockAST)$blk, alts)); } else { - $omos = factory.getEBNFBlock($ebnfRoot, alts); + $omos = DefaultOutputModelFactory.list(factory.getEBNFBlock($ebnfRoot, alts)); } } ; -alternative returns [List omos] +alternative returns [CodeBlockForAlt altCodeBlock] @init { List elems = new ArrayList(); // set alt if outer ALT only if ( inContext("RULE BLOCK") && ((AltAST)$start).alt!=null ) factory.setCurrentAlt(((AltAST)$start).alt); } - : ^(ALT_REWRITE a=alternative {$omos=$a.omos;} (rewrite {DefaultOutputModelFactory.list($omos, $rewrite.omos);} | )) - | ^(ALT EPSILON) {$omos = factory.epsilon();} + : ^(ALT_REWRITE + a=alternative + ( rewrite {$a.altCodeBlock.ops.add($rewrite.code);} // insert at end of alt's code + | + ) + {$altCodeBlock=$a.altCodeBlock;} + ) + | ^(ALT EPSILON) {$altCodeBlock = factory.epsilon();} | ^( ALT ( element {if ($element.omos!=null) elems.addAll($element.omos);} )+ ) - {$omos = factory.alternative(elems);} + {$altCodeBlock = factory.alternative(elems);} ; -element returns [List omos] +element returns [List omos] : labeledElement {$omos = $labeledElement.omos;} | atom[null] {$omos = $atom.omos;} | ebnf {$omos = $ebnf.omos;} @@ -64,7 +70,7 @@ element returns [List omos] | treeSpec ; -labeledElement returns [List omos] +labeledElement returns [List omos] : ^(ASSIGN ID atom[$ID] ) {$omos = $atom.omos;} | ^(ASSIGN ID block[$ID,null]) {$omos = $block.omos;} | ^(PLUS_ASSIGN ID atom[$ID]) {$omos = $atom.omos;} @@ -75,7 +81,7 @@ treeSpec returns [SrcOp omo] : ^(TREE_BEGIN (e=element )+) ; -ebnf returns [List omos] +ebnf returns [List omos] : ^(astBlockSuffix block[null,null]) | ^(OPTIONAL block[null,$OPTIONAL]) {$omos = $block.omos;} | ^(CLOSURE block[null,$CLOSURE]) {$omos = $block.omos;} @@ -142,8 +148,8 @@ elementOption // R E W R I T E S T U F F -rewrite returns [List omos] - : predicatedRewrite* nakedRewrite {$omos = nakedRewrite.omos;} +rewrite returns [Rewrite code] + : predicatedRewrite* nakedRewrite {$code = factory.treeRewrite($nakedRewrite.omos);} ; predicatedRewrite returns [List omos] @@ -157,15 +163,19 @@ nakedRewrite returns [List omos] ; rewriteTreeAlt returns [List omos] - : ^(ALT rewriteTreeElement+) + : ^(ALT + {List elems = new ArrayList();} + ( rewriteTreeElement {elems.addAll($rewriteTreeElement.omos);} )+ + ) + {$omos = elems;} | ETC | EPSILON ; rewriteTreeElement returns [List omos] - : rewriteTreeAtom - | rewriteTree - | rewriteTreeEbnf + : rewriteTreeAtom {$omos = $rewriteTreeAtom.omos;} + | rewriteTree {$omos = $rewriteTree.omos;} + | rewriteTreeEbnf {$omos = $rewriteTreeEbnf.omos;} ; rewriteTreeAtom returns [List omos] @@ -173,16 +183,16 @@ rewriteTreeAtom returns [List omos] | ^(TOKEN_REF elementOptions) | ^(TOKEN_REF ARG_ACTION) | TOKEN_REF {$omos = factory.rewrite_tokenRef($TOKEN_REF);} - | RULE_REF {$omos = factory.rewrite_ruleRef($TOKEN_REF);} - | ^(STRING_LITERAL elementOptions) - | STRING_LITERAL + | RULE_REF {$omos = factory.rewrite_ruleRef($RULE_REF);} + | ^(STRING_LITERAL elementOptions) {$omos = factory.rewrite_stringRef($STRING_LITERAL);} + | STRING_LITERAL {$omos = factory.rewrite_stringRef($STRING_LITERAL);} | LABEL | ACTION ; rewriteTreeEbnf returns [List omos] : ^('?' ^(REWRITE_BLOCK rewriteTreeAlt)) - : ^('*' ^(REWRITE_BLOCK rewriteTreeAlt)) + | ^('*' ^(REWRITE_BLOCK rewriteTreeAlt)) ; rewriteTree returns [List omos] diff --git a/tool/src/org/antlr/v4/codegen/Target.java b/tool/src/org/antlr/v4/codegen/Target.java index b3beadec8..fc069c29a 100644 --- a/tool/src/org/antlr/v4/codegen/Target.java +++ b/tool/src/org/antlr/v4/codegen/Target.java @@ -208,7 +208,9 @@ public class Target { // should be same for all refs to same token like $ID within single rule function public String getImplicitTokenLabel(String tokenName) { ST st = gen.templates.getInstanceOf("ImplicitTokenLabel"); - st.add("tokenName", tokenName); + int ttype = gen.g.getTokenType(tokenName); + String text = getTokenTypeAsTargetLabel(gen.g, ttype); + st.add("tokenName", text); return st.render(); } @@ -228,7 +230,13 @@ public class Target { public String getElementListName(GrammarAST elem) { ST st = gen.templates.getInstanceOf("ElementListName"); - st.add("elemName", elem.getText()); // TODO: not right for literals + String text = elem.getText(); + if ( gen.g.getRule(text)!=null ) st.add("elemName", text); + else { + int ttype = gen.g.getTokenType(text); + text = getTokenTypeAsTargetLabel(gen.g, ttype); + st.add("elemName", text); + } return st.render(); } } diff --git a/tool/src/org/antlr/v4/codegen/model/AltBlock.java b/tool/src/org/antlr/v4/codegen/model/AltBlock.java index c99d8d5b8..26cb72ebe 100644 --- a/tool/src/org/antlr/v4/codegen/model/AltBlock.java +++ b/tool/src/org/antlr/v4/codegen/model/AltBlock.java @@ -40,7 +40,7 @@ public class AltBlock extends Choice { public AltBlock(OutputModelFactory factory, GrammarAST blkOrEbnfRootAST, - List alts) + List alts) { super(factory, blkOrEbnfRootAST, alts); decision = ((BlockStartState)blkOrEbnfRootAST.atnState).decision; diff --git a/tool/src/org/antlr/v4/codegen/model/Choice.java b/tool/src/org/antlr/v4/codegen/model/Choice.java index ca5d2dae7..aee11c6f4 100644 --- a/tool/src/org/antlr/v4/codegen/model/Choice.java +++ b/tool/src/org/antlr/v4/codegen/model/Choice.java @@ -50,12 +50,12 @@ import java.util.*; public abstract class Choice extends RuleElement { public int decision = -1; - @ModelElement public List alts; + @ModelElement public List alts; @ModelElement public List preamble; public Choice(OutputModelFactory factory, GrammarAST blkOrEbnfRootAST, - List alts) + List alts) { super(factory, blkOrEbnfRootAST); this.alts = alts; diff --git a/tool/src/org/antlr/v4/codegen/model/CodeBlock.java b/tool/src/org/antlr/v4/codegen/model/CodeBlockForAlt.java similarity index 81% rename from tool/src/org/antlr/v4/codegen/model/CodeBlock.java rename to tool/src/org/antlr/v4/codegen/model/CodeBlockForAlt.java index bfd83a22f..39263c1f7 100644 --- a/tool/src/org/antlr/v4/codegen/model/CodeBlock.java +++ b/tool/src/org/antlr/v4/codegen/model/CodeBlockForAlt.java @@ -34,17 +34,17 @@ import org.antlr.v4.codegen.OutputModelFactory; import java.util.*; /** */ -public class CodeBlock extends SrcOp { - @ModelElement public List ops; +public class CodeBlockForAlt extends SrcOp { + @ModelElement public List ops; // has to be unchecked so we can add different subclasses of SrcOp :( - public CodeBlock(OutputModelFactory factory) { this.factory = factory; } + public CodeBlockForAlt(OutputModelFactory factory) { this.factory = factory; } - public CodeBlock(OutputModelFactory factory, List ops) { + public CodeBlockForAlt(OutputModelFactory factory, List ops) { super(factory); this.ops = ops; } - public CodeBlock(OutputModelFactory factory, final SrcOp elem) { + public CodeBlockForAlt(OutputModelFactory factory, final SrcOp elem) { this(factory, new ArrayList() {{ add(elem); }}); } } diff --git a/tool/src/org/antlr/v4/codegen/model/LL1AltBlock.java b/tool/src/org/antlr/v4/codegen/model/LL1AltBlock.java index 9644b8f33..26aa8fd26 100644 --- a/tool/src/org/antlr/v4/codegen/model/LL1AltBlock.java +++ b/tool/src/org/antlr/v4/codegen/model/LL1AltBlock.java @@ -38,7 +38,7 @@ import java.util.List; /** (A | B | C) */ public class LL1AltBlock extends LL1Choice { - public LL1AltBlock(OutputModelFactory factory, GrammarAST blkAST, List alts) { + public LL1AltBlock(OutputModelFactory factory, GrammarAST blkAST, List alts) { super(factory, blkAST, alts); this.decision = ((DecisionState)blkAST.atnState).decision; diff --git a/tool/src/org/antlr/v4/codegen/model/LL1Choice.java b/tool/src/org/antlr/v4/codegen/model/LL1Choice.java index f49d65fa7..76be95ea2 100644 --- a/tool/src/org/antlr/v4/codegen/model/LL1Choice.java +++ b/tool/src/org/antlr/v4/codegen/model/LL1Choice.java @@ -40,7 +40,7 @@ public abstract class LL1Choice extends Choice { @ModelElement public ThrowNoViableAlt error; public LL1Choice(OutputModelFactory factory, GrammarAST blkAST, - List alts) + List alts) { super(factory, blkAST, alts); } diff --git a/tool/src/org/antlr/v4/codegen/model/LL1Loop.java b/tool/src/org/antlr/v4/codegen/model/LL1Loop.java index c7b6472c5..2685bf9f0 100644 --- a/tool/src/org/antlr/v4/codegen/model/LL1Loop.java +++ b/tool/src/org/antlr/v4/codegen/model/LL1Loop.java @@ -43,7 +43,7 @@ public abstract class LL1Loop extends Choice { public LL1Loop(OutputModelFactory factory, GrammarAST blkAST, - List alts) + List alts) { super(factory, blkAST, alts); } diff --git a/tool/src/org/antlr/v4/codegen/model/LL1OptionalBlock.java b/tool/src/org/antlr/v4/codegen/model/LL1OptionalBlock.java index 360e61b1f..71bc98493 100644 --- a/tool/src/org/antlr/v4/codegen/model/LL1OptionalBlock.java +++ b/tool/src/org/antlr/v4/codegen/model/LL1OptionalBlock.java @@ -40,7 +40,7 @@ import java.util.List; * (A | B | C)? */ public class LL1OptionalBlock extends LL1AltBlock { - public LL1OptionalBlock(OutputModelFactory factory, GrammarAST blkAST, List alts) { + public LL1OptionalBlock(OutputModelFactory factory, GrammarAST blkAST, List alts) { super(factory, blkAST, alts); } } diff --git a/tool/src/org/antlr/v4/codegen/model/LL1OptionalBlockSingleAlt.java b/tool/src/org/antlr/v4/codegen/model/LL1OptionalBlockSingleAlt.java index 6e1957b5c..3d2705e2d 100644 --- a/tool/src/org/antlr/v4/codegen/model/LL1OptionalBlockSingleAlt.java +++ b/tool/src/org/antlr/v4/codegen/model/LL1OptionalBlockSingleAlt.java @@ -43,7 +43,7 @@ public class LL1OptionalBlockSingleAlt extends LL1Choice { public LL1OptionalBlockSingleAlt(OutputModelFactory factory, GrammarAST blkAST, - List alts) + List alts) { super(factory, blkAST, alts); this.decision = ((DecisionState)blkAST.atnState).decision; diff --git a/tool/src/org/antlr/v4/codegen/model/LL1PlusBlock.java b/tool/src/org/antlr/v4/codegen/model/LL1PlusBlock.java index def0a28bd..fc973c66c 100644 --- a/tool/src/org/antlr/v4/codegen/model/LL1PlusBlock.java +++ b/tool/src/org/antlr/v4/codegen/model/LL1PlusBlock.java @@ -49,7 +49,7 @@ public class LL1PlusBlock extends LL1Loop { @ModelElement public SrcOp loopExpr; @ModelElement public ThrowNoViableAlt error; - public LL1PlusBlock(OutputModelFactory factory, GrammarAST plusRoot, List alts) { + public LL1PlusBlock(OutputModelFactory factory, GrammarAST plusRoot, List alts) { super(factory, plusRoot, alts); PlusBlockStartState blkStart = (PlusBlockStartState)plusRoot.atnState; diff --git a/tool/src/org/antlr/v4/codegen/model/LL1PlusBlockSingleAlt.java b/tool/src/org/antlr/v4/codegen/model/LL1PlusBlockSingleAlt.java index b1af4055b..ac74832fe 100644 --- a/tool/src/org/antlr/v4/codegen/model/LL1PlusBlockSingleAlt.java +++ b/tool/src/org/antlr/v4/codegen/model/LL1PlusBlockSingleAlt.java @@ -40,7 +40,7 @@ import java.util.List; public class LL1PlusBlockSingleAlt extends LL1Loop { @ModelElement public Sync iterationSync; - public LL1PlusBlockSingleAlt(OutputModelFactory factory, GrammarAST blkAST, List alts) { + public LL1PlusBlockSingleAlt(OutputModelFactory factory, GrammarAST blkAST, List alts) { super(factory, blkAST, alts); PlusBlockStartState plus = (PlusBlockStartState)blkAST.atnState; diff --git a/tool/src/org/antlr/v4/codegen/model/LL1StarBlock.java b/tool/src/org/antlr/v4/codegen/model/LL1StarBlock.java index 4d849f9ff..df82a27b3 100644 --- a/tool/src/org/antlr/v4/codegen/model/LL1StarBlock.java +++ b/tool/src/org/antlr/v4/codegen/model/LL1StarBlock.java @@ -43,7 +43,7 @@ public class LL1StarBlock extends LL1Loop { public String loopLabel; public String[] exitLook; - public LL1StarBlock(OutputModelFactory factory, GrammarAST blkAST, List alts) { + public LL1StarBlock(OutputModelFactory factory, GrammarAST blkAST, List alts) { super(factory, blkAST, alts); StarBlockStartState blkStart = (StarBlockStartState)blkAST.atnState; diff --git a/tool/src/org/antlr/v4/codegen/model/LL1StarBlockSingleAlt.java b/tool/src/org/antlr/v4/codegen/model/LL1StarBlockSingleAlt.java index 3278671a9..3520f6ec7 100644 --- a/tool/src/org/antlr/v4/codegen/model/LL1StarBlockSingleAlt.java +++ b/tool/src/org/antlr/v4/codegen/model/LL1StarBlockSingleAlt.java @@ -38,7 +38,7 @@ import java.util.List; /** */ public class LL1StarBlockSingleAlt extends LL1Loop { - public LL1StarBlockSingleAlt(OutputModelFactory factory, GrammarAST starRoot, List alts) { + public LL1StarBlockSingleAlt(OutputModelFactory factory, GrammarAST starRoot, List alts) { super(factory, starRoot, alts); StarBlockStartState star = (StarBlockStartState)starRoot.atnState; diff --git a/tool/src/org/antlr/v4/codegen/model/Loop.java b/tool/src/org/antlr/v4/codegen/model/Loop.java index 9b3e4bd7d..9e3766643 100644 --- a/tool/src/org/antlr/v4/codegen/model/Loop.java +++ b/tool/src/org/antlr/v4/codegen/model/Loop.java @@ -38,7 +38,7 @@ public class Loop extends Choice { public int exitAlt; public Loop(OutputModelFactory factory, GrammarAST blkOrEbnfRootAST, - List alts) + List alts) { super(factory, blkOrEbnfRootAST, alts); } diff --git a/tool/src/org/antlr/v4/codegen/model/OptionalBlock.java b/tool/src/org/antlr/v4/codegen/model/OptionalBlock.java index ce5e24fbd..8f6be301d 100644 --- a/tool/src/org/antlr/v4/codegen/model/OptionalBlock.java +++ b/tool/src/org/antlr/v4/codegen/model/OptionalBlock.java @@ -38,7 +38,7 @@ import java.util.List; public class OptionalBlock extends AltBlock { public OptionalBlock(OutputModelFactory factory, GrammarAST questionAST, - List alts) + List alts) { super(factory, questionAST, alts); } diff --git a/tool/src/org/antlr/v4/codegen/model/PlusBlock.java b/tool/src/org/antlr/v4/codegen/model/PlusBlock.java index 11e12da85..c5533c23d 100644 --- a/tool/src/org/antlr/v4/codegen/model/PlusBlock.java +++ b/tool/src/org/antlr/v4/codegen/model/PlusBlock.java @@ -40,7 +40,7 @@ public class PlusBlock extends Loop { public PlusBlock(OutputModelFactory factory, GrammarAST ebnfRootAST, - List alts) + List alts) { super(factory, ebnfRootAST, alts); PlusLoopbackState loop = ((PlusBlockStartState)ebnfRootAST.atnState).loopBackState; diff --git a/tool/src/org/antlr/v4/codegen/model/Rewrite.java b/tool/src/org/antlr/v4/codegen/model/Rewrite.java new file mode 100644 index 000000000..78da2a451 --- /dev/null +++ b/tool/src/org/antlr/v4/codegen/model/Rewrite.java @@ -0,0 +1,43 @@ +/* + [The "BSD license"] + 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. + */ + +package org.antlr.v4.codegen.model; + +import org.antlr.v4.codegen.OutputModelFactory; + +import java.util.List; + +public class Rewrite extends SrcOp { + @ModelElement public List ops; + + public Rewrite(OutputModelFactory factory, List ops) { + super(factory); + this.ops = ops; + } +} diff --git a/tool/src/org/antlr/v4/codegen/model/StarBlock.java b/tool/src/org/antlr/v4/codegen/model/StarBlock.java index dc5d42b7a..a071c01f4 100644 --- a/tool/src/org/antlr/v4/codegen/model/StarBlock.java +++ b/tool/src/org/antlr/v4/codegen/model/StarBlock.java @@ -40,7 +40,7 @@ public class StarBlock extends Loop { public StarBlock(OutputModelFactory factory, GrammarAST blkOrEbnfRootAST, - List alts) + List alts) { super(factory, blkOrEbnfRootAST, alts); loopLabel = factory.getGenerator().target.getLoopLabel(blkOrEbnfRootAST); diff --git a/tool/src/org/antlr/v4/codegen/model/ast/RewriteRuleRef.java b/tool/src/org/antlr/v4/codegen/model/ast/RewriteRuleRef.java new file mode 100644 index 000000000..edbd51a5b --- /dev/null +++ b/tool/src/org/antlr/v4/codegen/model/ast/RewriteRuleRef.java @@ -0,0 +1,40 @@ +/* + [The "BSD license"] + 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. + */ + +package org.antlr.v4.codegen.model.ast; + +import org.antlr.v4.codegen.OutputModelFactory; +import org.antlr.v4.codegen.model.SrcOp; +import org.antlr.v4.tool.GrammarAST; + +public class RewriteRuleRef extends SrcOp { + public RewriteRuleRef(OutputModelFactory factory, GrammarAST ast) { + super(factory, ast); + } +} diff --git a/tool/src/org/antlr/v4/codegen/model/ast/RewriteTokenRef.java b/tool/src/org/antlr/v4/codegen/model/ast/RewriteTokenRef.java new file mode 100644 index 000000000..f146ac847 --- /dev/null +++ b/tool/src/org/antlr/v4/codegen/model/ast/RewriteTokenRef.java @@ -0,0 +1,40 @@ +/* + [The "BSD license"] + 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. + */ + +package org.antlr.v4.codegen.model.ast; + +import org.antlr.v4.codegen.OutputModelFactory; +import org.antlr.v4.codegen.model.SrcOp; +import org.antlr.v4.tool.GrammarAST; + +public class RewriteTokenRef extends SrcOp { + public RewriteTokenRef(OutputModelFactory factory, GrammarAST ast) { + super(factory, ast); + } +} diff --git a/tool/src/org/antlr/v4/codegen/model/ast/TrackElement.java b/tool/src/org/antlr/v4/codegen/model/ast/TrackRuleElement.java similarity index 87% rename from tool/src/org/antlr/v4/codegen/model/ast/TrackElement.java rename to tool/src/org/antlr/v4/codegen/model/ast/TrackRuleElement.java index e8afa5fee..9c8622f71 100644 --- a/tool/src/org/antlr/v4/codegen/model/ast/TrackElement.java +++ b/tool/src/org/antlr/v4/codegen/model/ast/TrackRuleElement.java @@ -33,10 +33,10 @@ import org.antlr.v4.codegen.OutputModelFactory; import org.antlr.v4.codegen.model.LabeledOp; import org.antlr.v4.tool.GrammarAST; -public class TrackElement extends ElementASTOp { - public String name; // ID, r, ... - public TrackElement(OutputModelFactory factory, GrammarAST ast, LabeledOp opWithResultToAdd) { +public class TrackRuleElement extends ElementASTOp { + public String name; + public TrackRuleElement(OutputModelFactory factory, GrammarAST ast, LabeledOp opWithResultToAdd) { super(factory, ast, opWithResultToAdd); - name = ast.getText(); + name = factory.getGenerator().target.getElementListName(ast); } } diff --git a/tool/src/org/antlr/v4/codegen/model/ast/TrackTokenElement.java b/tool/src/org/antlr/v4/codegen/model/ast/TrackTokenElement.java new file mode 100644 index 000000000..7f8fdcdf1 --- /dev/null +++ b/tool/src/org/antlr/v4/codegen/model/ast/TrackTokenElement.java @@ -0,0 +1,42 @@ +/* + [The "BSD license"] + 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. + */ + +package org.antlr.v4.codegen.model.ast; + +import org.antlr.v4.codegen.OutputModelFactory; +import org.antlr.v4.codegen.model.LabeledOp; +import org.antlr.v4.tool.GrammarAST; + +public class TrackTokenElement extends ElementASTOp { + public String name; + public TrackTokenElement(OutputModelFactory factory, GrammarAST ast, LabeledOp opWithResultToAdd) { + super(factory, ast, opWithResultToAdd); + name = factory.getGenerator().target.getElementListName(ast); + } +} diff --git a/tool/src/org/antlr/v4/codegen/model/ast/TreeRewrite.java b/tool/src/org/antlr/v4/codegen/model/ast/TreeRewrite.java new file mode 100644 index 000000000..c2eeaaa10 --- /dev/null +++ b/tool/src/org/antlr/v4/codegen/model/ast/TreeRewrite.java @@ -0,0 +1,41 @@ +/* + [The "BSD license"] + 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. + */ + +package org.antlr.v4.codegen.model.ast; + +import org.antlr.v4.codegen.OutputModelFactory; +import org.antlr.v4.codegen.model.*; + +import java.util.List; + +public class TreeRewrite extends Rewrite { + public TreeRewrite(OutputModelFactory factory, List ops) { + super(factory, ops); + } +}