antlr4 0.9.2

data/lib/antlr4/tree/RuleTagToken.rb

@@ -0,0 +1,39 @@
+
+class RuleTagToken < Token
+    # Constructs a new instance of {@link RuleTagToken} with the specified rule
+    # name, bypass token type, and label.
+    #
+    # @param ruleName The name of the parser rule this rule tag matches.
+    # @param bypassTokenType The bypass token type assigned to the parser rule.
+    # @param label The label associated with the rule tag, or {@code null} if
+    # the rule tag is unlabeled.
+    #
+    # @exception IllegalArgumentException if {@code ruleName} is {@code null}
+    # or empty.
+
+    attr_accessor :label, :ruleName
+
+    def initialize(ruleName, bypassTokenType, label=nil)
+        if ruleName.nil? or ruleName.length ==0 then
+            raise Exception.new("ruleName cannot be null or empty.")
+        end
+        self.source = nil
+        self.type = bypassTokenType # token type of the token
+        self.channel = Token::DEFAULT_CHANNEL # The parser ignores everything not on DEFAULT_CHANNEL
+        self.start = -1 # optional; return -1 if not implemented.
+        self.stop = -1  # optional; return -1 if not implemented.
+        self.tokenIndex = -1 # from 0..n-1 of the token object in the input stream
+        self.line = 0 # line=1..n of the 1st character
+        self.column = -1 # beginning of the line at which it occurs, 0..n-1
+        self.label = label
+        self.ruleName = ruleName
+        @text = getText()
+    end
+    def getText()
+        if self.label.nil? then
+            "<#{@ruleName}>"
+        else
+            "<#{@label}:#{@ruleName}>"
+        end
+    end
+end

data/lib/antlr4/tree/TokenTagToken.rb

@@ -0,0 +1,38 @@
+# A {@link Token} object representing a token of a particular type; e.g.,
+# {@code <ID>}. These tokens are created for {@link TagChunk} chunks where the
+# tag corresponds to a lexer rule or token type.
+#
+
+class TokenTagToken < CommonToken
+
+    # Constructs a new instance of {@link TokenTagToken} with the specified
+    # token name, type, and label.
+    #
+    # @param tokenName The token name.
+    # @param type The token type.
+    # @param label The label associated with the token tag, or {@code null} if
+    # the token tag is unlabeled.
+    #
+    attr_accessor :tokenName, :label
+    def initialize(tokenName, type, label=nil)
+        super(type)
+        self.tokenName = tokenName
+        self.label = label
+        @text = getText()
+    end
+    # <p>The implementation for {@link TokenTagToken} returns the token tag
+    # formatted with {@code <} and {@code >} delimiters.</p>
+    def getText()
+        if self.label.nil?
+            return "<" + self.tokenName + ">"
+        else
+            return "<" + self.label + ":" + self.tokenName + ">"
+        end
+    end
+    # <p>The implementation for {@link TokenTagToken} returns a string of the form
+    # {@code tokenName:type}.</p>
+    #
+    def to_s
+        "#{self.tokenName}:#{self.class}" 
+    end
+end

data/lib/antlr4/tree/Tree.rb

@@ -0,0 +1,204 @@
+# The basic notion of a tree has a parent, a payload, and a list of children.
+#  It is the most abstract interface for all the trees used by ANTLR.
+#
+
+class Tree
+end
+
+class SyntaxTree < Tree
+end
+
+class ParseTree < SyntaxTree
+end
+
+class RuleNode < ParseTree
+end
+
+class TerminalNode < ParseTree
+end
+
+class ErrorNode < TerminalNode
+end
+
+
+# This interface defines the basic notion of a parse tree visitor. Generated
+# visitors implement this interface and the {@code XVisitor} interface for
+# grammar {@code X}.
+class ParseTreeVisitor
+	 # Visit a parse tree, and return a user-defined result of the operation.
+	 #
+	 # @param tree The {@link ParseTree} to visit.
+	 # @return The result of visiting the parse tree.
+	def visit(tree) # tree:ParseTree 
+  end
+	# Visit the children of a node, and return a user-defined result of the
+	# operation.
+	# @param node The {@link RuleNode} whose children should be visited.
+	# @return The result of visiting the children of the node.
+	def visitChildren(node) # node:RuleNode 
+  end
+
+	# Visit a terminal node, and return a user-defined result of the operation.
+	#
+	# @param node The {@link TerminalNode} to visit.
+	# @return The result of visiting the node.
+	def visitTerminal(node) # node:TerminalNode 
+  end
+  #Visit an error node, and return a user-defined result of the operation.
+  #
+	# @param node The {@link ErrorNode} to visit.
+	# @return The result of visiting the node.
+	def visitErrorNode(node) # node:ErrorNode 
+  end
+end
+
+class ParseTreeListener
+    def visitTerminal(node)
+    end
+
+    def visitErrorNode(node)
+    end
+
+    def enterEveryRule(ctx)
+    end
+
+    def exitEveryRule(ctx)
+    end
+end
+
+module NodeImpl
+
+  def self.included(klass)
+    klass.send(:include, NodeImpl::Methods)
+    # klass.send(:extend, NodeImpl::Methods)
+    # klass.send(:extend, NodeImpl::ClassMethods)
+  end
+  module Methods
+    def initialize(symbol)
+        @parentCtx = nil
+        @symbol = symbol
+    end
+    def symbol
+      @symbol
+    end
+    def symbol=(value)
+      @symbol = value
+    end
+    def parentCtx
+      @parentCtx
+    end
+    def parentCtx=(value)
+      @parentCtx = value
+    end
+
+#    def []=(key, value)
+#        super(key, value)
+#    end
+
+    def getChild(i)
+        nil
+    end
+
+    def getSymbol()
+        self.symbol
+    end
+
+    def getParent()
+        self.parentCtx
+    end
+
+    def getPayload()
+        return self.symbol
+    end
+
+    def getSourceInterval()
+        return Antlr4::INVALID_INTERVAL if self.symbol.nil?
+        tokenIndex = self.symbol.tokenIndex
+        return [tokenIndex, tokenIndex]
+    end
+
+    def getChildCount()
+        return 0
+    end
+
+    def accept(visitor)
+        return visitor.visitTerminal(self)
+    end
+
+    def text
+        return self.symbol.text
+    end      
+    def getText()
+        return self.symbol.text
+    end
+
+    def to_s
+        if self.symbol.type == Token::EOF then
+            "<EOF>"
+        else
+            self.symbol.text
+        end
+    end
+  end
+end
+
+class TerminalNodeImpl < TerminalNode
+    include NodeImpl
+
+end
+# Represents a token that was consumed during resynchronization
+#  rather than during a valid match operation. For example,
+#  we will create this kind of a node during single token insertion
+#  and deletion as well as during "consume until error recovery set"
+#  upon no viable alternative exceptions.
+
+class ErrorNodeImpl < ErrorNode
+    include NodeImpl 
+
+    def accept(visitor)
+        return visitor.visitErrorNode(self)
+    end
+end
+
+
+class ParseTreeWalker
+    # ParseTreeWalker.DEFAULT = ParseTreeWalker()
+    @@default  = nil
+    def self.DEFAULT
+        if @@default.nil? 
+          @@default = new
+        end
+        @@default
+    end
+    def walk(listener, t)
+        if t.kind_of?  ErrorNode then
+            listener.visitErrorNode(t)
+            return
+        elsif t.kind_of? TerminalNode then
+            listener.visitTerminal(t)
+            return
+        end
+        self.enterRule(listener, t)
+        for child in t.getChildren() 
+            self.walk(listener, child)
+        end
+        self.exitRule(listener, t)
+    end
+    #
+    # The discovery of a rule node, involves sending two events: the generic
+    # {@link ParseTreeListener#enterEveryRule} and a
+    # {@link RuleContext}-specific event. First we trigger the generic and then
+    # the rule specific. We to them in reverse order upon finishing the node.
+    #
+    def enterRule(listener, r)
+        ctx = r.getRuleContext()
+        listener.enterEveryRule(ctx)
+        ctx.enterRule(listener)
+    end
+
+    def exitRule(listener, r)
+        ctx = r.getRuleContext()
+        ctx.exitRule(listener)
+        listener.exitEveryRule(ctx)
+    end
+end

data/lib/antlr4/tree/Trees.rb

@@ -0,0 +1,111 @@
+# A set of utility routines useful for all kinds of ANTLR trees.#
+#from io import StringIO
+#from antlr4.Token import Token
+#from antlr4.Utils import escapeWhitespace
+#from antlr4.tree.Tree import RuleNode, ErrorNode, TerminalNode, Tree, ParseTree
+
+class Trees
+
+     # Print out a whole tree in LISP form. {@link #getNodeText} is used on the
+    #  node payloads to get the text for the nodes.  Detect
+    #  parse trees and extract data appropriately.
+    def self.toStringTree(t, ruleNames=nil, recog=nil)
+        if not recog.nil? then 
+            ruleNames = recog.ruleNames
+        end
+        s = getNodeText(t, ruleNames).escapeWhitespace(false)
+        if t.getChildCount()==0 then
+            return s
+        end
+        StringIO.open  do |buf|
+            buf.write("(")
+            buf.write(s)
+            buf.write(' ')
+            for i in 0..t.getChildCount()-1 do
+                if i > 0 then
+                    buf.write(' ')
+                end
+                buf.write(toStringTree(t.getChild(i), ruleNames))
+            end
+            buf.write(")")
+            return buf.string()
+        end
+    end
+    def self.getNodeText(t, ruleNames=nil, recog=nil) 
+        if not recog.nil? then 
+            ruleNames = recog.ruleNames
+        end
+        if not ruleNames.nil? then 
+            if t.kind_of? RuleNode then
+                return ruleNames[t.getRuleContext().getRuleIndex()]
+            elsif t.kind_of? ErrorNode then
+                return t.to_s
+            elsif t.kind_of? TerminalNode then
+                if not t.symbol.nil? then 
+                    return t.symbol.text
+                end
+            end
+        end
+        # no recog for rule names
+        payload = t.getPayload()
+        if payload.kind_of? Token then
+            return payload.text
+        end
+        return t.getPayload().to_s
+    end
+
+    # Return ordered list of all children of this node
+    def self.getChildren(t)
+        return (0 .. t.getChildCount()-1).map{|i| t.getChild(i) }
+    end
+
+    # Return a list of all ancestors of this node.  The first node of
+    #  list is the root and the last is the parent of this node.
+    #
+    def self.getAncestors(t)
+        ancestors = []
+        t = t.getParent()
+        while not t.nil? do
+            ancestors.unshift(t) # insert at start
+            t = t.getParent()
+        end
+        return ancestors
+    end
+
+    def self.findAllTokenNodes(t, ttype)
+        return findAllNodes(t, ttype, true)
+    end
+
+    def self.findAllRuleNodes(t, ruleIndex)
+        return findAllNodes(t, ruleIndex, false)
+    end
+
+    def self.findAllNodes(cls, t, index, findTokens)
+        nodes = Array.new
+        _findAllNodes(t, index, findTokens, nodes)
+        return nodes
+    end
+
+    def self._findAllNodes(t, index, findTokens, nodes)
+        #from antlr4.ParserRuleContext import ParserRuleContext
+        # check this node (the root) first
+        if findTokens and t.kind_of? TerminalNode then
+            nodes.push(t) if t.symbol.type==index
+        elsif not findTokens and t.kind_of? ParserRuleContext then
+            nodes.push(t) if t.ruleIndex == index
+        end
+        # check children
+        for i in 0 .. t.getChildCount()-1
+            self._findAllNodes(t.getChild(i), index, findTokens, nodes)
+        end
+    end
+
+    def self.descendants(t)
+        nodes = Array.new
+        nodes.push(t)
+        for i in 0..t.getChildCount()-1 
+            nodes.concat(self.descendants(t.getChild(i)))
+        end
+        return nodes
+    end
+end

data/lib/antlr4/version.rb

@@ -0,0 +1,5 @@
+module Antlr4
+  VERSION = "0.9.2"
+  ANTLR_VERSION = '4.4'
+end
+

data/lib/antlr4/xpath/XPath.rb

@@ -0,0 +1,354 @@
+#
+# Represent a subset of XPath XML path syntax for use in identifying nodes in
+# parse trees.
+#
+# <p>
+# Split path into words and separators {@code /} and {@code //} via ANTLR
+# itself then walk path elements from left to right. At each separator-word
+# pair, find set of nodes. Next stage uses those as work list.</p>
+#
+# <p>
+# The basic interface is
+# {@link XPath#findAll ParseTree.findAll}{@code (tree, pathString, parser)}.
+# But that is just shorthand for:</p>
+#
+# <pre>
+# {@link XPath} p = new {@link XPath#XPath XPath}(parser, pathString);
+# return p.{@link #evaluate evaluate}(tree);
+# </pre>
+#
+# <p>
+# See {@code org.antlr.v4.test.TestXPath} for descriptions. In short, this
+# allows operators:</p>
+#
+# <dl>
+# <dt>/</dt> <dd>root</dd>
+# <dt>//</dt> <dd>anywhere</dd>
+# <dt>!</dt> <dd>invert; this must appear directly after root or anywhere
+# operator</dd>
+# </dl>
+#
+# <p>
+# and path elements:</p>
+#
+# <dl>
+# <dt>ID</dt> <dd>token name</dd>
+# <dt>'string'</dt> <dd>any string literal token from the grammar</dd>
+# <dt>expr</dt> <dd>rule name</dd>
+# <dt>*</dt> <dd>wildcard matching any node</dd>
+# </dl>
+#
+# <p>
+# Whitespace is not allowed.</p>
+#
+
+class XPathLexer < Lexer
+    include JavaSymbols
+
+    @@serializedATN = \
+        "\3\uacf5\uee8c\u4f5d\u8b0d\u4a45\u78bd\u1b2f\u3378\2\n\64\b\1\4\2\t\2" + \
+        "\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\3\2\3\2\3\2\3" + \
+        "\3\3\3\3\4\3\4\3\5\3\5\3\6\3\6\7\6\37\n\6\f\6\16\6\"\13\6\3\6\3\6\3\7" + \
+        "\3\7\5\7(\n\7\3\b\3\b\3\t\3\t\7\t.\n\t\f\t\16\t\61\13\t\3\t\3\t\3/\n\3" + \
+        "\5\1\5\6\1\7\7\1\t\b\1\13\t\2\r\2\1\17\2\1\21\n\1\3\2\4\7\2\62;aa\u00b9" + \
+        "\u00b9\u0302\u0371\u2041\u2042\17\2C\\c|\u00c2\u00d8\u00da\u00f8\u00fa" + \
+        "\u0301\u0372\u037f\u0381\u2001\u200e\u200f\u2072\u2191\u2c02\u2ff1\u3003" + \
+        "\ud801\uf902\ufdd1\ufdf2\uffff\64\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2" + \
+        "\2\t\3\2\2\2\2\13\3\2\2\2\2\21\3\2\2\2\3\23\3\2\2\2\5\26\3\2\2\2\7\30" + \
+        "\3\2\2\2\t\32\3\2\2\2\13\34\3\2\2\2\r\'\3\2\2\2\17)\3\2\2\2\21+\3\2\2" + \
+        "\2\23\24\7\61\2\2\24\25\7\61\2\2\25\4\3\2\2\2\26\27\7\61\2\2\27\6\3\2" + \
+        "\2\2\30\31\7,\2\2\31\b\3\2\2\2\32\33\7#\2\2\33\n\3\2\2\2\34 \5\17\b\2" + \
+        "\35\37\5\r\7\2\36\35\3\2\2\2\37\"\3\2\2\2 \36\3\2\2\2 !\3\2\2\2!#\3\2" + \
+        "\2\2\" \3\2\2\2#$\b\6\2\2$\f\3\2\2\2%(\5\17\b\2&(\t\2\2\2\'%\3\2\2\2\'" + \
+        "&\3\2\2\2(\16\3\2\2\2)*\t\3\2\2*\20\3\2\2\2+/\7)\2\2,.\13\2\2\2-,\3\2" + \
+        "\2\2.\61\3\2\2\2/\60\3\2\2\2/-\3\2\2\2\60\62\3\2\2\2\61/\3\2\2\2\62\63" + \
+        "\7)\2\2\63\22\3\2\2\2\6\2 \'/"
+
+    TOKEN_REF=1
+    RULE_REF=2
+    ANYWHERE=3
+    ROOT=4
+    WILDCARD=5
+    BANG=6
+    ID=7
+    STRING=8
+
+
+    def initialize(input)
+        super(input)
+        self.modeNames = [ "DEFAULT_MODE" ]
+        self.tokenNames = ["<INVALID>", "TOKEN_REF", "RULE_REF", "'//'", "'/'", "'*'", "'!'", "ID", "STRING" ]
+        self.ruleNames = [ "ANYWHERE", "ROOT", "WILDCARD", "BANG", "ID", "NameChar", "NameStartChar", "STRING" ]
+        @ATN = ATNDeserializer.new.deserialize(@@serializedATN)
+        @interp = LexerATNSimulator.new(@ATN, @decisionToDFA, @sharedContextCache)
+        @grammarFileName = "XPathLexer.g4"
+        @decisionToDFA = @ATN.decisionToState.map{|s| DFA.new(s)  } 
+        @sharedContextCache = PredictionContextCache()
+    end
+
+
+    def action(localctx, ruleIndex, actionIndex)
+        if ruleIndex==4 then
+            self.ID_action(localctx, actionIndex)
+        end
+    end
+
+    def ID_action(localctx, actionIndex)
+        if actionIndex==0 then
+            if self.text[0].is_uppercase?
+                self.type = TOKEN_REF
+            else
+                self.type = RULE_REF
+            end
+        end
+    end
+end
+
+class XPath
+
+    WILDCARD = "*" # word not operator/separator
+    NOT = "!" # word for invert operator
+    def self.WILDCARD
+      XPath::WILDCARD
+    end
+    def self.NOT
+      XPath::NOT
+    end
+
+    def initialize(parser, path)
+        self.parser = parser
+        self.path = path
+        self.elements = self.split(path)
+    end
+    def recover(e)
+       raise e
+    end
+    def split(path)
+        input = InputStream.new(path)
+        lexer = XPathLexer.new(input)
+        lexer.recover = recover
+        lexer.removeErrorListeners()
+        lexer.addErrorListener(ErrorListener.new()) # XPathErrorListener does no more
+        tokenStream = CommonTokenStream.new(lexer)
+        begin
+            tokenStream.fill()
+        rescue LexerNoViableAltException => e
+            pos = lexer.getColumn()
+            msg = "Invalid tokens or characters at index #{pos} in path '#{path}'"
+            ex = Exception.new(msg)
+            ex.set_backtrace(e.backtrace)
+            raise ex
+        end
+
+        tokens = tokenStream.getTokens()
+        elements = Array.new
+        n = tokens.length
+        i=0
+        while i < n do 
+            el = tokens[i]
+            next_token = nil
+            if [XPathLexer::ROOT, XPathLexer::ANYWHERE].member? el.type then
+                    anywhere = el.type == XPathLexer::ANYWHERE
+                     i = i + 1
+                    next_token = tokens[i]
+                    invert = next_token.type==XPathLexer::BANG
+                    if invert then
+                        i = i + 1
+                        next_token = tokens[i]
+                    end
+                    pathElement = self.getXPathElement(next_token, anywhere)
+                    pathElement.invert = invert
+                    elements.push(pathElement)
+                    i = i + 1
+            elsif [XPathLexer::TOKEN_REF, XPathLexer::RULE_REF, XPathLexer::WILDCARD].member? el.type then
+                    elements.push( self.getXPathElement(el, false) )
+                    i = i + 1
+            elsif el.type==Token::EOF then
+                    break
+            else
+                    raise Exception.new("Unknown path element #{el}")
+            end
+        end
+        return elements
+    end
+
+    #
+    # Convert word like {@code#} or {@code ID} or {@code expr} to a path
+    # element. {@code anywhere} is {@code true} if {@code //} precedes the
+    # word.
+    #
+    def getXPathElement(wordToken, anywhere)
+        if wordToken.type==Token::EOF then
+            raise Exception.new("Missing path element at end of path")
+        end
+        word = wordToken.text
+        ttype = self.parser.getTokenType(word)
+        ruleIndex = self.parser.getRuleIndex(word)
+
+        if wordToken.type==XPathLexer::WILDCARD then
+            if anywhere then
+              return XPathWildcardAnywhereElement.new() 
+            else  
+              return XPathWildcardElement.new()
+            end
+        elsif [XPathLexer::TOKEN_REF, XPathLexer::STRING].member?  wordToken.type 
+            if ttype==Token::INVALID_TYPE then
+                raise Exception.new("#{word} at index #{wordToken.startIndex} isn't a valid token name")
+            end
+            if anywhere then 
+              return XPathTokenAnywhereElement.new(word, ttype)   
+            else 
+                return XPathTokenElement.new(word, ttype)
+            end
+        else
+            if ruleIndex==-1 then
+                raise Exception( "#{word} at index #{wordToken.getStartIndex()} isn't a valid rule name")
+            end
+            if anywhere 
+              return XPathRuleAnywhereElement.new(word, ruleIndex)  
+            else 
+              return XPathRuleElement.new(word, ruleIndex)
+            end
+        end
+    end
+
+    def findAll(tree, xpath, parser)
+        p = XPath.new(parser, xpath)
+        return p.evaluate(tree)
+    end
+    #
+    # Return a list of all nodes starting at {@code t} as root that satisfy the
+    # path. The root {@code /} is relative to the node passed to
+    # {@link #evaluate}.
+    #
+    def evaluate(t)
+        dummyRoot = ParserRuleContext.new()
+        dummyRoot.children = [t] # don't set t's parent.
+        work = [dummyRoot]
+        for i in (0 .. (self.elements.length-1)) do
+            next_token = Set.new()
+            for node in work do
+                if node.children.length > 0 then
+                    # only try to match next element if it has children
+                    # e.g., //func/*/stat might have a token node for which
+                    # we can't go looking for stat nodes.
+                    matching = self.elements[i].evaluate(node)
+                    next_token.union(matching)
+                end
+            end
+            i = i + 1
+            work = next_token
+        end
+        return work
+    end
+end
+class XPathElement
+
+    attr_accessor :nodeNode, :invert
+    def initialize(nodename)
+        self.nodeName = nodename
+        self.invert = false
+    end
+
+    def to_s 
+        c = "!" if self.invert
+        return "#{self.class.to_s}[#{c}#{self.nodeName}]"
+    end
+end
+#
+# Either {@code ID} at start of path or {@code ...//ID} in middle of path.
+#
+class XPathRuleAnywhereElement < XPathElement
+
+    attr_accessor :ruleIndex
+    def initialize(rule_name, rule_index)
+        super(rule_name)
+        self.ruleIndex = rule_index
+    end
+
+    def evaluate(t)
+        return Trees.findAllRuleNodes(t, self.ruleIndex)
+    end
+end
+
+class XPathRuleElement <  XPathRuleAnywhereElement 
+
+    def initialize(rulename, ruleindex)
+        super(rulename, ruleindex)
+    end
+    def evaluate(t)
+        # return all children of t that match nodeName
+        nodes = []
+        for c in Trees.getChildren(t) do
+            if c.kind_of? ParserRuleContext  then
+                if (c.ruleIndex == self.ruleIndex ) == (not self.invert) then
+                    nodes.push(c)
+                end
+            end
+        end
+        return nodes
+    end
+end
+class XPathTokenAnywhereElement < XPathElement
+
+    attr_accessor :tokenType
+    def initialize(rulename, tokentype)
+        super(rulename)
+        self.tokenType = tokentype
+    end
+
+    def evaluate(t)
+        return Trees.findAllTokenNodes(t, self.tokenType)
+    end
+end
+
+class XPathTokenElement < XPathTokenAnywhereElement
+
+    def initialize(rulename, tokentype)
+        super(rulename, tokentype)
+    end
+
+    def evaluate(t)
+        # return all children of t that match nodeName
+        nodes = []
+        for c in Trees.getChildren(t) do
+            if c.kind_of? TerminalNode then
+                if (c.symbol.type == self.tokenType ) == (not self.invert) then
+                    nodes.push(c)
+                end
+            end
+        end
+        return nodes
+    end
+end
+
+class XPathWildcardAnywhereElement < XPathElement
+
+    def initialize()
+        super(XPath::WILDCARD)
+    end
+
+    def evaluate(t)
+        if self.invert then
+            return [] # !* is weird but valid (empty)
+        else
+            return Trees.descendants(t)
+        end
+    end
+end
+
+class XPathWildcardElement < XPathElement
+
+    def initialize()
+        super(XPath::WILDCARD)
+    end
+
+
+    def evaluate(t)
+        if self.invert then
+            return [] # !* is weird but valid (empty)
+        else
+            return Trees.getChildren(t)
+        end
+    end
+end