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

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

@@ -1,28 +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/TextChunk.h"
-
-using namespace antlr4::tree::pattern;
-
-TextChunk::TextChunk(const std::string &text) : text(text) {
-  if (text == "") {
-    throw IllegalArgumentException("text cannot be nul");
-  }
-
-}
-
-TextChunk::~TextChunk() {
-}
-
-std::string TextChunk::getText() {
-  return text;
-}
-
-std::string TextChunk::toString() {
-  return std::string("'") + text + std::string("'");
-}

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

@@ -1,51 +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 "Chunk.h"
-
-namespace antlr4 {
-namespace tree {
-namespace pattern {
-
-  /// <summary>
-  /// Represents a span of raw text (concrete syntax) between tags in a tree
-  /// pattern string.
-  /// </summary>
-  class ANTLR4CPP_PUBLIC TextChunk : public Chunk {
-  private:
-    /// <summary>
-    /// This is the backing field for <seealso cref="#getText"/>.
-    /// </summary>
-    const std::string text;
-
-    /// <summary>
-    /// Constructs a new instance of <seealso cref="TextChunk"/> with the specified text.
-    /// </summary>
-    /// <param name="text"> The text of this chunk. </param>
-    /// <exception cref="IllegalArgumentException"> if {@code text} is {@code null}. </exception>
-  public:
-    TextChunk(const std::string &text);
-    virtual ~TextChunk();
-
-    /// <summary>
-    /// Gets the raw text of this chunk.
-    /// </summary>
-    /// <returns> The text of the chunk. </returns>
-    std::string getText();
-
-    /// <summary>
-    /// {@inheritDoc}
-    /// <p/>
-    /// The implementation for <seealso cref="TextChunk"/> returns the result of
-    /// <seealso cref="#getText()"/> in single quotes.
-    /// </summary>
-    virtual std::string toString() override;
-  };
-
-} // namespace pattern
-} // namespace tree
-} // namespace antlr4

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

@@ -1,36 +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/TokenTagToken.h"
-
-using namespace antlr4::tree::pattern;
-
-TokenTagToken::TokenTagToken(const std::string &/*tokenName*/, int type)
-  : CommonToken(type), tokenName(""), label("") {
-}
-
-TokenTagToken::TokenTagToken(const std::string &tokenName, int type, const std::string &label)
-  : CommonToken(type), tokenName(tokenName), label(label) {
-}
-
-std::string TokenTagToken::getTokenName() const {
-  return tokenName;
-}
-
-std::string TokenTagToken::getLabel() const {
-  return label;
-}
-
-std::string TokenTagToken::getText() const {
-  if (!label.empty()) {
-    return "<" + label + ":" + tokenName + ">";
-  }
-
-  return "<" + tokenName + ">";
-}
-
-std::string TokenTagToken::toString() const {
-  return tokenName + ":" + std::to_string(_type);
-}

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

@@ -1,80 +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 "CommonToken.h"
-
-namespace antlr4 {
-namespace tree {
-namespace pattern {
-
-  /// <summary>
-  /// A <seealso cref="Token"/> object representing a token of a particular type; e.g.,
-  /// {@code <ID>}. These tokens are created for <seealso cref="TagChunk"/> chunks where the
-  /// tag corresponds to a lexer rule or token type.
-  /// </summary>
-  class ANTLR4CPP_PUBLIC TokenTagToken : public CommonToken {
-    /// <summary>
-    /// This is the backing field for <seealso cref="#getTokenName"/>.
-    /// </summary>
-  private:
-    const std::string tokenName;
-    /// <summary>
-    /// This is the backing field for <seealso cref="#getLabe"/>.
-    /// </summary>
-    const std::string label;
-
-    /// <summary>
-    /// Constructs a new instance of <seealso cref="TokenTagToken"/> for an unlabeled tag
-    /// with the specified token name and type.
-    /// </summary>
-    /// <param name="tokenName"> The token name. </param>
-    /// <param name="type"> The token type. </param>
-  public:
-    TokenTagToken(const std::string &tokenName, int type); //this(tokenName, type, nullptr);
-
-    /// <summary>
-    /// Constructs a new instance of <seealso cref="TokenTagToken"/> with the specified
-    /// token name, type, and label.
-    /// </summary>
-    /// <param name="tokenName"> The token name. </param>
-    /// <param name="type"> The token type. </param>
-    /// <param name="label"> The label associated with the token tag, or {@code null} if
-    /// the token tag is unlabeled. </param>
-    TokenTagToken(const std::string &tokenName, int type, const std::string &label);
-
-    /// <summary>
-    /// Gets the token name. </summary>
-    /// <returns> The token name. </returns>
-    std::string getTokenName() const;
-
-    /// <summary>
-    /// Gets the label associated with the rule tag.
-    /// </summary>
-    /// <returns> The name of the label associated with the rule tag, or
-    /// {@code null} if this is an unlabeled rule tag. </returns>
-    std::string getLabel() const;
-
-    /// <summary>
-    /// {@inheritDoc}
-    /// <p/>
-    /// The implementation for <seealso cref="TokenTagToken"/> returns the token tag
-    /// formatted with {@code <} and {@code >} delimiters.
-    /// </summary>
-    virtual std::string getText() const override;
-
-    /// <summary>
-    /// {@inheritDoc}
-    /// <p/>
-    /// The implementation for <seealso cref="TokenTagToken"/> returns a string of the form
-    /// {@code tokenName:type}.
-    /// </summary>
-    virtual std::string toString() const override;
-  };
-
-} // namespace pattern
-} // namespace tree
-} // namespace antlr4

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

@@ -1,154 +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 "XPathLexer.h"
-#include "XPathLexerErrorListener.h"
-#include "XPathElement.h"
-#include "XPathWildcardAnywhereElement.h"
-#include "XPathWildcardElement.h"
-#include "XPathTokenAnywhereElement.h"
-#include "XPathTokenElement.h"
-#include "XPathRuleAnywhereElement.h"
-#include "XPathRuleElement.h"
-
-#include "XPath.h"
-
-using namespace antlr4;
-using namespace antlr4::tree;
-using namespace antlr4::tree::xpath;
-
-const std::string XPath::WILDCARD = "*";
-const std::string XPath::NOT = "!";
-
-XPath::XPath(Parser *parser, const std::string &path) {
-  _parser = parser;
-  _path = path;
-}
-
-std::vector<std::unique_ptr<XPathElement>> XPath::split(const std::string &path) {
-  ANTLRInputStream in(path);
-  XPathLexer lexer(&in);
-  lexer.removeErrorListeners();
-  XPathLexerErrorListener listener;
-  lexer.addErrorListener(&listener);
-  CommonTokenStream tokenStream(&lexer);
-  try {
-    tokenStream.fill();
-  } catch (LexerNoViableAltException &) {
-    size_t pos = lexer.getCharPositionInLine();
-    std::string msg = "Invalid tokens or characters at index " + std::to_string(pos) + " in path '" + path + "'";
-    throw IllegalArgumentException(msg);
-  }
-
-  std::vector<Token *> tokens = tokenStream.getTokens();
-  std::vector<std::unique_ptr<XPathElement>> elements;
-  size_t n = tokens.size();
-  size_t i = 0;
-  bool done = false;
-  while (!done && i < n) {
-    Token *el = tokens[i];
-    Token *next = nullptr;
-    switch (el->getType()) {
-      case XPathLexer::ROOT:
-      case XPathLexer::ANYWHERE: {
-        bool anywhere = el->getType() == XPathLexer::ANYWHERE;
-        i++;
-        next = tokens[i];
-        bool invert = next->getType() == XPathLexer::BANG;
-        if (invert) {
-          i++;
-          next = tokens[i];
-        }
-        std::unique_ptr<XPathElement> pathElement = getXPathElement(next, anywhere);
-        pathElement->setInvert(invert);
-        elements.push_back(std::move(pathElement));
-        i++;
-        break;
-
-      }
-      case XPathLexer::TOKEN_REF:
-      case XPathLexer::RULE_REF:
-      case XPathLexer::WILDCARD:
-        elements.push_back(getXPathElement(el, false));
-        i++;
-        break;
-
-      case Token::EOF:
-        done = true;
-        break;
-
-      default :
-        throw IllegalArgumentException("Unknown path element " + el->toString());
-    }
-  }
-
-  return elements;
-}
-
-std::unique_ptr<XPathElement> XPath::getXPathElement(Token *wordToken, bool anywhere) {
-  if (wordToken->getType() == Token::EOF) {
-    throw IllegalArgumentException("Missing path element at end of path");
-  }
-
-  std::string word = wordToken->getText();
-  size_t ttype = _parser->getTokenType(word);
-  ssize_t ruleIndex = _parser->getRuleIndex(word);
-  switch (wordToken->getType()) {
-    case XPathLexer::WILDCARD :
-      if (anywhere)
-        return std::unique_ptr<XPathWildcardAnywhereElement>(new XPathWildcardAnywhereElement());
-      return std::unique_ptr<XPathWildcardElement>(new XPathWildcardElement());
-
-    case XPathLexer::TOKEN_REF:
-    case XPathLexer::STRING :
-      if (ttype == Token::INVALID_TYPE) {
-        throw IllegalArgumentException(word + " at index " + std::to_string(wordToken->getStartIndex()) + " isn't a valid token name");
-      }
-      if (anywhere)
-        return std::unique_ptr<XPathTokenAnywhereElement>(new XPathTokenAnywhereElement(word, (int)ttype));
-      return std::unique_ptr<XPathTokenElement>(new XPathTokenElement(word, (int)ttype));
-
-    default :
-      if (ruleIndex == -1) {
-        throw IllegalArgumentException(word + " at index " + std::to_string(wordToken->getStartIndex()) + " isn't a valid rule name");
-      }
-      if (anywhere)
-        return std::unique_ptr<XPathRuleAnywhereElement>(new XPathRuleAnywhereElement(word, (int)ruleIndex));
-      return std::unique_ptr<XPathRuleElement>(new XPathRuleElement(word, (int)ruleIndex));
-  }
-}
-
-static ParserRuleContext dummyRoot;
-
-std::vector<ParseTree *> XPath::findAll(ParseTree *tree, std::string const& xpath, Parser *parser) {
-  XPath p(parser, xpath);
-  return p.evaluate(tree);
-}
-
-std::vector<ParseTree *> XPath::evaluate(ParseTree *t) {
-  dummyRoot.children = { t }; // don't set t's parent.
-
-  std::vector<ParseTree *> work = { &dummyRoot };
-
-  size_t i = 0;
-  std::vector<std::unique_ptr<XPathElement>> elements = split(_path);
-
-  while (i < elements.size()) {
-    std::vector<ParseTree *> next;
-    for (auto node : work) {
-      if (!node->children.empty()) {
-        // only try to match next element if it has children
-        // e.g., //func/*/stat might have a token node for which
-        // we can't go looking for stat nodes.
-        auto matching = elements[i]->evaluate(node);
-        next.insert(next.end(), matching.begin(), matching.end());
-      }
-    }
-    i++;
-    work = next;
-  }
-
-  return work;
-}

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

@@ -1,86 +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 xpath {
-
-  /// Represent a subset of XPath XML path syntax for use in identifying nodes in
-  /// parse trees.
-  ///
-  /// <para>
-  /// Split path into words and separators {@code /} and {@code //} via ANTLR
-  /// itself then walk path elements from left to right. At each separator-word
-  /// pair, find set of nodes. Next stage uses those as work list.</para>
-  ///
-  /// <para>
-  /// The basic interface is
-  /// <seealso cref="XPath#findAll ParseTree.findAll"/>{@code (tree, pathString, parser)}.
-  /// But that is just shorthand for:</para>
-  ///
-  /// <pre>
-  /// <seealso cref="XPath"/> p = new <seealso cref="XPath#XPath XPath"/>(parser, pathString);
-  /// return p.<seealso cref="#evaluate evaluate"/>(tree);
-  /// </pre>
-  ///
-  /// <para>
-  /// See {@code org.antlr.v4.test.TestXPath} for descriptions. In short, this
-  /// allows operators:</para>
-  ///
-  /// <dl>
-  /// <dt>/</dt> <dd>root</dd>
-  /// <dt>//</dt> <dd>anywhere</dd>
-  /// <dt>!</dt> <dd>invert; this must appear directly after root or anywhere
-  /// operator</dd>
-  /// </dl>
-  ///
-  /// <para>
-  /// and path elements:</para>
-  ///
-  /// <dl>
-  /// <dt>ID</dt> <dd>token name</dd>
-  /// <dt>'string'</dt> <dd>any string literal token from the grammar</dd>
-  /// <dt>expr</dt> <dd>rule name</dd>
-  /// <dt>*</dt> <dd>wildcard matching any node</dd>
-  /// </dl>
-  ///
-  /// <para>
-  /// Whitespace is not allowed.</para>
-
-  class ANTLR4CPP_PUBLIC XPath {
-  public:
-    static const std::string WILDCARD; // word not operator/separator
-    static const std::string NOT; // word for invert operator
-
-    XPath(Parser *parser, const std::string &path);
-    virtual ~XPath() {}
-
-    // TODO: check for invalid token/rule names, bad syntax
-    virtual std::vector<std::unique_ptr<XPathElement>> split(const std::string &path);
-
-    static std::vector<ParseTree *> findAll(ParseTree *tree, std::string const& xpath, Parser *parser);
-
-    /// Return a list of all nodes starting at {@code t} as root that satisfy the
-    /// path. The root {@code /} is relative to the node passed to
-    /// <seealso cref="#evaluate"/>.
-    virtual std::vector<ParseTree *> evaluate(ParseTree *t);
-
-  protected:
-    std::string _path;
-    Parser *_parser;
-
-    /// Convert word like {@code *} or {@code ID} or {@code expr} to a path
-    /// element. {@code anywhere} is {@code true} if {@code //} precedes the
-    /// word.
-    virtual std::unique_ptr<XPathElement> getXPathElement(Token *wordToken, bool anywhere);
-  };
-
-} // namespace xpath
-} // namespace tree
-} // namespace antlr4

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

@@ -1,31 +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 "support/CPPUtils.h"
-
-#include "XPathElement.h"
-
-using namespace antlr4::tree;
-using namespace antlr4::tree::xpath;
-
-XPathElement::XPathElement(const std::string &nodeName) {
-  _nodeName = nodeName;
-}
-
-XPathElement::~XPathElement() {
-}
-
-std::vector<ParseTree *> XPathElement::evaluate(ParseTree * /*t*/) {
-  return {};
-}
-
-std::string XPathElement::toString() const {
-  std::string inv = _invert ? "!" : "";
-  return antlrcpp::toString(*this) + "[" + inv + _nodeName + "]";
-}
-
-void XPathElement::setInvert(bool value) {
-  _invert = value;
-}