Gecko [ klinikpearlcity.com ]

Name	Size	Permission	Date
atn	[ DIR ]	drwxr-xr-x	2026-05-04 18:19
dfa	[ DIR ]	drwxr-xr-x	2026-05-04 18:19
error	[ DIR ]	drwxr-xr-x	2026-05-04 18:19
tree	[ DIR ]	drwxr-xr-x	2026-05-04 18:19
xpath	[ DIR ]	drwxr-xr-x	2026-05-04 18:19
BufferedTokenStream.py	10.53 KB	-rw-r--r--	2026-03-24 06:27
CommonTokenFactory.py	2.06 KB	-rw-r--r--	2026-03-24 06:27
CommonTokenStream.py	2.71 KB	-rw-r--r--	2026-03-24 06:27
FileStream.py	868 B	-rw-r--r--	2026-03-24 06:27
InputStream.py	2.28 KB	-rw-r--r--	2026-03-24 06:27
IntervalSet.py	5.83 KB	-rw-r--r--	2026-03-24 06:27
LL1Analyzer.py	7.57 KB	-rw-r--r--	2026-03-24 06:27
Lexer.py	11.27 KB	-rw-r--r--	2026-03-24 06:27
ListTokenSource.py	5.23 KB	-rw-r--r--	2026-03-24 06:27
Parser.py	22.35 KB	-rw-r--r--	2026-03-24 06:27
ParserInterpreter.py	7.04 KB	-rw-r--r--	2026-03-24 06:27
ParserRuleContext.py	6.6 KB	-rw-r--r--	2026-03-24 06:27
PredictionContext.py	22.94 KB	-rw-r--r--	2026-03-24 06:27
Recognizer.py	5.26 KB	-rw-r--r--	2026-03-24 06:27
RuleContext.py	7.91 KB	-rw-r--r--	2026-03-24 06:27
StdinStream.py	303 B	-rw-r--r--	2026-03-24 06:27
Token.py	5.08 KB	-rw-r--r--	2026-03-24 06:27
TokenStreamRewriter.py	10.08 KB	-rw-r--r--	2026-03-24 06:27
Utils.py	931 B	-rw-r--r--	2026-03-24 06:27
__init__.py	1.1 KB	-rw-r--r--	2026-03-24 06:27
_pygrun.py	6.14 KB	-rw-r--r--	2026-03-24 06:27

Rename

# 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 antlr4.tree.Tree import RuleNode, INVALID_INTERVAL, ParseTreeVisitor
from antlr4.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()