expressir 1.4.3 → 2.1.0

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

@@ -1,77 +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/RuleTagToken.h"
-
-using namespace antlr4::tree::pattern;
-
-RuleTagToken::RuleTagToken(const std::string &/*ruleName*/, int _bypassTokenType) : bypassTokenType(_bypassTokenType) {
-}
-
-RuleTagToken::RuleTagToken(const std::string &ruleName, size_t bypassTokenType, const std::string &label)
-  : ruleName(ruleName), bypassTokenType(bypassTokenType), label(label) {
-  if (ruleName.empty()) {
-    throw IllegalArgumentException("ruleName cannot be null or empty.");
-  }
-
-}
-
-std::string RuleTagToken::getRuleName() const {
-  return ruleName;
-}
-
-std::string RuleTagToken::getLabel() const {
-  return label;
-}
-
-size_t RuleTagToken::getChannel() const {
-  return DEFAULT_CHANNEL;
-}
-
-std::string RuleTagToken::getText() const {
-  if (label != "") {
-    return std::string("<") + label + std::string(":") + ruleName + std::string(">");
-  }
-
-  return std::string("<") + ruleName + std::string(">");
-}
-
-size_t RuleTagToken::getType() const {
-  return bypassTokenType;
-}
-
-size_t RuleTagToken::getLine() const {
-  return 0;
-}
-
-size_t RuleTagToken::getCharPositionInLine() const {
-  return INVALID_INDEX;
-}
-
-size_t RuleTagToken::getTokenIndex() const {
-  return INVALID_INDEX;
-}
-
-size_t RuleTagToken::getStartIndex() const {
-  return INVALID_INDEX;
-}
-
-size_t RuleTagToken::getStopIndex() const {
-  return INVALID_INDEX;
-}
-
-antlr4::TokenSource *RuleTagToken::getTokenSource() const {
-  return nullptr;
-}
-
-antlr4::CharStream *RuleTagToken::getInputStream() const {
-  return nullptr;
-}
-
-std::string RuleTagToken::toString() const {
-  return ruleName + ":" + std::to_string(bypassTokenType);
-}

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

@@ -1,117 +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 "Token.h"
-
-namespace antlr4 {
-namespace tree {
-namespace pattern {
-
-  /// <summary>
-  /// A <seealso cref="Token"/> object representing an entire subtree matched by a parser
-  /// rule; e.g., {@code <expr>}. These tokens are created for <seealso cref="TagChunk"/>
-  /// chunks where the tag corresponds to a parser rule.
-  /// </summary>
-  class ANTLR4CPP_PUBLIC RuleTagToken : public Token {
-    /// <summary>
-    /// This is the backing field for <seealso cref="#getRuleName"/>.
-    /// </summary>
-  private:
-    const std::string ruleName;
-
-    /// The token type for the current token. This is the token type assigned to
-    /// the bypass alternative for the rule during ATN deserialization.
-    const size_t bypassTokenType;
-
-    /// This is the backing field for <seealso cref="#getLabe"/>.
-    const std::string label;
-
-  public:
-    /// <summary>
-    /// Constructs a new instance of <seealso cref="RuleTagToken"/> with the specified rule
-    /// name and bypass token type and no label.
-    /// </summary>
-    /// <param name="ruleName"> The name of the parser rule this rule tag matches. </param>
-    /// <param name="bypassTokenType"> The bypass token type assigned to the parser rule.
-    /// </param>
-    /// <exception cref="IllegalArgumentException"> if {@code ruleName} is {@code null}
-    /// or empty. </exception>
-    RuleTagToken(const std::string &ruleName, int bypassTokenType); //this(ruleName, bypassTokenType, nullptr);
-
-    /// <summary>
-    /// Constructs a new instance of <seealso cref="RuleTagToken"/> with the specified rule
-    /// name, bypass token type, and label.
-    /// </summary>
-    /// <param name="ruleName"> The name of the parser rule this rule tag matches. </param>
-    /// <param name="bypassTokenType"> The bypass token type assigned to the parser rule. </param>
-    /// <param name="label"> The label associated with the rule tag, or {@code null} if
-    /// the rule tag is unlabeled.
-    /// </param>
-    /// <exception cref="IllegalArgumentException"> if {@code ruleName} is {@code null}
-    /// or empty. </exception>
-    RuleTagToken(const std::string &ruleName, size_t bypassTokenType, const std::string &label);
-
-    /// <summary>
-    /// Gets the name of the rule associated with this rule tag.
-    /// </summary>
-    /// <returns> The name of the parser rule associated with this rule tag. </returns>
-    std::string getRuleName() 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/>
-    /// Rule tag tokens are always placed on the <seealso cref="#DEFAULT_CHANNE"/>.
-    /// </summary>
-    virtual size_t getChannel() const override;
-
-    /// <summary>
-    /// {@inheritDoc}
-    /// <p/>
-    /// This method returns the rule tag formatted with {@code <} and {@code >}
-    /// delimiters.
-    /// </summary>
-    virtual std::string getText() const override;
-
-    /// Rule tag tokens have types assigned according to the rule bypass
-    /// transitions created during ATN deserialization.
-    virtual size_t getType() const override;
-
-    /// The implementation for <seealso cref="RuleTagToken"/> always returns 0.
-    virtual size_t getLine() const override;
-
-    /// The implementation for <seealso cref="RuleTagToken"/> always returns INVALID_INDEX.
-    virtual size_t getCharPositionInLine() const override;
-
-    /// The implementation for <seealso cref="RuleTagToken"/> always returns INVALID_INDEX.
-    virtual size_t getTokenIndex() const override;
-
-    /// The implementation for <seealso cref="RuleTagToken"/> always returns INVALID_INDEX.
-    virtual size_t getStartIndex() const override;
-
-    /// The implementation for <seealso cref="RuleTagToken"/> always returns INVALID_INDEX.
-    virtual size_t getStopIndex() const override;
-
-    /// The implementation for <seealso cref="RuleTagToken"/> always returns {@code null}.
-    virtual TokenSource *getTokenSource() const override;
-
-    /// The implementation for <seealso cref="RuleTagToken"/> always returns {@code null}.
-    virtual CharStream *getInputStream() const override;
-
-    /// The implementation for <seealso cref="RuleTagToken"/> returns a string of the form {@code ruleName:bypassTokenType}.
-    virtual std::string toString() const override;
-  };
-
-} // namespace pattern
-} // namespace tree
-} // namespace antlr4

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

@@ -1,39 +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/TagChunk.h"
-
-using namespace antlr4::tree::pattern;
-
-TagChunk::TagChunk(const std::string &tag) : TagChunk("", tag) {
-}
-
-TagChunk::TagChunk(const std::string &label, const std::string &tag) : _tag(tag), _label(label) {
-  if (tag.empty()) {
-    throw IllegalArgumentException("tag cannot be null or empty");
-  }
-
-}
-
-TagChunk::~TagChunk() {
-}
-
-std::string TagChunk::getTag() {
-  return _tag;
-}
-
-std::string TagChunk::getLabel() {
-  return _label;
-}
-
-std::string TagChunk::toString() {
-  if (!_label.empty()) {
-    return _label + ":" + _tag;
-  }
-
-  return _tag;
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/pattern/TagChunk.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 "Chunk.h"
-
-namespace antlr4 {
-namespace tree {
-namespace pattern {
-
-  /// <summary>
-  /// Represents a placeholder tag in a tree pattern. A tag can have any of the
-  /// following forms.
-  ///
-  /// <ul>
-  /// <li>{@code expr}: An unlabeled placeholder for a parser rule {@code expr}.</li>
-  /// <li>{@code ID}: An unlabeled placeholder for a token of type {@code ID}.</li>
-  /// <li>{@code e:expr}: A labeled placeholder for a parser rule {@code expr}.</li>
-  /// <li>{@code id:ID}: A labeled placeholder for a token of type {@code ID}.</li>
-  /// </ul>
-  ///
-  /// This class does not perform any validation on the tag or label names aside
-  /// from ensuring that the tag is a non-null, non-empty string.
-  /// </summary>
-  class ANTLR4CPP_PUBLIC TagChunk : public Chunk {
-  public:
-    /// <summary>
-    /// Construct a new instance of <seealso cref="TagChunk"/> using the specified tag and
-    /// no label.
-    /// </summary>
-    /// <param name="tag"> The tag, which should be the name of a parser rule or token
-    /// type.
-    /// </param>
-    /// <exception cref="IllegalArgumentException"> if {@code tag} is {@code null} or
-    /// empty. </exception>
-    TagChunk(const std::string &tag);
-    virtual ~TagChunk();
-
-    /// <summary>
-    /// Construct a new instance of <seealso cref="TagChunk"/> using the specified label
-    /// and tag.
-    /// </summary>
-    /// <param name="label"> The label for the tag. If this is {@code null}, the
-    /// <seealso cref="TagChunk"/> represents an unlabeled tag. </param>
-    /// <param name="tag"> The tag, which should be the name of a parser rule or token
-    /// type.
-    /// </param>
-    /// <exception cref="IllegalArgumentException"> if {@code tag} is {@code null} or
-    /// empty. </exception>
-    TagChunk(const std::string &label, const std::string &tag);
-
-    /// <summary>
-    /// Get the tag for this chunk.
-    /// </summary>
-    /// <returns> The tag for the chunk. </returns>
-    std::string getTag();
-
-    /// <summary>
-    /// Get the label, if any, assigned to this chunk.
-    /// </summary>
-    /// <returns> The label assigned to this chunk, or {@code null} if no label is
-    /// assigned to the chunk. </returns>
-    std::string getLabel();
-
-    /// <summary>
-    /// 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.
-    /// </summary>
-    virtual std::string toString() override;
-
-  private:
-    /// This is the backing field for <seealso cref="#getTag"/>.
-    const std::string _tag;
-    /// <summary>
-    /// This is the backing field for <seealso cref="#getLabe"/>.
-    /// </summary>
-    const std::string _label;
-  };
-
-} // namespace pattern
-} // namespace tree
-} // namespace antlr4

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