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

omlish/antlr/_runtime/Recognizer.py

@@ -0,0 +1,150 @@
+# 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 .RuleContext import RuleContext
+from .Token import Token
+from .error.ErrorListener import ProxyErrorListener, ConsoleErrorListener
+
+# need forward delcaration
+RecognitionException = None
+
+class Recognizer(object):
+    __slots__ = ('_listeners', '_interp', '_stateNumber')
+
+    tokenTypeMapCache = dict()
+    ruleIndexMapCache = dict()
+
+    def __init__(self):
+        self._listeners = [ ConsoleErrorListener.INSTANCE ]
+        self._interp = None
+        self._stateNumber = -1
+
+    def extractVersion(self, version):
+        pos = version.find(".")
+        major = version[0:pos]
+        version = version[pos+1:]
+        pos = version.find(".")
+        if pos==-1:
+            pos = version.find("-")
+        if pos==-1:
+            pos = len(version)
+        minor = version[0:pos]
+        return major, minor
+
+    def checkVersion(self, toolVersion):
+        runtimeVersion = "4.13.1"
+        rvmajor, rvminor = self.extractVersion(runtimeVersion)
+        tvmajor, tvminor = self.extractVersion(toolVersion)
+        if rvmajor!=tvmajor or rvminor!=tvminor:
+            print("ANTLR runtime and generated code versions disagree: "+runtimeVersion+"!="+toolVersion)
+
+    def addErrorListener(self, listener):
+        self._listeners.append(listener)
+
+    def removeErrorListener(self, listener):
+        self._listeners.remove(listener)
+
+    def removeErrorListeners(self):
+        self._listeners = []
+
+    def getTokenTypeMap(self):
+        tokenNames = self.getTokenNames()
+        if tokenNames is None:
+            from .error.Errors import UnsupportedOperationException
+            raise UnsupportedOperationException("The current recognizer does not provide a list of token names.")
+        result = self.tokenTypeMapCache.get(tokenNames, None)
+        if result is None:
+            result = zip( tokenNames, range(0, len(tokenNames)))
+            result["EOF"] = Token.EOF
+            self.tokenTypeMapCache[tokenNames] = result
+        return result
+
+    # Get a map from rule names to rule indexes.
+    #
+    # <p>Used for XPath and tree pattern compilation.</p>
+    #
+    def getRuleIndexMap(self):
+        ruleNames = self.getRuleNames()
+        if ruleNames is None:
+            from .error.Errors import UnsupportedOperationException
+            raise UnsupportedOperationException("The current recognizer does not provide a list of rule names.")
+        result = self.ruleIndexMapCache.get(ruleNames, None)
+        if result is None:
+            result = zip( ruleNames, range(0, len(ruleNames)))
+            self.ruleIndexMapCache[ruleNames] = result
+        return result
+
+    def getTokenType(self, tokenName:str):
+        ttype = self.getTokenTypeMap().get(tokenName, None)
+        if ttype is not None:
+            return ttype
+        else:
+            return Token.INVALID_TYPE
+
+
+    # What is the error header, normally line/character position information?#
+    def getErrorHeader(self, e:RecognitionException):
+        line = e.getOffendingToken().line
+        column = e.getOffendingToken().column
+        return "line "+line+":"+column
+
+
+    # How should a token be displayed in an error message? The default
+    #  is to display just the text, but during development you might
+    #  want to have a lot of information spit out.  Override in that case
+    #  to use t.toString() (which, for CommonToken, dumps everything about
+    #  the token). This is better than forcing you to override a method in
+    #  your token objects because you don't have to go modify your lexer
+    #  so that it creates a new Java type.
+    #
+    # @deprecated This method is not called by the ANTLR 4 Runtime. Specific
+    # implementations of {@link ANTLRErrorStrategy} may provide a similar
+    # feature when necessary. For example, see
+    # {@link DefaultErrorStrategy#getTokenErrorDisplay}.
+    #
+    def getTokenErrorDisplay(self, t:Token):
+        if t is None:
+            return "<no token>"
+        s = t.text
+        if s is None:
+            if t.type==Token.EOF:
+                s = "<EOF>"
+            else:
+                s = "<" + str(t.type) + ">"
+        s = s.replace("\n","\\n")
+        s = s.replace("\r","\\r")
+        s = s.replace("\t","\\t")
+        return "'" + s + "'"
+
+    def getErrorListenerDispatch(self):
+        return ProxyErrorListener(self._listeners)
+
+    # subclass needs to override these if there are sempreds or actions
+    # that the ATN interp needs to execute
+    def sempred(self, localctx:RuleContext, ruleIndex:int, actionIndex:int):
+        return True
+
+    def precpred(self, localctx:RuleContext , precedence:int):
+        return True
+
+    @property
+    def state(self):
+        return self._stateNumber
+
+    # Indicate that the recognizer has changed internal state that is
+    #  consistent with the ATN state passed in.  This way we always know
+    #  where we are in the ATN as the parser goes along. The rule
+    #  context objects form a stack that lets us see the stack of
+    #  invoking rules. Combine this and we have complete ATN
+    #  configuration information.
+
+    @state.setter
+    def state(self, atnState:int):
+        self._stateNumber = atnState
+
+del RecognitionException

omlish/antlr/_runtime/RuleContext.py

@@ -0,0 +1,230 @@
+# 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 rule context is a record of a single rule invocation. It knows
+#  which context invoked it, if any. If there is no parent context, then
+#  naturally the invoking state is not valid.  The parent link
+#  provides a chain upwards from the current rule invocation to the root
+#  of the invocation tree, forming a stack. We actually carry no
+#  information about the rule associated with this context (except
+#  when parsing). We keep only the state number of the invoking state from
+#  the ATN submachine that invoked this. Contrast this with the s
+#  pointer inside ParserRuleContext that tracks the current state
+#  being "executed" for the current rule.
+#
+#  The parent contexts are useful for computing lookahead sets and
+#  getting error information.
+#
+#  These objects are used during parsing and prediction.
+#  For the special case of parsers, we use the subclass
+#  ParserRuleContext.
+#
+#  @see ParserRuleContext
+#/
+from io import StringIO
+from .tree.Tree import RuleNode, INVALID_INTERVAL, ParseTreeVisitor
+from .tree.Trees import Trees
+
+# need forward declarations
+RuleContext = None
+Parser = None
+
+class RuleContext(RuleNode):
+    __slots__ = ('parentCtx', 'invokingState')
+    EMPTY = None
+
+    def __init__(self, parent:RuleContext=None, invokingState:int=-1):
+        super().__init__()
+        # What context invoked this rule?
+        self.parentCtx = parent
+        # What state invoked the rule associated with this context?
+        #  The "return address" is the followState of invokingState
+        #  If parent is null, this should be -1.
+        self.invokingState = invokingState
+
+
+    def depth(self):
+        n = 0
+        p = self
+        while p is not None:
+            p = p.parentCtx
+            n += 1
+        return n
+
+    # A context is empty if there is no invoking state; meaning nobody call
+    #  current context.
+    def isEmpty(self):
+        return self.invokingState == -1
+
+    # satisfy the ParseTree / SyntaxTree interface
+
+    def getSourceInterval(self):
+        return INVALID_INTERVAL
+
+    def getRuleContext(self):
+        return self
+
+    def getPayload(self):
+        return self
+
+   # Return the combined text of all child nodes. This method only considers
+    #  tokens which have been added to the parse tree.
+    #  <p>
+    #  Since tokens on hidden channels (e.g. whitespace or comments) are not
+    #  added to the parse trees, they will not appear in the output of this
+    #  method.
+    #/
+    def getText(self):
+        if self.getChildCount() == 0:
+            return ""
+        with StringIO() as builder:
+            for child in self.getChildren():
+                builder.write(child.getText())
+            return builder.getvalue()
+
+    def getRuleIndex(self):
+        return -1
+
+    # For rule associated with this parse tree internal node, return
+    # the outer alternative number used to match the input. Default
+    # implementation does not compute nor store this alt num. Create
+    # a subclass of ParserRuleContext with backing field and set
+    # option contextSuperClass.
+    # to set it.
+    def getAltNumber(self):
+        return 0 # should use ATN.INVALID_ALT_NUMBER but won't compile
+
+    # Set the outer alternative number for this context node. Default
+    # implementation does nothing to avoid backing field overhead for
+    # trees that don't need it.  Create
+    # a subclass of ParserRuleContext with backing field and set
+    # option contextSuperClass.
+    def setAltNumber(self, altNumber:int):
+        pass
+
+    def getChild(self, i:int):
+        return None
+
+    def getChildCount(self):
+        return 0
+
+    def getChildren(self):
+        for c in []:
+            yield c
+
+    def accept(self, visitor:ParseTreeVisitor):
+        return visitor.visitChildren(self)
+
+   # # Call this method to view a parse tree in a dialog box visually.#/
+   #  public Future<JDialog> inspect(@Nullable Parser parser) {
+   #      List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+   #      return inspect(ruleNames);
+   #  }
+   #
+   #  public Future<JDialog> inspect(@Nullable List<String> ruleNames) {
+   #      TreeViewer viewer = new TreeViewer(ruleNames, this);
+   #      return viewer.open();
+   #  }
+   #
+   # # Save this tree in a postscript file#/
+   #  public void save(@Nullable Parser parser, String fileName)
+   #      throws IOException, PrintException
+   #  {
+   #      List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+   #      save(ruleNames, fileName);
+   #  }
+   #
+   # # Save this tree in a postscript file using a particular font name and size#/
+   #  public void save(@Nullable Parser parser, String fileName,
+   #                   String fontName, int fontSize)
+   #      throws IOException
+   #  {
+   #      List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+   #      save(ruleNames, fileName, fontName, fontSize);
+   #  }
+   #
+   # # Save this tree in a postscript file#/
+   #  public void save(@Nullable List<String> ruleNames, String fileName)
+   #      throws IOException, PrintException
+   #  {
+   #      Trees.writePS(this, ruleNames, fileName);
+   #  }
+   #
+   # # Save this tree in a postscript file using a particular font name and size#/
+   #  public void save(@Nullable List<String> ruleNames, String fileName,
+   #                   String fontName, int fontSize)
+   #      throws IOException
+   #  {
+   #      Trees.writePS(this, ruleNames, fileName, fontName, fontSize);
+   #  }
+   #
+   # # Print out a whole tree, not just a node, in LISP format
+   #  #  (root child1 .. childN). Print just a node if this is a leaf.
+   #  #  We have to know the recognizer so we can get rule names.
+   #  #/
+   #  @Override
+   #  public String toStringTree(@Nullable Parser recog) {
+   #      return Trees.toStringTree(this, recog);
+   #  }
+   #
+   # Print out a whole tree, not just a node, in LISP format
+   #  (root child1 .. childN). Print just a node if this is a leaf.
+   #
+    def toStringTree(self, ruleNames:list=None, recog:Parser=None):
+        return Trees.toStringTree(self, ruleNames=ruleNames, recog=recog)
+   #  }
+   #
+   #  @Override
+   #  public String toStringTree() {
+   #      return toStringTree((List<String>)null);
+   #  }
+   #
+    def __str__(self):
+        return self.toString(None, None)
+
+   #  @Override
+   #  public String toString() {
+   #      return toString((List<String>)null, (RuleContext)null);
+   #  }
+   #
+   #  public final String toString(@Nullable Recognizer<?,?> recog) {
+   #      return toString(recog, ParserRuleContext.EMPTY);
+   #  }
+   #
+   #  public final String toString(@Nullable List<String> ruleNames) {
+   #      return toString(ruleNames, null);
+   #  }
+   #
+   #  // recog null unless ParserRuleContext, in which case we use subclass toString(...)
+   #  public String toString(@Nullable Recognizer<?,?> recog, @Nullable RuleContext stop) {
+   #      String[] ruleNames = recog != null ? recog.getRuleNames() : null;
+   #      List<String> ruleNamesList = ruleNames != null ? Arrays.asList(ruleNames) : null;
+   #      return toString(ruleNamesList, stop);
+   #  }
+
+    def toString(self, ruleNames:list, stop:RuleContext)->str:
+        with StringIO() as buf:
+            p = self
+            buf.write("[")
+            while p is not None and p is not stop:
+                if ruleNames is None:
+                    if not p.isEmpty():
+                        buf.write(str(p.invokingState))
+                else:
+                    ri = p.getRuleIndex()
+                    ruleName = ruleNames[ri] if ri >= 0 and ri < len(ruleNames) else str(ri)
+                    buf.write(ruleName)
+
+                if p.parentCtx is not None and (ruleNames is not None or not p.parentCtx.isEmpty()):
+                    buf.write(" ")
+
+                p = p.parentCtx
+
+            buf.write("]")
+            return buf.getvalue()

omlish/antlr/_runtime/StdinStream.py

@@ -0,0 +1,14 @@
+# type: ignore
+# ruff: noqa
+# flake8: noqa
+import codecs
+import sys
+
+from .InputStream import InputStream
+
+
+class StdinStream(InputStream):
+    def __init__(self, encoding:str='ascii', errors:str='strict') -> None:
+        bytes = sys.stdin.buffer.read()
+        data = codecs.decode(bytes, encoding, errors)
+        super().__init__(data)

omlish/antlr/_runtime/Token.py

@@ -0,0 +1,158 @@
+# 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 token has properties: text, type, line, character position in the line
+# (so we can ignore tabs), token channel, index, and source from which
+# we obtained this token.
+from io import StringIO
+
+
+class Token (object):
+    __slots__ = ('source', 'type', 'channel', 'start', 'stop', 'tokenIndex', 'line', 'column', '_text')
+
+    INVALID_TYPE = 0
+
+    # During lookahead operations, this "token" signifies we hit rule end ATN state
+    # and did not follow it despite needing to.
+    EPSILON = -2
+
+    MIN_USER_TOKEN_TYPE = 1
+
+    EOF = -1
+
+    # All tokens go to the parser (unless skip() is called in that rule)
+    # on a particular "channel".  The parser tunes to a particular channel
+    # so that whitespace etc... can go to the parser on a "hidden" channel.
+
+    DEFAULT_CHANNEL = 0
+
+    # Anything on different channel than DEFAULT_CHANNEL is not parsed
+    # by parser.
+
+    HIDDEN_CHANNEL = 1
+
+    def __init__(self):
+        self.source = None
+        self.type = None # token type of the token
+        self.channel = None # The parser ignores everything not on DEFAULT_CHANNEL
+        self.start = None # optional; return -1 if not implemented.
+        self.stop = None  # optional; return -1 if not implemented.
+        self.tokenIndex = None # from 0..n-1 of the token object in the input stream
+        self.line = None # line=1..n of the 1st character
+        self.column = None # beginning of the line at which it occurs, 0..n-1
+        self._text = None # text of the token.
+
+    @property
+    def text(self):
+        return self._text
+
+    # Explicitly set the text for this token. If {code text} is not
+    # {@code null}, then {@link #getText} will return this value rather than
+    # extracting the text from the input.
+    #
+    # @param text The explicit text of the token, or {@code null} if the text
+    # should be obtained from the input along with the start and stop indexes
+    # of the token.
+
+    @text.setter
+    def text(self, text:str):
+        self._text = text
+
+
+    def getTokenSource(self):
+        return self.source[0]
+
+    def getInputStream(self):
+        return self.source[1]
+
+class CommonToken(Token):
+
+    # An empty {@link Pair} which is used as the default value of
+    # {@link #source} for tokens that do not have a source.
+    EMPTY_SOURCE = (None, None)
+
+    def __init__(self, source:tuple = EMPTY_SOURCE, type:int = None, channel:int=Token.DEFAULT_CHANNEL, start:int=-1, stop:int=-1):
+        super().__init__()
+        self.source = source
+        self.type = type
+        self.channel = channel
+        self.start = start
+        self.stop = stop
+        self.tokenIndex = -1
+        if source[0] is not None:
+            self.line = source[0].line
+            self.column = source[0].column
+        else:
+            self.column = -1
+
+    # Constructs a new {@link CommonToken} as a copy of another {@link Token}.
+    #
+    # <p>
+    # If {@code oldToken} is also a {@link CommonToken} instance, the newly
+    # constructed token will share a reference to the {@link #text} field and
+    # the {@link Pair} stored in {@link #source}. Otherwise, {@link #text} will
+    # be assigned the result of calling {@link #getText}, and {@link #source}
+    # will be constructed from the result of {@link Token#getTokenSource} and
+    # {@link Token#getInputStream}.</p>
+    #
+    # @param oldToken The token to copy.
+     #
+    def clone(self):
+        t = CommonToken(self.source, self.type, self.channel, self.start, self.stop)
+        t.tokenIndex = self.tokenIndex
+        t.line = self.line
+        t.column = self.column
+        t.text = self.text
+        return t
+
+    @property
+    def text(self):
+        if self._text is not None:
+            return self._text
+        input = self.getInputStream()
+        if input is None:
+            return None
+        n = input.size
+        if self.start < n and self.stop < n:
+            return input.getText(self.start, self.stop)
+        else:
+            return "<EOF>"
+
+    @text.setter
+    def text(self, text:str):
+        self._text = text
+
+    def __str__(self):
+        with StringIO() as buf:
+            buf.write("[@")
+            buf.write(str(self.tokenIndex))
+            buf.write(",")
+            buf.write(str(self.start))
+            buf.write(":")
+            buf.write(str(self.stop))
+            buf.write("='")
+            txt = self.text
+            if txt is not None:
+                txt = txt.replace("\n","\\n")
+                txt = txt.replace("\r","\\r")
+                txt = txt.replace("\t","\\t")
+            else:
+                txt = "<no text>"
+            buf.write(txt)
+            buf.write("',<")
+            buf.write(str(self.type))
+            buf.write(">")
+            if self.channel > 0:
+                buf.write(",channel=")
+                buf.write(str(self.channel))
+            buf.write(",")
+            buf.write(str(self.line))
+            buf.write(":")
+            buf.write(str(self.column))
+            buf.write("]")
+            return buf.getvalue()