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

omextra/text/antlr/_runtime/FileStream.py

@@ -0,0 +1,30 @@
+# 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 is an InputStream that is loaded from a file all at once
+#  when you construct the object.
+#
+
+import codecs
+from .InputStream import InputStream
+
+
+class FileStream(InputStream):
+    __slots__ = 'fileName'
+
+    def __init__(self, fileName:str, encoding:str='ascii', errors:str='strict'):
+        super().__init__(self.readDataFrom(fileName, encoding, errors))
+        self.fileName = fileName
+
+    def readDataFrom(self, fileName:str, encoding:str, errors:str='strict'):
+        # read binary to avoid line ending conversion
+        with open(fileName, 'rb') as file:
+            bytes = file.read()
+            return codecs.decode(bytes, encoding, errors)

omextra/text/antlr/_runtime/InputStream.py

@@ -0,0 +1,90 @@
+# 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.
+#
+
+
+#
+#  Vacuum all input from a string and then treat it like a buffer.
+#
+from .Token import Token
+
+
+class InputStream (object):
+    __slots__ = ('name', 'strdata', '_index', 'data', '_size')
+
+    def __init__(self, data: str):
+        self.name = "<empty>"
+        self.strdata = data
+        self._loadString()
+
+    def _loadString(self):
+        self._index = 0
+        self.data = [ord(c) for c in self.strdata]
+        self._size = len(self.data)
+
+    @property
+    def index(self):
+        return self._index
+
+    @property
+    def size(self):
+        return self._size
+
+    # Reset the stream so that it's in the same state it was
+    #  when the object was created *except* the data array is not
+    #  touched.
+    #
+    def reset(self):
+        self._index = 0
+
+    def consume(self):
+        if self._index >= self._size:
+            assert self.LA(1) == Token.EOF
+            raise Exception("cannot consume EOF")
+        self._index += 1
+
+    def LA(self, offset: int):
+        if offset==0:
+            return 0 # undefined
+        if offset<0:
+            offset += 1 # e.g., translate LA(-1) to use offset=0
+        pos = self._index + offset - 1
+        if pos < 0 or pos >= self._size: # invalid
+            return Token.EOF
+        return self.data[pos]
+
+    def LT(self, offset: int):
+        return self.LA(offset)
+
+    # mark/release do nothing; we have entire buffer
+    def mark(self):
+        return -1
+
+    def release(self, marker: int):
+        pass
+
+    # consume() ahead until p==_index; can't just set p=_index as we must
+    # update line and column. If we seek backwards, just set p
+    #
+    def seek(self, _index: int):
+        if _index<=self._index:
+            self._index = _index # just jump; don't update stream state (line, ...)
+            return
+        # seek forward
+        self._index = min(_index, self._size)
+
+    def getText(self, start :int, stop: int):
+        if stop >= self._size:
+            stop = self._size-1
+        if start >= self._size:
+            return ""
+        else:
+            return self.strdata[start:stop+1]
+
+    def __str__(self):
+        return self.strdata

omextra/text/antlr/_runtime/IntervalSet.py

@@ -0,0 +1,183 @@
+# 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>"

omextra/text/antlr/_runtime/LICENSE.txt

@@ -0,0 +1,28 @@
+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.

omextra/text/antlr/_runtime/LL1Analyzer.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.
+#/
+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_)