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

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 const size_t DEFAULT_MODE = 0;
-    static const size_t MORE = static_cast<size_t>(-2);
-    static const size_t SKIP = static_cast<size_t>(-3);
-
-    static const size_t DEFAULT_TOKEN_CHANNEL = Token::DEFAULT_CHANNEL;
-    static const size_t HIDDEN = Token::HIDDEN_CHANNEL;
-    static const size_t MIN_CHAR_VALUE = 0;
-    static const size_t MAX_CHAR_VALUE = 0x10FFFF;
-
-    CharStream *_input; // Pure reference, usually from statically allocated instance.
-
-  protected:
-    /// How to create token objects.
-    Ref<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 Ref<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,75 +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 "atn/EmptyPredictionContext.h"
-#include "Exceptions.h"
-#include "Vocabulary.h"
-
-#include "LexerInterpreter.h"
-
-using namespace antlr4;
-
-LexerInterpreter::LexerInterpreter(const std::string &grammarFileName, const std::vector<std::string> &tokenNames,
-  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(grammarFileName, dfa::Vocabulary::fromTokenNames(tokenNames), ruleNames, channelNames, modeNames, atn, input) {
-}
-
-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.maxTokenType; i++) {
-    _tokenNames.push_back(vocabulary.getDisplayName(i));
-  }
-
-  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::getTokenNames() const {
-  return _tokenNames;
-}
-
-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,52 +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 "Vocabulary.h"
-
-namespace antlr4 {
-
-  class ANTLR4CPP_PUBLIC LexerInterpreter : public Lexer {
-  public:
-    // @deprecated
-    LexerInterpreter(const std::string &grammarFileName, const std::vector<std::string> &tokenNames,
-                     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(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>& getTokenNames() 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;
-
-    // @deprecated
-    std::vector<std::string> _tokenNames;
-    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;
-}

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

@@ -1,31 +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 "RecognitionException.h"
-#include "atn/ATNConfigSet.h"
-
-namespace antlr4 {
-
-  class ANTLR4CPP_PUBLIC LexerNoViableAltException : public RecognitionException {
-  public:
-    LexerNoViableAltException(Lexer *lexer, CharStream *input, size_t startIndex,
-                              atn::ATNConfigSet *deadEndConfigs);
-
-    virtual size_t getStartIndex();
-    virtual atn::ATNConfigSet* getDeadEndConfigs();
-    virtual std::string toString();
-
-  private:
-    /// Matching attempted at what input index?
-    const size_t _startIndex;
-
-    /// Which configurations did we try at input.index() that couldn't match input.LA(1)?
-    atn::ATNConfigSet *_deadEndConfigs;
-
-  };
-
-} // namespace antlr4

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

@@ -1,92 +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 "Token.h"
-#include "CommonToken.h"
-#include "CharStream.h"
-
-#include "ListTokenSource.h"
-
-using namespace antlr4;
-
-ListTokenSource::ListTokenSource(std::vector<std::unique_ptr<Token>> tokens_) : ListTokenSource(std::move(tokens_), "") {
-}
-
-ListTokenSource::ListTokenSource(std::vector<std::unique_ptr<Token>> tokens_, const std::string &sourceName_)
-  : tokens(std::move(tokens_)), sourceName(sourceName_) {
-  InitializeInstanceFields();
-  if (tokens.empty()) {
-    throw "tokens cannot be null";
-  }
-
-  // Check if there is an eof token and create one if not.
-  if (tokens.back()->getType() != Token::EOF) {
-    Token *lastToken = tokens.back().get();
-    size_t start = INVALID_INDEX;
-    size_t previousStop = lastToken->getStopIndex();
-    if (previousStop != INVALID_INDEX) {
-      start = previousStop + 1;
-    }
-
-    size_t stop = std::max(INVALID_INDEX, start - 1);
-    tokens.emplace_back((_factory->create({ this, getInputStream() }, Token::EOF, "EOF",
-      Token::DEFAULT_CHANNEL, start, stop, static_cast<int>(lastToken->getLine()), lastToken->getCharPositionInLine())));
-  }
-}
-
-size_t ListTokenSource::getCharPositionInLine() {
-  if (i < tokens.size()) {
-    return tokens[i]->getCharPositionInLine();
-  }
-  return 0;
-}
-
-std::unique_ptr<Token> ListTokenSource::nextToken() {
-  if (i < tokens.size()) {
-    return std::move(tokens[i++]);
-  }
-  return nullptr;
-}
-
-size_t ListTokenSource::getLine() const {
-  if (i < tokens.size()) {
-    return tokens[i]->getLine();
-  }
-
-  return 1;
-}
-
-CharStream *ListTokenSource::getInputStream() {
-  if (i < tokens.size()) {
-    return tokens[i]->getInputStream();
-  } else if (!tokens.empty()) {
-    return tokens.back()->getInputStream();
-  }
-
-  // no input stream information is available
-  return nullptr;
-}
-
-std::string ListTokenSource::getSourceName() {
-  if (sourceName != "") {
-    return sourceName;
-  }
-
-  CharStream *inputStream = getInputStream();
-  if (inputStream != nullptr) {
-    return inputStream->getSourceName();
-  }
-
-  return "List";
-}
-
-Ref<TokenFactory<CommonToken>> ListTokenSource::getTokenFactory() {
-  return _factory;
-}
-
-void ListTokenSource::InitializeInstanceFields() {
-  i = 0;
-  _factory = CommonTokenFactory::DEFAULT;
-}