expressir 1.4.3 → 2.1.0

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/Recognizer.h

@@ -1,160 +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 "ProxyErrorListener.h"
-#include "support/Casts.h"
-#include "atn/SerializedATNView.h"
-#include "internal/Synchronization.h"
-
-namespace antlr4 {
-
-  class ANTLR4CPP_PUBLIC Recognizer {
-  public:
-    static constexpr size_t EOF = std::numeric_limits<size_t>::max();
-
-    Recognizer();
-    Recognizer(Recognizer const&) = delete;
-    virtual ~Recognizer();
-
-    Recognizer& operator=(Recognizer const&) = delete;
-
-    virtual std::vector<std::string> const& getRuleNames() const = 0;
-
-    /**
-     * Get the vocabulary used by the recognizer.
-     *
-     * @return A {@link Vocabulary} instance providing information about the
-     * vocabulary used by the grammar.
-     */
-    virtual dfa::Vocabulary const& getVocabulary() const = 0;
-
-    /// <summary>
-    /// Get a map from token names to token types.
-    /// <p/>
-    /// Used for XPath and tree pattern compilation.
-    /// </summary>
-    virtual std::map<std::string_view, size_t> getTokenTypeMap();
-
-    /// <summary>
-    /// Get a map from rule names to rule indexes.
-    /// <p/>
-    /// Used for XPath and tree pattern compilation.
-    /// </summary>
-    virtual std::map<std::string, size_t> getRuleIndexMap();
-
-    virtual size_t getTokenType(std::string_view tokenName);
-
-    /// <summary>
-    /// If this recognizer was generated, it will have a serialized ATN
-    /// representation of the grammar.
-    /// <p/>
-    /// For interpreters, we don't know their serialized ATN despite having
-    /// created the interpreter from it.
-    /// </summary>
-    virtual atn::SerializedATNView getSerializedATN() const {
-      throw "there is no serialized ATN";
-    }
-
-    /// <summary>
-    /// For debugging and other purposes, might want the grammar name.
-    ///  Have ANTLR generate an implementation for this method.
-    /// </summary>
-    virtual std::string getGrammarFileName() const = 0;
-
-    /// Get the ATN interpreter (in fact one of it's descendants) used by the recognizer for prediction.
-    /// @returns The ATN interpreter used by the recognizer for prediction.
-    template <class T>
-    T* getInterpreter() const {
-      return antlrcpp::downCast<T *>(_interpreter);
-    }
-
-    /**
-     * Set the ATN interpreter used by the recognizer for prediction.
-     *
-     * @param interpreter The ATN interpreter used by the recognizer for
-     * prediction.
-     */
-    void setInterpreter(atn::ATNSimulator *interpreter);
-
-    /// What is the error header, normally line/character position information?
-    virtual std::string getErrorHeader(RecognitionException *e);
-
-    /** How should a token be displayed in an error message? The default
-     *  is to display just the text, but during development you might
-     *  want to have a lot of information spit out.  Override in that case
-     *  to use t.toString() (which, for CommonToken, dumps everything about
-     *  the token). This is better than forcing you to override a method in
-     *  your token objects because you don't have to go modify your lexer
-     *  so that it creates a new Java type.
-     *
-     * @deprecated This method is not called by the ANTLR 4 Runtime. Specific
-     * implementations of {@link ANTLRErrorStrategy} may provide a similar
-     * feature when necessary. For example, see
-     * {@link DefaultErrorStrategy#getTokenErrorDisplay}.
-     */
-    virtual std::string getTokenErrorDisplay(Token *t);
-
-    /// <exception cref="NullPointerException"> if {@code listener} is {@code null}. </exception>
-    virtual void addErrorListener(ANTLRErrorListener *listener);
-
-    virtual void removeErrorListener(ANTLRErrorListener *listener);
-
-    virtual void removeErrorListeners();
-
-    virtual ProxyErrorListener& getErrorListenerDispatch();
-
-    // subclass needs to override these if there are sempreds or actions
-    // that the ATN interp needs to execute
-    virtual bool sempred(RuleContext *localctx, size_t ruleIndex, size_t actionIndex);
-
-    virtual bool precpred(RuleContext *localctx, int precedence);
-
-    virtual void action(RuleContext *localctx, size_t ruleIndex, size_t actionIndex);
-
-    size_t getState() const { return _stateNumber; }
-
-    // Get the ATN used by the recognizer for prediction.
-    virtual const atn::ATN& getATN() const = 0;
-
-    /// <summary>
-    /// Indicate that the recognizer has changed internal state that is
-    ///  consistent with the ATN state passed in.  This way we always know
-    ///  where we are in the ATN as the parser goes along. The rule
-    ///  context objects form a stack that lets us see the stack of
-    ///  invoking rules. Combine this and we have complete ATN
-    ///  configuration information.
-    /// </summary>
-    void setState(size_t atnState) { _stateNumber = atnState; }
-
-    virtual IntStream* getInputStream() = 0;
-
-    virtual void setInputStream(IntStream *input) = 0;
-
-    virtual TokenFactory<CommonToken>* getTokenFactory() = 0;
-
-    template<typename T1>
-    void setTokenFactory(TokenFactory<T1> *input);
-
-  protected:
-    atn::ATNSimulator *_interpreter; // Set and deleted in descendants (or the profiler).
-
-    // Mutex to manage synchronized access for multithreading.
-    internal::Mutex _mutex;
-
-  private:
-    static std::map<const dfa::Vocabulary*, std::map<std::string_view, size_t>> _tokenTypeMapCache;
-    static std::map<std::vector<std::string>, std::map<std::string, size_t>> _ruleIndexMapCache;
-
-    ProxyErrorListener _proxListener; // Manages a collection of listeners.
-
-    size_t _stateNumber;
-
-    void InitializeInstanceFields();
-
-  };
-
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/RuleContext.cpp

@@ -1,144 +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/Trees.h"
-#include "misc/Interval.h"
-#include "Parser.h"
-#include "atn/ATN.h"
-#include "atn/ATNState.h"
-#include "tree/ParseTreeVisitor.h"
-
-#include "RuleContext.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlr4::tree;
-
-RuleContext::RuleContext() : ParseTree(ParseTreeType::RULE) {
-  InitializeInstanceFields();
-}
-
-RuleContext::RuleContext(RuleContext *parent_, size_t invokingState_) : ParseTree(ParseTreeType::RULE) {
-  InitializeInstanceFields();
-  this->parent = parent_;
-  this->invokingState = invokingState_;
-}
-
-int RuleContext::depth() {
-  int n = 1;
-  RuleContext *p = this;
-  while (true) {
-    if (p->parent == nullptr)
-      break;
-    p = static_cast<RuleContext *>(p->parent);
-    n++;
-  }
-  return n;
-}
-
-bool RuleContext::isEmpty() {
-  return invokingState == ATNState::INVALID_STATE_NUMBER;
-}
-
-misc::Interval RuleContext::getSourceInterval() {
-  return misc::Interval::INVALID;
-}
-
-std::string RuleContext::getText() {
-  if (children.empty()) {
-    return "";
-  }
-
-  std::stringstream ss;
-  for (size_t i = 0; i < children.size(); i++) {
-    ParseTree *tree = children[i];
-    if (tree != nullptr)
-      ss << tree->getText();
-  }
-
-  return ss.str();
-}
-
-size_t RuleContext::getRuleIndex() const {
-  return INVALID_INDEX;
-}
-
-size_t RuleContext::getAltNumber() const {
-  return atn::ATN::INVALID_ALT_NUMBER;
-}
-
-void RuleContext::setAltNumber(size_t /*altNumber*/) {
-}
-
-std::any RuleContext::accept(tree::ParseTreeVisitor *visitor) {
-  return visitor->visitChildren(this);
-}
-
-std::string RuleContext::toStringTree(Parser *recog, bool pretty) {
-  return tree::Trees::toStringTree(this, recog, pretty);
-}
-
-std::string RuleContext::toStringTree(std::vector<std::string> &ruleNames, bool pretty) {
-  return tree::Trees::toStringTree(this, ruleNames, pretty);
-}
-
-std::string RuleContext::toStringTree(bool pretty) {
-  return toStringTree(nullptr, pretty);
-}
-
-
-std::string RuleContext::toString(const std::vector<std::string> &ruleNames) {
-  return toString(ruleNames, nullptr);
-}
-
-
-std::string RuleContext::toString(const std::vector<std::string> &ruleNames, RuleContext *stop) {
-  std::stringstream ss;
-
-  RuleContext *currentParent = this;
-  ss << "[";
-  while (currentParent != stop) {
-    if (ruleNames.empty()) {
-      if (!currentParent->isEmpty()) {
-        ss << currentParent->invokingState;
-      }
-    } else {
-      size_t ruleIndex = currentParent->getRuleIndex();
-
-      std::string ruleName = (ruleIndex < ruleNames.size()) ? ruleNames[ruleIndex] : std::to_string(ruleIndex);
-      ss << ruleName;
-    }
-
-    if (currentParent->parent == nullptr) // No parent anymore.
-      break;
-    currentParent = static_cast<RuleContext *>(currentParent->parent);
-    if (!ruleNames.empty() || !currentParent->isEmpty()) {
-      ss << " ";
-    }
-  }
-
-  ss << "]";
-
-  return ss.str();
-}
-
-std::string RuleContext::toString() {
-  return toString(nullptr);
-}
-
-std::string RuleContext::toString(Recognizer *recog) {
-  return toString(recog, &ParserRuleContext::EMPTY);
-}
-
-std::string RuleContext::toString(Recognizer *recog, RuleContext *stop) {
-  if (recog == nullptr)
-    return toString(std::vector<std::string>(), stop); // Don't use an initializer {} here or we end up calling ourselve recursivly.
-  return toString(recog->getRuleNames(), stop);
-}
-
-void RuleContext::InitializeInstanceFields() {
-  invokingState = INVALID_INDEX;
-}
-

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/RuleContext.h

@@ -1,141 +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/ParseTree.h"
-
-namespace antlr4 {
-
-  /** A rule context is a record of a single rule invocation.
-   *
-   *  We form a stack of these context objects using the parent
-   *  pointer. A parent pointer of null indicates that the current
-   *  context is the bottom of the stack. The ParserRuleContext subclass
-   *  as a children list so that we can turn this data structure into a
-   *  tree.
-   *
-   *  The root node always has a null pointer and invokingState of -1.
-   *
-   *  Upon entry to parsing, the first invoked rule function creates a
-   *  context object (asubclass specialized for that rule such as
-   *  SContext) and makes it the root of a parse tree, recorded by field
-   *  Parser._ctx.
-   *
-   *  public final SContext s() throws RecognitionException {
-   *      SContext _localctx = new SContext(_ctx, getState()); <-- create new node
-   *      enterRule(_localctx, 0, RULE_s);                     <-- push it
-   *      ...
-   *      exitRule();                                          <-- pop back to _localctx
-   *      return _localctx;
-   *  }
-   *
-   *  A subsequent rule invocation of r from the start rule s pushes a
-   *  new context object for r whose parent points at s and use invoking
-   *  state is the state with r emanating as edge label.
-   *
-   *  The invokingState fields from a context object to the root
-   *  together form a stack of rule indication states where the root
-   *  (bottom of the stack) has a -1 sentinel value. If we invoke start
-   *  symbol s then call r1, which calls r2, the  would look like
-   *  this:
-   *
-   *     SContext[-1]   <- root node (bottom of the stack)
-   *     R1Context[p]   <- p in rule s called r1
-   *     R2Context[q]   <- q in rule r1 called r2
-   *
-   *  So the top of the stack, _ctx, represents a call to the current
-   *  rule and it holds the return address from another rule that invoke
-   *  to this rule. To invoke a rule, we must always have a current context.
-   *
-   *  The parent contexts are useful for computing lookahead sets and
-   *  getting error information.
-   *
-   *  These objects are used during parsing and prediction.
-   *  For the special case of parsers, we use the subclass
-   *  ParserRuleContext.
-   *
-   *  @see ParserRuleContext
-   */
-  class ANTLR4CPP_PUBLIC RuleContext : public tree::ParseTree {
-  public:
-    static bool is(const tree::ParseTree &parseTree) { return parseTree.getTreeType() == tree::ParseTreeType::RULE; }
-
-    static bool is(const tree::ParseTree *parseTree) { return parseTree != nullptr && is(*parseTree); }
-
-    /// What state invoked the rule associated with this context?
-    /// The "return address" is the followState of invokingState
-    /// If parent is null, this should be -1 and this context object represents the start rule.
-    size_t invokingState;
-
-    RuleContext();
-    RuleContext(RuleContext *parent, size_t invokingState);
-
-    virtual int depth();
-
-    /// A context is empty if there is no invoking state; meaning nobody called current context.
-    virtual bool isEmpty();
-
-    // satisfy the ParseTree / SyntaxTree interface
-
-    virtual misc::Interval getSourceInterval() override;
-
-    virtual std::string getText() override;
-
-    virtual size_t getRuleIndex() const;
-
-    /** For rule associated with this parse tree internal node, return
-     *  the outer alternative number used to match the input. Default
-     *  implementation does not compute nor store this alt num. Create
-     *  a subclass of ParserRuleContext with backing field and set
-     *  option contextSuperClass.
-     *  to set it.
-     *
-     *  @since 4.5.3
-     */
-    virtual size_t getAltNumber() const;
-
-    /** Set the outer alternative number for this context node. Default
-     *  implementation does nothing to avoid backing field overhead for
-     *  trees that don't need it.  Create
-     *  a subclass of ParserRuleContext with backing field and set
-     *  option contextSuperClass.
-     *
-     *  @since 4.5.3
-     */
-    virtual void setAltNumber(size_t altNumber);
-
-    virtual std::any accept(tree::ParseTreeVisitor *visitor) override;
-
-    /// <summary>
-    /// Print out a whole tree, not just a node, in LISP format
-    ///  (root child1 .. childN). Print just a node if this is a leaf.
-    ///  We have to know the recognizer so we can get rule names.
-    /// </summary>
-    virtual std::string toStringTree(Parser *recog, bool pretty = false) override;
-
-    /// <summary>
-    /// Print out a whole tree, not just a node, in LISP format
-    ///  (root child1 .. childN). Print just a node if this is a leaf.
-    /// </summary>
-    virtual std::string toStringTree(std::vector<std::string> &ruleNames, bool pretty = false);
-
-    virtual std::string toStringTree(bool pretty = false) override;
-    virtual std::string toString() override;
-    std::string toString(Recognizer *recog);
-    std::string toString(const std::vector<std::string> &ruleNames);
-
-    // recog null unless ParserRuleContext, in which case we use subclass toString(...)
-    std::string toString(Recognizer *recog, RuleContext *stop);
-
-    virtual std::string toString(const std::vector<std::string> &ruleNames, RuleContext *stop);
-
-    bool operator == (const RuleContext &other) { return this == &other; } // Simple address comparison.
-
-  private:
-    void InitializeInstanceFields();
-  };
-
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/RuleContextWithAltNum.cpp

@@ -1,27 +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 "atn/ATN.h"
-
-#include "RuleContextWithAltNum.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-
-RuleContextWithAltNum::RuleContextWithAltNum() : ParserRuleContext() {
-  altNum = ATN::INVALID_ALT_NUMBER;
-}
-
-RuleContextWithAltNum::RuleContextWithAltNum(ParserRuleContext *parent, int invokingStateNumber)
-  : ParserRuleContext(parent, invokingStateNumber) {
-}
-
-size_t RuleContextWithAltNum::getAltNumber() const {
-  return altNum;
-}
-
-void RuleContextWithAltNum::setAltNumber(size_t number) {
-  altNum = number;
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/RuleContextWithAltNum.h

@@ -1,32 +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 "ParserRuleContext.h"
-
-namespace antlr4 {
-
-  /// A handy class for use with
-  ///
-  ///  options {contextSuperClass=org.antlr.v4.runtime.RuleContextWithAltNum;}
-  ///
-  ///  that provides a backing field / impl for the outer alternative number
-  ///  matched for an internal parse tree node.
-  ///
-  ///  I'm only putting into Java runtime as I'm certain I'm the only one that
-  ///  will really every use this.
-  class ANTLR4CPP_PUBLIC RuleContextWithAltNum : public ParserRuleContext {
-  public:
-    size_t altNum = 0;
-
-    RuleContextWithAltNum();
-    RuleContextWithAltNum(ParserRuleContext *parent, int invokingStateNumber);
-
-    virtual size_t getAltNumber() const override;
-    virtual void setAltNumber(size_t altNum) override;
-  };
-
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/RuntimeMetaData.cpp

@@ -1,54 +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 "RuntimeMetaData.h"
-#include "Version.h"
-
-using namespace antlr4;
-
-const std::string RuntimeMetaData::VERSION = ANTLRCPP_VERSION_STRING;
-
-std::string RuntimeMetaData::getRuntimeVersion() {
-  return VERSION;
-}
-
-void RuntimeMetaData::checkVersion(const std::string &generatingToolVersion, const std::string &compileTimeVersion) {
-  std::string runtimeVersion = VERSION;
-  bool runtimeConflictsWithGeneratingTool = false;
-  bool runtimeConflictsWithCompileTimeTool = false;
-
-  if (generatingToolVersion != "") {
-    runtimeConflictsWithGeneratingTool = runtimeVersion != generatingToolVersion
-      && getMajorMinorVersion(runtimeVersion) != getMajorMinorVersion(generatingToolVersion);
-  }
-
-  runtimeConflictsWithCompileTimeTool = runtimeVersion != compileTimeVersion
-    && getMajorMinorVersion(runtimeVersion) != getMajorMinorVersion(compileTimeVersion);
-
-  if (runtimeConflictsWithGeneratingTool) {
-    std::cerr << "ANTLR Tool version " << generatingToolVersion << " used for code generation does not match "
-      "the current runtime version " << runtimeVersion << std::endl;
-  }
-  if (runtimeConflictsWithCompileTimeTool) {
-    std::cerr << "ANTLR Runtime version " << compileTimeVersion << " used for parser compilation does not match "
-      "the current runtime version " << runtimeVersion << std::endl;
-  }
-}
-
-std::string RuntimeMetaData::getMajorMinorVersion(const std::string &version) {
-  size_t firstDot = version.find('.');
-  size_t secondDot = firstDot != std::string::npos ? version.find('.', firstDot + 1) : std::string::npos;
-  size_t firstDash = version.find('-');
-  size_t referenceLength = version.size();
-  if (secondDot != std::string::npos) {
-    referenceLength = std::min(referenceLength, secondDot);
-  }
-
-  if (firstDash != std::string::npos) {
-    referenceLength = std::min(referenceLength, firstDash);
-  }
-
-  return version.substr(0, referenceLength);
-}