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

omlish/antlr/_runtime/atn/ATNConfig.py

@@ -0,0 +1,162 @@
+# 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 tuple: (ATN state, predicted alt, syntactic, semantic context).
+#  The syntactic context is a graph-structured stack node whose
+#  path(s) to the root is the rule invocation(s)
+#  chain used to arrive at the state.  The semantic context is
+#  the tree of semantic predicates encountered before reaching
+#  an ATN state.
+#/
+from io import StringIO
+from ..PredictionContext import PredictionContext
+from .ATNState import ATNState, DecisionState
+from .LexerActionExecutor import LexerActionExecutor
+from .SemanticContext import SemanticContext
+
+# need a forward declaration
+ATNConfig = None
+
+class ATNConfig(object):
+    __slots__ = (
+        'state', 'alt', 'context', 'semanticContext', 'reachesIntoOuterContext',
+        'precedenceFilterSuppressed'
+    )
+
+    def __init__(self, state:ATNState=None, alt:int=None, context:PredictionContext=None, semantic:SemanticContext=None, config:ATNConfig=None):
+        if config is not None:
+            if state is None:
+                state = config.state
+            if alt is None:
+                alt = config.alt
+            if context is None:
+                context = config.context
+            if semantic is None:
+                semantic = config.semanticContext
+        if semantic is None:
+            semantic = SemanticContext.NONE
+        # The ATN state associated with this configuration#/
+        self.state = state
+        # What alt (or lexer rule) is predicted by this configuration#/
+        self.alt = alt
+        # The stack of invoking states leading to the rule/states associated
+        #  with this config.  We track only those contexts pushed during
+        #  execution of the ATN simulator.
+        self.context = context
+        self.semanticContext = semantic
+        # We cannot execute predicates dependent upon local context unless
+        # we know for sure we are in the correct context. Because there is
+        # no way to do this efficiently, we simply cannot evaluate
+        # dependent predicates unless we are in the rule that initially
+        # invokes the ATN simulator.
+        #
+        # closure() tracks the depth of how far we dip into the
+        # outer context: depth > 0.  Note that it may not be totally
+        # accurate depth since I don't ever decrement. TODO: make it a boolean then
+        self.reachesIntoOuterContext = 0 if config is None else config.reachesIntoOuterContext
+        self.precedenceFilterSuppressed = False if config is None else config.precedenceFilterSuppressed
+
+    # An ATN configuration is equal to another if both have
+    #  the same state, they predict the same alternative, and
+    #  syntactic/semantic contexts are the same.
+    #/
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, ATNConfig):
+            return False
+        else:
+            return self.state.stateNumber==other.state.stateNumber \
+                and self.alt==other.alt \
+                and ((self.context is other.context) or (self.context==other.context)) \
+                and self.semanticContext==other.semanticContext \
+                and self.precedenceFilterSuppressed==other.precedenceFilterSuppressed
+
+    def __hash__(self):
+        return hash((self.state.stateNumber, self.alt, self.context, self.semanticContext))
+
+    def hashCodeForConfigSet(self):
+        return hash((self.state.stateNumber, self.alt, hash(self.semanticContext)))
+
+    def equalsForConfigSet(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, ATNConfig):
+            return False
+        else:
+            return self.state.stateNumber==other.state.stateNumber \
+                and self.alt==other.alt \
+                and self.semanticContext==other.semanticContext
+
+    def __str__(self):
+        with StringIO() as buf:
+            buf.write('(')
+            buf.write(str(self.state))
+            buf.write(",")
+            buf.write(str(self.alt))
+            if self.context is not None:
+                buf.write(",[")
+                buf.write(str(self.context))
+                buf.write("]")
+            if self.semanticContext is not None and self.semanticContext is not SemanticContext.NONE:
+                buf.write(",")
+                buf.write(str(self.semanticContext))
+            if self.reachesIntoOuterContext>0:
+                buf.write(",up=")
+                buf.write(str(self.reachesIntoOuterContext))
+            buf.write(')')
+            return buf.getvalue()
+
+# need a forward declaration
+LexerATNConfig = None
+
+class LexerATNConfig(ATNConfig):
+    __slots__ = ('lexerActionExecutor', 'passedThroughNonGreedyDecision')
+
+    def __init__(self, state:ATNState, alt:int=None, context:PredictionContext=None, semantic:SemanticContext=SemanticContext.NONE,
+                 lexerActionExecutor:LexerActionExecutor=None, config:LexerATNConfig=None):
+        super().__init__(state=state, alt=alt, context=context, semantic=semantic, config=config)
+        if config is not None:
+            if lexerActionExecutor is None:
+                lexerActionExecutor = config.lexerActionExecutor
+        # This is the backing field for {@link #getLexerActionExecutor}.
+        self.lexerActionExecutor = lexerActionExecutor
+        self.passedThroughNonGreedyDecision = False if config is None else self.checkNonGreedyDecision(config, state)
+
+    def __hash__(self):
+        return hash((self.state.stateNumber, self.alt, self.context,
+                self.semanticContext, self.passedThroughNonGreedyDecision,
+                self.lexerActionExecutor))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerATNConfig):
+            return False
+        if self.passedThroughNonGreedyDecision != other.passedThroughNonGreedyDecision:
+            return False
+        if not(self.lexerActionExecutor == other.lexerActionExecutor):
+            return False
+        return super().__eq__(other)
+
+
+
+    def hashCodeForConfigSet(self):
+        return hash(self)
+
+
+
+    def equalsForConfigSet(self, other):
+        return self==other
+
+
+
+    def checkNonGreedyDecision(self, source:LexerATNConfig, target:ATNState):
+        return source.passedThroughNonGreedyDecision \
+            or isinstance(target, DecisionState) and target.nonGreedy

omlish/antlr/_runtime/atn/ATNConfigSet.py

@@ -0,0 +1,215 @@
+# 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 ..PredictionContext import merge
+from ..Utils import str_list
+from .ATN import ATN
+from .ATNConfig import ATNConfig
+from .SemanticContext import SemanticContext
+from ..error.Errors import UnsupportedOperationException, IllegalStateException
+from functools import reduce
+#
+# Specialized {@link Set}{@code <}{@link ATNConfig}{@code >} that can track
+# info about the set, with support for combining similar configurations using a
+# graph-structured stack.
+# /
+from io import StringIO
+
+ATNSimulator = None
+
+class ATNConfigSet(object):
+    __slots__ = (
+        'configLookup', 'fullCtx', 'readonly', 'configs', 'uniqueAlt',
+        'conflictingAlts', 'hasSemanticContext', 'dipsIntoOuterContext',
+        'cachedHashCode'
+    )
+
+    #
+    # The reason that we need this is because we don't want the hash map to use
+    # the standard hash code and equals. We need all configurations with the same
+    # {@code (s,i,_,semctx)} to be equal. Unfortunately, this key effectively doubles
+    # the number of objects associated with ATNConfigs. The other solution is to
+    # use a hash table that lets us specify the equals/hashcode operation.
+
+    def __init__(self, fullCtx:bool=True):
+        # All configs but hashed by (s, i, _, pi) not including context. Wiped out
+        # when we go readonly as this set becomes a DFA state.
+        self.configLookup = dict()
+        # Indicates that this configuration set is part of a full context
+        #  LL prediction. It will be used to determine how to merge $. With SLL
+        #  it's a wildcard whereas it is not for LL context merge.
+        self.fullCtx = fullCtx
+        # Indicates that the set of configurations is read-only. Do not
+        #  allow any code to manipulate the set; DFA states will point at
+        #  the sets and they must not change. This does not protect the other
+        #  fields; in particular, conflictingAlts is set after
+        #  we've made this readonly.
+        self.readonly = False
+        # Track the elements as they are added to the set; supports get(i)#/
+        self.configs = []
+
+        # TODO: these fields make me pretty uncomfortable but nice to pack up info together, saves recomputation
+        # TODO: can we track conflicts as they are added to save scanning configs later?
+        self.uniqueAlt = 0
+        self.conflictingAlts = None
+
+        # Used in parser and lexer. In lexer, it indicates we hit a pred
+        # while computing a closure operation.  Don't make a DFA state from this.
+        self.hasSemanticContext = False
+        self.dipsIntoOuterContext = False
+
+        self.cachedHashCode = -1
+
+    def __iter__(self):
+        return self.configs.__iter__()
+
+    # Adding a new config means merging contexts with existing configs for
+    # {@code (s, i, pi, _)}, where {@code s} is the
+    # {@link ATNConfig#state}, {@code i} is the {@link ATNConfig#alt}, and
+    # {@code pi} is the {@link ATNConfig#semanticContext}. We use
+    # {@code (s,i,pi)} as key.
+    #
+    # <p>This method updates {@link #dipsIntoOuterContext} and
+    # {@link #hasSemanticContext} when necessary.</p>
+    #/
+    def add(self, config:ATNConfig, mergeCache=None):
+        if self.readonly:
+            raise Exception("This set is readonly")
+        if config.semanticContext is not SemanticContext.NONE:
+            self.hasSemanticContext = True
+        if config.reachesIntoOuterContext > 0:
+            self.dipsIntoOuterContext = True
+        existing = self.getOrAdd(config)
+        if existing is config:
+            self.cachedHashCode = -1
+            self.configs.append(config)  # track order here
+            return True
+        # a previous (s,i,pi,_), merge with it and save result
+        rootIsWildcard = not self.fullCtx
+        merged = merge(existing.context, config.context, rootIsWildcard, mergeCache)
+        # no need to check for existing.context, config.context in cache
+        # since only way to create new graphs is "call rule" and here.
+        # We cache at both places.
+        existing.reachesIntoOuterContext = max(existing.reachesIntoOuterContext, config.reachesIntoOuterContext)
+        # make sure to preserve the precedence filter suppression during the merge
+        if config.precedenceFilterSuppressed:
+            existing.precedenceFilterSuppressed = True
+        existing.context = merged # replace context; no need to alt mapping
+        return True
+
+    def getOrAdd(self, config:ATNConfig):
+        h = config.hashCodeForConfigSet()
+        l = self.configLookup.get(h, None)
+        if l is not None:
+            r = next((cfg for cfg in l if config.equalsForConfigSet(cfg)), None)
+            if r is not None:
+                return r
+        if l is None:
+            l = [config]
+            self.configLookup[h] = l
+        else:
+            l.append(config)
+        return config
+
+    def getStates(self):
+        return set(c.state for c in self.configs)
+
+    def getPredicates(self):
+        return list(cfg.semanticContext for cfg in self.configs if cfg.semanticContext!=SemanticContext.NONE)
+
+    def get(self, i:int):
+        return self.configs[i]
+
+    def optimizeConfigs(self, interpreter:ATNSimulator):
+        if self.readonly:
+            raise IllegalStateException("This set is readonly")
+        if len(self.configs)==0:
+            return
+        for config in self.configs:
+            config.context = interpreter.getCachedContext(config.context)
+
+    def addAll(self, coll:list):
+        for c in coll:
+            self.add(c)
+        return False
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, ATNConfigSet):
+            return False
+
+        same = self.configs is not None and \
+            self.configs==other.configs and \
+            self.fullCtx == other.fullCtx and \
+            self.uniqueAlt == other.uniqueAlt and \
+            self.conflictingAlts == other.conflictingAlts and \
+            self.hasSemanticContext == other.hasSemanticContext and \
+            self.dipsIntoOuterContext == other.dipsIntoOuterContext
+
+        return same
+
+    def __hash__(self):
+        if self.readonly:
+            if self.cachedHashCode == -1:
+                self.cachedHashCode = self.hashConfigs()
+            return self.cachedHashCode
+        return self.hashConfigs()
+
+    def hashConfigs(self):
+        return reduce(lambda h, cfg: hash((h, cfg)), self.configs, 0)
+
+    def __len__(self):
+        return len(self.configs)
+
+    def isEmpty(self):
+        return len(self.configs)==0
+
+    def __contains__(self, config):
+        if self.configLookup is None:
+            raise UnsupportedOperationException("This method is not implemented for readonly sets.")
+        h = config.hashCodeForConfigSet()
+        l = self.configLookup.get(h, None)
+        if l is not None:
+            for c in l:
+                if config.equalsForConfigSet(c):
+                    return True
+        return False
+
+    def clear(self):
+        if self.readonly:
+            raise IllegalStateException("This set is readonly")
+        self.configs.clear()
+        self.cachedHashCode = -1
+        self.configLookup.clear()
+
+    def setReadonly(self, readonly:bool):
+        self.readonly = readonly
+        self.configLookup = None # can't mod, no need for lookup cache
+
+    def __str__(self):
+        with StringIO() as buf:
+            buf.write(str_list(self.configs))
+            if self.hasSemanticContext:
+                buf.write(",hasSemanticContext=")
+                buf.write(str(self.hasSemanticContext).lower()) # lower() to conform to java output
+            if self.uniqueAlt!=ATN.INVALID_ALT_NUMBER:
+                buf.write(",uniqueAlt=")
+                buf.write(str(self.uniqueAlt))
+            if self.conflictingAlts is not None:
+                buf.write(",conflictingAlts=")
+                buf.write(str(self.conflictingAlts))
+            if self.dipsIntoOuterContext:
+                buf.write(",dipsIntoOuterContext")
+            return buf.getvalue()
+
+
+class OrderedATNConfigSet(ATNConfigSet):
+
+    def __init__(self):
+        super().__init__()

omlish/antlr/_runtime/atn/ATNDeserializationOptions.py

@@ -0,0 +1,27 @@
+# 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 a forward declaration
+ATNDeserializationOptions = None
+
+class ATNDeserializationOptions(object):
+    __slots__ = ('readonly', 'verifyATN', 'generateRuleBypassTransitions')
+
+    defaultOptions = None
+
+    def __init__(self, copyFrom:ATNDeserializationOptions = None):
+        self.readonly = False
+        self.verifyATN = True if copyFrom is None else copyFrom.verifyATN
+        self.generateRuleBypassTransitions = False if copyFrom is None else copyFrom.generateRuleBypassTransitions
+
+    def __setattr__(self, key, value):
+        if key!="readonly" and self.readonly:
+            raise Exception("The object is read only.")
+        super(type(self), self).__setattr__(key,value)
+
+ATNDeserializationOptions.defaultOptions = ATNDeserializationOptions()
+ATNDeserializationOptions.defaultOptions.readonly = True