expressir 1.4.2 → 2.0.0

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";
-  }
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/pattern/ParseTreeMatch.h

@@ -1,132 +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 {
-
-  /// Represents the result of matching a ParseTree against a tree pattern.
-  class ANTLR4CPP_PUBLIC ParseTreeMatch {
-  private:
-    /// This is the backing field for getTree().
-    ParseTree *_tree;
-
-    /// This is the backing field for getPattern().
-    const ParseTreePattern &_pattern;
-
-    /// This is the backing field for getLabels().
-    std::map<std::string, std::vector<ParseTree *>> _labels;
-
-    /// This is the backing field for getMismatchedNode().
-    ParseTree *_mismatchedNode;
-
-  public:
-    /// <summary>
-    /// Constructs a new instance of <seealso cref="ParseTreeMatch"/> from the specified
-    /// parse tree and pattern.
-    /// </summary>
-    /// <param name="tree"> The parse tree to match against the pattern. </param>
-    /// <param name="pattern"> The parse tree pattern. </param>
-    /// <param name="labels"> A mapping from label names to collections of
-    /// <seealso cref="ParseTree"/> objects located by the tree pattern matching process. </param>
-    /// <param name="mismatchedNode"> The first node which failed to match the tree
-    /// pattern during the matching process.
-    /// </param>
-    /// <exception cref="IllegalArgumentException"> if {@code tree} is {@code null} </exception>
-    /// <exception cref="IllegalArgumentException"> if {@code pattern} is {@code null} </exception>
-    /// <exception cref="IllegalArgumentException"> if {@code labels} is {@code null} </exception>
-    ParseTreeMatch(ParseTree *tree, ParseTreePattern const& pattern,
-                   const std::map<std::string, std::vector<ParseTree *>> &labels, ParseTree *mismatchedNode);
-    ParseTreeMatch(ParseTreeMatch const&) = default;
-    virtual ~ParseTreeMatch();
-
-    /// <summary>
-    /// Get the last node associated with a specific {@code label}.
-    /// <p/>
-    /// For example, for pattern {@code <id:ID>}, {@code get("id")} returns the
-    /// node matched for that {@code ID}. If more than one node
-    /// matched the specified label, only the last is returned. If there is
-    /// no node associated with the label, this returns {@code null}.
-    /// <p/>
-    /// Pattern tags like {@code <ID>} and {@code <expr>} without labels are
-    /// considered to be labeled with {@code ID} and {@code expr}, respectively.
-    /// </summary>
-    /// <param name="labe"> The label to check.
-    /// </param>
-    /// <returns> The last <seealso cref="ParseTree"/> to match a tag with the specified
-    /// label, or {@code null} if no parse tree matched a tag with the label. </returns>
-    virtual ParseTree* get(const std::string &label);
-
-    /// <summary>
-    /// Return all nodes matching a rule or token tag with the specified label.
-    /// <p/>
-    /// If the {@code label} is the name of a parser rule or token in the
-    /// grammar, the resulting list will contain both the parse trees matching
-    /// rule or tags explicitly labeled with the label and the complete set of
-    /// parse trees matching the labeled and unlabeled tags in the pattern for
-    /// the parser rule or token. For example, if {@code label} is {@code "foo"},
-    /// the result will contain <em>all</em> of the following.
-    ///
-    /// <ul>
-    /// <li>Parse tree nodes matching tags of the form {@code <foo:anyRuleName>} and
-    /// {@code <foo:AnyTokenName>}.</li>
-    /// <li>Parse tree nodes matching tags of the form {@code <anyLabel:foo>}.</li>
-    /// <li>Parse tree nodes matching tags of the form {@code <foo>}.</li>
-    /// </ul>
-    /// </summary>
-    /// <param name="labe"> The label.
-    /// </param>
-    /// <returns> A collection of all <seealso cref="ParseTree"/> nodes matching tags with
-    /// the specified {@code label}. If no nodes matched the label, an empty list
-    /// is returned. </returns>
-    virtual std::vector<ParseTree *> getAll(const std::string &label);
-
-    /// <summary>
-    /// Return a mapping from label &rarr; [list of nodes].
-    /// <p/>
-    /// The map includes special entries corresponding to the names of rules and
-    /// tokens referenced in tags in the original pattern. For additional
-    /// information, see the description of <seealso cref="#getAll(String)"/>.
-    /// </summary>
-    /// <returns> A mapping from labels to parse tree nodes. If the parse tree
-    /// pattern did not contain any rule or token tags, this map will be empty. </returns>
-    virtual std::map<std::string, std::vector<ParseTree *>>& getLabels();
-
-    /// <summary>
-    /// Get the node at which we first detected a mismatch.
-    /// </summary>
-    /// <returns> the node at which we first detected a mismatch, or {@code null}
-    /// if the match was successful. </returns>
-    virtual ParseTree* getMismatchedNode();
-
-    /// <summary>
-    /// Gets a value indicating whether the match operation succeeded.
-    /// </summary>
-    /// <returns> {@code true} if the match operation succeeded; otherwise,
-    /// {@code false}. </returns>
-    virtual bool succeeded();
-
-    /// <summary>
-    /// Get the tree pattern we are matching against.
-    /// </summary>
-    /// <returns> The tree pattern we are matching against. </returns>
-    virtual const ParseTreePattern& getPattern();
-
-    /// <summary>
-    /// Get the parse tree we are trying to match to a pattern.
-    /// </summary>
-    /// <returns> The <seealso cref="ParseTree"/> we are trying to match to a pattern. </returns>
-    virtual ParseTree* getTree();
-
-    virtual std::string toString();
-  };
-
-} // namespace pattern
-} // namespace tree
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/pattern/ParseTreePattern.cpp

@@ -1,64 +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/ParseTree.h"
-#include "tree/pattern/ParseTreePatternMatcher.h"
-#include "tree/pattern/ParseTreeMatch.h"
-
-#include "tree/xpath/XPath.h"
-#include "tree/xpath/XPathElement.h"
-
-#include "tree/pattern/ParseTreePattern.h"
-
-using namespace antlr4::tree;
-using namespace antlr4::tree::pattern;
-
-using namespace antlrcpp;
-
-ParseTreePattern::ParseTreePattern(ParseTreePatternMatcher *matcher, const std::string &pattern, int patternRuleIndex_,
-                                   ParseTree *patternTree)
-  : patternRuleIndex(patternRuleIndex_), _pattern(pattern), _patternTree(patternTree), _matcher(matcher) {
-}
-
-ParseTreePattern::~ParseTreePattern() {
-}
-
-ParseTreeMatch ParseTreePattern::match(ParseTree *tree) {
-  return _matcher->match(tree, *this);
-}
-
-bool ParseTreePattern::matches(ParseTree *tree) {
-  return _matcher->match(tree, *this).succeeded();
-}
-
-std::vector<ParseTreeMatch> ParseTreePattern::findAll(ParseTree *tree, const std::string &xpath) {
-  xpath::XPath finder(_matcher->getParser(), xpath);
-  std::vector<ParseTree *> subtrees = finder.evaluate(tree);
-  std::vector<ParseTreeMatch> matches;
-  for (auto *t : subtrees) {
-    ParseTreeMatch aMatch = match(t);
-    if (aMatch.succeeded()) {
-      matches.push_back(aMatch);
-    }
-  }
-  return matches;
-}
-
-
-ParseTreePatternMatcher *ParseTreePattern::getMatcher() const {
-  return _matcher;
-}
-
-std::string ParseTreePattern::getPattern() const {
-  return _pattern;
-}
-
-int ParseTreePattern::getPatternRuleIndex() const {
-  return patternRuleIndex;
-}
-
-ParseTree* ParseTreePattern::getPatternTree() const {
-  return _patternTree;
-}