omlish 0.0.0.dev436__py3-none-any.whl → 0.0.0.dev438__py3-none-any.whl

omlish/text/antlr/_runtime/IntervalSet.py

@@ -1,183 +0,0 @@
-# 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 io import StringIO
-from .Token import Token
-
-# need forward declarations
-IntervalSet = None
-
-class IntervalSet(object):
-    __slots__ = ('intervals', 'readonly')
-
-    def __init__(self):
-        self.intervals = None
-        self.readonly = False
-
-    def __iter__(self):
-        if self.intervals is not None:
-            for i in self.intervals:
-                for c in i:
-                    yield c
-
-    def __getitem__(self, item):
-        i = 0
-        for k in self:
-            if i==item:
-                return k
-            else:
-                i += 1
-        return Token.INVALID_TYPE
-
-    def addOne(self, v:int):
-        self.addRange(range(v, v+1))
-
-    def addRange(self, v:range):
-        if self.intervals is None:
-            self.intervals = list()
-            self.intervals.append(v)
-        else:
-            # find insert pos
-            k = 0
-            for i in self.intervals:
-                # distinct range -> insert
-                if v.stop<i.start:
-                    self.intervals.insert(k, v)
-                    return
-                # contiguous range -> adjust
-                elif v.stop==i.start:
-                    self.intervals[k] = range(v.start, i.stop)
-                    return
-                # overlapping range -> adjust and reduce
-                elif v.start<=i.stop:
-                    self.intervals[k] = range(min(i.start,v.start), max(i.stop,v.stop))
-                    self.reduce(k)
-                    return
-                k += 1
-            # greater than any existing
-            self.intervals.append(v)
-
-    def addSet(self, other:IntervalSet):
-        if other.intervals is not None:
-            for i in other.intervals:
-                self.addRange(i)
-        return self
-
-    def reduce(self, k:int):
-        # only need to reduce if k is not the last
-        if k<len(self.intervals)-1:
-            l = self.intervals[k]
-            r = self.intervals[k+1]
-            # if r contained in l
-            if l.stop >= r.stop:
-                self.intervals.pop(k+1)
-                self.reduce(k)
-            elif l.stop >= r.start:
-                self.intervals[k] = range(l.start, r.stop)
-                self.intervals.pop(k+1)
-
-    def complement(self, start, stop):
-        result = IntervalSet()
-        result.addRange(range(start,stop+1))
-        for i in self.intervals:
-            result.removeRange(i)
-        return result
-
-    def __contains__(self, item):
-        if self.intervals is None:
-            return False
-        else:
-            return any(item in i for i in self.intervals)
-
-    def __len__(self):
-        return sum(len(i) for i in self.intervals)
-
-    def removeRange(self, v):
-        if v.start==v.stop-1:
-            self.removeOne(v.start)
-        elif self.intervals is not None:
-            k = 0
-            for i in self.intervals:
-                # intervals are ordered
-                if v.stop<=i.start:
-                    return
-                # check for including range, split it
-                elif v.start>i.start and v.stop<i.stop:
-                    self.intervals[k] = range(i.start, v.start)
-                    x = range(v.stop, i.stop)
-                    self.intervals.insert(k, x)
-                    return
-                # check for included range, remove it
-                elif v.start<=i.start and v.stop>=i.stop:
-                    self.intervals.pop(k)
-                    k -= 1  # need another pass
-                # check for lower boundary
-                elif v.start<i.stop:
-                    self.intervals[k] = range(i.start, v.start)
-                # check for upper boundary
-                elif v.stop<i.stop:
-                    self.intervals[k] = range(v.stop, i.stop)
-                k += 1
-
-    def removeOne(self, v):
-        if self.intervals is not None:
-            k = 0
-            for i in self.intervals:
-                # intervals is ordered
-                if v<i.start:
-                    return
-                # check for single value range
-                elif v==i.start and v==i.stop-1:
-                    self.intervals.pop(k)
-                    return
-                # check for lower boundary
-                elif v==i.start:
-                    self.intervals[k] = range(i.start+1, i.stop)
-                    return
-                # check for upper boundary
-                elif v==i.stop-1:
-                    self.intervals[k] = range(i.start, i.stop-1)
-                    return
-                # split existing range
-                elif v<i.stop-1:
-                    x = range(i.start, v)
-                    self.intervals[k] = range(v + 1, i.stop)
-                    self.intervals.insert(k, x)
-                    return
-                k += 1
-
-
-    def toString(self, literalNames:list, symbolicNames:list):
-        if self.intervals is None:
-            return "{}"
-        with StringIO() as buf:
-            if len(self)>1:
-                buf.write("{")
-            first = True
-            for i in self.intervals:
-                for j in i:
-                    if not first:
-                        buf.write(", ")
-                    buf.write(self.elementName(literalNames, symbolicNames, j))
-                    first = False
-            if len(self)>1:
-                buf.write("}")
-            return buf.getvalue()
-
-    def elementName(self, literalNames:list, symbolicNames:list, a:int):
-        if a==Token.EOF:
-            return "<EOF>"
-        elif a==Token.EPSILON:
-            return "<EPSILON>"
-        else:
-            if a<len(literalNames) and literalNames[a] != "<INVALID>":
-                return literalNames[a]
-            if a<len(symbolicNames):
-                return symbolicNames[a]
-            return "<UNKNOWN>"

omlish/text/antlr/_runtime/LICENSE.txt

@@ -1,28 +0,0 @@
-Copyright (c) 2012-2022 The ANTLR Project. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
-
-3. Neither name of copyright holders nor the names of its contributors
-may be used to endorse or promote products derived from this software
-without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR
-CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

omlish/text/antlr/_runtime/LL1Analyzer.py

@@ -1,176 +0,0 @@
-# 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 .IntervalSet import IntervalSet
-from .Token import Token
-from .PredictionContext import PredictionContext, SingletonPredictionContext, PredictionContextFromRuleContext
-from .RuleContext import RuleContext
-from .atn.ATN import ATN
-from .atn.ATNConfig import ATNConfig
-from .atn.ATNState import ATNState, RuleStopState
-from .atn.Transition import WildcardTransition, NotSetTransition, AbstractPredicateTransition, RuleTransition
-
-
-class LL1Analyzer (object):
-    __slots__ = 'atn'
-
-    #* Special value added to the lookahead sets to indicate that we hit
-    #  a predicate during analysis if {@code seeThruPreds==false}.
-    #/
-    HIT_PRED = Token.INVALID_TYPE
-
-    def __init__(self, atn:ATN):
-        self.atn = atn
-
-    #*
-    # Calculates the SLL(1) expected lookahead set for each outgoing transition
-    # of an {@link ATNState}. The returned array has one element for each
-    # outgoing transition in {@code s}. If the closure from transition
-    # <em>i</em> leads to a semantic predicate before matching a symbol, the
-    # element at index <em>i</em> of the result will be {@code null}.
-    #
-    # @param s the ATN state
-    # @return the expected symbols for each outgoing transition of {@code s}.
-    #/
-    def getDecisionLookahead(self, s:ATNState):
-        if s is None:
-            return None
-
-        count = len(s.transitions)
-        look = [] * count
-        for alt in range(0, count):
-            look[alt] = set()
-            lookBusy = set()
-            seeThruPreds = False # fail to get lookahead upon pred
-            self._LOOK(s.transition(alt).target, None, PredictionContext.EMPTY,
-                  look[alt], lookBusy, set(), seeThruPreds, False)
-            # Wipe out lookahead for this alternative if we found nothing
-            # or we had a predicate when we !seeThruPreds
-            if len(look[alt])==0 or self.HIT_PRED in look[alt]:
-                look[alt] = None
-        return look
-
-    #*
-    # Compute set of tokens that can follow {@code s} in the ATN in the
-    # specified {@code ctx}.
-    #
-    # <p>If {@code ctx} is {@code null} and the end of the rule containing
-    # {@code s} is reached, {@link Token#EPSILON} is added to the result set.
-    # If {@code ctx} is not {@code null} and the end of the outermost rule is
-    # reached, {@link Token#EOF} is added to the result set.</p>
-    #
-    # @param s the ATN state
-    # @param stopState the ATN state to stop at. This can be a
-    # {@link BlockEndState} to detect epsilon paths through a closure.
-    # @param ctx the complete parser context, or {@code null} if the context
-    # should be ignored
-    #
-    # @return The set of tokens that can follow {@code s} in the ATN in the
-    # specified {@code ctx}.
-    #/
-    def LOOK(self, s:ATNState, stopState:ATNState=None, ctx:RuleContext=None):
-        r = IntervalSet()
-        seeThruPreds = True # ignore preds; get all lookahead
-        lookContext = PredictionContextFromRuleContext(s.atn, ctx) if ctx is not None else None
-        self._LOOK(s, stopState, lookContext, r, set(), set(), seeThruPreds, True)
-        return r
-
-    #*
-    # Compute set of tokens that can follow {@code s} in the ATN in the
-    # specified {@code ctx}.
-    #
-    # <p>If {@code ctx} is {@code null} and {@code stopState} or the end of the
-    # rule containing {@code s} is reached, {@link Token#EPSILON} is added to
-    # the result set. If {@code ctx} is not {@code null} and {@code addEOF} is
-    # {@code true} and {@code stopState} or the end of the outermost rule is
-    # reached, {@link Token#EOF} is added to the result set.</p>
-    #
-    # @param s the ATN state.
-    # @param stopState the ATN state to stop at. This can be a
-    # {@link BlockEndState} to detect epsilon paths through a closure.
-    # @param ctx The outer context, or {@code null} if the outer context should
-    # not be used.
-    # @param look The result lookahead set.
-    # @param lookBusy A set used for preventing epsilon closures in the ATN
-    # from causing a stack overflow. Outside code should pass
-    # {@code new HashSet<ATNConfig>} for this argument.
-    # @param calledRuleStack A set used for preventing left recursion in the
-    # ATN from causing a stack overflow. Outside code should pass
-    # {@code new BitSet()} for this argument.
-    # @param seeThruPreds {@code true} to true semantic predicates as
-    # implicitly {@code true} and "see through them", otherwise {@code false}
-    # to treat semantic predicates as opaque and add {@link #HIT_PRED} to the
-    # result if one is encountered.
-    # @param addEOF Add {@link Token#EOF} to the result if the end of the
-    # outermost context is reached. This parameter has no effect if {@code ctx}
-    # is {@code null}.
-    #/
-    def _LOOK(self, s:ATNState, stopState:ATNState , ctx:PredictionContext, look:IntervalSet, lookBusy:set,
-                     calledRuleStack:set, seeThruPreds:bool, addEOF:bool):
-        c = ATNConfig(s, 0, ctx)
-
-        if c in lookBusy:
-            return
-        lookBusy.add(c)
-
-        if s == stopState:
-            if ctx is None:
-                look.addOne(Token.EPSILON)
-                return
-            elif ctx.isEmpty() and addEOF:
-                look.addOne(Token.EOF)
-                return
-
-        if isinstance(s, RuleStopState ):
-            if ctx is None:
-                look.addOne(Token.EPSILON)
-                return
-            elif ctx.isEmpty() and addEOF:
-                look.addOne(Token.EOF)
-                return
-
-            if ctx != PredictionContext.EMPTY:
-                removed = s.ruleIndex in calledRuleStack
-                try:
-                    calledRuleStack.discard(s.ruleIndex)
-                    # run thru all possible stack tops in ctx
-                    for i in range(0, len(ctx)):
-                        returnState = self.atn.states[ctx.getReturnState(i)]
-                        self._LOOK(returnState, stopState, ctx.getParent(i), look, lookBusy, calledRuleStack, seeThruPreds, addEOF)
-                finally:
-                    if removed:
-                        calledRuleStack.add(s.ruleIndex)
-                return
-
-        for t in s.transitions:
-            if type(t) == RuleTransition:
-                if t.target.ruleIndex in calledRuleStack:
-                    continue
-
-                newContext = SingletonPredictionContext.create(ctx, t.followState.stateNumber)
-
-                try:
-                    calledRuleStack.add(t.target.ruleIndex)
-                    self._LOOK(t.target, stopState, newContext, look, lookBusy, calledRuleStack, seeThruPreds, addEOF)
-                finally:
-                    calledRuleStack.remove(t.target.ruleIndex)
-            elif isinstance(t, AbstractPredicateTransition ):
-                if seeThruPreds:
-                    self._LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF)
-                else:
-                    look.addOne(self.HIT_PRED)
-            elif t.isEpsilon:
-                self._LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF)
-            elif type(t) == WildcardTransition:
-                look.addRange( range(Token.MIN_USER_TOKEN_TYPE, self.atn.maxTokenType + 1) )
-            else:
-                set_ = t.label
-                if set_ is not None:
-                    if isinstance(t, NotSetTransition):
-                        set_ = set_.complement(Token.MIN_USER_TOKEN_TYPE, self.atn.maxTokenType)
-                    look.addSet(set_)