text: # 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
  from antlr4.tree.Trees import Trees
  from antlr4.atn.ATN import ATN
  
  class RuleContext(RuleNode):
  
      EMPTY = None
  
      def __init__(self, parent=None, invokingState=-1):
          super(RuleContext, self).__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 u""
          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 ATN.INVALID_ALT_NUMBER
  
  	# 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):
          pass
  
      def getChild(self, i):
          return None
  
      def getChildCount(self):
          return 0
  
      def getChildren(self):
          for c in []:
              yield c
  
      def accept(self, visitor):
          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=None, recog=None):
          return Trees.toStringTree(self, ruleNames=ruleNames, recog=recog)
      #  }
      #
      #  @Override
      #  public String toStringTree() {
      #      return toStringTree((List<String>)null);
      #  }
      #
      def __unicode__(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, stop):
          with StringIO() as buf:
              p = self
              buf.write(u"[")
              while p is not None and p is not stop:
                  if ruleNames is None:
                      if not p.isEmpty():
                          buf.write(unicode(p.invokingState))
                  else:
                      ri = p.getRuleIndex()
                      ruleName = ruleNames[ri] if ri >= 0 and ri < len(ruleNames) else unicode(ri)
                      buf.write(ruleName)
  
                  if p.parentCtx is not None and (ruleNames is not None or not p.parentCtx.isEmpty()):
                      buf.write(u" ")
  
                  p = p.parentCtx
  
              buf.write(u"]")
              return buf.getvalue()
  
  