antlr4 0.9.2

data/lib/antlr4/tree/Chunk.rb

@@ -0,0 +1,31 @@
+class Chunk
+end
+
+class TagChunk < Chunk
+
+    attr_accessor :tag, :label
+    def initialize(tag, label=nil)
+        self.tag = tag
+        self.label = label
+    end
+
+    def to_s
+        if self.label.nil?
+            self.tag
+        else
+            "#{self.label}:#{self.tag}"
+        end
+    end
+end
+class TextChunk < Chunk
+
+     attr_accessor :text
+    def initialize(text) 
+        self.text = text
+    end
+
+    def to_s
+        "'#{ self.text }'"
+    end
+
+end

data/lib/antlr4/tree/ParseTreeMatch.rb

@@ -0,0 +1,105 @@
+# Represents the result of matching a {@link ParseTree} against a tree pattern.
+
+class ParseTreeMatch
+    # Constructs a new instance of {@link ParseTreeMatch} from the specified
+    # parse tree and pattern.
+    #
+    # @param tree The parse tree to match against the pattern.
+    # @param pattern The parse tree pattern.
+    # @param labels A mapping from label names to collections of
+    # {@link ParseTree} objects located by the tree pattern matching process.
+    # @param mismatchedNode The first node which failed to match the tree
+    # pattern during the matching process.
+    #
+    # @exception IllegalArgumentException if {@code tree} is {@code null}
+    # @exception IllegalArgumentException if {@code pattern} is {@code null}
+    # @exception IllegalArgumentException if {@code labels} is {@code null}
+    #
+    attr_accessor :tree, :pattern, :labels, :mismatchedNode
+    def initialize(tree, pattern, labels, mismatchedNode)
+        raise Exception.new("tree cannot be null") if tree.nil? 
+        raise Exception.new("pattern cannot be null") if pattern.nil?
+        raise Exception.new("labels cannot be null") if labels.nil? 
+        self.tree = tree
+        self.pattern = pattern
+        self.labels = labels
+        self.mismatchedNode = mismatchedNode
+    end
+    #
+    # Get the last node associated with a specific {@code label}.
+    #
+    # <p>For example, for pattern {@code <id:ID>}, {@code get("id")} returns the
+    # node matched for that {@code ID}. If more than one node
+    # matched the specified label, only the last is returned. If there is
+    # no node associated with the label, this returns {@code null}.</p>
+    #
+    # <p>Pattern tags like {@code <ID>} and {@code <expr>} without labels are
+    # considered to be labeled with {@code ID} and {@code expr}, respectively.</p>
+    #
+    # @param label The label to check.
+    #
+    # @return The last {@link ParseTree} to match a tag with the specified
+    # label, or {@code null} if no parse tree matched a tag with the label.
+    #
+    def get(label)
+        parseTrees = self.labels.get(label, nil)
+        if parseTrees.nil? or parseTrees.empty? then
+            return nil
+        else
+            return parseTrees[-1]
+        end
+    end
+    #
+    # Return all nodes matching a rule or token tag with the specified label.
+    #
+    # <p>If the {@code label} is the name of a parser rule or token in the
+    # grammar, the resulting list will contain both the parse trees matching
+    # rule or tags explicitly labeled with the label and the complete set of
+    # parse trees matching the labeled and unlabeled tags in the pattern for
+    # the parser rule or token. For example, if {@code label} is {@code "foo"},
+    # the result will contain <em>all</em> of the following.</p>
+    #
+    # <ul>
+    # <li>Parse tree nodes matching tags of the form {@code <foo:anyRuleName>} and
+    # {@code <foo:AnyTokenName>}.</li>
+    # <li>Parse tree nodes matching tags of the form {@code <anyLabel:foo>}.</li>
+    # <li>Parse tree nodes matching tags of the form {@code <foo>}.</li>
+    # </ul>
+    #
+    # @param label The label.
+    #
+    # @return A collection of all {@link ParseTree} nodes matching tags with
+    # the specified {@code label}. If no nodes matched the label, an empty list
+    # is returned.
+    #
+    def getAll(label)
+        self.labels.get(label, Array.new)
+    end
+
+    #
+    # Gets a value indicating whether the match operation succeeded.
+    #
+    # @return {@code true} if the match operation succeeded; otherwise,
+    # {@code false}.
+    #
+    def succeeded
+        return self.mismatchedNode.nil?
+    end
+    #
+    # {@inheritDoc}
+    #
+    def to_s
+        StringIO.open do |buf|
+            buf.write("Match ")
+            if self.succeeded() 
+                buf.write("succeeded") 
+            else 
+                buf.write("failed")
+            end
+            buf.write("; found ")
+            buf.write(self.labels.length.to_s)
+            buf.write(" labels")
+            return buf.string
+        end
+    end
+end

data/lib/antlr4/tree/ParseTreePattern.rb

@@ -0,0 +1,70 @@
+# A pattern like {@code <ID> = <expr>;} converted to a {@link ParseTree} by
+# {@link ParseTreePatternMatcher#compile(String, int)}.
+#
+#from antlr4.tree.ParseTreePatternMatcher import ParseTreePatternMatcher
+#from antlr4.tree.Tree import ParseTree
+#from antlr4.xpath.XPath import XPath
+
+
+class ParseTreePattern
+
+    # Construct a new instance of the {@link ParseTreePattern} class.
+    #
+    # @param matcher The {@link ParseTreePatternMatcher} which created this
+    # tree pattern.
+    # @param pattern The tree pattern in concrete syntax form.
+    # @param patternRuleIndex The parser rule which serves as the root of the
+    # tree pattern.
+    # @param patternTree The tree pattern in {@link ParseTree} form.
+    #
+    attr_accessor :matcher, :patternRuleIndex, :pattern, :patternTree
+    def initialize(matcher, pattern, patternRuleIndex, patternTree)
+        self.matcher = matcher
+        self.patternRuleIndex = patternRuleIndex
+        self.pattern = pattern
+        self.patternTree = patternTree
+    end
+
+    #
+    # Match a specific parse tree against this tree pattern.
+    #
+    # @param tree The parse tree to match against this tree pattern.
+    # @return A {@link ParseTreeMatch} object describing the result of the
+    # match operation. The {@link ParseTreeMatch#succeeded()} method can be
+    # used to determine whether or not the match was successful.
+    #
+    def match(tree)
+        return self.matcher.match(tree, self)
+    end
+
+    #
+    # Determine whether or not a parse tree matches this tree pattern.
+    #
+    # @param tree The parse tree to match against this tree pattern.
+    # @return {@code true} if {@code tree} is a match for the current tree
+    # pattern; otherwise, {@code false}.
+    #
+    def matches(tree)
+        return self.matcher.match(tree, self).succeeded()
+    end
+
+    # Find all nodes using XPath and then try to match those subtrees against
+    # this tree pattern.
+    #
+    # @param tree The {@link ParseTree} to match against this pattern.
+    # @param xpath An expression matching the nodes
+    #
+    # @return A collection of {@link ParseTreeMatch} objects describing the
+    # successful matches. Unsuccessful matches are omitted from the result,
+    # regardless of the reason for the failure.
+    #
+    def findAll(tree, xpath)
+        subtrees = XPath.findAll(tree, xpath, self.matcher.parser)
+        subtrees.map do |t| 
+            match = self.match(t)
+            if match.succeeded() then
+                match
+            end
+        end.compact
+    end
+end

data/lib/antlr4/tree/ParseTreePatternMatcher.rb

@@ -0,0 +1,334 @@
+#
+#from antlr4 import Lexer, CommonTokenStream, ParserRuleContext
+#from antlr4.InputStream import InputStream
+#from antlr4.ListTokenSource import ListTokenSource
+#from antlr4.Token import Token
+#from antlr4.error.ErrorStrategy import BailErrorStrategy
+#from antlr4.error.Errors import RecognitionException, ParseCancellationException
+#from antlr4.tree.Chunk import TagChunk, TextChunk
+#from antlr4.tree.RuleTagToken import RuleTagToken
+##from antlr4.tree.TokenTagToken import TokenTagToken
+#from antlr4.tree.Tree import ParseTree, TerminalNode, RuleNode
+        #from antlr4.tree.ParseTreeMatch import ParseTreeMatch
+#        from antlr4.tree.ParseTreePattern import ParseTreePattern
+
+class CannotInvokeStartRule < Exception
+end
+
+class StartRuleDoesNotConsumeFullPattern < Exception
+end
+
+class ParseTreePatternMatcher
+    # Constructs a {@link ParseTreePatternMatcher} or from a {@link Lexer} and
+    # {@link Parser} object. The lexer input stream is altered for tokenizing
+    # the tree patterns. The parser is used as a convenient mechanism to get
+    # the grammar name, plus token, rule names.
+    attr_accessor :lexer, :parser, :start, :stop, :escape
+    def initialize(lexer, parser)
+        self.lexer = lexer
+        self.parser = parser
+        self.start = "<"
+        self.stop = ">"
+        self.escape = "\\"  # e.g., \< and \> must escape BOTH!
+    end
+
+    # Set the delimiters used for marking rule and token tags within concrete
+    # syntax used by the tree pattern parser.
+    #
+    # @param start The start delimiter.
+    # @param stop The stop delimiter.
+    # @param escapeLeft The escape sequence to use for escaping a start or stop delimiter.
+    #
+    # @exception IllegalArgumentException if {@code start} is {@code null} or empty.
+    # @exception IllegalArgumentException if {@code stop} is {@code null} or empty.
+    #
+    def setDelimiters(start, stop, escapeLeft)
+        raise Exception.new("start cannot be null or empty") if start.nil? or start.empty? 
+        raise Exception.new("stop cannot be null or empty") if stop.nil? or stop.empty?
+        self.start = start
+        self.stop = stop
+        self.escape = escapeLeft
+    end
+
+    # Does {@code pattern} matched as rule {@code patternRuleIndex} match {@code tree}?#
+    def matchesRuleIndex(tree, pattern, patternRuleIndex)
+        p = self.compileTreePattern(pattern, patternRuleIndex)
+        return self.matches(tree, p)
+    end
+
+    # Does {@code pattern} matched as rule patternRuleIndex match tree? Pass in a
+    #  compiled pattern instead of a string representation of a tree pattern.
+    #
+    def matchesPattern(tree, pattern)
+        mismatchedNode = self.matchImpl(tree, pattern.patternTree, Hash.new)
+        return mismatchedNode.nil? 
+    end
+
+    #
+    # Compare {@code pattern} matched as rule {@code patternRuleIndex} against
+    # {@code tree} and return a {@link ParseTreeMatch} object that contains the
+    # matched elements, or the node at which the match failed.
+    #
+    def matchRuleIndex(tree, pattern, patternRuleIndex)
+        p = self.compileTreePattern(pattern, patternRuleIndex)
+        return self.matchPattern(tree, p)
+    end
+
+    #
+    # Compare {@code pattern} matched against {@code tree} and return a
+    # {@link ParseTreeMatch} object that contains the matched elements, or the
+    # node at which the match failed. Pass in a compiled pattern instead of a
+    # string representation of a tree pattern.
+    #
+    def matchPattern(tree, pattern)
+        labels = Hash.new
+        mismatchedNode = self.matchImpl(tree, pattern.patternTree, labels)
+        return ParseTreeMatch.new(tree, pattern, labels, mismatchedNode)
+    end
+
+    #
+    # For repeated use of a tree pattern, compile it to a
+    # {@link ParseTreePattern} using this method.
+    #
+    def compileTreePattern(pattern, patternRuleIndex)
+        tokenList = self.tokenize(pattern)
+        tokenSrc = ListTokenSource.new(tokenList)
+        tokens = CommonTokenStream.new(tokenSrc)
+#        from antlr4.ParserInterpreter import ParserInterpreter
+
+        p = self.parser
+        parserInterp = ParserInterpreter.new(p.grammarFileName, p.tokenNames, p.ruleNames, 
+                                              p.getATNWithBypassAlts(),tokens)
+        tree = nil
+        begin
+            parserInterp.setErrorHandler(BailErrorStrategy())
+            tree = parserInterp.parse(patternRuleIndex)
+        rescue ParseCancellationException => e
+            raise e.cause
+        rescue RecognitionException => e
+            raise e
+        rescue Exception => e
+            raise CannotInvokeStartRule.new(e)
+        end
+
+        # Make sure tree pattern compilation checks for a complete parse
+        if tokens.LA(1)!=Token::EOF then
+            raise StartRuleDoesNotConsumeFullPattern.new()
+        end
+
+        return ParseTreePattern.new(self, pattern, patternRuleIndex, tree)
+    end
+    #
+    # Recursively walk {@code tree} against {@code patternTree}, filling
+    # {@code match.}{@link ParseTreeMatch#labels labels}.
+    #
+    # @return the first node encountered in {@code tree} which does not match
+    # a corresponding node in {@code patternTree}, or {@code null} if the match
+    # was successful. The specific node returned depends on the matching
+    # algorithm used by the implementation, and may be overridden.
+    #
+    def matchImpl(tree, patternTree, labels)
+        raise Exception.new("tree cannot be null") if tree.nil?
+        raise Exception.new("patternTree cannot be null") if patternTree.nil?
+
+        # x and <ID>, x and y, or x and x; or could be mismatched types
+        if tree.kind_of? TerminalNode and patternTree.kind_of? TerminalNode then
+            mismatchedNode = nil
+            # both are tokens and they have same type
+            if tree.symbol.type == patternTree.symbol.type then
+                if patternTree.symbol.kind_of? TokenTagToken then # x and <ID>
+                    tokenTagToken = patternTree.symbol
+                    # track label->list-of-nodes for both token name and label (if any)
+                    self.map(labels, tokenTagToken.tokenName, tree)
+                    if not tokenTagToken.label.nil? 
+                        self.map(labels, tokenTagToken.label, tree)
+                    end
+                elsif tree.getText()==patternTree.getText() then
+                    # x and x
+                    nil
+                else
+                    # x and y
+                    mismatchedNode = tree if mismatchedNode.nil?
+                end
+            else
+                mismatchedNode = tree if mismatchedNode.nil? 
+            end
+
+            return mismatchedNode
+        end
+
+        if tree.kind_of? ParserRuleContext and patternTree.kind_of?  ParserRuleContext then
+            mismatchedNode = nil
+            # (expr ...) and <expr>
+            ruleTagToken = self.getRuleTagToken(patternTree)
+            if not ruleTagToken.nil? then
+                m = nil
+                if tree.ruleContext.ruleIndex == patternTree.ruleContext.ruleIndex then
+                    # track label->list-of-nodes for both rule name and label (if any)
+                    self.map(labels, ruleTagToken.ruleName, tree)
+                    if not ruleTagToken.label.nil? then
+                        self.map(labels, ruleTagToken.label, tree)
+                    end
+                else
+                    mismatchedNode = tree if mismatchedNode.nil?
+                end
+                return mismatchedNode
+            end
+
+            # (expr ...) and (expr ...)
+            if tree.getChildCount()!=patternTree.getChildCount() then
+                mismatchedNode = tree if mismatchedNode.nil?
+                return mismatchedNode
+            end
+
+            n = tree.getChildCount()
+            for i in 0..n-1 do
+                childMatch = self.matchImpl(tree.getChild(i), patternTree.getChild(i), labels)
+                return childMatch if not childMatch.nil? 
+            end
+            return mismatchedNode
+        end
+        # if nodes aren't both tokens or both rule nodes, can't match
+        return tree
+    end
+    def map(labels, label, tree)
+        v = labels.get(label, nil)
+        if v.nil? 
+            v = Array.new
+        end
+        v.push(tree)
+        labels[label] = v
+    end
+    # Is {@code t} {@code (expr <expr>)} subtree?#
+    def getRuleTagToken(tree)
+        if tree.kind_of? RuleNode then
+            if tree.getChildCount()==1 and tree.getChild(0).kind_of?  TerminalNode then
+                c = tree.getChild(0)
+                return c.symbol if c.symbol.kind_of?  RuleTagToken
+            end
+        end
+        return nil
+    end
+    def tokenize(pattern)
+        # split pattern into chunks: sea (raw input) and islands (<ID>, <expr>)
+        chunks = self.split(pattern)
+
+        # create token stream from text and tags
+        tokens = Array.new
+        for chunk in chunks do
+            if chunk.kind_of? TagChunk then
+                # add special rule token or conjure up new token from name
+                if chunk.tag[0].isupper() then
+                    ttype = self.parser.getTokenType(chunk.tag)
+                    if ttype==Token::INVALID_TYPE then
+                        raise Exception.new("Unknown token #{chunk.tag} in pattern: #{pattern}")
+                    end
+                    tokens.push(TokenTagToken(chunk.tag, ttype, chunk.label))
+                elsif chunk.tag[0].islower() then
+                    ruleIndex = self.parser.getRuleIndex(chunk.tag)
+                    if ruleIndex==-1 then
+                        raise Exception.new("Unknown rule #{chunk.tag} in pattern: #{pattern}")
+                    end
+                    ruleImaginaryTokenType = self.parser.getATNWithBypassAlts().ruleToTokenType[ruleIndex]
+                    tokens.push(RuleTagToken(chunk.tag, ruleImaginaryTokenType, chunk.label))
+                else
+                    raise Exception.new("Invalid tag #{chunk.tag} in pattern: #{pattern}")
+                end
+            else
+                self.lexer.setInputStream(InputStream.new(chunk.text))
+                t = self.lexer.nextToken()
+                while t.type!=Token::EOF do 
+                    tokens.push(t)
+                    t = self.lexer.nextToken()
+                end
+            end
+        end
+        return tokens
+    end 
+    # Split {@code <ID> = <e:expr> ;} into 4 chunks for tokenizing by {@link #tokenize}.#
+    def split(pattern)
+        p = 0
+        n = pattern.length
+        chunks = list()
+        # find all start and stop indexes first, then collect
+        starts = Array.new
+        stops = Array.new
+        while p < n do
+            if p == pattern.find(self.escape + self.start, p) then
+                p = p + self.escape.length + self.start.length
+            elsif p == pattern.find(self.escape + self.stop, p) then
+                p = p + self.escape.length + self.stop.length
+            elsif p == pattern.find(self.start, p) then
+                starts.push(p)
+                p = p + self.start.length
+            elsif p == pattern.find(self.stop, p) then
+                stops.push(p)
+                p = p + self.stop.length
+            else
+                p = p + 1
+            end
+        end
+        nt = starts.length
+
+        if nt > stops.length
+            raise Exception.new("unterminated tag in pattern: #{pattern}")
+        end
+        if nt < stops.length
+            raise Exception.new("missing start tag in pattern: #{pattern}")
+        end
+
+        for i in 0..(nt-1) do
+            if starts[i] >= stops[i] then
+                raise Exception.new("tag delimiters out of order in pattern: " + pattern)
+            end
+        end
+
+        # collect into chunks now
+        chunks.push(TextChunk.new(pattern)) if nt==0
+
+        if nt>0 and starts[0]>0 then # copy text up to first tag into chunks
+            text = pattern[0..starts[0]-1]
+            chunks.add(TextChunk.new(text))
+        end
+
+        for i in 0..(nt-1) do
+            # copy inside of <tag>
+            tag = pattern[(starts[i] + self.start.length)..stops[i]-1]
+            ruleOrToken = tag
+            label = nil
+            colon = tag.find(':')
+            if colon >= 0 then
+                label = tag[0..colon-1]
+                ruleOrToken = tag[colon+1..tag.length-1]
+            end
+            chunks.push(TagChunk.new(label, ruleOrToken))
+            if i+1 < (starts.length) then
+                # copy from end of <tag> to start of next
+                text = pattern[(stops[i] + self.stop.length())..starts[i+1]-1]
+                chunks.push(TextChunk.new(text))
+            end
+        end
+
+        if nt > 0 then
+            afterLastTag = stops[nt - 1] + self.stop.length
+            if afterLastTag < n then # copy text from end of last tag to end
+                text = pattern[afterLastTag .. n -1]
+                chunks.push(TextChunk.new(text))
+            end
+        end
+
+        # strip out the escape sequences from text chunks but not tags
+        return chunks.map do |c| 
+            if c.kind_of? TextChunk then
+                unescaped = c.text.replace(self.escape, "")
+                if unescaped.length < c.text.length then
+                   TextChunk.new(unescaped)
+                else
+                   c
+                end
+            else 
+                c
+            end
+        end
+    end
+end