expressir 0.2.5-x64-mingw32 → 0.2.7-x64-mingw32

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/ParserRuleContext.h

@@ -1,147 +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 "RuleContext.h"
-#include "support/CPPUtils.h"
-
-namespace antlr4 {
-
-  /// <summary>
-  /// A rule invocation record for parsing.
-  ///
-  ///  Contains all of the information about the current rule not stored in the
-  ///  RuleContext. It handles parse tree children list, Any ATN state
-  ///  tracing, and the default values available for rule invocatons:
-  ///  start, stop, rule index, current alt number.
-  ///
-  ///  Subclasses made for each rule and grammar track the parameters,
-  ///  return values, locals, and labels specific to that rule. These
-  ///  are the objects that are returned from rules.
-  ///
-  ///  Note text is not an actual field of a rule return value; it is computed
-  ///  from start and stop using the input stream's toString() method.  I
-  ///  could add a ctor to this so that we can pass in and store the input
-  ///  stream, but I'm not sure we want to do that.  It would seem to be undefined
-  ///  to get the .text property anyway if the rule matches tokens from multiple
-  ///  input streams.
-  ///
-  ///  I do not use getters for fields of objects that are used simply to
-  ///  group values such as this aggregate.  The getters/setters are there to
-  ///  satisfy the superclass interface.
-  /// </summary>
-  class ANTLR4CPP_PUBLIC ParserRuleContext : public RuleContext {
-  public:
-    static ParserRuleContext EMPTY;
-
-    /// <summary>
-    /// For debugging/tracing purposes, we want to track all of the nodes in
-    ///  the ATN traversed by the parser for a particular rule.
-    ///  This list indicates the sequence of ATN nodes used to match
-    ///  the elements of the children list. This list does not include
-    ///  ATN nodes and other rules used to match rule invocations. It
-    ///  traces the rule invocation node itself but nothing inside that
-    ///  other rule's ATN submachine.
-    ///
-    ///  There is NOT a one-to-one correspondence between the children and
-    ///  states list. There are typically many nodes in the ATN traversed
-    ///  for each element in the children list. For example, for a rule
-    ///  invocation there is the invoking state and the following state.
-    ///
-    ///  The parser setState() method updates field s and adds it to this list
-    ///  if we are debugging/tracing.
-    ///
-    ///  This does not trace states visited during prediction.
-    /// </summary>
-    //	public List<Integer> states;
-
-    Token *start;
-    Token *stop;
-
-    /// The exception that forced this rule to return. If the rule successfully
-    /// completed, this is "null exception pointer".
-    std::exception_ptr exception;
-
-    ParserRuleContext();
-    ParserRuleContext(ParserRuleContext *parent, size_t invokingStateNumber);
-    virtual ~ParserRuleContext() {}
-
-    /** COPY a ctx (I'm deliberately not using copy constructor) to avoid
-     *  confusion with creating node with parent. Does not copy children
-     *  (except error leaves).
-     */
-    virtual void copyFrom(ParserRuleContext *ctx);
-
-
-    // Double dispatch methods for listeners
-
-    virtual void enterRule(tree::ParseTreeListener *listener);
-    virtual void exitRule(tree::ParseTreeListener *listener);
-
-    /** Add a token leaf node child and force its parent to be this node. */
-    tree::TerminalNode* addChild(tree::TerminalNode *t);
-    RuleContext* addChild(RuleContext *ruleInvocation);
-
-    /// Used by enterOuterAlt to toss out a RuleContext previously added as
-    /// we entered a rule. If we have # label, we will need to remove
-    /// generic ruleContext object.
-    virtual void removeLastChild();
-
-    virtual tree::TerminalNode* getToken(size_t ttype, std::size_t i);
-
-    virtual std::vector<tree::TerminalNode *> getTokens(size_t ttype);
-
-    template<typename T>
-    T* getRuleContext(size_t i) {
-      if (children.empty()) {
-        return nullptr;
-      }
-
-      size_t j = 0; // what element have we found with ctxType?
-      for (auto &child : children) {
-        if (antlrcpp::is<T *>(child)) {
-          if (j++ == i) {
-            return dynamic_cast<T *>(child);
-          }
-        }
-      }
-      return nullptr;
-    }
-
-    template<typename T>
-    std::vector<T *> getRuleContexts() {
-      std::vector<T *> contexts;
-      for (auto child : children) {
-        if (antlrcpp::is<T *>(child)) {
-          contexts.push_back(dynamic_cast<T *>(child));
-        }
-      }
-
-      return contexts;
-    }
-
-    virtual misc::Interval getSourceInterval() override;
-
-    /**
-     * Get the initial token in this context.
-     * Note that the range from start to stop is inclusive, so for rules that do not consume anything
-     * (for example, zero length or error productions) this token may exceed stop.
-     */
-    virtual Token *getStart();
-
-    /**
-     * Get the final token in this context.
-     * Note that the range from start to stop is inclusive, so for rules that do not consume anything
-     * (for example, zero length or error productions) this token may precede start.
-     */
-    virtual Token *getStop();
-
-    /// <summary>
-    /// Used for rule context info debugging during parse-time, not so much for ATN debugging </summary>
-    virtual std::string toInfoString(Parser *recognizer);
-  };
-
-} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/ProxyErrorListener.cpp

@@ -1,53 +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 "ProxyErrorListener.h"
-
-using namespace antlr4;
-
-void ProxyErrorListener::addErrorListener(ANTLRErrorListener *listener) {
-  if (listener == nullptr) {
-    throw "listener cannot be null.";
-  }
-
-  _delegates.insert(listener);
-}
-
-void ProxyErrorListener::removeErrorListener(ANTLRErrorListener *listener) {
-  _delegates.erase(listener);
-}
-
-void ProxyErrorListener::removeErrorListeners() {
-  _delegates.clear();
-}
-
-void ProxyErrorListener::syntaxError(Recognizer *recognizer, Token *offendingSymbol, size_t line,
-  size_t charPositionInLine, const std::string &msg, std::exception_ptr e) {
-
-  for (auto listener : _delegates) {
-    listener->syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e);
-  }
-}
-
-void ProxyErrorListener::reportAmbiguity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex,
-  bool exact, const antlrcpp::BitSet &ambigAlts, atn::ATNConfigSet *configs) {
-  for (auto listener : _delegates) {
-    listener->reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs);
-  }
-}
-
-void ProxyErrorListener::reportAttemptingFullContext(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex,
-  size_t stopIndex, const antlrcpp::BitSet &conflictingAlts, atn::ATNConfigSet *configs) {
-  for (auto listener : _delegates) {
-    listener->reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs);
-  }
-}
-
-void ProxyErrorListener::reportContextSensitivity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex,
-  size_t prediction, atn::ATNConfigSet *configs) {
-  for (auto listener : _delegates) {
-    listener->reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs);
-  }
-}

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/ProxyErrorListener.h

@@ -1,38 +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 "ANTLRErrorListener.h"
-#include "Exceptions.h"
-
-namespace antlr4 {
-
-  /// This implementation of ANTLRErrorListener dispatches all calls to a
-  /// collection of delegate listeners. This reduces the effort required to support multiple
-  /// listeners.
-  class ANTLR4CPP_PUBLIC ProxyErrorListener : public ANTLRErrorListener {
-  private:
-    std::set<ANTLRErrorListener *> _delegates; // Not owned.
-
-  public:
-    void addErrorListener(ANTLRErrorListener *listener);
-    void removeErrorListener(ANTLRErrorListener *listener);
-    void removeErrorListeners();
-
-    void syntaxError(Recognizer *recognizer, Token *offendingSymbol, size_t line, size_t charPositionInLine,
-                     const std::string &msg, std::exception_ptr e) override;
-
-    virtual void reportAmbiguity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex, bool exact,
-                                 const antlrcpp::BitSet &ambigAlts, atn::ATNConfigSet *configs) override;
-
-    virtual void reportAttemptingFullContext(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex,
-      const antlrcpp::BitSet &conflictingAlts, atn::ATNConfigSet *configs) override;
-
-    virtual void reportContextSensitivity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex,
-                                          size_t prediction, atn::ATNConfigSet *configs) override;
-  };
-
-} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/RecognitionException.cpp

@@ -1,66 +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 "Recognizer.h"
-#include "support/StringUtils.h"
-#include "ParserRuleContext.h"
-#include "misc/IntervalSet.h"
-
-#include "RecognitionException.h"
-
-using namespace antlr4;
-
-RecognitionException::RecognitionException(Recognizer *recognizer, IntStream *input, ParserRuleContext *ctx,
-                                           Token *offendingToken)
-  : RecognitionException("", recognizer, input, ctx, offendingToken) {
-}
-
-RecognitionException::RecognitionException(const std::string &message, Recognizer *recognizer, IntStream *input,
-                                           ParserRuleContext *ctx, Token *offendingToken)
-  : RuntimeException(message), _recognizer(recognizer), _input(input), _ctx(ctx), _offendingToken(offendingToken) {
-  InitializeInstanceFields();
-  if (recognizer != nullptr) {
-    _offendingState = recognizer->getState();
-  }
-}
-
-RecognitionException::~RecognitionException() {
-}
-
-size_t RecognitionException::getOffendingState() const {
-  return _offendingState;
-}
-
-void RecognitionException::setOffendingState(size_t offendingState) {
-  _offendingState = offendingState;
-}
-
-misc::IntervalSet RecognitionException::getExpectedTokens() const {
-  if (_recognizer) {
-    return _recognizer->getATN().getExpectedTokens(_offendingState, _ctx);
-  }
-  return misc::IntervalSet::EMPTY_SET;
-}
-
-RuleContext* RecognitionException::getCtx() const {
-  return _ctx;
-}
-
-IntStream* RecognitionException::getInputStream() const {
-  return _input;
-}
-
-Token* RecognitionException::getOffendingToken() const {
-  return _offendingToken;
-}
-
-Recognizer* RecognitionException::getRecognizer() const {
-  return _recognizer;
-}
-
-void RecognitionException::InitializeInstanceFields() {
-  _offendingState = INVALID_INDEX;
-}

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/RecognitionException.h

@@ -1,98 +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 {
-
-  /// The root of the ANTLR exception hierarchy. In general, ANTLR tracks just
-  /// 3 kinds of errors: prediction errors, failed predicate errors, and
-  /// mismatched input errors. In each case, the parser knows where it is
-  /// in the input, where it is in the ATN, the rule invocation stack,
-  /// and what kind of problem occurred.
-  class ANTLR4CPP_PUBLIC RecognitionException : public RuntimeException {
-  private:
-    /// The Recognizer where this exception originated.
-    Recognizer *_recognizer;
-    IntStream *_input;
-    ParserRuleContext *_ctx;
-
-    /// The current Token when an error occurred. Since not all streams
-    /// support accessing symbols by index, we have to track the Token
-    /// instance itself.
-    Token *_offendingToken;
-
-    size_t _offendingState;
-
-  public:
-    RecognitionException(Recognizer *recognizer, IntStream *input, ParserRuleContext *ctx,
-                         Token *offendingToken = nullptr);
-    RecognitionException(const std::string &message, Recognizer *recognizer, IntStream *input,
-                         ParserRuleContext *ctx, Token *offendingToken = nullptr);
-    RecognitionException(RecognitionException const&) = default;
-    ~RecognitionException();
-    RecognitionException& operator=(RecognitionException const&) = default;
-
-    /// Get the ATN state number the parser was in at the time the error
-    /// occurred. For NoViableAltException and
-    /// LexerNoViableAltException exceptions, this is the
-    /// DecisionState number. For others, it is the state whose outgoing
-    /// edge we couldn't match.
-    ///
-    /// If the state number is not known, this method returns -1.
-    virtual size_t getOffendingState() const;
-
-  protected:
-    void setOffendingState(size_t offendingState);
-
-    /// Gets the set of input symbols which could potentially follow the
-    /// previously matched symbol at the time this exception was thrown.
-    ///
-    /// If the set of expected tokens is not known and could not be computed,
-    /// this method returns an empty set.
-    ///
-    /// @returns The set of token types that could potentially follow the current
-    /// state in the ATN, or an empty set if the information is not available.
-  public:
-    virtual misc::IntervalSet getExpectedTokens() const;
-
-    /// <summary>
-    /// Gets the <seealso cref="RuleContext"/> at the time this exception was thrown.
-    /// <p/>
-    /// If the context is not available, this method returns {@code null}.
-    /// </summary>
-    /// <returns> The <seealso cref="RuleContext"/> at the time this exception was thrown.
-    /// If the context is not available, this method returns {@code null}. </returns>
-    virtual RuleContext* getCtx() const;
-
-    /// <summary>
-    /// Gets the input stream which is the symbol source for the recognizer where
-    /// this exception was thrown.
-    /// <p/>
-    /// If the input stream is not available, this method returns {@code null}.
-    /// </summary>
-    /// <returns> The input stream which is the symbol source for the recognizer
-    /// where this exception was thrown, or {@code null} if the stream is not
-    /// available. </returns>
-    virtual IntStream* getInputStream() const;
-
-    virtual Token* getOffendingToken() const;
-
-    /// <summary>
-    /// Gets the <seealso cref="Recognizer"/> where this exception occurred.
-    /// <p/>
-    /// If the recognizer is not available, this method returns {@code null}.
-    /// </summary>
-    /// <returns> The recognizer where this exception occurred, or {@code null} if
-    /// the recognizer is not available. </returns>
-    virtual Recognizer* getRecognizer() const;
-
-  private:
-    void InitializeInstanceFields();
-  };
-
-} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/Recognizer.cpp

@@ -1,167 +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 "ConsoleErrorListener.h"
-#include "RecognitionException.h"
-#include "support/CPPUtils.h"
-#include "support/StringUtils.h"
-#include "Token.h"
-#include "atn/ATN.h"
-#include "atn/ATNSimulator.h"
-#include "support/CPPUtils.h"
-
-#include "Vocabulary.h"
-
-#include "Recognizer.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-
-std::map<const dfa::Vocabulary*, std::map<std::string, size_t>> Recognizer::_tokenTypeMapCache;
-std::map<std::vector<std::string>, std::map<std::string, size_t>> Recognizer::_ruleIndexMapCache;
-
-Recognizer::Recognizer() {
-  InitializeInstanceFields();
-  _proxListener.addErrorListener(&ConsoleErrorListener::INSTANCE);
-}
-
-Recognizer::~Recognizer() {
-}
-
-dfa::Vocabulary const& Recognizer::getVocabulary() const {
-  static dfa::Vocabulary vocabulary = dfa::Vocabulary::fromTokenNames(getTokenNames());
-  return vocabulary;
-}
-
-std::map<std::string, size_t> Recognizer::getTokenTypeMap() {
-  const dfa::Vocabulary& vocabulary = getVocabulary();
-
-  std::lock_guard<std::mutex> lck(_mutex);
-  std::map<std::string, size_t> result;
-  auto iterator = _tokenTypeMapCache.find(&vocabulary);
-  if (iterator != _tokenTypeMapCache.end()) {
-    result = iterator->second;
-  } else {
-    for (size_t i = 0; i <= getATN().maxTokenType; ++i) {
-      std::string literalName = vocabulary.getLiteralName(i);
-      if (!literalName.empty()) {
-        result[literalName] = i;
-      }
-
-      std::string symbolicName = vocabulary.getSymbolicName(i);
-      if (!symbolicName.empty()) {
-        result[symbolicName] = i;
-      }
-				}
-    result["EOF"] = EOF;
-    _tokenTypeMapCache[&vocabulary] = result;
-  }
-
-  return result;
-}
-
-std::map<std::string, size_t> Recognizer::getRuleIndexMap() {
-  const std::vector<std::string>& ruleNames = getRuleNames();
-  if (ruleNames.empty()) {
-    throw "The current recognizer does not provide a list of rule names.";
-  }
-
-  std::lock_guard<std::mutex> lck(_mutex);
-  std::map<std::string, size_t> result;
-  auto iterator = _ruleIndexMapCache.find(ruleNames);
-  if (iterator != _ruleIndexMapCache.end()) {
-    result = iterator->second;
-  } else {
-    result = antlrcpp::toMap(ruleNames);
-    _ruleIndexMapCache[ruleNames] = result;
-  }
-  return result;
-}
-
-size_t Recognizer::getTokenType(const std::string &tokenName) {
-  const std::map<std::string, size_t> &map = getTokenTypeMap();
-  auto iterator = map.find(tokenName);
-  if (iterator == map.end())
-    return Token::INVALID_TYPE;
-
-  return iterator->second;
-}
-
-void Recognizer::setInterpreter(atn::ATNSimulator *interpreter) {
-  // Usually the interpreter is set by the descendant (lexer or parser (simulator), but can also be exchanged
-  // by the profiling ATN simulator.
-  delete _interpreter;
-  _interpreter = interpreter;
-}
-
-std::string Recognizer::getErrorHeader(RecognitionException *e) {
-  // We're having issues with cross header dependencies, these two classes will need to be
-  // rewritten to remove that.
-  size_t line = e->getOffendingToken()->getLine();
-  size_t charPositionInLine = e->getOffendingToken()->getCharPositionInLine();
-  return std::string("line ") + std::to_string(line) + ":" + std::to_string(charPositionInLine);
-
-}
-
-std::string Recognizer::getTokenErrorDisplay(Token *t) {
-  if (t == nullptr) {
-    return "<no Token>";
-  }
-  std::string s = t->getText();
-  if (s == "") {
-    if (t->getType() == EOF) {
-      s = "<EOF>";
-    } else {
-      s = std::string("<") + std::to_string(t->getType()) + std::string(">");
-    }
-  }
-
-  antlrcpp::replaceAll(s, "\n", "\\n");
-  antlrcpp::replaceAll(s, "\r","\\r");
-  antlrcpp::replaceAll(s, "\t", "\\t");
-
-  return "'" + s + "'";
-}
-
-void Recognizer::addErrorListener(ANTLRErrorListener *listener) {
-  _proxListener.addErrorListener(listener);
-}
-
-void Recognizer::removeErrorListener(ANTLRErrorListener *listener) {
-  _proxListener.removeErrorListener(listener);
-}
-
-void Recognizer::removeErrorListeners() {
-  _proxListener.removeErrorListeners();
-}
-
-ProxyErrorListener& Recognizer::getErrorListenerDispatch() {
-  return _proxListener;
-}
-
-bool Recognizer::sempred(RuleContext * /*localctx*/, size_t /*ruleIndex*/, size_t /*actionIndex*/) {
-  return true;
-}
-
-bool Recognizer::precpred(RuleContext * /*localctx*/, int /*precedence*/) {
-  return true;
-}
-
-void Recognizer::action(RuleContext * /*localctx*/, size_t /*ruleIndex*/, size_t /*actionIndex*/) {
-}
-
-size_t Recognizer::getState() const {
-  return _stateNumber;
-}
-
-void Recognizer::setState(size_t atnState) {
-  _stateNumber = atnState;
-}
-
-void Recognizer::InitializeInstanceFields() {
-  _stateNumber = ATNState::INVALID_STATE_NUMBER;
-  _interpreter = nullptr;
-}
-