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

omlish/antlr/_runtime/dfa/DFA.py

@@ -0,0 +1,136 @@
+# 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.
+from ..atn.ATNState import StarLoopEntryState
+
+from ..atn.ATNConfigSet import ATNConfigSet
+from ..atn.ATNState import DecisionState
+from .DFAState import DFAState
+from ..error.Errors import IllegalStateException
+
+
+class DFA(object):
+    __slots__ = ('atnStartState', 'decision', '_states', 's0', 'precedenceDfa')
+
+    def __init__(self, atnStartState:DecisionState, decision:int=0):
+        # From which ATN state did we create this DFA?
+        self.atnStartState = atnStartState
+        self.decision = decision
+        # A set of all DFA states. Use {@link Map} so we can get old state back
+        #  ({@link Set} only allows you to see if it's there).
+        self._states = dict()
+        self.s0 = None
+        # {@code true} if this DFA is for a precedence decision; otherwise,
+        # {@code false}. This is the backing field for {@link #isPrecedenceDfa},
+        # {@link #setPrecedenceDfa}.
+        self.precedenceDfa = False
+
+        if isinstance(atnStartState, StarLoopEntryState):
+            if atnStartState.isPrecedenceDecision:
+                self.precedenceDfa = True
+                precedenceState = DFAState(configs=ATNConfigSet())
+                precedenceState.edges = []
+                precedenceState.isAcceptState = False
+                precedenceState.requiresFullContext = False
+                self.s0 = precedenceState
+
+
+    # Get the start state for a specific precedence value.
+    #
+    # @param precedence The current precedence.
+    # @return The start state corresponding to the specified precedence, or
+    # {@code null} if no start state exists for the specified precedence.
+    #
+    # @throws IllegalStateException if this is not a precedence DFA.
+    # @see #isPrecedenceDfa()
+
+    def getPrecedenceStartState(self, precedence:int):
+        if not self.precedenceDfa:
+            raise IllegalStateException("Only precedence DFAs may contain a precedence start state.")
+
+        # s0.edges is never null for a precedence DFA
+        if precedence < 0 or precedence >= len(self.s0.edges):
+            return None
+        return self.s0.edges[precedence]
+
+    # Set the start state for a specific precedence value.
+    #
+    # @param precedence The current precedence.
+    # @param startState The start state corresponding to the specified
+    # precedence.
+    #
+    # @throws IllegalStateException if this is not a precedence DFA.
+    # @see #isPrecedenceDfa()
+    #
+    def setPrecedenceStartState(self, precedence:int, startState:DFAState):
+        if not self.precedenceDfa:
+            raise IllegalStateException("Only precedence DFAs may contain a precedence start state.")
+
+        if precedence < 0:
+            return
+
+        # synchronization on s0 here is ok. when the DFA is turned into a
+        # precedence DFA, s0 will be initialized once and not updated again
+        # s0.edges is never null for a precedence DFA
+        if precedence >= len(self.s0.edges):
+            ext = [None] * (precedence + 1 - len(self.s0.edges))
+            self.s0.edges.extend(ext)
+        self.s0.edges[precedence] = startState
+    #
+    # Sets whether this is a precedence DFA. If the specified value differs
+    # from the current DFA configuration, the following actions are taken;
+    # otherwise no changes are made to the current DFA.
+    #
+    # <ul>
+    # <li>The {@link #states} map is cleared</li>
+    # <li>If {@code precedenceDfa} is {@code false}, the initial state
+    # {@link #s0} is set to {@code null}; otherwise, it is initialized to a new
+    # {@link DFAState} with an empty outgoing {@link DFAState#edges} array to
+    # store the start states for individual precedence values.</li>
+    # <li>The {@link #precedenceDfa} field is updated</li>
+    # </ul>
+    #
+    # @param precedenceDfa {@code true} if this is a precedence DFA; otherwise,
+    # {@code false}
+
+    def setPrecedenceDfa(self, precedenceDfa:bool):
+        if self.precedenceDfa != precedenceDfa:
+            self._states = dict()
+            if precedenceDfa:
+                precedenceState = DFAState(configs=ATNConfigSet())
+                precedenceState.edges = []
+                precedenceState.isAcceptState = False
+                precedenceState.requiresFullContext = False
+                self.s0 = precedenceState
+            else:
+                self.s0 = None
+            self.precedenceDfa = precedenceDfa
+
+    @property
+    def states(self):
+        return self._states
+
+    # Return a list of all states in this DFA, ordered by state number.
+    def sortedStates(self):
+        return sorted(self._states.keys(), key=lambda state: state.stateNumber)
+
+    def __str__(self):
+        return self.toString(None)
+
+    def toString(self, literalNames:list=None, symbolicNames:list=None):
+        if self.s0 is None:
+            return ""
+        from .DFASerializer import DFASerializer
+        serializer = DFASerializer(self,literalNames,symbolicNames)
+        return str(serializer)
+
+    def toLexerString(self):
+        if self.s0 is None:
+            return ""
+        from .DFASerializer import LexerDFASerializer
+        serializer = LexerDFASerializer(self)
+        return str(serializer)

omlish/antlr/_runtime/dfa/DFASerializer.py

@@ -0,0 +1,76 @@
+# 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 DFA walker that knows how to dump them to serialized strings.#/
+from io import StringIO
+from .. import DFA
+from ..Utils import str_list
+from .DFAState import DFAState
+
+
+class DFASerializer(object):
+    __slots__ = ('dfa', 'literalNames', 'symbolicNames')
+
+    def __init__(self, dfa:DFA, literalNames:list=None, symbolicNames:list=None):
+        self.dfa = dfa
+        self.literalNames = literalNames
+        self.symbolicNames = symbolicNames
+
+    def __str__(self):
+        if self.dfa.s0 is None:
+            return None
+        with StringIO() as buf:
+            for s in self.dfa.sortedStates():
+                n = 0
+                if s.edges is not None:
+                    n = len(s.edges)
+                for i in range(0, n):
+                    t = s.edges[i]
+                    if t is not None and t.stateNumber != 0x7FFFFFFF:
+                        buf.write(self.getStateString(s))
+                        label = self.getEdgeLabel(i)
+                        buf.write("-")
+                        buf.write(label)
+                        buf.write("->")
+                        buf.write(self.getStateString(t))
+                        buf.write('\n')
+            output = buf.getvalue()
+            if len(output)==0:
+                return None
+            else:
+                return output
+
+    def getEdgeLabel(self, i:int):
+        if i==0:
+            return "EOF"
+        if self.literalNames is not None and i<=len(self.literalNames):
+            return self.literalNames[i-1]
+        elif self.symbolicNames is not None and i<=len(self.symbolicNames):
+            return self.symbolicNames[i-1]
+        else:
+            return str(i-1)
+
+    def getStateString(self, s:DFAState):
+        n = s.stateNumber
+        baseStateStr = ( ":" if s.isAcceptState else "") + "s" + str(n) + ( "^" if s.requiresFullContext else "")
+        if s.isAcceptState:
+            if s.predicates is not None:
+                return baseStateStr + "=>" + str_list(s.predicates)
+            else:
+                return baseStateStr + "=>" + str(s.prediction)
+        else:
+            return baseStateStr
+
+class LexerDFASerializer(DFASerializer):
+
+    def __init__(self, dfa:DFA):
+        super().__init__(dfa, None)
+
+    def getEdgeLabel(self, i:int):
+        return "'" + chr(i) + "'"

omlish/antlr/_runtime/dfa/DFAState.py

@@ -0,0 +1,129 @@
+# 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.
+#/
+
+# Map a predicate to a predicted alternative.#/
+from io import StringIO
+from ..atn.ATNConfigSet import ATNConfigSet
+from ..atn.SemanticContext import SemanticContext
+
+
+class PredPrediction(object):
+    __slots__ = ('alt', 'pred')
+
+    def __init__(self, pred:SemanticContext, alt:int):
+        self.alt = alt
+        self.pred = pred
+
+    def __str__(self):
+        return "(" + str(self.pred) + ", " + str(self.alt) +  ")"
+
+# A DFA state represents a set of possible ATN configurations.
+#  As Aho, Sethi, Ullman p. 117 says "The DFA uses its state
+#  to keep track of all possible states the ATN can be in after
+#  reading each input symbol.  That is to say, after reading
+#  input a1a2..an, the DFA is in a state that represents the
+#  subset T of the states of the ATN that are reachable from the
+#  ATN's start state along some path labeled a1a2..an."
+#  In conventional NFA→DFA conversion, therefore, the subset T
+#  would be a bitset representing the set of states the
+#  ATN could be in.  We need to track the alt predicted by each
+#  state as well, however.  More importantly, we need to maintain
+#  a stack of states, tracking the closure operations as they
+#  jump from rule to rule, emulating rule invocations (method calls).
+#  I have to add a stack to simulate the proper lookahead sequences for
+#  the underlying LL grammar from which the ATN was derived.
+#
+#  <p>I use a set of ATNConfig objects not simple states.  An ATNConfig
+#  is both a state (ala normal conversion) and a RuleContext describing
+#  the chain of rules (if any) followed to arrive at that state.</p>
+#
+#  <p>A DFA state may have multiple references to a particular state,
+#  but with different ATN contexts (with same or different alts)
+#  meaning that state was reached via a different set of rule invocations.</p>
+#/
+class DFAState(object):
+    __slots__ = (
+        'stateNumber', 'configs', 'edges', 'isAcceptState', 'prediction',
+        'lexerActionExecutor', 'requiresFullContext', 'predicates'
+    )
+
+    def __init__(self, stateNumber:int=-1, configs:ATNConfigSet=ATNConfigSet()):
+        self.stateNumber = stateNumber
+        self.configs = configs
+        # {@code edges[symbol]} points to target of symbol. Shift up by 1 so (-1)
+        #  {@link Token#EOF} maps to {@code edges[0]}.
+        self.edges = None
+        self.isAcceptState = False
+        # if accept state, what ttype do we match or alt do we predict?
+        #  This is set to {@link ATN#INVALID_ALT_NUMBER} when {@link #predicates}{@code !=null} or
+        #  {@link #requiresFullContext}.
+        self.prediction = 0
+        self.lexerActionExecutor = None
+        # Indicates that this state was created during SLL prediction that
+        # discovered a conflict between the configurations in the state. Future
+        # {@link ParserATNSimulator#execATN} invocations immediately jumped doing
+        # full context prediction if this field is true.
+        self.requiresFullContext = False
+        # During SLL parsing, this is a list of predicates associated with the
+        #  ATN configurations of the DFA state. When we have predicates,
+        #  {@link #requiresFullContext} is {@code false} since full context prediction evaluates predicates
+        #  on-the-fly. If this is not null, then {@link #prediction} is
+        #  {@link ATN#INVALID_ALT_NUMBER}.
+        #
+        #  <p>We only use these for non-{@link #requiresFullContext} but conflicting states. That
+        #  means we know from the context (it's $ or we don't dip into outer
+        #  context) that it's an ambiguity not a conflict.</p>
+        #
+        #  <p>This list is computed by {@link ParserATNSimulator#predicateDFAState}.</p>
+        self.predicates = None
+
+
+
+    # Get the set of all alts mentioned by all ATN configurations in this
+    #  DFA state.
+    def getAltSet(self):
+        if self.configs is not None:
+            return set(cfg.alt for cfg in self.configs) or None
+        return None
+
+    def __hash__(self):
+        return hash(self.configs)
+
+    # Two {@link DFAState} instances are equal if their ATN configuration sets
+    # are the same. This method is used to see if a state already exists.
+    #
+    # <p>Because the number of alternatives and number of ATN configurations are
+    # finite, there is a finite number of DFA states that can be processed.
+    # This is necessary to show that the algorithm terminates.</p>
+    #
+    # <p>Cannot test the DFA state numbers here because in
+    # {@link ParserATNSimulator#addDFAState} we need to know if any other state
+    # exists that has this exact set of ATN configurations. The
+    # {@link #stateNumber} is irrelevant.</p>
+    def __eq__(self, other):
+        # compare set of ATN configurations in this set with other
+        if self is other:
+            return True
+        elif not isinstance(other, DFAState):
+            return False
+        else:
+            return self.configs==other.configs
+
+    def __str__(self):
+        with StringIO() as buf:
+            buf.write(str(self.stateNumber))
+            buf.write(":")
+            buf.write(str(self.configs))
+            if self.isAcceptState:
+                buf.write("=>")
+                if self.predicates is not None:
+                    buf.write(str(self.predicates))
+                else:
+                    buf.write(str(self.prediction))
+            return buf.getvalue()

omlish/antlr/_runtime/dfa/__init__.py

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

omlish/antlr/_runtime/error/DiagnosticErrorListener.py

@@ -0,0 +1,110 @@
+# 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.
+#
+
+
+#
+# This implementation of {@link ANTLRErrorListener} can be used to identify
+# certain potential correctness and performance problems in grammars. "Reports"
+# are made by calling {@link Parser#notifyErrorListeners} with the appropriate
+# message.
+#
+# <ul>
+# <li><b>Ambiguities</b>: These are cases where more than one path through the
+# grammar can match the input.</li>
+# <li><b>Weak context sensitivity</b>: These are cases where full-context
+# prediction resolved an SLL conflict to a unique alternative which equaled the
+# minimum alternative of the SLL conflict.</li>
+# <li><b>Strong (forced) context sensitivity</b>: These are cases where the
+# full-context prediction resolved an SLL conflict to a unique alternative,
+# <em>and</em> the minimum alternative of the SLL conflict was found to not be
+# a truly viable alternative. Two-stage parsing cannot be used for inputs where
+# this situation occurs.</li>
+# </ul>
+
+from io import StringIO
+from .. import Parser, DFA
+from ..atn.ATNConfigSet import ATNConfigSet
+from .ErrorListener import ErrorListener
+
+class DiagnosticErrorListener(ErrorListener):
+
+    def __init__(self, exactOnly:bool=True):
+        # whether all ambiguities or only exact ambiguities are reported.
+        self.exactOnly = exactOnly
+
+    def reportAmbiguity(self, recognizer:Parser, dfa:DFA, startIndex:int,
+                       stopIndex:int, exact:bool, ambigAlts:set, configs:ATNConfigSet):
+        if self.exactOnly and not exact:
+            return
+
+        with StringIO() as buf:
+            buf.write("reportAmbiguity d=")
+            buf.write(self.getDecisionDescription(recognizer, dfa))
+            buf.write(": ambigAlts=")
+            buf.write(str(self.getConflictingAlts(ambigAlts, configs)))
+            buf.write(", input='")
+            buf.write(recognizer.getTokenStream().getText(startIndex, stopIndex))
+            buf.write("'")
+            recognizer.notifyErrorListeners(buf.getvalue())
+
+
+    def reportAttemptingFullContext(self, recognizer:Parser, dfa:DFA, startIndex:int,
+                       stopIndex:int, conflictingAlts:set, configs:ATNConfigSet):
+        with StringIO() as buf:
+            buf.write("reportAttemptingFullContext d=")
+            buf.write(self.getDecisionDescription(recognizer, dfa))
+            buf.write(", input='")
+            buf.write(recognizer.getTokenStream().getText(startIndex, stopIndex))
+            buf.write("'")
+            recognizer.notifyErrorListeners(buf.getvalue())
+
+    def reportContextSensitivity(self, recognizer:Parser, dfa:DFA, startIndex:int,
+                       stopIndex:int, prediction:int, configs:ATNConfigSet):
+        with StringIO() as buf:
+            buf.write("reportContextSensitivity d=")
+            buf.write(self.getDecisionDescription(recognizer, dfa))
+            buf.write(", input='")
+            buf.write(recognizer.getTokenStream().getText(startIndex, stopIndex))
+            buf.write("'")
+            recognizer.notifyErrorListeners(buf.getvalue())
+
+    def getDecisionDescription(self, recognizer:Parser, dfa:DFA):
+        decision = dfa.decision
+        ruleIndex = dfa.atnStartState.ruleIndex
+
+        ruleNames = recognizer.ruleNames
+        if ruleIndex < 0 or ruleIndex >= len(ruleNames):
+            return str(decision)
+
+        ruleName = ruleNames[ruleIndex]
+        if ruleName is None or len(ruleName)==0:
+            return str(decision)
+
+        return str(decision) + " (" + ruleName + ")"
+
+    #
+    # Computes the set of conflicting or ambiguous alternatives from a
+    # configuration set, if that information was not already provided by the
+    # parser.
+    #
+    # @param reportedAlts The set of conflicting or ambiguous alternatives, as
+    # reported by the parser.
+    # @param configs The conflicting or ambiguous configuration set.
+    # @return Returns {@code reportedAlts} if it is not {@code null}, otherwise
+    # returns the set of alternatives represented in {@code configs}.
+    #
+    def getConflictingAlts(self, reportedAlts:set, configs:ATNConfigSet):
+        if reportedAlts is not None:
+            return reportedAlts
+
+        result = set()
+        for config in configs:
+            result.add(config.alt)
+
+        return result

omlish/antlr/_runtime/error/ErrorListener.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.
+
+# Provides an empty default implementation of {@link ANTLRErrorListener}. The
+# default implementation of each method does nothing, but can be overridden as
+# necessary.
+
+
+import sys
+
+class ErrorListener(object):
+
+    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
+        pass
+
+    def reportAmbiguity(self, recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs):
+        pass
+
+    def reportAttemptingFullContext(self, recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs):
+        pass
+
+    def reportContextSensitivity(self, recognizer, dfa, startIndex, stopIndex, prediction, configs):
+        pass
+
+class ConsoleErrorListener(ErrorListener):
+    #
+    # Provides a default instance of {@link ConsoleErrorListener}.
+    #
+    INSTANCE = None
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>
+    # This implementation prints messages to {@link System#err} containing the
+    # values of {@code line}, {@code charPositionInLine}, and {@code msg} using
+    # the following format.</p>
+    #
+    # <pre>
+    # line <em>line</em>:<em>charPositionInLine</em> <em>msg</em>
+    # </pre>
+    #
+    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
+        print("line " + str(line) + ":" + str(column) + " " + msg, file=sys.stderr)
+
+ConsoleErrorListener.INSTANCE = ConsoleErrorListener()
+
+class ProxyErrorListener(ErrorListener):
+
+    def __init__(self, delegates):
+        super().__init__()
+        if delegates is None:
+            raise ReferenceError("delegates")
+        self.delegates = delegates
+
+    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
+        for delegate in self.delegates:
+            delegate.syntaxError(recognizer, offendingSymbol, line, column, msg, e)
+
+    def reportAmbiguity(self, recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs):
+        for delegate in self.delegates:
+            delegate.reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs)
+
+    def reportAttemptingFullContext(self, recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs):
+        for delegate in self.delegates:
+            delegate.reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs)
+
+    def reportContextSensitivity(self, recognizer, dfa, startIndex, stopIndex, prediction, configs):
+        for delegate in self.delegates:
+            delegate.reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs)