expressir 0.2.4-x64-mingw32 → 0.2.10-x64-mingw32

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

@@ -1,33 +0,0 @@
-/* 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

@@ -1,241 +0,0 @@
-/* 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

@@ -1,78 +0,0 @@
-/* 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

@@ -1,9 +0,0 @@
-/* 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

@@ -1,44 +0,0 @@
-/* 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

@@ -1,69 +0,0 @@
-/* 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";
-  }
-}