omlish 0.0.0.dev57__py3-none-any.whl → 0.0.0.dev58__py3-none-any.whl

omlish/antlr/_runtime/error/Errors.py

@@ -0,0 +1,176 @@
+# type: ignore
+# ruff: noqa
+# flake8: noqa
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+# need forward declaration
+Token = None
+Lexer = None
+Parser = None
+TokenStream = None
+ATNConfigSet = None
+ParserRulecontext = None
+PredicateTransition = None
+BufferedTokenStream = None
+
+class UnsupportedOperationException(Exception):
+
+    def __init__(self, msg:str):
+        super().__init__(msg)
+
+class IllegalStateException(Exception):
+
+    def __init__(self, msg:str):
+        super().__init__(msg)
+
+class CancellationException(IllegalStateException):
+
+    def __init__(self, msg:str):
+        super().__init__(msg)
+
+# The root of the ANTLR exception hierarchy. In general, ANTLR tracks just
+#  3 kinds of errors: prediction errors, failed predicate errors, and
+#  mismatched input errors. In each case, the parser knows where it is
+#  in the input, where it is in the ATN, the rule invocation stack,
+#  and what kind of problem occurred.
+
+from ..InputStream import InputStream
+from ..ParserRuleContext import ParserRuleContext
+from ..Recognizer import Recognizer
+
+class RecognitionException(Exception):
+
+
+    def __init__(self, message:str=None, recognizer:Recognizer=None, input:InputStream=None, ctx:ParserRulecontext=None):
+        super().__init__(message)
+        self.message = message
+        self.recognizer = recognizer
+        self.input = input
+        self.ctx = ctx
+        # The current {@link Token} when an error occurred. Since not all streams
+        # support accessing symbols by index, we have to track the {@link Token}
+        # instance itself.
+        self.offendingToken = None
+        # Get the ATN state number the parser was in at the time the error
+        # occurred. For {@link NoViableAltException} and
+        # {@link LexerNoViableAltException} exceptions, this is the
+        # {@link DecisionState} number. For others, it is the state whose outgoing
+        # edge we couldn't match.
+        self.offendingState = -1
+        if recognizer is not None:
+            self.offendingState = recognizer.state
+
+    # <p>If the state number is not known, this method returns -1.</p>
+
+    #
+    # Gets the set of input symbols which could potentially follow the
+    # previously matched symbol at the time this exception was thrown.
+    #
+    # <p>If the set of expected tokens is not known and could not be computed,
+    # this method returns {@code null}.</p>
+    #
+    # @return The set of token types that could potentially follow the current
+    # state in the ATN, or {@code null} if the information is not available.
+    #/
+    def getExpectedTokens(self):
+        if self.recognizer is not None:
+            return self.recognizer.atn.getExpectedTokens(self.offendingState, self.ctx)
+        else:
+            return None
+
+
+class LexerNoViableAltException(RecognitionException):
+
+    def __init__(self, lexer:Lexer, input:InputStream, startIndex:int, deadEndConfigs:ATNConfigSet):
+        super().__init__(message=None, recognizer=lexer, input=input, ctx=None)
+        self.startIndex = startIndex
+        self.deadEndConfigs = deadEndConfigs
+        self.message = ""
+
+    def __str__(self):
+        symbol = ""
+        if self.startIndex >= 0 and self.startIndex < self.input.size:
+            symbol = self.input.getText(self.startIndex, self.startIndex)
+            # TODO symbol = Utils.escapeWhitespace(symbol, false);
+        return "LexerNoViableAltException('" + symbol + "')"
+
+# Indicates that the parser could not decide which of two or more paths
+#  to take based upon the remaining input. It tracks the starting token
+#  of the offending input and also knows where the parser was
+#  in the various paths when the error. Reported by reportNoViableAlternative()
+#
+class NoViableAltException(RecognitionException):
+
+    def __init__(self, recognizer:Parser, input:TokenStream=None, startToken:Token=None,
+                    offendingToken:Token=None, deadEndConfigs:ATNConfigSet=None, ctx:ParserRuleContext=None):
+        if ctx is None:
+            ctx = recognizer._ctx
+        if offendingToken is None:
+            offendingToken = recognizer.getCurrentToken()
+        if startToken is None:
+            startToken = recognizer.getCurrentToken()
+        if input is None:
+            input = recognizer.getInputStream()
+        super().__init__(recognizer=recognizer, input=input, ctx=ctx)
+        # Which configurations did we try at input.index() that couldn't match input.LT(1)?#
+        self.deadEndConfigs = deadEndConfigs
+        # The token object at the start index; the input stream might
+        # 	not be buffering tokens so get a reference to it. (At the
+        #  time the error occurred, of course the stream needs to keep a
+        #  buffer all of the tokens but later we might not have access to those.)
+        self.startToken = startToken
+        self.offendingToken = offendingToken
+
+# This signifies any kind of mismatched input exceptions such as
+#  when the current input does not match the expected token.
+#
+class InputMismatchException(RecognitionException):
+
+    def __init__(self, recognizer:Parser):
+        super().__init__(recognizer=recognizer, input=recognizer.getInputStream(), ctx=recognizer._ctx)
+        self.offendingToken = recognizer.getCurrentToken()
+
+
+# A semantic predicate failed during validation.  Validation of predicates
+#  occurs when normally parsing the alternative just like matching a token.
+#  Disambiguating predicate evaluation occurs when we test a predicate during
+#  prediction.
+
+class FailedPredicateException(RecognitionException):
+
+    def __init__(self, recognizer:Parser, predicate:str=None, message:str=None):
+        super().__init__(message=self.formatMessage(predicate,message), recognizer=recognizer,
+                         input=recognizer.getInputStream(), ctx=recognizer._ctx)
+        s = recognizer._interp.atn.states[recognizer.state]
+        trans = s.transitions[0]
+        from ..atn.Transition import PredicateTransition
+        if isinstance(trans, PredicateTransition):
+            self.ruleIndex = trans.ruleIndex
+            self.predicateIndex = trans.predIndex
+        else:
+            self.ruleIndex = 0
+            self.predicateIndex = 0
+        self.predicate = predicate
+        self.offendingToken = recognizer.getCurrentToken()
+
+    def formatMessage(self, predicate:str, message:str):
+        if message is not None:
+            return message
+        else:
+            return "failed predicate: {" + predicate + "}?"
+
+class ParseCancellationException(CancellationException):
+
+    pass
+
+del Token
+del Lexer
+del Parser
+del TokenStream
+del ATNConfigSet
+del ParserRulecontext
+del PredicateTransition
+del BufferedTokenStream

omlish/antlr/_runtime/error/__init__.py

@@ -0,0 +1,4 @@
+# type: ignore
+# ruff: noqa
+# flake8: noqa
+__author__ = 'ericvergnaud'

omlish/antlr/_runtime/tree/Chunk.py

@@ -0,0 +1,33 @@
+# type: ignore
+# ruff: noqa
+# flake8: noqa
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+class Chunk(object):
+    pass
+
+class TagChunk(Chunk):
+    __slots__ = ('tag', 'label')
+
+    def __init__(self, tag:str, label:str=None):
+        self.tag = tag
+        self.label = label
+
+    def __str__(self):
+        if self.label is None:
+            return self.tag
+        else:
+            return self.label + ":" + self.tag
+
+class TextChunk(Chunk):
+    __slots__ = 'text'
+
+    def __init__(self, text:str):
+        self.text = text
+
+    def __str__(self):
+        return "'" + self.text + "'"

omlish/antlr/_runtime/tree/ParseTreeMatch.py

@@ -0,0 +1,121 @@
+# type: ignore
+# ruff: noqa
+# flake8: noqa
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+
+#
+# Represents the result of matching a {@link ParseTree} against a tree pattern.
+#
+from io import StringIO
+from .ParseTreePattern import ParseTreePattern
+from .Tree import ParseTree
+
+
+class ParseTreeMatch(object):
+    __slots__ = ('tree', 'pattern', 'labels', 'mismatchedNode')
+    #
+    # 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}
+    #
+    def __init__(self, tree:ParseTree, pattern:ParseTreePattern, labels:dict, mismatchedNode:ParseTree):
+        if tree is None:
+            raise Exception("tree cannot be null")
+        if pattern is None:
+            raise Exception("pattern cannot be null")
+        if labels is None:
+            raise Exception("labels cannot be null")
+        self.tree = tree
+        self.pattern = pattern
+        self.labels = labels
+        self.mismatchedNode = mismatchedNode
+
+    #
+    # 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(self, label:str):
+        parseTrees = self.labels.get(label, None)
+        if parseTrees is None or len(parseTrees)==0:
+            return None
+        else:
+            return parseTrees[len(parseTrees)-1]
+
+    #
+    # 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(self, label:str):
+        nodes = self.labels.get(label, None)
+        if nodes is None:
+            return list()
+        else:
+            return nodes
+
+
+    #
+    # Gets a value indicating whether the match operation succeeded.
+    #
+    # @return {@code true} if the match operation succeeded; otherwise,
+    # {@code false}.
+    #
+    def succeeded(self):
+        return self.mismatchedNode is None
+
+    #
+    # {@inheritDoc}
+    #
+    def __str__(self):
+        with StringIO() as buf:
+            buf.write("Match ")
+            buf.write("succeeded" if self.succeeded() else "failed")
+            buf.write("; found ")
+            buf.write(str(len(self.labels)))
+            buf.write(" labels")
+            return buf.getvalue()

omlish/antlr/_runtime/tree/ParseTreePattern.py

@@ -0,0 +1,75 @@
+# type: ignore
+# ruff: noqa
+# flake8: noqa
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+#
+# A pattern like {@code <ID> = <expr>;} converted to a {@link ParseTree} by
+# {@link ParseTreePatternMatcher#compile(String, int)}.
+#
+from .ParseTreePatternMatcher import ParseTreePatternMatcher
+from .Tree import ParseTree
+from ..xpath.XPathLexer import XPathLexer
+
+
+class ParseTreePattern(object):
+    __slots__ = ('matcher', 'patternRuleIndex', 'pattern', 'patternTree')
+
+    # 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.
+    #
+    def __init__(self, matcher:ParseTreePatternMatcher, pattern:str, patternRuleIndex:int , patternTree:ParseTree):
+        self.matcher = matcher
+        self.patternRuleIndex = patternRuleIndex
+        self.pattern = pattern
+        self.patternTree = patternTree
+
+    #
+    # 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(self, tree:ParseTree):
+        return self.matcher.match(tree, self)
+
+    #
+    # 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(self, tree:ParseTree):
+        return self.matcher.match(tree, self).succeeded()
+
+    # 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(self, tree:ParseTree, xpath:str):
+        subtrees = XPath.findAll(tree, xpath, self.matcher.parser)
+        matches = list()
+        for t in subtrees:
+            match = self.match(t)
+            if match.succeeded():
+                matches.append(match)
+        return matches