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

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

@@ -1,185 +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 "Exceptions.h"
-
-namespace antlr4 {
-namespace tree {
-namespace pattern {
-
-  /// <summary>
-  /// A tree pattern matching mechanism for ANTLR <seealso cref="ParseTree"/>s.
-  /// <p/>
-  /// Patterns are strings of source input text with special tags representing
-  /// token or rule references such as:
-  /// <p/>
-  /// {@code <ID> = <expr>;}
-  /// <p/>
-  /// Given a pattern start rule such as {@code statement}, this object constructs
-  /// a <seealso cref="ParseTree"/> with placeholders for the {@code ID} and {@code expr}
-  /// subtree. Then the <seealso cref="#match"/> routines can compare an actual
-  /// <seealso cref="ParseTree"/> from a parse with this pattern. Tag {@code <ID>} matches
-  /// any {@code ID} token and tag {@code <expr>} references the result of the
-  /// {@code expr} rule (generally an instance of {@code ExprContext}.
-  /// <p/>
-  /// Pattern {@code x = 0;} is a similar pattern that matches the same pattern
-  /// except that it requires the identifier to be {@code x} and the expression to
-  /// be {@code 0}.
-  /// <p/>
-  /// The <seealso cref="#matches"/> routines return {@code true} or {@code false} based
-  /// upon a match for the tree rooted at the parameter sent in. The
-  /// <seealso cref="#match"/> routines return a <seealso cref="ParseTreeMatch"/> object that
-  /// contains the parse tree, the parse tree pattern, and a map from tag name to
-  /// matched nodes (more below). A subtree that fails to match, returns with
-  /// <seealso cref="ParseTreeMatch#mismatchedNode"/> set to the first tree node that did not
-  /// match.
-  /// <p/>
-  /// For efficiency, you can compile a tree pattern in string form to a
-  /// <seealso cref="ParseTreePattern"/> object.
-  /// <p/>
-  /// See {@code TestParseTreeMatcher} for lots of examples.
-  /// <seealso cref="ParseTreePattern"/> has two static helper methods:
-  /// <seealso cref="ParseTreePattern#findAll"/> and <seealso cref="ParseTreePattern#match"/> that
-  /// are easy to use but not super efficient because they create new
-  /// <seealso cref="ParseTreePatternMatcher"/> objects each time and have to compile the
-  /// pattern in string form before using it.
-  /// <p/>
-  /// The lexer and parser that you pass into the <seealso cref="ParseTreePatternMatcher"/>
-  /// constructor are used to parse the pattern in string form. The lexer converts
-  /// the {@code <ID> = <expr>;} into a sequence of four tokens (assuming lexer
-  /// throws out whitespace or puts it on a hidden channel). Be aware that the
-  /// input stream is reset for the lexer (but not the parser; a
-  /// <seealso cref="ParserInterpreter"/> is created to parse the input.). Any user-defined
-  /// fields you have put into the lexer might get changed when this mechanism asks
-  /// it to scan the pattern string.
-  /// <p/>
-  /// Normally a parser does not accept token {@code <expr>} as a valid
-  /// {@code expr} but, from the parser passed in, we create a special version of
-  /// the underlying grammar representation (an <seealso cref="ATN"/>) that allows imaginary
-  /// tokens representing rules ({@code <expr>}) to match entire rules. We call
-  /// these <em>bypass alternatives</em>.
-  /// <p/>
-  /// Delimiters are {@code <} and {@code >}, with {@code \} as the escape string
-  /// by default, but you can set them to whatever you want using
-  /// <seealso cref="#setDelimiters"/>. You must escape both start and stop strings
-  /// {@code \<} and {@code \>}.
-  /// </summary>
-  class ANTLR4CPP_PUBLIC ParseTreePatternMatcher {
-  public:
-    class CannotInvokeStartRule : public RuntimeException {
-    public:
-      CannotInvokeStartRule(const RuntimeException &e);
-      ~CannotInvokeStartRule();
-    };
-
-    // Fixes https://github.com/antlr/antlr4/issues/413
-    // "Tree pattern compilation doesn't check for a complete parse"
-    class StartRuleDoesNotConsumeFullPattern : public RuntimeException {
-    public:
-      StartRuleDoesNotConsumeFullPattern() = default;
-      StartRuleDoesNotConsumeFullPattern(StartRuleDoesNotConsumeFullPattern const&) = default;
-      ~StartRuleDoesNotConsumeFullPattern();
-
-      StartRuleDoesNotConsumeFullPattern& operator=(StartRuleDoesNotConsumeFullPattern const&) = default;
-    };
-
-    /// Constructs a <seealso cref="ParseTreePatternMatcher"/> or from a <seealso cref="Lexer"/> and
-    /// <seealso cref="Parser"/> object. The lexer input stream is altered for tokenizing
-    /// the tree patterns. The parser is used as a convenient mechanism to get
-    /// the grammar name, plus token, rule names.
-    ParseTreePatternMatcher(Lexer *lexer, Parser *parser);
-    virtual ~ParseTreePatternMatcher();
-
-    /// <summary>
-    /// Set the delimiters used for marking rule and token tags within concrete
-    /// syntax used by the tree pattern parser.
-    /// </summary>
-    /// <param name="start"> The start delimiter. </param>
-    /// <param name="stop"> The stop delimiter. </param>
-    /// <param name="escapeLeft"> The escape sequence to use for escaping a start or stop delimiter.
-    /// </param>
-    /// <exception cref="IllegalArgumentException"> if {@code start} is {@code null} or empty. </exception>
-    /// <exception cref="IllegalArgumentException"> if {@code stop} is {@code null} or empty. </exception>
-    virtual void setDelimiters(const std::string &start, const std::string &stop, const std::string &escapeLeft);
-
-    /// <summary>
-    /// Does {@code pattern} matched as rule {@code patternRuleIndex} match {@code tree}? </summary>
-    virtual bool matches(ParseTree *tree, const std::string &pattern, int patternRuleIndex);
-
-    /// <summary>
-    /// Does {@code pattern} matched as rule patternRuleIndex match tree? Pass in a
-    ///  compiled pattern instead of a string representation of a tree pattern.
-    /// </summary>
-    virtual bool matches(ParseTree *tree, const ParseTreePattern &pattern);
-
-    /// <summary>
-    /// Compare {@code pattern} matched as rule {@code patternRuleIndex} against
-    /// {@code tree} and return a <seealso cref="ParseTreeMatch"/> object that contains the
-    /// matched elements, or the node at which the match failed.
-    /// </summary>
-    virtual ParseTreeMatch match(ParseTree *tree, const std::string &pattern, int patternRuleIndex);
-
-    /// <summary>
-    /// Compare {@code pattern} matched against {@code tree} and return a
-    /// <seealso cref="ParseTreeMatch"/> object that contains the matched elements, or the
-    /// node at which the match failed. Pass in a compiled pattern instead of a
-    /// string representation of a tree pattern.
-    /// </summary>
-    virtual ParseTreeMatch match(ParseTree *tree, const ParseTreePattern &pattern);
-
-    /// <summary>
-    /// For repeated use of a tree pattern, compile it to a
-    /// <seealso cref="ParseTreePattern"/> using this method.
-    /// </summary>
-    virtual ParseTreePattern compile(const std::string &pattern, int patternRuleIndex);
-
-    /// <summary>
-    /// Used to convert the tree pattern string into a series of tokens. The
-    /// input stream is reset.
-    /// </summary>
-    virtual Lexer* getLexer();
-
-    /// <summary>
-    /// Used to collect to the grammar file name, token names, rule names for
-    /// used to parse the pattern into a parse tree.
-    /// </summary>
-    virtual Parser* getParser();
-
-    // ---- SUPPORT CODE ----
-
-    virtual std::vector<std::unique_ptr<Token>> tokenize(const std::string &pattern);
-
-    /// Split "<ID> = <e:expr>;" into 4 chunks for tokenizing by tokenize().
-    virtual std::vector<Chunk> split(const std::string &pattern);
-
-  protected:
-    std::string _start;
-    std::string _stop;
-    std::string _escape; // e.g., \< and \> must escape BOTH!
-
-    /// Recursively walk {@code tree} against {@code patternTree}, filling
-    /// {@code match.}<seealso cref="ParseTreeMatch#labels labels"/>.
-    ///
-    /// <returns> the first node encountered in {@code tree} which does not match
-    /// a corresponding node in {@code patternTree}, or {@code null} if the match
-    /// was successful. The specific node returned depends on the matching
-    /// algorithm used by the implementation, and may be overridden. </returns>
-    virtual ParseTree* matchImpl(ParseTree *tree, ParseTree *patternTree, std::map<std::string, std::vector<ParseTree *>> &labels);
-
-    /// Is t <expr> subtree?
-    virtual RuleTagToken* getRuleTagToken(ParseTree *t);
-
-  private:
-    Lexer *_lexer;
-    Parser *_parser;
-
-    void InitializeInstanceFields();
-  };
-
-} // namespace pattern
-} // namespace tree
-} // namespace antlr4

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