expressir 1.4.3 → 2.0.0

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

@@ -1,45 +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 {
-
-  /**
-   * This class extends {@link ParserRuleContext} by allowing the value of
-   * {@link #getRuleIndex} to be explicitly set for the context.
-   *
-   * <p>
-   * {@link ParserRuleContext} does not include field storage for the rule index
-   * since the context classes created by the code generator override the
-   * {@link #getRuleIndex} method to return the correct value for that context.
-   * Since the parser interpreter does not use the context classes generated for a
-   * parser, this class (with slightly more memory overhead per node) is used to
-   * provide equivalent functionality.</p>
-   */
-  class ANTLR4CPP_PUBLIC InterpreterRuleContext : public ParserRuleContext {
-  public:
-    InterpreterRuleContext();
-
-    /**
-     * Constructs a new {@link InterpreterRuleContext} with the specified
-     * parent, invoking state, and rule index.
-     *
-     * @param parent The parent context.
-     * @param invokingStateNumber The invoking state number.
-     * @param ruleIndex The rule index for the current context.
-     */
-    InterpreterRuleContext(ParserRuleContext *parent, size_t invokingStateNumber, size_t ruleIndex);
-
-    virtual size_t getRuleIndex() const override;
-
-  protected:
-    /** This is the backing field for {@link #getRuleIndex}. */
-    const size_t _ruleIndex = INVALID_INDEX;
-};
-
-} // namespace antlr4

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

@@ -1,294 +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/LexerATNSimulator.h"
-#include "Exceptions.h"
-#include "misc/Interval.h"
-#include "CommonTokenFactory.h"
-#include "LexerNoViableAltException.h"
-#include "ANTLRErrorListener.h"
-#include "support/CPPUtils.h"
-#include "CommonToken.h"
-
-#include "Lexer.h"
-
-#define DEBUG_LEXER 0
-
-using namespace antlrcpp;
-using namespace antlr4;
-
-Lexer::Lexer() : Recognizer() {
-  InitializeInstanceFields();
-  _input = nullptr;
-}
-
-Lexer::Lexer(CharStream *input) : Recognizer(), _input(input) {
-  InitializeInstanceFields();
-}
-
-void Lexer::reset() {
-  // wack Lexer state variables
-  _input->seek(0); // rewind the input
-
-  _syntaxErrors = 0;
-  token.reset();
-  type = Token::INVALID_TYPE;
-  channel = Token::DEFAULT_CHANNEL;
-  tokenStartCharIndex = INVALID_INDEX;
-  tokenStartCharPositionInLine = 0;
-  tokenStartLine = 0;
-  type = 0;
-  _text = "";
-
-  hitEOF = false;
-  mode = Lexer::DEFAULT_MODE;
-  modeStack.clear();
-
-  getInterpreter<atn::LexerATNSimulator>()->reset();
-}
-
-std::unique_ptr<Token> Lexer::nextToken() {
-  // Mark start location in char stream so unbuffered streams are
-  // guaranteed at least have text of current token
-  ssize_t tokenStartMarker = _input->mark();
-
-  auto onExit = finally([this, tokenStartMarker]{
-    // make sure we release marker after match or
-    // unbuffered char stream will keep buffering
-    _input->release(tokenStartMarker);
-  });
-
-  while (true) {
-  outerContinue:
-    if (hitEOF) {
-      emitEOF();
-      return std::move(token);
-    }
-
-    token.reset();
-    channel = Token::DEFAULT_CHANNEL;
-    tokenStartCharIndex = _input->index();
-    tokenStartCharPositionInLine = getInterpreter<atn::LexerATNSimulator>()->getCharPositionInLine();
-    tokenStartLine = getInterpreter<atn::LexerATNSimulator>()->getLine();
-    _text = "";
-    do {
-      type = Token::INVALID_TYPE;
-      size_t ttype;
-      try {
-        ttype = getInterpreter<atn::LexerATNSimulator>()->match(_input, mode);
-      } catch (LexerNoViableAltException &e) {
-        notifyListeners(e); // report error
-        recover(e);
-        ttype = SKIP;
-      }
-      if (_input->LA(1) == EOF) {
-        hitEOF = true;
-      }
-      if (type == Token::INVALID_TYPE) {
-        type = ttype;
-      }
-      if (type == SKIP) {
-        goto outerContinue;
-      }
-    } while (type == MORE);
-    if (token == nullptr) {
-      emit();
-    }
-    return std::move(token);
-  }
-}
-
-void Lexer::skip() {
-  type = SKIP;
-}
-
-void Lexer::more() {
-  type = MORE;
-}
-
-void Lexer::setMode(size_t m) {
-  mode = m;
-}
-
-void Lexer::pushMode(size_t m) {
-#if DEBUG_LEXER == 1
-    std::cout << "pushMode " << m << std::endl;
-#endif
-
-  modeStack.push_back(mode);
-  setMode(m);
-}
-
-size_t Lexer::popMode() {
-  if (modeStack.empty()) {
-    throw EmptyStackException();
-  }
-#if DEBUG_LEXER == 1
-    std::cout << std::string("popMode back to ") << modeStack.back() << std::endl;
-#endif
-
-  setMode(modeStack.back());
-  modeStack.pop_back();
-  return mode;
-}
-
-
-TokenFactory<CommonToken>* Lexer::getTokenFactory() {
-  return _factory;
-}
-
-void Lexer::setInputStream(IntStream *input) {
-  reset();
-  _input = dynamic_cast<CharStream*>(input);
-}
-
-std::string Lexer::getSourceName() {
-  return _input->getSourceName();
-}
-
-CharStream* Lexer::getInputStream() {
-  return _input;
-}
-
-void Lexer::emit(std::unique_ptr<Token> newToken) {
-  token = std::move(newToken);
-}
-
-Token* Lexer::emit() {
-  emit(_factory->create({ this, _input }, type, _text, channel,
-    tokenStartCharIndex, getCharIndex() - 1, tokenStartLine, tokenStartCharPositionInLine));
-  return token.get();
-}
-
-Token* Lexer::emitEOF() {
-  size_t cpos = getCharPositionInLine();
-  size_t line = getLine();
-  emit(_factory->create({ this, _input }, EOF, "", Token::DEFAULT_CHANNEL, _input->index(), _input->index() - 1, line, cpos));
-  return token.get();
-}
-
-size_t Lexer::getLine() const {
-  return getInterpreter<atn::LexerATNSimulator>()->getLine();
-}
-
-size_t Lexer::getCharPositionInLine() {
-  return getInterpreter<atn::LexerATNSimulator>()->getCharPositionInLine();
-}
-
-void Lexer::setLine(size_t line) {
-  getInterpreter<atn::LexerATNSimulator>()->setLine(line);
-}
-
-void Lexer::setCharPositionInLine(size_t charPositionInLine) {
-  getInterpreter<atn::LexerATNSimulator>()->setCharPositionInLine(charPositionInLine);
-}
-
-size_t Lexer::getCharIndex() {
-  return _input->index();
-}
-
-std::string Lexer::getText() {
-  if (!_text.empty()) {
-    return _text;
-  }
-  return getInterpreter<atn::LexerATNSimulator>()->getText(_input);
-}
-
-void Lexer::setText(const std::string &text) {
-  _text = text;
-}
-
-std::unique_ptr<Token> Lexer::getToken() {
-  return std::move(token);
-}
-
-void Lexer::setToken(std::unique_ptr<Token> newToken) {
-  token = std::move(newToken);
-}
-
-void Lexer::setType(size_t ttype) {
-  type = ttype;
-}
-
-size_t Lexer::getType() {
-  return type;
-}
-
-void Lexer::setChannel(size_t newChannel) {
-  channel = newChannel;
-}
-
-size_t Lexer::getChannel() {
-  return channel;
-}
-
-std::vector<std::unique_ptr<Token>> Lexer::getAllTokens() {
-  std::vector<std::unique_ptr<Token>> tokens;
-  std::unique_ptr<Token> t = nextToken();
-  while (t->getType() != EOF) {
-    tokens.push_back(std::move(t));
-    t = nextToken();
-  }
-  return tokens;
-}
-
-void Lexer::recover(const LexerNoViableAltException &/*e*/) {
-  if (_input->LA(1) != EOF) {
-    // skip a char and try again
-    getInterpreter<atn::LexerATNSimulator>()->consume(_input);
-  }
-}
-
-void Lexer::notifyListeners(const LexerNoViableAltException & /*e*/) {
-  ++_syntaxErrors;
-  std::string text = _input->getText(misc::Interval(tokenStartCharIndex, _input->index()));
-  std::string msg = std::string("token recognition error at: '") + getErrorDisplay(text) + std::string("'");
-
-  ProxyErrorListener &listener = getErrorListenerDispatch();
-  listener.syntaxError(this, nullptr, tokenStartLine, tokenStartCharPositionInLine, msg, std::current_exception());
-}
-
-std::string Lexer::getErrorDisplay(const std::string &s) {
-  std::stringstream ss;
-  for (auto c : s) {
-    switch (c) {
-    case '\n':
-      ss << "\\n";
-      break;
-    case '\t':
-      ss << "\\t";
-      break;
-    case '\r':
-      ss << "\\r";
-      break;
-    default:
-      ss << c;
-      break;
-    }
-  }
-  return ss.str();
-}
-
-void Lexer::recover(RecognitionException * /*re*/) {
-  // TODO: Do we lose character or line position information?
-  _input->consume();
-}
-
-size_t Lexer::getNumberOfSyntaxErrors() {
-  return _syntaxErrors;
-}
-
-void Lexer::InitializeInstanceFields() {
-  _syntaxErrors = 0;
-  token = nullptr;
-  _factory = CommonTokenFactory::DEFAULT.get();
-  tokenStartCharIndex = INVALID_INDEX;
-  tokenStartLine = 0;
-  tokenStartCharPositionInLine = 0;
-  hitEOF = false;
-  channel = 0;
-  type = 0;
-  mode = Lexer::DEFAULT_MODE;
-}

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

@@ -1,196 +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 "Recognizer.h"
-#include "TokenSource.h"
-#include "CharStream.h"
-#include "Token.h"
-
-namespace antlr4 {
-
-  /// A lexer is recognizer that draws input symbols from a character stream.
-  /// lexer grammars result in a subclass of this object. A Lexer object
-  /// uses simplified match() and error recovery mechanisms in the interest
-  /// of speed.
-  class ANTLR4CPP_PUBLIC Lexer : public Recognizer, public TokenSource {
-  public:
-    static constexpr size_t DEFAULT_MODE = 0;
-    static constexpr size_t MORE = std::numeric_limits<size_t>::max() - 1;
-    static constexpr size_t SKIP = std::numeric_limits<size_t>::max() - 2;
-
-    static constexpr size_t DEFAULT_TOKEN_CHANNEL = Token::DEFAULT_CHANNEL;
-    static constexpr size_t HIDDEN = Token::HIDDEN_CHANNEL;
-    static constexpr size_t MIN_CHAR_VALUE = 0;
-    static constexpr size_t MAX_CHAR_VALUE = 0x10FFFF;
-
-    CharStream *_input; // Pure reference, usually from statically allocated instance.
-
-  protected:
-    /// How to create token objects.
-    TokenFactory<CommonToken> *_factory;
-
-  public:
-    /// The goal of all lexer rules/methods is to create a token object.
-    ///  This is an instance variable as multiple rules may collaborate to
-    ///  create a single token.  nextToken will return this object after
-    ///  matching lexer rule(s).  If you subclass to allow multiple token
-    ///  emissions, then set this to the last token to be matched or
-    ///  something nonnull so that the auto token emit mechanism will not
-    ///  emit another token.
-
-    // Life cycle of a token is this:
-    // Created by emit() (via the token factory) or by action code, holding ownership of it.
-    // Ownership is handed over to the token stream when calling nextToken().
-    std::unique_ptr<Token> token;
-
-    /// <summary>
-    /// What character index in the stream did the current token start at?
-    ///  Needed, for example, to get the text for current token.  Set at
-    ///  the start of nextToken.
-    /// </summary>
-    size_t tokenStartCharIndex;
-
-    /// <summary>
-    /// The line on which the first character of the token resides </summary>
-    size_t tokenStartLine;
-
-    /// The character position of first character within the line.
-    size_t tokenStartCharPositionInLine;
-
-    /// Once we see EOF on char stream, next token will be EOF.
-    /// If you have DONE : EOF ; then you see DONE EOF.
-    bool hitEOF;
-
-    /// The channel number for the current token.
-    size_t channel;
-
-    /// The token type for the current token.
-    size_t type;
-
-    // Use the vector as a stack.
-    std::vector<size_t> modeStack;
-    size_t mode;
-
-    Lexer();
-    Lexer(CharStream *input);
-    virtual ~Lexer() {}
-
-    virtual void reset();
-
-    /// Return a token from this source; i.e., match a token on the char stream.
-    virtual std::unique_ptr<Token> nextToken() override;
-
-    /// Instruct the lexer to skip creating a token for current lexer rule
-    /// and look for another token.  nextToken() knows to keep looking when
-    /// a lexer rule finishes with token set to SKIP_TOKEN.  Recall that
-    /// if token == null at end of any token rule, it creates one for you
-    /// and emits it.
-    virtual void skip();
-    virtual void more();
-    virtual void setMode(size_t m);
-    virtual void pushMode(size_t m);
-    virtual size_t popMode();
-
-    template<typename T1>
-    void setTokenFactory(TokenFactory<T1> *factory)  {
-      this->_factory = factory;
-    }
-
-    virtual TokenFactory<CommonToken>* getTokenFactory() override;
-
-    /// Set the char stream and reset the lexer
-    virtual void setInputStream(IntStream *input) override;
-
-    virtual std::string getSourceName() override;
-
-    virtual CharStream* getInputStream() override;
-
-    /// By default does not support multiple emits per nextToken invocation
-    /// for efficiency reasons. Subclasses can override this method, nextToken,
-    /// and getToken (to push tokens into a list and pull from that list
-    /// rather than a single variable as this implementation does).
-    virtual void emit(std::unique_ptr<Token> newToken);
-
-    /// The standard method called to automatically emit a token at the
-    /// outermost lexical rule.  The token object should point into the
-    /// char buffer start..stop.  If there is a text override in 'text',
-    /// use that to set the token's text.  Override this method to emit
-    /// custom Token objects or provide a new factory.
-    virtual Token* emit();
-
-    virtual Token* emitEOF();
-
-    virtual size_t getLine() const override;
-
-    virtual size_t getCharPositionInLine() override;
-
-    virtual void setLine(size_t line);
-
-    virtual void setCharPositionInLine(size_t charPositionInLine);
-
-    /// What is the index of the current character of lookahead?
-    virtual size_t getCharIndex();
-
-    /// Return the text matched so far for the current token or any
-    /// text override.
-    virtual std::string getText();
-
-    /// Set the complete text of this token; it wipes any previous
-    /// changes to the text.
-    virtual void setText(const std::string &text);
-
-    /// Override if emitting multiple tokens.
-    virtual std::unique_ptr<Token> getToken();
-
-    virtual void setToken(std::unique_ptr<Token> newToken);
-
-    virtual void setType(size_t ttype);
-
-    virtual size_t getType();
-
-    virtual void setChannel(size_t newChannel);
-
-    virtual size_t getChannel();
-
-    virtual const std::vector<std::string>& getChannelNames() const = 0;
-
-    virtual const std::vector<std::string>& getModeNames() const = 0;
-
-    /// Return a list of all Token objects in input char stream.
-    /// Forces load of all tokens. Does not include EOF token.
-    virtual std::vector<std::unique_ptr<Token>> getAllTokens();
-
-    virtual void recover(const LexerNoViableAltException &e);
-
-    virtual void notifyListeners(const LexerNoViableAltException &e);
-
-    virtual std::string getErrorDisplay(const std::string &s);
-
-    /// Lexers can normally match any char in it's vocabulary after matching
-    /// a token, so do the easy thing and just kill a character and hope
-    /// it all works out.  You can instead use the rule invocation stack
-    /// to do sophisticated error recovery if you are in a fragment rule.
-    virtual void recover(RecognitionException *re);
-
-    /// <summary>
-    /// Gets the number of syntax errors reported during parsing. This value is
-    /// incremented each time <seealso cref="#notifyErrorListeners"/> is called.
-    /// </summary>
-    /// <seealso cref= #notifyListeners </seealso>
-    virtual size_t getNumberOfSyntaxErrors();
-
-  protected:
-    /// You can set the text for the current token to override what is in
-    /// the input char buffer (via setText()).
-    std::string _text;
-
-  private:
-    size_t _syntaxErrors;
-    void InitializeInstanceFields();
-  };
-
-} // namespace antlr4

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

@@ -1,60 +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/ATNType.h"
-#include "atn/LexerATNSimulator.h"
-#include "dfa/DFA.h"
-#include "Exceptions.h"
-#include "Vocabulary.h"
-
-#include "LexerInterpreter.h"
-
-using namespace antlr4;
-
-LexerInterpreter::LexerInterpreter(const std::string &grammarFileName, const dfa::Vocabulary &vocabulary,
-  const std::vector<std::string> &ruleNames, const std::vector<std::string> &channelNames, const std::vector<std::string> &modeNames,
-  const atn::ATN &atn, CharStream *input)
-  : Lexer(input), _grammarFileName(grammarFileName), _atn(atn), _ruleNames(ruleNames),
-                  _channelNames(channelNames), _modeNames(modeNames),
-                  _vocabulary(vocabulary) {
-
-  if (_atn.grammarType != atn::ATNType::LEXER) {
-    throw IllegalArgumentException("The ATN must be a lexer ATN.");
-  }
-
-  for (size_t i = 0; i < atn.getNumberOfDecisions(); ++i) {
-    _decisionToDFA.push_back(dfa::DFA(_atn.getDecisionState(i), i));
-  }
-  _interpreter = new atn::LexerATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache); /* mem-check: deleted in d-tor */
-}
-
-LexerInterpreter::~LexerInterpreter()
-{
-  delete _interpreter;
-}
-
-const atn::ATN& LexerInterpreter::getATN() const {
-  return _atn;
-}
-
-std::string LexerInterpreter::getGrammarFileName() const {
-  return _grammarFileName;
-}
-
-const std::vector<std::string>& LexerInterpreter::getRuleNames() const {
-  return _ruleNames;
-}
-
-const std::vector<std::string>& LexerInterpreter::getChannelNames() const {
-  return _channelNames;
-}
-
-const std::vector<std::string>& LexerInterpreter::getModeNames() const {
-  return _modeNames;
-}
-
-const dfa::Vocabulary& LexerInterpreter::getVocabulary() const {
-  return _vocabulary;
-}

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

@@ -1,46 +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 "Lexer.h"
-#include "atn/PredictionContext.h"
-#include "atn/PredictionContextCache.h"
-#include "Vocabulary.h"
-
-namespace antlr4 {
-
-  class ANTLR4CPP_PUBLIC LexerInterpreter : public Lexer {
-  public:
-    LexerInterpreter(const std::string &grammarFileName, const dfa::Vocabulary &vocabulary,
-                     const std::vector<std::string> &ruleNames, const std::vector<std::string> &channelNames,
-                     const std::vector<std::string> &modeNames, const atn::ATN &atn, CharStream *input);
-
-    ~LexerInterpreter();
-
-    virtual const atn::ATN& getATN() const override;
-    virtual std::string getGrammarFileName() const override;
-    virtual const std::vector<std::string>& getRuleNames() const override;
-    virtual const std::vector<std::string>& getChannelNames() const override;
-    virtual const std::vector<std::string>& getModeNames() const override;
-
-    virtual const dfa::Vocabulary& getVocabulary() const override;
-
-  protected:
-    const std::string _grammarFileName;
-    const atn::ATN &_atn;
-
-    const std::vector<std::string> &_ruleNames;
-    const std::vector<std::string> &_channelNames;
-    const std::vector<std::string> &_modeNames;
-    std::vector<dfa::DFA> _decisionToDFA;
-
-    atn::PredictionContextCache _sharedContextCache;
-
-  private:
-    dfa::Vocabulary _vocabulary;
-  };
-
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/LexerNoViableAltException.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 "misc/Interval.h"
-#include "support/CPPUtils.h"
-#include "CharStream.h"
-#include "Lexer.h"
-
-#include "LexerNoViableAltException.h"
-
-using namespace antlr4;
-
-LexerNoViableAltException::LexerNoViableAltException(Lexer *lexer, CharStream *input, size_t startIndex,
-                                                     atn::ATNConfigSet *deadEndConfigs)
-  : RecognitionException(lexer, input, nullptr, nullptr), _startIndex(startIndex), _deadEndConfigs(deadEndConfigs) {
-}
-
-size_t LexerNoViableAltException::getStartIndex() {
-  return _startIndex;
-}
-
-atn::ATNConfigSet* LexerNoViableAltException::getDeadEndConfigs() {
-  return _deadEndConfigs;
-}
-
-std::string LexerNoViableAltException::toString() {
-  std::string symbol;
-  if (_startIndex < getInputStream()->size()) {
-    symbol = static_cast<CharStream *>(getInputStream())->getText(misc::Interval(_startIndex, _startIndex));
-    symbol = antlrcpp::escapeWhitespace(symbol, false);
-  }
-  std::string format = "LexerNoViableAltException('" + symbol + "')";
-  return format;
-}