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

omlish/antlr/_runtime/ParserInterpreter.py

@@ -0,0 +1,173 @@
+# 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 parser simulator that mimics what ANTLR's generated
+#  parser code does. A ParserATNSimulator is used to make
+#  predictions via adaptivePredict but this class moves a pointer through the
+#  ATN to simulate parsing. ParserATNSimulator just
+#  makes us efficient rather than having to backtrack, for example.
+#
+#  This properly creates parse trees even for left recursive rules.
+#
+#  We rely on the left recursive rule invocation and special predicate
+#  transitions to make left recursive rules work.
+#
+#  See TestParserInterpreter for examples.
+#
+from .dfa.DFA import DFA
+from .BufferedTokenStream import TokenStream
+from .Lexer import Lexer
+from .Parser import Parser
+from .ParserRuleContext import InterpreterRuleContext, ParserRuleContext
+from .Token import Token
+from .atn.ATN import ATN
+from .atn.ATNState import StarLoopEntryState, ATNState, LoopEndState
+from .atn.ParserATNSimulator import ParserATNSimulator
+from .PredictionContext import PredictionContextCache
+from .atn.Transition import Transition
+from .error.Errors import RecognitionException, UnsupportedOperationException, FailedPredicateException
+
+
+class ParserInterpreter(Parser):
+    __slots__ = (
+        'grammarFileName', 'atn', 'tokenNames', 'ruleNames', 'decisionToDFA',
+        'sharedContextCache', '_parentContextStack',
+        'pushRecursionContextStates'
+    )
+
+    def __init__(self, grammarFileName:str, tokenNames:list, ruleNames:list, atn:ATN, input:TokenStream):
+        super().__init__(input)
+        self.grammarFileName = grammarFileName
+        self.atn = atn
+        self.tokenNames = tokenNames
+        self.ruleNames = ruleNames
+        self.decisionToDFA = [ DFA(state) for state in atn.decisionToState ]
+        self.sharedContextCache = PredictionContextCache()
+        self._parentContextStack = list()
+        # identify the ATN states where pushNewRecursionContext must be called
+        self.pushRecursionContextStates = set()
+        for state in atn.states:
+            if not isinstance(state, StarLoopEntryState):
+                continue
+            if state.isPrecedenceDecision:
+                self.pushRecursionContextStates.add(state.stateNumber)
+        # get atn simulator that knows how to do predictions
+        self._interp = ParserATNSimulator(self, atn, self.decisionToDFA, self.sharedContextCache)
+
+    # Begin parsing at startRuleIndex#
+    def parse(self, startRuleIndex:int):
+        startRuleStartState = self.atn.ruleToStartState[startRuleIndex]
+        rootContext = InterpreterRuleContext(None, ATNState.INVALID_STATE_NUMBER, startRuleIndex)
+        if startRuleStartState.isPrecedenceRule:
+            self.enterRecursionRule(rootContext, startRuleStartState.stateNumber, startRuleIndex, 0)
+        else:
+            self.enterRule(rootContext, startRuleStartState.stateNumber, startRuleIndex)
+        while True:
+            p = self.getATNState()
+            if p.stateType==ATNState.RULE_STOP :
+                # pop; return from rule
+                if len(self._ctx)==0:
+                    if startRuleStartState.isPrecedenceRule:
+                        result = self._ctx
+                        parentContext = self._parentContextStack.pop()
+                        self.unrollRecursionContexts(parentContext.a)
+                        return result
+                    else:
+                        self.exitRule()
+                        return rootContext
+                self.visitRuleStopState(p)
+
+            else:
+                try:
+                    self.visitState(p)
+                except RecognitionException as e:
+                    self.state = self.atn.ruleToStopState[p.ruleIndex].stateNumber
+                    self._ctx.exception = e
+                    self._errHandler.reportError(self, e)
+                    self._errHandler.recover(self, e)
+
+    def enterRecursionRule(self, localctx:ParserRuleContext, state:int, ruleIndex:int, precedence:int):
+        self._parentContextStack.append((self._ctx, localctx.invokingState))
+        super().enterRecursionRule(localctx, state, ruleIndex, precedence)
+
+    def getATNState(self):
+        return self.atn.states[self.state]
+
+    def visitState(self, p:ATNState):
+        edge = 0
+        if len(p.transitions) > 1:
+            self._errHandler.sync(self)
+            edge = self._interp.adaptivePredict(self._input, p.decision, self._ctx)
+        else:
+            edge = 1
+
+        transition = p.transitions[edge - 1]
+        tt = transition.serializationType
+        if tt==Transition.EPSILON:
+
+            if self.pushRecursionContextStates[p.stateNumber] and not isinstance(transition.target, LoopEndState):
+                t = self._parentContextStack[-1]
+                ctx = InterpreterRuleContext(t[0], t[1], self._ctx.ruleIndex)
+                self.pushNewRecursionContext(ctx, self.atn.ruleToStartState[p.ruleIndex].stateNumber, self._ctx.ruleIndex)
+
+        elif tt==Transition.ATOM:
+
+            self.match(transition.label)
+
+        elif tt in [ Transition.RANGE, Transition.SET, Transition.NOT_SET]:
+
+            if not transition.matches(self._input.LA(1), Token.MIN_USER_TOKEN_TYPE, Lexer.MAX_CHAR_VALUE):
+                self._errHandler.recoverInline(self)
+            self.matchWildcard()
+
+        elif tt==Transition.WILDCARD:
+
+            self.matchWildcard()
+
+        elif tt==Transition.RULE:
+
+            ruleStartState = transition.target
+            ruleIndex = ruleStartState.ruleIndex
+            ctx = InterpreterRuleContext(self._ctx, p.stateNumber, ruleIndex)
+            if ruleStartState.isPrecedenceRule:
+                self.enterRecursionRule(ctx, ruleStartState.stateNumber, ruleIndex, transition.precedence)
+            else:
+                self.enterRule(ctx, transition.target.stateNumber, ruleIndex)
+
+        elif tt==Transition.PREDICATE:
+
+            if not self.sempred(self._ctx, transition.ruleIndex, transition.predIndex):
+                raise FailedPredicateException(self)
+
+        elif tt==Transition.ACTION:
+
+            self.action(self._ctx, transition.ruleIndex, transition.actionIndex)
+
+        elif tt==Transition.PRECEDENCE:
+
+            if not self.precpred(self._ctx, transition.precedence):
+                msg = "precpred(_ctx, " + str(transition.precedence) + ")"
+                raise FailedPredicateException(self, msg)
+
+        else:
+            raise UnsupportedOperationException("Unrecognized ATN transition type.")
+
+        self.state = transition.target.stateNumber
+
+    def visitRuleStopState(self, p:ATNState):
+        ruleStartState = self.atn.ruleToStartState[p.ruleIndex]
+        if ruleStartState.isPrecedenceRule:
+            parentContext = self._parentContextStack.pop()
+            self.unrollRecursionContexts(parentContext.a)
+            self.state = parentContext[1]
+        else:
+            self.exitRule()
+
+        ruleTransition = self.atn.states[self.state].transitions[0]
+        self.state = ruleTransition.followState.stateNumber

omlish/antlr/_runtime/ParserRuleContext.py

@@ -0,0 +1,189 @@
+# 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 invocation record for parsing.
+#
+#  Contains all of the information about the current rule not stored in the
+#  RuleContext. It handles parse tree children list, Any ATN state
+#  tracing, and the default values available for rule indications:
+#  start, stop, rule index, current alt number, current
+#  ATN state.
+#
+#  Subclasses made for each rule and grammar track the parameters,
+#  return values, locals, and labels specific to that rule. These
+#  are the objects that are returned from rules.
+#
+#  Note text is not an actual field of a rule return value; it is computed
+#  from start and stop using the input stream's toString() method.  I
+#  could add a ctor to this so that we can pass in and store the input
+#  stream, but I'm not sure we want to do that.  It would seem to be undefined
+#  to get the .text property anyway if the rule matches tokens from multiple
+#  input streams.
+#
+#  I do not use getters for fields of objects that are used simply to
+#  group values such as this aggregate.  The getters/setters are there to
+#  satisfy the superclass interface.
+
+from .RuleContext import RuleContext
+from .Token import Token
+from .tree.Tree import ParseTreeListener, ParseTree, TerminalNodeImpl, ErrorNodeImpl, TerminalNode, \
+    INVALID_INTERVAL
+
+# need forward declaration
+ParserRuleContext = None
+
+class ParserRuleContext(RuleContext):
+    __slots__ = ('children', 'start', 'stop', 'exception')
+    def __init__(self, parent:ParserRuleContext = None, invokingStateNumber:int = None ):
+        super().__init__(parent, invokingStateNumber)
+        #* If we are debugging or building a parse tree for a visitor,
+        #  we need to track all of the tokens and rule invocations associated
+        #  with this rule's context. This is empty for parsing w/o tree constr.
+        #  operation because we don't the need to track the details about
+        #  how we parse this rule.
+        #/
+        self.children = None
+        self.start = None
+        self.stop = None
+        # The exception that forced this rule to return. If the rule successfully
+        # completed, this is {@code null}.
+        self.exception = None
+
+    #* COPY a ctx (I'm deliberately not using copy constructor)#/
+    #
+    # This is used in the generated parser code to flip a generic XContext
+    # node for rule X to a YContext for alt label Y. In that sense, it is
+    # not really a generic copy function.
+    #
+    # If we do an error sync() at start of a rule, we might add error nodes
+    # to the generic XContext so this function must copy those nodes to
+    # the YContext as well else they are lost!
+    #/
+    def copyFrom(self, ctx:ParserRuleContext):
+        # from RuleContext
+        self.parentCtx = ctx.parentCtx
+        self.invokingState = ctx.invokingState
+        self.children = None
+        self.start = ctx.start
+        self.stop = ctx.stop
+
+        # copy any error nodes to alt label node
+        if ctx.children is not None:
+            self.children = []
+            # reset parent pointer for any error nodes
+            for child in ctx.children:
+                if isinstance(child, ErrorNodeImpl):
+                    self.children.append(child)
+                    child.parentCtx = self
+
+    # Double dispatch methods for listeners
+    def enterRule(self, listener:ParseTreeListener):
+        pass
+
+    def exitRule(self, listener:ParseTreeListener):
+        pass
+
+    #* Does not set parent link; other add methods do that#/
+    def addChild(self, child:ParseTree):
+        if self.children is None:
+            self.children = []
+        self.children.append(child)
+        return child
+
+    #* Used by enterOuterAlt to toss out a RuleContext previously added as
+    #  we entered a rule. If we have # label, we will need to remove
+    #  generic ruleContext object.
+    #/
+    def removeLastChild(self):
+        if self.children is not None:
+            del self.children[len(self.children)-1]
+
+    def addTokenNode(self, token:Token):
+        node = TerminalNodeImpl(token)
+        self.addChild(node)
+        node.parentCtx = self
+        return node
+
+    def addErrorNode(self, badToken:Token):
+        node = ErrorNodeImpl(badToken)
+        self.addChild(node)
+        node.parentCtx = self
+        return node
+
+    def getChild(self, i:int, ttype:type = None):
+        if ttype is None:
+            return self.children[i] if len(self.children)>i else None
+        else:
+            for child in self.getChildren():
+                if not isinstance(child, ttype):
+                    continue
+                if i==0:
+                    return child
+                i -= 1
+            return None
+
+    def getChildren(self, predicate = None):
+        if self.children is not None:
+            for child in self.children:
+                if predicate is not None and not predicate(child):
+                    continue
+                yield child
+
+    def getToken(self, ttype:int, i:int):
+        for child in self.getChildren():
+            if not isinstance(child, TerminalNode):
+                continue
+            if child.symbol.type != ttype:
+                continue
+            if i==0:
+                return child
+            i -= 1
+        return None
+
+    def getTokens(self, ttype:int ):
+        if self.getChildren() is None:
+            return []
+        tokens = []
+        for child in self.getChildren():
+            if not isinstance(child, TerminalNode):
+                continue
+            if child.symbol.type != ttype:
+                continue
+            tokens.append(child)
+        return tokens
+
+    def getTypedRuleContext(self, ctxType:type, i:int):
+        return self.getChild(i, ctxType)
+
+    def getTypedRuleContexts(self, ctxType:type):
+        children = self.getChildren()
+        if children is None:
+            return []
+        contexts = []
+        for child in children:
+            if not isinstance(child, ctxType):
+                continue
+            contexts.append(child)
+        return contexts
+
+    def getChildCount(self):
+        return len(self.children) if self.children else 0
+
+    def getSourceInterval(self):
+        if self.start is None or self.stop is None:
+            return INVALID_INTERVAL
+        else:
+            return (self.start.tokenIndex, self.stop.tokenIndex)
+
+
+RuleContext.EMPTY = ParserRuleContext()
+
+class InterpreterRuleContext(ParserRuleContext):
+
+    def __init__(self, parent:ParserRuleContext, invokingStateNumber:int, ruleIndex:int):
+        super().__init__(parent, invokingStateNumber)
+        self.ruleIndex = ruleIndex