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

omlish/antlr/_runtime/atn/SemanticContext.py

@@ -0,0 +1,333 @@
+# 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 tree structure used to record the semantic context in which
+#  an ATN configuration is valid.  It's either a single predicate,
+#  a conjunction {@code p1&&p2}, or a sum of products {@code p1||p2}.
+#
+#  <p>I have scoped the {@link AND}, {@link OR}, and {@link Predicate} subclasses of
+#  {@link SemanticContext} within the scope of this outer class.</p>
+#
+from ..Recognizer import Recognizer
+from ..RuleContext import RuleContext
+from io import StringIO
+
+
+class SemanticContext(object):
+    #
+    # The default {@link SemanticContext}, which is semantically equivalent to
+    # a predicate of the form {@code {true}?}.
+    #
+    NONE = None
+
+    #
+    # For context independent predicates, we evaluate them without a local
+    # context (i.e., null context). That way, we can evaluate them without
+    # having to create proper rule-specific context during prediction (as
+    # opposed to the parser, which creates them naturally). In a practical
+    # sense, this avoids a cast exception from RuleContext to myruleContext.
+    #
+    # <p>For context dependent predicates, we must pass in a local context so that
+    # references such as $arg evaluate properly as _localctx.arg. We only
+    # capture context dependent predicates in the context in which we begin
+    # prediction, so we passed in the outer context here in case of context
+    # dependent predicate evaluation.</p>
+    #
+    def eval(self, parser:Recognizer , outerContext:RuleContext ):
+        pass
+
+    #
+    # Evaluate the precedence predicates for the context and reduce the result.
+    #
+    # @param parser The parser instance.
+    # @param outerContext The current parser context object.
+    # @return The simplified semantic context after precedence predicates are
+    # evaluated, which will be one of the following values.
+    # <ul>
+    # <li>{@link #NONE}: if the predicate simplifies to {@code true} after
+    # precedence predicates are evaluated.</li>
+    # <li>{@code null}: if the predicate simplifies to {@code false} after
+    # precedence predicates are evaluated.</li>
+    # <li>{@code this}: if the semantic context is not changed as a result of
+    # precedence predicate evaluation.</li>
+    # <li>A non-{@code null} {@link SemanticContext}: the new simplified
+    # semantic context after precedence predicates are evaluated.</li>
+    # </ul>
+    #
+    def evalPrecedence(self, parser:Recognizer, outerContext:RuleContext):
+        return self
+
+# need forward declaration
+AND = None
+
+def andContext(a:SemanticContext, b:SemanticContext):
+    if a is None or a is SemanticContext.NONE:
+        return b
+    if b is None or b is SemanticContext.NONE:
+        return a
+    result = AND(a, b)
+    if len(result.opnds) == 1:
+        return result.opnds[0]
+    else:
+        return result
+
+# need forward declaration
+OR = None
+
+def orContext(a:SemanticContext, b:SemanticContext):
+    if a is None:
+        return b
+    if b is None:
+        return a
+    if a is SemanticContext.NONE or b is SemanticContext.NONE:
+        return SemanticContext.NONE
+    result = OR(a, b)
+    if len(result.opnds) == 1:
+        return result.opnds[0]
+    else:
+        return result
+
+def filterPrecedencePredicates(collection:set):
+    return [context for context in collection if isinstance(context, PrecedencePredicate)]
+
+
+class EmptySemanticContext(SemanticContext):
+    pass
+
+class Predicate(SemanticContext):
+    __slots__ = ('ruleIndex', 'predIndex', 'isCtxDependent')
+
+    def __init__(self, ruleIndex:int=-1, predIndex:int=-1, isCtxDependent:bool=False):
+        self.ruleIndex = ruleIndex
+        self.predIndex = predIndex
+        self.isCtxDependent = isCtxDependent # e.g., $i ref in pred
+
+    def eval(self, parser:Recognizer , outerContext:RuleContext ):
+        localctx = outerContext if self.isCtxDependent else None
+        return parser.sempred(localctx, self.ruleIndex, self.predIndex)
+
+    def __hash__(self):
+        return hash((self.ruleIndex, self.predIndex, self.isCtxDependent))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, Predicate):
+            return False
+        return self.ruleIndex == other.ruleIndex and \
+               self.predIndex == other.predIndex and \
+               self.isCtxDependent == other.isCtxDependent
+
+    def __str__(self):
+        return "{" + str(self.ruleIndex) + ":" + str(self.predIndex) + "}?"
+
+
+class PrecedencePredicate(SemanticContext):
+
+    def __init__(self, precedence:int=0):
+        self.precedence = precedence
+
+    def eval(self, parser:Recognizer , outerContext:RuleContext ):
+        return parser.precpred(outerContext, self.precedence)
+
+    def evalPrecedence(self, parser:Recognizer, outerContext:RuleContext):
+        if parser.precpred(outerContext, self.precedence):
+            return SemanticContext.NONE
+        else:
+            return None
+
+    def __lt__(self, other):
+        return self.precedence < other.precedence
+
+    def __hash__(self):
+        return 31
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, PrecedencePredicate):
+            return False
+        else:
+            return self.precedence == other.precedence
+
+    def __str__(self):
+        return "{" + str(self.precedence) + ">=prec}?"
+
+
+# A semantic context which is true whenever none of the contained contexts
+# is false.
+del AND
+class AND(SemanticContext):
+    __slots__ = 'opnds'
+
+    def __init__(self, a:SemanticContext, b:SemanticContext):
+        operands = set()
+        if isinstance( a, AND ):
+            operands.update(a.opnds)
+        else:
+            operands.add(a)
+        if isinstance( b, AND ):
+            operands.update(b.opnds)
+        else:
+            operands.add(b)
+
+        precedencePredicates = filterPrecedencePredicates(operands)
+        if len(precedencePredicates)>0:
+            # interested in the transition with the lowest precedence
+            reduced = min(precedencePredicates)
+            operands.add(reduced)
+
+        self.opnds = list(operands)
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, AND):
+            return False
+        else:
+            return self.opnds == other.opnds
+
+    def __hash__(self):
+        h = 0
+        for o in self.opnds:
+            h = hash((h, o))
+        return hash((h, "AND"))
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>
+    # The evaluation of predicates by this context is short-circuiting, but
+    # unordered.</p>
+    #
+    def eval(self, parser:Recognizer, outerContext:RuleContext):
+        return all(opnd.eval(parser, outerContext) for opnd in self.opnds)
+
+    def evalPrecedence(self, parser:Recognizer, outerContext:RuleContext):
+        differs = False
+        operands = []
+        for context in self.opnds:
+            evaluated = context.evalPrecedence(parser, outerContext)
+            differs |= evaluated is not context
+            if evaluated is None:
+                # The AND context is false if any element is false
+                return None
+            elif evaluated is not SemanticContext.NONE:
+                # Reduce the result by skipping true elements
+                operands.append(evaluated)
+
+        if not differs:
+            return self
+
+        if len(operands)==0:
+            # all elements were true, so the AND context is true
+            return SemanticContext.NONE
+
+        result = None
+        for o in operands:
+            result = o if result is None else andContext(result, o)
+
+        return result
+
+    def __str__(self):
+        with StringIO() as buf:
+            first = True
+            for o in self.opnds:
+                if not first:
+                    buf.write("&&")
+                buf.write(str(o))
+                first = False
+            return buf.getvalue()
+
+#
+# A semantic context which is true whenever at least one of the contained
+# contexts is true.
+del OR
+class OR (SemanticContext):
+    __slots__ = 'opnds'
+
+    def __init__(self, a:SemanticContext, b:SemanticContext):
+        operands = set()
+        if isinstance( a, OR ):
+            operands.update(a.opnds)
+        else:
+            operands.add(a)
+        if isinstance( b, OR ):
+            operands.update(b.opnds)
+        else:
+            operands.add(b)
+
+        precedencePredicates = filterPrecedencePredicates(operands)
+        if len(precedencePredicates)>0:
+            # interested in the transition with the highest precedence
+            s = sorted(precedencePredicates)
+            reduced = s[-1]
+            operands.add(reduced)
+
+        self.opnds = list(operands)
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, OR):
+            return False
+        else:
+            return self.opnds == other.opnds
+
+    def __hash__(self):
+        h = 0
+        for o in self.opnds:
+            h = hash((h, o))
+        return hash((h, "OR"))
+
+    # <p>
+    # The evaluation of predicates by this context is short-circuiting, but
+    # unordered.</p>
+    #
+    def eval(self, parser:Recognizer, outerContext:RuleContext):
+        return any(opnd.eval(parser, outerContext) for opnd in self.opnds)
+
+    def evalPrecedence(self, parser:Recognizer, outerContext:RuleContext):
+        differs = False
+        operands = []
+        for context in self.opnds:
+            evaluated = context.evalPrecedence(parser, outerContext)
+            differs |= evaluated is not context
+            if evaluated is SemanticContext.NONE:
+                # The OR context is true if any element is true
+                return SemanticContext.NONE
+            elif evaluated is not None:
+                # Reduce the result by skipping false elements
+                operands.append(evaluated)
+
+        if not differs:
+            return self
+
+        if len(operands)==0:
+            # all elements were false, so the OR context is false
+            return None
+
+        result = None
+        for o in operands:
+            result = o if result is None else orContext(result, o)
+
+        return result
+
+    def __str__(self):
+        with StringIO() as buf:
+            first = True
+            for o in self.opnds:
+                if not first:
+                    buf.write("||")
+                buf.write(str(o))
+                first = False
+            return buf.getvalue()
+
+
+SemanticContext.NONE = EmptySemanticContext()

omlish/antlr/_runtime/atn/Transition.py

@@ -0,0 +1,271 @@
+# 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.
+#
+
+#  An ATN transition between any two ATN states.  Subclasses define
+#  atom, set, epsilon, action, predicate, rule transitions.
+#
+#  <p>This is a one way link.  It emanates from a state (usually via a list of
+#  transitions) and has a target state.</p>
+#
+#  <p>Since we never have to change the ATN transitions once we construct it,
+#  we can fix these transitions as specific classes. The DFA transitions
+#  on the other hand need to update the labels as it adds transitions to
+#  the states. We'll use the term Edge for the DFA to distinguish them from
+#  ATN transitions.</p>
+#
+from ..IntervalSet import IntervalSet
+from ..Token import Token
+
+# need forward declarations
+from .SemanticContext import Predicate, PrecedencePredicate
+
+ATNState = None
+RuleStartState = None
+
+class Transition (object):
+    __slots__ = ('target','isEpsilon','label')
+
+    # constants for serialization
+    EPSILON			= 1
+    RANGE			= 2
+    RULE			= 3
+    PREDICATE		= 4 # e.g., {isType(input.LT(1))}?
+    ATOM			= 5
+    ACTION			= 6
+    SET				= 7 # ~(A|B) or ~atom, wildcard, which convert to next 2
+    NOT_SET			= 8
+    WILDCARD		= 9
+    PRECEDENCE		= 10
+
+    serializationNames = [
+            "INVALID",
+            "EPSILON",
+            "RANGE",
+            "RULE",
+            "PREDICATE",
+            "ATOM",
+            "ACTION",
+            "SET",
+            "NOT_SET",
+            "WILDCARD",
+            "PRECEDENCE"
+        ]
+
+    serializationTypes = dict()
+
+    def __init__(self, target:ATNState):
+        # The target of this transition.
+        if target is None:
+            raise Exception("target cannot be null.")
+        self.target = target
+        # Are we epsilon, action, sempred?
+        self.isEpsilon = False
+        self.label = None
+
+
+# TODO: make all transitions sets? no, should remove set edges
+class AtomTransition(Transition):
+    __slots__ = ('label_', 'serializationType')
+
+    def __init__(self, target:ATNState, label:int):
+        super().__init__(target)
+        self.label_ = label # The token type or character value; or, signifies special label.
+        self.label = self.makeLabel()
+        self.serializationType = self.ATOM
+
+    def makeLabel(self):
+        s = IntervalSet()
+        s.addOne(self.label_)
+        return s
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return self.label_ == symbol
+
+    def __str__(self):
+        return str(self.label_)
+
+class RuleTransition(Transition):
+    __slots__ = ('ruleIndex', 'precedence', 'followState', 'serializationType')
+
+    def __init__(self, ruleStart:RuleStartState, ruleIndex:int, precedence:int, followState:ATNState):
+        super().__init__(ruleStart)
+        self.ruleIndex = ruleIndex # ptr to the rule definition object for this rule ref
+        self.precedence = precedence
+        self.followState = followState # what node to begin computations following ref to rule
+        self.serializationType = self.RULE
+        self.isEpsilon = True
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+
+class EpsilonTransition(Transition):
+    __slots__ = ('serializationType', 'outermostPrecedenceReturn')
+
+    def __init__(self, target, outermostPrecedenceReturn=-1):
+        super(EpsilonTransition, self).__init__(target)
+        self.serializationType = self.EPSILON
+        self.isEpsilon = True
+        self.outermostPrecedenceReturn = outermostPrecedenceReturn
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+    def __str__(self):
+        return "epsilon"
+
+class RangeTransition(Transition):
+    __slots__ = ('serializationType', 'start', 'stop')
+
+    def __init__(self, target:ATNState, start:int, stop:int):
+        super().__init__(target)
+        self.serializationType = self.RANGE
+        self.start = start
+        self.stop = stop
+        self.label = self.makeLabel()
+
+    def makeLabel(self):
+        s = IntervalSet()
+        s.addRange(range(self.start, self.stop + 1))
+        return s
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return symbol >= self.start and symbol <= self.stop
+
+    def __str__(self):
+        return "'" + chr(self.start) + "'..'" + chr(self.stop) + "'"
+
+class AbstractPredicateTransition(Transition):
+
+    def __init__(self, target:ATNState):
+        super().__init__(target)
+
+
+class PredicateTransition(AbstractPredicateTransition):
+    __slots__ = ('serializationType', 'ruleIndex', 'predIndex', 'isCtxDependent')
+
+    def __init__(self, target:ATNState, ruleIndex:int, predIndex:int, isCtxDependent:bool):
+        super().__init__(target)
+        self.serializationType = self.PREDICATE
+        self.ruleIndex = ruleIndex
+        self.predIndex = predIndex
+        self.isCtxDependent = isCtxDependent # e.g., $i ref in pred
+        self.isEpsilon = True
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+    def getPredicate(self):
+        return Predicate(self.ruleIndex, self.predIndex, self.isCtxDependent)
+
+    def __str__(self):
+        return "pred_" + str(self.ruleIndex) + ":" + str(self.predIndex)
+
+class ActionTransition(Transition):
+    __slots__ = ('serializationType', 'ruleIndex', 'actionIndex', 'isCtxDependent')
+
+    def __init__(self, target:ATNState, ruleIndex:int, actionIndex:int=-1, isCtxDependent:bool=False):
+        super().__init__(target)
+        self.serializationType = self.ACTION
+        self.ruleIndex = ruleIndex
+        self.actionIndex = actionIndex
+        self.isCtxDependent = isCtxDependent # e.g., $i ref in pred
+        self.isEpsilon = True
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+    def __str__(self):
+        return "action_"+self.ruleIndex+":"+self.actionIndex
+
+# A transition containing a set of values.
+class SetTransition(Transition):
+    __slots__ = 'serializationType'
+
+    def __init__(self, target:ATNState, set:IntervalSet):
+        super().__init__(target)
+        self.serializationType = self.SET
+        if set is not None:
+            self.label = set
+        else:
+            self.label = IntervalSet()
+            self.label.addRange(range(Token.INVALID_TYPE, Token.INVALID_TYPE + 1))
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return symbol in self.label
+
+    def __str__(self):
+        return str(self.label)
+
+class NotSetTransition(SetTransition):
+
+    def __init__(self, target:ATNState, set:IntervalSet):
+        super().__init__(target, set)
+        self.serializationType = self.NOT_SET
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return symbol >= minVocabSymbol \
+            and symbol <= maxVocabSymbol \
+            and not super(type(self), self).matches(symbol, minVocabSymbol, maxVocabSymbol)
+
+    def __str__(self):
+        return '~' + super(type(self), self).__str__()
+
+
+class WildcardTransition(Transition):
+    __slots__ = 'serializationType'
+
+    def __init__(self, target:ATNState):
+        super().__init__(target)
+        self.serializationType = self.WILDCARD
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return symbol >= minVocabSymbol and symbol <= maxVocabSymbol
+
+    def __str__(self):
+        return "."
+
+
+class PrecedencePredicateTransition(AbstractPredicateTransition):
+    __slots__ = ('serializationType', 'precedence')
+
+    def __init__(self, target:ATNState, precedence:int):
+        super().__init__(target)
+        self.serializationType = self.PRECEDENCE
+        self.precedence = precedence
+        self.isEpsilon = True
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+
+    def getPredicate(self):
+        return PrecedencePredicate(self.precedence)
+
+    def __str__(self):
+        return self.precedence + " >= _p"
+
+
+Transition.serializationTypes = {
+             EpsilonTransition: Transition.EPSILON,
+             RangeTransition: Transition.RANGE,
+             RuleTransition: Transition.RULE,
+             PredicateTransition: Transition.PREDICATE,
+             AtomTransition: Transition.ATOM,
+             ActionTransition: Transition.ACTION,
+             SetTransition: Transition.SET,
+             NotSetTransition: Transition.NOT_SET,
+             WildcardTransition: Transition.WILDCARD,
+             PrecedencePredicateTransition: Transition.PRECEDENCE
+         }
+
+del ATNState
+del RuleStartState
+
+from .ATNState import *

omlish/antlr/_runtime/atn/__init__.py

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