Initial commit from sysy-main

antlr/antlr4-runtime-4.12.0/runtime/src/RuleContext.cpp

@@ -0,0 +1,144 @@
+/* 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.
+ */
+
+#include "tree/Trees.h"
+#include "misc/Interval.h"
+#include "Parser.h"
+#include "atn/ATN.h"
+#include "atn/ATNState.h"
+#include "tree/ParseTreeVisitor.h"
+
+#include "RuleContext.h"
+
+using namespace antlr4;
+using namespace antlr4::atn;
+using namespace antlr4::tree;
+
+RuleContext::RuleContext() : ParseTree(ParseTreeType::RULE) {
+  InitializeInstanceFields();
+}
+
+RuleContext::RuleContext(RuleContext *parent_, size_t invokingState_) : ParseTree(ParseTreeType::RULE) {
+  InitializeInstanceFields();
+  this->parent = parent_;
+  this->invokingState = invokingState_;
+}
+
+int RuleContext::depth() {
+  int n = 1;
+  RuleContext *p = this;
+  while (true) {
+    if (p->parent == nullptr)
+      break;
+    p = static_cast<RuleContext *>(p->parent);
+    n++;
+  }
+  return n;
+}
+
+bool RuleContext::isEmpty() {
+  return invokingState == ATNState::INVALID_STATE_NUMBER;
+}
+
+misc::Interval RuleContext::getSourceInterval() {
+  return misc::Interval::INVALID;
+}
+
+std::string RuleContext::getText() {
+  if (children.empty()) {
+    return "";
+  }
+
+  std::stringstream ss;
+  for (size_t i = 0; i < children.size(); i++) {
+    ParseTree *tree = children[i];
+    if (tree != nullptr)
+      ss << tree->getText();
+  }
+
+  return ss.str();
+}
+
+size_t RuleContext::getRuleIndex() const {
+  return INVALID_INDEX;
+}
+
+size_t RuleContext::getAltNumber() const {
+  return atn::ATN::INVALID_ALT_NUMBER;
+}
+
+void RuleContext::setAltNumber(size_t /*altNumber*/) {
+}
+
+std::any RuleContext::accept(tree::ParseTreeVisitor *visitor) {
+  return visitor->visitChildren(this);
+}
+
+std::string RuleContext::toStringTree(Parser *recog, bool pretty) {
+  return tree::Trees::toStringTree(this, recog, pretty);
+}
+
+std::string RuleContext::toStringTree(std::vector<std::string> &ruleNames, bool pretty) {
+  return tree::Trees::toStringTree(this, ruleNames, pretty);
+}
+
+std::string RuleContext::toStringTree(bool pretty) {
+  return toStringTree(nullptr, pretty);
+}
+
+
+std::string RuleContext::toString(const std::vector<std::string> &ruleNames) {
+  return toString(ruleNames, nullptr);
+}
+
+
+std::string RuleContext::toString(const std::vector<std::string> &ruleNames, RuleContext *stop) {
+  std::stringstream ss;
+
+  RuleContext *currentParent = this;
+  ss << "[";
+  while (currentParent != stop) {
+    if (ruleNames.empty()) {
+      if (!currentParent->isEmpty()) {
+        ss << currentParent->invokingState;
+      }
+    } else {
+      size_t ruleIndex = currentParent->getRuleIndex();
+
+      std::string ruleName = (ruleIndex < ruleNames.size()) ? ruleNames[ruleIndex] : std::to_string(ruleIndex);
+      ss << ruleName;
+    }
+
+    if (currentParent->parent == nullptr) // No parent anymore.
+      break;
+    currentParent = static_cast<RuleContext *>(currentParent->parent);
+    if (!ruleNames.empty() || !currentParent->isEmpty()) {
+      ss << " ";
+    }
+  }
+
+  ss << "]";
+
+  return ss.str();
+}
+
+std::string RuleContext::toString() {
+  return toString(nullptr);
+}
+
+std::string RuleContext::toString(Recognizer *recog) {
+  return toString(recog, &ParserRuleContext::EMPTY);
+}
+
+std::string RuleContext::toString(Recognizer *recog, RuleContext *stop) {
+  if (recog == nullptr)
+    return toString(std::vector<std::string>(), stop); // Don't use an initializer {} here or we end up calling ourselve recursivly.
+  return toString(recog->getRuleNames(), stop);
+}
+
+void RuleContext::InitializeInstanceFields() {
+  invokingState = INVALID_INDEX;
+}
+