antlr3 1.2.3

data/templates/AST.stg

@@ -0,0 +1,335 @@
+group AST;
+
+@parserBody.mixins() ::= <<
+<@super.mixins()>
+include ANTLR3::ASTBuilder
+>>
+
+gatedAction(block) ::= <<
+<if(backtracking)>
+if <actions.(actionScope).synpredgate>
+  <block>
+end
+<else>
+<block>
+<endif>
+>>
+
+ruleDeclarations() ::= <<
+<super.ruleDeclarations()>
+root_0 = nil<\n>
+>>
+
+ruleLabelDefs() ::= <<
+<super.ruleLabelDefs()>
+<[ruleDescriptor.tokenLabels,ruleDescriptor.wildcardTreeLabels,ruleDescriptor.wildcardTreeListLabels,ruleDescriptor.tokenListLabels]
+    :{tree_for_<it.label.text> = nil}; separator="\n">
+<ruleDescriptor.allTokenRefsInAltsWithRewrites
+    :{stream_<it> = ANTLR3::AST::RewriteRule<rewriteElementType>Stream.new(@adaptor, "token <it>")}; separator="\n">
+<ruleDescriptor.allRuleRefsInAltsWithRewrites
+    :{stream_<it> = ANTLR3::AST::RewriteRuleSubtreeStream.new(@adaptor, "rule <it>")}; separator="\n">
+>>
+
+alt(elements,altNum,description,autoAST,outerAlt,treeLevel,rew) ::= <<
+<if(autoAST)><if(outerAlt)><if(!rewriteMode)>
+root_0 = @adaptor.create_flat_list!<\n><\n>
+<endif><endif><endif>
+# at line <description>
+<elements:element()><rew>
+>>
+
+tokenRefTrack(token,label,elementIndex,hetero) ::= <<
+<tokenRefBang(...)> <! Track implies no auto AST construction!>
+<gatedAction({stream_<token>.add(<label; format="label">)})>
+>>
+
+tokenRefTrackAndListLabel(token,label,elementIndex,hetero) ::= <<
+<tokenRefTrack(...)>
+<addToList(elem={<label; format="label">},...)>
+>>
+
+tokenRefRuleRootTrack(token,label,elementIndex,hetero) ::= <<
+<tokenRefBang(...)>
+<gatedAction({stream_<token>.add(<label; format="label">)})>
+>>
+
+tokenRefRuleRootTrackAndListLabel(token,label,elementIndex,hetero) ::= <<
+<tokenRefRuleRootTrack(...)>
+<addToList(elem=label,...)>
+>>
+
+ruleRefTrack(rule,label,elementIndex,args,scope) ::= <<
+<super.ruleRef(...)>
+<gatedAction({stream_<rule.name>.add(<label; format="label">.tree)})>
+>>
+
+ruleRefTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRefTrack(...)>
+<addToList(elem={<label; format="label">.tree},...)>
+>>
+ruleRefRuleRootTrack(rule,label,elementIndex,args,scope) ::= <<
+<ruleRefRuleRoot(...)>
+<gatedAction({stream_<rule.name>.add(<label; format="label">.tree)})>
+>>
+
+ruleRefRuleRootTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRefRuleRootTrack(...)>
+<addToList(elem={<label; format="label">.tree},...)>
+>>
+
+
+rewriteCode(alts, description,
+        referencedElementsDeep, // ALL referenced elements to right of ->
+        referencedTokenLabels,
+        referencedTokenListLabels,
+        referencedRuleLabels,
+        referencedRuleListLabels,
+        referencedWildcardLabels,
+        referencedWildcardListLabels,
+        rewriteBlockLevel, enclosingTreeLevel, treeLevel) ::=
+<<
+# 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=", ">
+<gatedAction({
+<prevRuleRootRef(); format="label">.tree = root_0
+<rewriteCodeLabels()>
+root_0 = @adaptor.create_flat_list!
+<first(alts):rewriteAltFirst(); anchor>
+
+<rest(alts):{a| els<rewriteAltRest(a)>}; anchor, separator="\n\n">
+
+<! if tree parser and rewrite=true !>
+<if(TREE_PARSER)>
+<if(rewriteMode)>
+<prevRuleRootRef(); format="label">.tree = @adaptor.rule_post_processing(root_0)
+@input.replace_children(
+  @adaptor.parent(return_value.start),
+  @adaptor.child_index(return_value.start),
+  @adaptor.child_index(_last),
+  return_value.tree
+)<\n>
+<endif>
+<endif>
+
+<! if parser or tree-parser and rewrite!=true, we need to set result !>
+<if(!TREE_PARSER)>
+<prevRuleRootRef(); format="label">.tree = root_0<\n>
+<else>
+<if(!rewriteMode)>
+<prevRuleRootRef(); format="label">.tree = root_0<\n>
+<endif>
+<endif>
+})>
+>>
+
+rewriteCodeLabels() ::= <<
+<referencedTokenLabels:
+{stream_<it> = <rewriteElementType; format="snakecase">_stream("token <it>", <it; format="label">)};
+separator="\n">
+<referencedTokenListLabels:
+{stream_<it> = <rewriteElementType; format="snakecase">_stream("token <it>", list_of_<it; format="label">)};
+separator="\n">
+<referencedWildcardLabels:
+{stream_<it> = subtree_stream("wildcard <it>", <it; format="label">)};
+separator="\n">
+<referencedWildcardListLabels:
+{stream_<it> = subtree_stream("wildcard <it>", list_of_<it; format="label">)};
+separator="\n">
+<referencedRuleLabels:
+{stream_<it> = <it; format="label"> ? subtree_stream("rule <it>", <it; format="label">.tree) : subtree_stream("token <it>")};
+separator="\n">
+<referencedRuleListLabels:
+{stream_<it> = subtree_stream("token <it>", list_of_<it; format="label">)};
+separator="\n">
+>>
+
+rewriteOptionalBlock(
+        alt,rewriteBlockLevel,
+        referencedElementsDeep, // all nested refs
+        referencedElements, // elements in immediately block; no nested blocks
+        description) ::=
+<<
+# at line <description>
+if <referencedElementsDeep:{el | stream_<el>.has_next?}; separator=" || ">
+  <alt>
+end
+
+<referencedElementsDeep:{el | stream_<el>.reset();<\n>}>
+>>
+
+rewriteClosureBlock(
+        alt,rewriteBlockLevel,
+        referencedElementsDeep, // all nested refs
+        referencedElements, // elements in immediately block; no nested blocks
+        description) ::=
+<<
+# at line <description>
+while <referencedElements:{el | stream_<el>.has_next?}; separator=" || ">
+  <alt>
+end
+
+<referencedElements:{el | stream_<el>.reset();<\n>}>
+>>
+
+rewritePositiveClosureBlock(
+        alt,rewriteBlockLevel,
+        referencedElementsDeep, // all nested refs
+        referencedElements, // elements in immediately block; no nested blocks
+        description) ::=
+<<
+# at line <description>
+unless <referencedElements:{el | stream_<el>.has_next?}; separator=" || ">
+  raise ANTLR3::RewriteEarlyExit
+end
+
+while <referencedElements:{el | stream_<el>.has_next?}; separator=" || ">
+  <alt>
+end
+
+<referencedElements:{el | stream_<el>.reset<\n>}>
+>>
+
+rewriteAltRest(a) ::= <<
+<if(a.pred)>
+if <a.pred>
+  # <a.description>
+  <a.alt>
+<else>
+e <! little hack to get if .. elsif .. else block right !>
+  # <a.description>
+  <a.alt>
+end
+<endif>
+>>
+
+rewriteAltFirst(a) ::= <<
+<if(a.pred)>
+if <a.pred>
+  # <a.description>
+  <a.alt>
+<else>
+# <a.description>
+<a.alt>
+<endif>
+>>
+
+rewriteEmptyAlt() ::= "root_0 = nil"
+
+rewriteTree(root,children,description,enclosingTreeLevel,treeLevel) ::= <<
+# at line <description>
+root_<treeLevel> = @adaptor.create_flat_list!
+<root:rewriteElement()>
+<children:rewriteElement()>
+@adaptor.add_child(root_<enclosingTreeLevel>, root_<treeLevel>)<\n>
+>>
+
+rewriteElementList(elements) ::= "<elements:rewriteElement()>"
+rewriteElement(e) ::= <<
+<@pregen()>
+<e.el>
+>>
+
+rewriteTokenRef(token,elementIndex,hetero,args) ::= <<
+@adaptor.add_child(root_<treeLevel>, <createRewriteNodeFromElement(...)>)<\n>
+>>
+
+rewriteTokenLabelRef(label,elementIndex) ::= <<
+@adaptor.add_child(root_<treeLevel>, stream_<label>.next_node)<\n>
+>>
+
+rewriteTokenListLabelRef(label,elementIndex) ::= <<
+@adaptor.add_child(root_<treeLevel>, stream_<label>.next_node)<\n>
+>>
+
+rewriteTokenLabelRefRoot(label,elementIndex) ::= <<
+root_<treeLevel> = @adaptor.become_root(stream_<label>.next_node, root_<treeLevel>)<\n>
+>>
+
+rewriteTokenListLabelRefRoot ::= rewriteTokenLabelRefRoot
+
+rewriteTokenRefRoot(token,elementIndex,hetero,args) ::= <<
+root_<treeLevel> = @adaptor.become_root(<createRewriteNodeFromElement(...)>, root_<treeLevel>)<\n>
+>>
+
+rewriteImaginaryTokenRef(args,token,hetero,elementIndex) ::= <<
+@adaptor.add_child(root_<treeLevel>, <createImaginaryNode(tokenType=token, ...)>)<\n>
+>>
+
+rewriteImaginaryTokenRefRoot(args,token,hetero,elementIndex) ::= <<
+root_<treeLevel> = @adaptor.become_root(<createImaginaryNode(tokenType=token, ...)>, root_<treeLevel>)<\n>
+>>
+
+rewriteAction(action) ::= <<
+root_0 = <action><\n>
+>>
+
+prevRuleRootRef() ::= "return_value"
+
+rewriteRuleRef(rule) ::= <<
+@adaptor.add_child(root_<treeLevel>, stream_<rule>.next_tree)<\n>
+>>
+
+rewriteRuleRefRoot(rule) ::= <<
+root_<treeLevel> = @adaptor.become_root(stream_<rule>.next_node(), root_<treeLevel>)<\n>
+>>
+
+rewriteNodeAction(action) ::= <<
+@adaptor.add_child(root_<treeLevel>, <action>)<\n>
+>>
+
+rewriteNodeActionRoot(action) ::= <<
+root_<treeLevel> = @adaptor.become_root(<action>, root_<treeLevel>)<\n>
+>>
+
+rewriteRuleLabelRef(label) ::= <<
+@adaptor.add_child(root_<treeLevel>, stream_<label>.next_tree)<\n>
+>>
+
+rewriteRuleListLabelRef(label) ::= <<
+@adaptor.add_child(root_<treeLevel>, stream_<label>.next_tree)<\n>
+>>
+
+rewriteRuleLabelRefRoot(label) ::= <<
+root_<treeLevel> = @adaptor.become_root(stream_<label>.next_node, root_<treeLevel>)<\n>
+>>
+
+rewriteRuleListLabelRefRoot(label) ::= <<
+root_<treeLevel> = @adaptor.become_root(stream_<label>.next_node(), root_<treeLevel>)<\n>
+>>
+
+rewriteWildcardLabelRef(label) ::= <<
+@adaptor.add_child(root_<treeLevel>, stream_<label>.next_tree)<\n>
+>>
+
+createImaginaryNode(tokenType,hetero,args) ::= <<
+<if(hetero)>
+<hetero; format="constantPath">.new(create_token(<tokenType>)<if(args)>, <args; separator=", "><endif>)
+<else>
+<if(!args)>@adaptor.create_from_type!(<tokenType>, "<tokenType>")
+<else>@adaptor.create!(<tokenType>, <args; separator=", ">)
+<endif>
+<endif>
+>>
+
+createRewriteNodeFromElement(token,hetero,args) ::= <<
+<if(hetero)>
+<hetero; format="constantPath">.new(stream_<token>.next<if(args)>, <args; separator=", "><endif>)
+<else>
+<if(args)><! must create new node from old !>
+<! need to call different adaptor.create!*() methods depending of argument count !>
+<if(!args)>@adaptor.create_from_type!(<token>, "<token>")
+<else><if(!rest(args))>@adaptor.create_from_token!(<token>, <first(args)>)
+<else><if(!rest(rest(args)))>@adaptor.create_from_token!(<token>, <first(args)>, <first(rest(args))>)
+<endif>
+<endif>
+<endif>
+<else>
+stream_<token>.next_node
+<endif>
+<endif>
+>>

data/templates/ASTDbg.stg

@@ -0,0 +1,40 @@
+group ASTDbg;
+
+@parserBody.additionalMembers() ::= <<
+def self.return_scope_members
+  super.push(:tree)
+end
+
+attr_reader :adaptor
+def adaptor=(adaptor)
+  @adaptor = 
+    adaptor.is_a?(ANTLR3::Debug::TreeAdaptor) ? adaptor : 
+      ANTLR3::Debug::TreeAdaptor.wrap(adaptor, @debug_listener)
+  <grammar.directDelegates:{g|<g:delegateName()>.adaptor = @adaptor}; separator="\n">
+end
+
+alias tree_adaptor adaptor
+alias tree_adaptor= adaptor=
+
+>>
+
+
+createListenerAndHandshake() ::= <<
+options[:debug_listener] ||= begin
+  port = options[:port]
+  log  = options[:log]
+  proxy = ANTLR3::Debug::EventSocketProxy.new(
+    self, :adaptor => adaptor,
+    :log => log, :port => port
+  )
+  proxy.handshake
+  proxy
+end
+>>
+@parserConstructor.init() ::= "self.adaptor = adaptor"
+
+
+@newDelegate.delegateOptions() ::= ", :adaptor => adaptor"
+
+
+@rewriteElement.pregen() ::= "@debug_listener.location(<e.line>, <e.pos>)"

data/templates/ASTParser.stg

@@ -0,0 +1,153 @@
+group ASTParser;
+gatedAction(block) ::= <<
+<if(backtracking)>
+if <actions.(actionScope).synpredgate>
+  <block>
+end
+<else>
+<block>
+<endif>
+>>
+
+@ruleBody.setErrorReturnValue() ::= <<
+return_value.tree = @adaptor.create_error_node!(@input, return_value.start, @input.look(-1), re)<\n>
+>>
+
+tokenRef(token,label,elementIndex,hetero) ::= <<
+<super.tokenRef(...)>
+<gatedAction({
+tree_for_<label> = <createNodeFromToken(...)>
+@adaptor.add_child(root_0, tree_for_<label>)
+})>
+>>
+
+tokenRefBang(token,label,elementIndex) ::= "<super.tokenRef(...)>"
+
+tokenRefRuleRoot(token,label,elementIndex,hetero) ::= <<
+<super.tokenRef(...)>
+<gatedAction({
+tree_for_<label> = <createNodeFromToken(...)>
+root_0 = @adaptor.become_root(tree_for_<label>, root_0)
+})>
+>>
+
+
+
+tokenRefBangAndListLabel(token,label,elementIndex,hetero) ::= <<
+<tokenRefBang(...)>
+<addToList(elem={<label; format="label">},...)>
+>>
+
+
+
+tokenRefAndListLabel(token,label,elementIndex,hetero) ::= <<
+<tokenRef(...)>
+<addToList(elem={<label; format="label">},...)>
+>>
+tokenRefRuleRootAndListLabel(token,label,hetero,elementIndex) ::= <<
+<tokenRefRuleRoot(...)>
+<addToList(elem={<label; format="label">},...)>
+>>
+
+
+
+matchSet(s,label,hetero,elementIndex,postmatchCode) ::= <<
+<super.matchSet(..., postmatchCode={<gatedAction({@adaptor.add_child(root_0, <createNodeFromToken(...)>)})>})>
+>>
+
+
+
+matchRuleBlockSet(s,label,hetero,elementIndex,postmatchCode,treeLevel="0") ::= <<
+<matchSet(...)>
+>>
+
+
+
+matchSetBang(s,label,elementIndex,postmatchCode) ::= "<super.matchSet(...)>"
+matchSetRuleRoot(s,label,hetero,elementIndex,debug) ::= <<
+<if(label)>
+<label; format="label"> = @input.look<\n>
+<endif>
+<super.matchSet(..., postmatchCode={<gatedAction({root_0 = @adaptor.become_root(<createNodeFromToken(...)>, root_0)})>})>
+>>
+matchSetRuleRootAndListLabel(s,label,hetero,elementIndex,debug) ::= <<
+<matchSetRuleRoot(...)>
+<addToList(elem={<label; format="label">},...)>
+>>
+
+
+
+ruleRef(rule,label,elementIndex,args,scope) ::= <<
+<super.ruleRef(...)>
+<gatedAction({@adaptor.add_child(root_0, <label; format="label">.tree)})>
+>>
+
+
+
+ruleRefBang(rule,label,elementIndex,args,scope) ::= "<super.ruleRef(...)>"
+
+
+
+ruleRefRuleRoot(rule,label,elementIndex,args,scope) ::= <<
+<super.ruleRef(...)>
+<gatedAction({root_0 = @adaptor.become_root(<label; format="label">.tree, root_0)})>
+>>
+
+
+
+ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRef(...)>
+<addToList(elem={<label; format="label">.tree},...)>
+>>
+
+
+
+ruleRefBangAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRefBang(...)>
+<addToList(elem={<label; format="label">.tree},...)>
+>>
+
+
+
+ruleRefRuleRootAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRefRuleRoot(...)>
+<addToList(elem={<label; format="label">.tree},...)>
+>>
+
+wildcard(label,elementIndex) ::= <<
+<super.wildcard(...)>
+<gatedAction({
+tree_for_<label> = @adaptor.create_with_payload!(<label; format="label">)
+@adaptor.add_child(root_0, tree_for_<label>)
+})>
+>>
+
+
+
+wildcardBang(label,elementIndex) ::= "<super.wildcard(...)>"
+
+wildcardRuleRoot(label,elementIndex) ::= <<
+<super.wildcard(...)>
+<gatedAction({
+tree_for_<label> = @adaptor.create_with_payload!(<label; format="label">)
+root_0 = @adaptor.become_root(tree_for_<label>, root_0)
+})>
+>>
+
+createNodeFromToken(label,hetero) ::= <<
+<if(hetero)>
+<hetero; format="constantPath">.new(<label; format="label">)
+<else>
+@adaptor.create_with_payload!(<label; format="label">)
+<endif>
+>>
+
+ruleCleanUp() ::= <<
+<super.ruleCleanUp()>
+<gatedAction({
+return_value.tree = @adaptor.rule_post_processing(root_0)
+@adaptor.set_token_boundaries(return_value.tree, return_value.start, return_value.stop)
+})>
+>>
+
+