expressir 0.2.4 → 0.2.5

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/TerminalNodeImpl.h

@@ -0,0 +1,33 @@
+/* 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.
+ */
+
+#pragma once
+
+#include "tree/TerminalNode.h"
+
+namespace antlr4 {
+namespace tree {
+
+  class ANTLR4CPP_PUBLIC TerminalNodeImpl : public virtual TerminalNode {
+  public:
+    Token *symbol;
+
+    TerminalNodeImpl(Token *symbol);
+
+    virtual Token* getSymbol() override;
+    virtual void setParent(RuleContext *parent) override;
+    virtual misc::Interval getSourceInterval() override;
+
+    virtual antlrcpp::Any accept(ParseTreeVisitor *visitor) override;
+
+    virtual std::string getText() override;
+    virtual std::string toStringTree(Parser *parser, bool pretty = false) override;
+    virtual std::string toString() override;
+    virtual std::string toStringTree(bool pretty = false) override;
+
+  };
+
+} // namespace tree
+} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/Trees.cpp

@@ -0,0 +1,241 @@
+/* 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/ErrorNode.h"
+#include "Parser.h"
+#include "ParserRuleContext.h"
+#include "support/CPPUtils.h"
+#include "tree/TerminalNodeImpl.h"
+#include "atn/ATN.h"
+#include "misc/Interval.h"
+#include "Token.h"
+#include "CommonToken.h"
+#include "misc/Predicate.h"
+
+#include "tree/Trees.h"
+
+using namespace antlr4;
+using namespace antlr4::misc;
+using namespace antlr4::tree;
+
+using namespace antlrcpp;
+
+Trees::Trees() {
+}
+
+std::string Trees::toStringTree(ParseTree *t, bool pretty) {
+  return toStringTree(t, nullptr, pretty);
+}
+
+std::string Trees::toStringTree(ParseTree *t, Parser *recog, bool pretty) {
+  if (recog == nullptr)
+    return toStringTree(t, std::vector<std::string>(), pretty);
+  return toStringTree(t, recog->getRuleNames(), pretty);
+}
+
+std::string Trees::toStringTree(ParseTree *t, const std::vector<std::string> &ruleNames, bool pretty) {
+  std::string temp = antlrcpp::escapeWhitespace(Trees::getNodeText(t, ruleNames), false);
+  if (t->children.empty()) {
+    return temp;
+  }
+
+  std::stringstream ss;
+  ss << "(" << temp << ' ';
+
+  // Implement the recursive walk as iteration to avoid trouble with deep nesting.
+  std::stack<size_t> stack;
+  size_t childIndex = 0;
+  ParseTree *run = t;
+  size_t indentationLevel = 1;
+  while (childIndex < run->children.size()) {
+    if (childIndex > 0) {
+      ss << ' ';
+    }
+    ParseTree *child = run->children[childIndex];
+    temp = antlrcpp::escapeWhitespace(Trees::getNodeText(child, ruleNames), false);
+    if (!child->children.empty()) {
+      // Go deeper one level.
+      stack.push(childIndex);
+      run = child;
+      childIndex = 0;
+      if (pretty) {
+        ++indentationLevel;
+        ss << std::endl;
+        for (size_t i = 0; i < indentationLevel; ++i) {
+          ss << "    ";
+        }
+      }
+      ss << "(" << temp << " ";
+    } else {
+      ss << temp;
+      while (++childIndex == run->children.size()) {
+        if (stack.size() > 0) {
+          // Reached the end of the current level. See if we can step up from here.
+          childIndex = stack.top();
+          stack.pop();
+          run = run->parent;
+          if (pretty) {
+            --indentationLevel;
+          }
+          ss << ")";
+        } else {
+          break;
+        }
+      }
+    }
+  }
+
+  ss << ")";
+  return ss.str();
+}
+
+std::string Trees::getNodeText(ParseTree *t, Parser *recog) {
+  return getNodeText(t, recog->getRuleNames());
+}
+
+std::string Trees::getNodeText(ParseTree *t, const std::vector<std::string> &ruleNames) {
+  if (ruleNames.size() > 0) {
+    if (is<RuleContext *>(t)) {
+      size_t ruleIndex = dynamic_cast<RuleContext *>(t)->getRuleIndex();
+      std::string ruleName = ruleNames[ruleIndex];
+      size_t altNumber = dynamic_cast<RuleContext *>(t)->getAltNumber();
+      if (altNumber != atn::ATN::INVALID_ALT_NUMBER) {
+        return ruleName + ":" + std::to_string(altNumber);
+      }
+      return ruleName;
+    } else if (is<ErrorNode *>(t)) {
+      return t->toString();
+    } else if (is<TerminalNode *>(t)) {
+      Token *symbol = dynamic_cast<TerminalNode *>(t)->getSymbol();
+      if (symbol != nullptr) {
+        std::string s = symbol->getText();
+        return s;
+      }
+    }
+  }
+  // no recog for rule names
+  if (is<RuleContext *>(t)) {
+    return dynamic_cast<RuleContext *>(t)->getText();
+  }
+
+  if (is<TerminalNodeImpl *>(t)) {
+    return dynamic_cast<TerminalNodeImpl *>(t)->getSymbol()->getText();
+  }
+
+  return "";
+}
+
+std::vector<ParseTree *> Trees::getAncestors(ParseTree *t) {
+  std::vector<ParseTree *> ancestors;
+  ParseTree *parent = t->parent;
+  while (parent != nullptr) {
+    ancestors.insert(ancestors.begin(), parent); // insert at start
+    parent = parent->parent;
+  }
+  return ancestors;
+}
+
+template<typename T>
+static void _findAllNodes(ParseTree *t, size_t index, bool findTokens, std::vector<T> &nodes) {
+  // check this node (the root) first
+  if (findTokens && is<TerminalNode *>(t)) {
+    TerminalNode *tnode = dynamic_cast<TerminalNode *>(t);
+    if (tnode->getSymbol()->getType() == index) {
+      nodes.push_back(t);
+    }
+  } else if (!findTokens && is<ParserRuleContext *>(t)) {
+    ParserRuleContext *ctx = dynamic_cast<ParserRuleContext *>(t);
+    if (ctx->getRuleIndex() == index) {
+      nodes.push_back(t);
+    }
+  }
+  // check children
+  for (size_t i = 0; i < t->children.size(); i++) {
+    _findAllNodes(t->children[i], index, findTokens, nodes);
+  }
+}
+
+bool Trees::isAncestorOf(ParseTree *t, ParseTree *u) {
+  if (t == nullptr || u == nullptr || t->parent == nullptr) {
+    return false;
+  }
+
+  ParseTree *p = u->parent;
+  while (p != nullptr) {
+    if (t == p) {
+      return true;
+    }
+    p = p->parent;
+  }
+  return false;
+}
+
+std::vector<ParseTree *> Trees::findAllTokenNodes(ParseTree *t, size_t ttype) {
+  return findAllNodes(t, ttype, true);
+}
+
+std::vector<ParseTree *> Trees::findAllRuleNodes(ParseTree *t, size_t ruleIndex) {
+  return findAllNodes(t, ruleIndex, false);
+}
+
+std::vector<ParseTree *> Trees::findAllNodes(ParseTree *t, size_t index, bool findTokens) {
+  std::vector<ParseTree *> nodes;
+  _findAllNodes<ParseTree *>(t, index, findTokens, nodes);
+  return nodes;
+}
+
+std::vector<ParseTree *> Trees::getDescendants(ParseTree *t) {
+  std::vector<ParseTree *> nodes;
+  nodes.push_back(t);
+  std::size_t n = t->children.size();
+  for (size_t i = 0 ; i < n ; i++) {
+    auto descentants = getDescendants(t->children[i]);
+    for (auto entry: descentants) {
+      nodes.push_back(entry);
+    }
+  }
+  return nodes;
+}
+
+std::vector<ParseTree *> Trees::descendants(ParseTree *t) {
+  return getDescendants(t);
+}
+
+ParserRuleContext* Trees::getRootOfSubtreeEnclosingRegion(ParseTree *t, size_t startTokenIndex, size_t stopTokenIndex) {
+  size_t n = t->children.size();
+  for (size_t i = 0; i < n; i++) {
+    ParserRuleContext *r = getRootOfSubtreeEnclosingRegion(t->children[i], startTokenIndex, stopTokenIndex);
+    if (r != nullptr) {
+      return r;
+    }
+  }
+
+  if (is<ParserRuleContext *>(t)) {
+    ParserRuleContext *r = dynamic_cast<ParserRuleContext *>(t);
+    if (startTokenIndex >= r->getStart()->getTokenIndex() && // is range fully contained in t?
+        (r->getStop() == nullptr || stopTokenIndex <= r->getStop()->getTokenIndex())) {
+      // note: r.getStop()==null likely implies that we bailed out of parser and there's nothing to the right
+      return r;
+    }
+  }
+  return nullptr;
+}
+
+ParseTree * Trees::findNodeSuchThat(ParseTree *t, Ref<Predicate> const& pred) {
+  if (pred->test(t)) {
+    return t;
+  }
+
+  size_t n = t->children.size();
+  for (size_t i = 0 ; i < n ; ++i) {
+    ParseTree *u = findNodeSuchThat(t->children[i], pred);
+    if (u != nullptr) {
+      return u;
+    }
+  }
+
+  return nullptr;
+}
+

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/Trees.h

@@ -0,0 +1,78 @@
+/* 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.
+ */
+
+#pragma once
+
+#include "tree/TerminalNode.h"
+#include "ParserRuleContext.h"
+#include "Recognizer.h"
+
+namespace antlr4 {
+namespace tree {
+
+  /// A set of utility routines useful for all kinds of ANTLR trees.
+  class ANTLR4CPP_PUBLIC Trees {
+  public:
+    /// Print out a whole tree in LISP form. getNodeText is used on the
+    /// node payloads to get the text for the nodes.  Detect
+    /// parse trees and extract data appropriately.
+    static std::string toStringTree(ParseTree *t, bool pretty = false);
+
+    /// Print out a whole tree in LISP form. getNodeText is used on the
+    ///  node payloads to get the text for the nodes.  Detect
+    ///  parse trees and extract data appropriately.
+    static std::string toStringTree(ParseTree *t, Parser *recog, bool pretty = false);
+
+    /// Print out a whole tree in LISP form. getNodeText is used on the
+    /// node payloads to get the text for the nodes.  Detect
+    /// parse trees and extract data appropriately.
+    static std::string toStringTree(ParseTree *t, const std::vector<std::string> &ruleNames, bool pretty = false);
+    static std::string getNodeText(ParseTree *t, Parser *recog);
+    static std::string getNodeText(ParseTree *t, const std::vector<std::string> &ruleNames);
+
+    /// Return a list of all ancestors of this node.  The first node of
+    ///  list is the root and the last is the parent of this node.
+    static std::vector<ParseTree *> getAncestors(ParseTree *t);
+
+    /** Return true if t is u's parent or a node on path to root from u.
+     *  Use == not equals().
+     *
+     *  @since 4.5.1
+     */
+    static bool isAncestorOf(ParseTree *t, ParseTree *u);
+    static std::vector<ParseTree *> findAllTokenNodes(ParseTree *t, size_t ttype);
+    static std::vector<ParseTree *> findAllRuleNodes(ParseTree *t, size_t ruleIndex);
+    static std::vector<ParseTree *> findAllNodes(ParseTree *t, size_t index, bool findTokens);
+
+    /** Get all descendents; includes t itself.
+     *
+     * @since 4.5.1
+     */
+    static std::vector<ParseTree *> getDescendants(ParseTree *t);
+
+    /** @deprecated */
+    static std::vector<ParseTree *> descendants(ParseTree *t);
+
+    /** Find smallest subtree of t enclosing range startTokenIndex..stopTokenIndex
+     *  inclusively using postorder traversal.  Recursive depth-first-search.
+     *
+     *  @since 4.5.1
+     */
+    static ParserRuleContext* getRootOfSubtreeEnclosingRegion(ParseTree *t,
+                                                              size_t startTokenIndex, // inclusive
+                                                              size_t stopTokenIndex); // inclusive
+
+    /** Return first node satisfying the pred
+     *
+     *  @since 4.5.1
+     */
+    static ParseTree* findNodeSuchThat(ParseTree *t, Ref<misc::Predicate> const& pred);
+
+  private:
+    Trees();
+  };
+
+} // namespace tree
+} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/pattern/Chunk.cpp

@@ -0,0 +1,9 @@
+/* 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/pattern/Chunk.h"
+
+antlr4::tree::pattern::Chunk::~Chunk() {
+}

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/pattern/Chunk.h

@@ -0,0 +1,44 @@
+/* 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.
+ */
+
+#pragma once
+
+#include "antlr4-common.h"
+
+namespace antlr4 {
+namespace tree {
+namespace pattern {
+
+  /// <summary>
+  /// A chunk is either a token tag, a rule tag, or a span of literal text within a
+  /// tree pattern.
+  /// <p/>
+  /// The method <seealso cref="ParseTreePatternMatcher#split(String)"/> returns a list of
+  /// chunks in preparation for creating a token stream by
+  /// <seealso cref="ParseTreePatternMatcher#tokenize(String)"/>. From there, we get a parse
+  /// tree from with <seealso cref="ParseTreePatternMatcher#compile(String, int)"/>. These
+  /// chunks are converted to <seealso cref="RuleTagToken"/>, <seealso cref="TokenTagToken"/>, or the
+  /// regular tokens of the text surrounding the tags.
+  /// </summary>
+  class ANTLR4CPP_PUBLIC Chunk {
+  public:
+    Chunk() = default;
+    Chunk(Chunk const&) = default;
+    virtual ~Chunk();
+
+    Chunk& operator=(Chunk const&) = default;
+
+    /// This method returns a text representation of the tag chunk. Labeled tags
+    /// are returned in the form {@code label:tag}, and unlabeled tags are
+    /// returned as just the tag name.
+    virtual std::string toString() {
+      std::string str;
+      return str;
+    }
+  };
+
+} // namespace pattern
+} // namespace tree
+} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/pattern/ParseTreeMatch.cpp

@@ -0,0 +1,69 @@
+/* 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 "Exceptions.h"
+
+#include "tree/pattern/ParseTreeMatch.h"
+
+using namespace antlr4::tree;
+using namespace antlr4::tree::pattern;
+
+ParseTreeMatch::ParseTreeMatch(ParseTree *tree, const ParseTreePattern &pattern,
+                               const std::map<std::string, std::vector<ParseTree *>> &labels,
+                               ParseTree *mismatchedNode)
+  : _tree(tree), _pattern(pattern), _labels(labels), _mismatchedNode(mismatchedNode) {
+  if (tree == nullptr) {
+    throw IllegalArgumentException("tree cannot be nul");
+  }
+}
+
+ParseTreeMatch::~ParseTreeMatch() {
+}
+
+ParseTree* ParseTreeMatch::get(const std::string &label) {
+  auto iterator = _labels.find(label);
+  if (iterator == _labels.end() || iterator->second.empty()) {
+    return nullptr;
+  }
+
+  return iterator->second.back(); // return last if multiple
+}
+
+std::vector<ParseTree *> ParseTreeMatch::getAll(const std::string &label) {
+  auto iterator = _labels.find(label);
+  if (iterator == _labels.end()) {
+    return {};
+  }
+
+  return iterator->second;
+}
+
+std::map<std::string, std::vector<ParseTree *>>& ParseTreeMatch::getLabels() {
+  return _labels;
+}
+
+ParseTree *ParseTreeMatch::getMismatchedNode() {
+  return _mismatchedNode;
+}
+
+bool ParseTreeMatch::succeeded() {
+  return _mismatchedNode == nullptr;
+}
+
+const ParseTreePattern& ParseTreeMatch::getPattern() {
+  return _pattern;
+}
+
+ParseTree * ParseTreeMatch::getTree() {
+  return _tree;
+}
+
+std::string ParseTreeMatch::toString() {
+  if (succeeded()) {
+    return "Match succeeded; found " + std::to_string(_labels.size()) + " labels";
+  } else {
+    return "Match failed; found " + std::to_string(_labels.size()) + " labels";
+  }
+}