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

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

@@ -1,414 +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 "WritableToken.h"
-#include "Lexer.h"
-#include "RuleContext.h"
-#include "misc/Interval.h"
-#include "Exceptions.h"
-#include "support/CPPUtils.h"
-
-#include "BufferedTokenStream.h"
-
-using namespace antlr4;
-using namespace antlrcpp;
-
-BufferedTokenStream::BufferedTokenStream(TokenSource *tokenSource) : _tokenSource(tokenSource){
-  InitializeInstanceFields();
-}
-
-TokenSource* BufferedTokenStream::getTokenSource() const {
-  return _tokenSource;
-}
-
-size_t BufferedTokenStream::index() {
-  return _p;
-}
-
-ssize_t BufferedTokenStream::mark() {
-  return 0;
-}
-
-void BufferedTokenStream::release(ssize_t /*marker*/) {
-  // no resources to release
-}
-
-void BufferedTokenStream::reset() {
-  seek(0);
-}
-
-void BufferedTokenStream::seek(size_t index) {
-  lazyInit();
-  _p = adjustSeekIndex(index);
-}
-
-size_t BufferedTokenStream::size() {
-  return _tokens.size();
-}
-
-void BufferedTokenStream::consume() {
-  bool skipEofCheck = false;
-  if (!_needSetup) {
-    if (_fetchedEOF) {
-      // the last token in tokens is EOF. skip check if p indexes any
-      // fetched token except the last.
-      skipEofCheck = _p < _tokens.size() - 1;
-    } else {
-      // no EOF token in tokens. skip check if p indexes a fetched token.
-      skipEofCheck = _p < _tokens.size();
-    }
-  } else {
-    // not yet initialized
-    skipEofCheck = false;
-  }
-
-  if (!skipEofCheck && LA(1) == Token::EOF) {
-    throw IllegalStateException("cannot consume EOF");
-  }
-
-  if (sync(_p + 1)) {
-    _p = adjustSeekIndex(_p + 1);
-  }
-}
-
-bool BufferedTokenStream::sync(size_t i) {
-  if (i + 1 < _tokens.size())
-    return true;
-  size_t n = i - _tokens.size() + 1; // how many more elements we need?
-
-  if (n > 0) {
-    size_t fetched = fetch(n);
-    return fetched >= n;
-  }
-
-  return true;
-}
-
-size_t BufferedTokenStream::fetch(size_t n) {
-  if (_fetchedEOF) {
-    return 0;
-  }
-
-  size_t i = 0;
-  while (i < n) {
-    std::unique_ptr<Token> t(_tokenSource->nextToken());
-
-    if (is<WritableToken *>(t.get())) {
-      (static_cast<WritableToken *>(t.get()))->setTokenIndex(_tokens.size());
-    }
-
-    _tokens.push_back(std::move(t));
-    ++i;
-
-    if (_tokens.back()->getType() == Token::EOF) {
-      _fetchedEOF = true;
-      break;
-    }
-  }
-
-  return i;
-}
-
-Token* BufferedTokenStream::get(size_t i) const {
-  if (i >= _tokens.size()) {
-    throw IndexOutOfBoundsException(std::string("token index ") +
-                                    std::to_string(i) +
-                                    std::string(" out of range 0..") +
-                                    std::to_string(_tokens.size() - 1));
-  }
-  return _tokens[i].get();
-}
-
-std::vector<Token *> BufferedTokenStream::get(size_t start, size_t stop) {
-  std::vector<Token *> subset;
-
-  lazyInit();
-
-  if (_tokens.empty()) {
-    return subset;
-  }
-
-  if (stop >= _tokens.size()) {
-    stop = _tokens.size() - 1;
-  }
-  for (size_t i = start; i <= stop; i++) {
-    Token *t = _tokens[i].get();
-    if (t->getType() == Token::EOF) {
-      break;
-    }
-    subset.push_back(t);
-  }
-  return subset;
-}
-
-size_t BufferedTokenStream::LA(ssize_t i) {
-  return LT(i)->getType();
-}
-
-Token* BufferedTokenStream::LB(size_t k) {
-  if (k > _p) {
-    return nullptr;
-  }
-  return _tokens[_p - k].get();
-}
-
-Token* BufferedTokenStream::LT(ssize_t k) {
-  lazyInit();
-  if (k == 0) {
-    return nullptr;
-  }
-  if (k < 0) {
-    return LB(-k);
-  }
-
-  size_t i = _p + k - 1;
-  sync(i);
-  if (i >= _tokens.size()) { // return EOF token
-                             // EOF must be last token
-    return _tokens.back().get();
-  }
-
-  return _tokens[i].get();
-}
-
-ssize_t BufferedTokenStream::adjustSeekIndex(size_t i) {
-  return i;
-}
-
-void BufferedTokenStream::lazyInit() {
-  if (_needSetup) {
-    setup();
-  }
-}
-
-void BufferedTokenStream::setup() {
-  _needSetup = false;
-  sync(0);
-  _p = adjustSeekIndex(0);
-}
-
-void BufferedTokenStream::setTokenSource(TokenSource *tokenSource) {
-  _tokenSource = tokenSource;
-  _tokens.clear();
-  _fetchedEOF = false;
-  _needSetup = true;
-}
-
-std::vector<Token *> BufferedTokenStream::getTokens() {
-  std::vector<Token *> result;
-  for (auto &t : _tokens)
-    result.push_back(t.get());
-  return result;
-}
-
-std::vector<Token *> BufferedTokenStream::getTokens(size_t start, size_t stop) {
-  return getTokens(start, stop, std::vector<size_t>());
-}
-
-std::vector<Token *> BufferedTokenStream::getTokens(size_t start, size_t stop, const std::vector<size_t> &types) {
-  lazyInit();
-  if (stop >= _tokens.size() || start >= _tokens.size()) {
-    throw IndexOutOfBoundsException(std::string("start ") +
-                                    std::to_string(start) +
-                                    std::string(" or stop ") +
-                                    std::to_string(stop) +
-                                    std::string(" not in 0..") +
-                                    std::to_string(_tokens.size() - 1));
-  }
-
-  std::vector<Token *> filteredTokens;
-
-  if (start > stop) {
-    return filteredTokens;
-  }
-
-  for (size_t i = start; i <= stop; i++) {
-    Token *tok = _tokens[i].get();
-
-    if (types.empty() || std::find(types.begin(), types.end(), tok->getType()) != types.end()) {
-      filteredTokens.push_back(tok);
-    }
-  }
-  return filteredTokens;
-}
-
-std::vector<Token *> BufferedTokenStream::getTokens(size_t start, size_t stop, size_t ttype) {
-  std::vector<size_t> s;
-  s.push_back(ttype);
-  return getTokens(start, stop, s);
-}
-
-ssize_t BufferedTokenStream::nextTokenOnChannel(size_t i, size_t channel) {
-  sync(i);
-  if (i >= size()) {
-    return size() - 1;
-  }
-
-  Token *token = _tokens[i].get();
-  while (token->getChannel() != channel) {
-    if (token->getType() == Token::EOF) {
-      return i;
-    }
-    i++;
-    sync(i);
-    token = _tokens[i].get();
-  }
-  return i;
-}
-
-ssize_t BufferedTokenStream::previousTokenOnChannel(size_t i, size_t channel) {
-  sync(i);
-  if (i >= size()) {
-    // the EOF token is on every channel
-    return size() - 1;
-  }
-
-  while (true) {
-    Token *token = _tokens[i].get();
-    if (token->getType() == Token::EOF || token->getChannel() == channel) {
-      return i;
-    }
-
-    if (i == 0)
-      return -1;
-    i--;
-  }
-  return i;
-}
-
-std::vector<Token *> BufferedTokenStream::getHiddenTokensToRight(size_t tokenIndex, ssize_t channel) {
-  lazyInit();
-  if (tokenIndex >= _tokens.size()) {
-    throw IndexOutOfBoundsException(std::to_string(tokenIndex) + " not in 0.." + std::to_string(_tokens.size() - 1));
-  }
-
-  ssize_t nextOnChannel = nextTokenOnChannel(tokenIndex + 1, Lexer::DEFAULT_TOKEN_CHANNEL);
-  size_t to;
-  size_t from = tokenIndex + 1;
-  // if none onchannel to right, nextOnChannel=-1 so set to = last token
-  if (nextOnChannel == -1) {
-    to = static_cast<ssize_t>(size() - 1);
-  } else {
-    to = nextOnChannel;
-  }
-
-  return filterForChannel(from, to, channel);
-}
-
-std::vector<Token *> BufferedTokenStream::getHiddenTokensToRight(size_t tokenIndex) {
-  return getHiddenTokensToRight(tokenIndex, -1);
-}
-
-std::vector<Token *> BufferedTokenStream::getHiddenTokensToLeft(size_t tokenIndex, ssize_t channel) {
-  lazyInit();
-  if (tokenIndex >= _tokens.size()) {
-    throw IndexOutOfBoundsException(std::to_string(tokenIndex) + " not in 0.." + std::to_string(_tokens.size() - 1));
-  }
-
-  if (tokenIndex == 0) {
-    // Obviously no tokens can appear before the first token.
-    return { };
-  }
-
-  ssize_t prevOnChannel = previousTokenOnChannel(tokenIndex - 1, Lexer::DEFAULT_TOKEN_CHANNEL);
-  if (prevOnChannel == static_cast<ssize_t>(tokenIndex - 1)) {
-    return { };
-  }
-  // if none onchannel to left, prevOnChannel=-1 then from=0
-  size_t from = static_cast<size_t>(prevOnChannel + 1);
-  size_t to = tokenIndex - 1;
-
-  return filterForChannel(from, to, channel);
-}
-
-std::vector<Token *> BufferedTokenStream::getHiddenTokensToLeft(size_t tokenIndex) {
-  return getHiddenTokensToLeft(tokenIndex, -1);
-}
-
-std::vector<Token *> BufferedTokenStream::filterForChannel(size_t from, size_t to, ssize_t channel) {
-  std::vector<Token *> hidden;
-  for (size_t i = from; i <= to; i++) {
-    Token *t = _tokens[i].get();
-    if (channel == -1) {
-      if (t->getChannel() != Lexer::DEFAULT_TOKEN_CHANNEL) {
-        hidden.push_back(t);
-      }
-    } else {
-      if (t->getChannel() == static_cast<size_t>(channel)) {
-        hidden.push_back(t);
-      }
-    }
-  }
-
-  return hidden;
-}
-
-bool BufferedTokenStream::isInitialized() const {
-  return !_needSetup;
-}
-
-/**
- * Get the text of all tokens in this buffer.
- */
-std::string BufferedTokenStream::getSourceName() const
-{
-  return _tokenSource->getSourceName();
-}
-
-std::string BufferedTokenStream::getText() {
-  fill();
-  return getText(misc::Interval(0U, size() - 1));
-}
-
-std::string BufferedTokenStream::getText(const misc::Interval &interval) {
-  lazyInit();
-  size_t start = interval.a;
-  size_t stop = interval.b;
-  if (start == INVALID_INDEX || stop == INVALID_INDEX) {
-    return "";
-  }
-  sync(stop);
-  if (stop >= _tokens.size()) {
-    stop = _tokens.size() - 1;
-  }
-
-  std::stringstream ss;
-  for (size_t i = start; i <= stop; i++) {
-    Token *t = _tokens[i].get();
-    if (t->getType() == Token::EOF) {
-      break;
-    }
-    ss << t->getText();
-  }
-  return ss.str();
-}
-
-std::string BufferedTokenStream::getText(RuleContext *ctx) {
-  return getText(ctx->getSourceInterval());
-}
-
-std::string BufferedTokenStream::getText(Token *start, Token *stop) {
-  if (start != nullptr && stop != nullptr) {
-    return getText(misc::Interval(start->getTokenIndex(), stop->getTokenIndex()));
-  }
-
-  return "";
-}
-
-void BufferedTokenStream::fill() {
-  lazyInit();
-  const size_t blockSize = 1000;
-  while (true) {
-    size_t fetched = fetch(blockSize);
-    if (fetched < blockSize) {
-      return;
-    }
-  }
-}
-
-void BufferedTokenStream::InitializeInstanceFields() {
-  _needSetup = true;
-  _fetchedEOF = false;
-}

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

@@ -1,200 +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 "TokenStream.h"
-
-namespace antlr4 {
-
-  /**
-   * This implementation of {@link TokenStream} loads tokens from a
-   * {@link TokenSource} on-demand, and places the tokens in a buffer to provide
-   * access to any previous token by index.
-   *
-   * <p>
-   * This token stream ignores the value of {@link Token#getChannel}. If your
-   * parser requires the token stream filter tokens to only those on a particular
-   * channel, such as {@link Token#DEFAULT_CHANNEL} or
-   * {@link Token#HIDDEN_CHANNEL}, use a filtering token stream such a
-   * {@link CommonTokenStream}.</p>
-   */
-  class ANTLR4CPP_PUBLIC BufferedTokenStream : public TokenStream {
-  public:
-    BufferedTokenStream(TokenSource *tokenSource);
-    BufferedTokenStream(const BufferedTokenStream& other) = delete;
-
-    BufferedTokenStream& operator = (const BufferedTokenStream& other) = delete;
-
-    virtual TokenSource* getTokenSource() const override;
-    virtual size_t index() override;
-    virtual ssize_t mark() override;
-
-    virtual void release(ssize_t marker) override;
-    virtual void reset();
-    virtual void seek(size_t index) override;
-
-    virtual size_t size() override;
-    virtual void consume() override;
-
-    virtual Token* get(size_t i) const override;
-
-    /// Get all tokens from start..stop inclusively.
-    virtual std::vector<Token *> get(size_t start, size_t stop);
-
-    virtual size_t LA(ssize_t i) override;
-    virtual Token* LT(ssize_t k) override;
-
-    /// Reset this token stream by setting its token source.
-    virtual void setTokenSource(TokenSource *tokenSource);
-    virtual std::vector<Token *> getTokens();
-    virtual std::vector<Token *> getTokens(size_t start, size_t stop);
-
-    /// <summary>
-    /// Given a start and stop index, return a List of all tokens in
-    ///  the token type BitSet.  Return null if no tokens were found.  This
-    ///  method looks at both on and off channel tokens.
-    /// </summary>
-    virtual std::vector<Token *> getTokens(size_t start, size_t stop, const std::vector<size_t> &types);
-    virtual std::vector<Token *> getTokens(size_t start, size_t stop, size_t ttype);
-
-    /// Collect all tokens on specified channel to the right of
-    ///  the current token up until we see a token on DEFAULT_TOKEN_CHANNEL or
-    ///  EOF. If channel is -1, find any non default channel token.
-    virtual std::vector<Token *> getHiddenTokensToRight(size_t tokenIndex, ssize_t channel);
-
-    /// <summary>
-    /// Collect all hidden tokens (any off-default channel) to the right of
-    ///  the current token up until we see a token on DEFAULT_TOKEN_CHANNEL
-    ///  or EOF.
-    /// </summary>
-    virtual std::vector<Token *> getHiddenTokensToRight(size_t tokenIndex);
-
-    /// <summary>
-    /// Collect all tokens on specified channel to the left of
-    ///  the current token up until we see a token on DEFAULT_TOKEN_CHANNEL.
-    ///  If channel is -1, find any non default channel token.
-    /// </summary>
-    virtual std::vector<Token *> getHiddenTokensToLeft(size_t tokenIndex, ssize_t channel);
-
-    /// <summary>
-    /// Collect all hidden tokens (any off-default channel) to the left of
-    ///  the current token up until we see a token on DEFAULT_TOKEN_CHANNEL.
-    /// </summary>
-    virtual std::vector<Token *> getHiddenTokensToLeft(size_t tokenIndex);
-
-    virtual std::string getSourceName() const override;
-    virtual std::string getText() override;
-    virtual std::string getText(const misc::Interval &interval) override;
-    virtual std::string getText(RuleContext *ctx) override;
-    virtual std::string getText(Token *start, Token *stop) override;
-
-    /// Get all tokens from lexer until EOF.
-    virtual void fill();
-
-  protected:
-    /**
-     * The {@link TokenSource} from which tokens for this stream are fetched.
-     */
-    TokenSource *_tokenSource;
-
-    /**
-     * A collection of all tokens fetched from the token source. The list is
-     * considered a complete view of the input once {@link #fetchedEOF} is set
-     * to {@code true}.
-     */
-    std::vector<std::unique_ptr<Token>> _tokens;
-
-    /**
-     * The index into {@link #tokens} of the current token (next token to
-     * {@link #consume}). {@link #tokens}{@code [}{@link #p}{@code ]} should be
-     * {@link #LT LT(1)}.
-     *
-     * <p>This field is set to -1 when the stream is first constructed or when
-     * {@link #setTokenSource} is called, indicating that the first token has
-     * not yet been fetched from the token source. For additional information,
-     * see the documentation of {@link IntStream} for a description of
-     * Initializing Methods.</p>
-     */
-    // ml: since -1 requires to make this member signed for just this single aspect we use a member _needSetup instead.
-    //     Use bool isInitialized() to find out if this stream has started reading.
-    size_t _p;
-
-    /**
-     * Indicates whether the {@link Token#EOF} token has been fetched from
-     * {@link #tokenSource} and added to {@link #tokens}. This field improves
-     * performance for the following cases:
-     *
-     * <ul>
-     * <li>{@link #consume}: The lookahead check in {@link #consume} to prevent
-     * consuming the EOF symbol is optimized by checking the values of
-     * {@link #fetchedEOF} and {@link #p} instead of calling {@link #LA}.</li>
-     * <li>{@link #fetch}: The check to prevent adding multiple EOF symbols into
-     * {@link #tokens} is trivial with this field.</li>
-     * <ul>
-     */
-    bool _fetchedEOF;
-
-    /// <summary>
-    /// Make sure index {@code i} in tokens has a token.
-    /// </summary>
-    /// <returns> {@code true} if a token is located at index {@code i}, otherwise
-    ///    {@code false}. </returns>
-    /// <seealso cref= #get(int i) </seealso>
-    virtual bool sync(size_t i);
-
-    /// <summary>
-    /// Add {@code n} elements to buffer.
-    /// </summary>
-    /// <returns> The actual number of elements added to the buffer. </returns>
-    virtual size_t fetch(size_t n);
-
-    virtual Token* LB(size_t k);
-
-    /// Allowed derived classes to modify the behavior of operations which change
-    /// the current stream position by adjusting the target token index of a seek
-    /// operation. The default implementation simply returns {@code i}. If an
-    /// exception is thrown in this method, the current stream index should not be
-    /// changed.
-    /// <p/>
-    /// For example, <seealso cref="CommonTokenStream"/> overrides this method to ensure that
-    /// the seek target is always an on-channel token.
-    ///
-    /// <param name="i"> The target token index. </param>
-    /// <returns> The adjusted target token index. </returns>
-    virtual ssize_t adjustSeekIndex(size_t i);
-    void lazyInit();
-    virtual void setup();
-
-    /**
-     * Given a starting index, return the index of the next token on channel.
-     * Return {@code i} if {@code tokens[i]} is on channel. Return the index of
-     * the EOF token if there are no tokens on channel between {@code i} and
-     * EOF.
-     */
-    virtual ssize_t nextTokenOnChannel(size_t i, size_t channel);
-
-    /**
-     * Given a starting index, return the index of the previous token on
-     * channel. Return {@code i} if {@code tokens[i]} is on channel. Return -1
-     * if there are no tokens on channel between {@code i} and 0.
-     *
-     * <p>
-     * If {@code i} specifies an index at or after the EOF token, the EOF token
-     * index is returned. This is due to the fact that the EOF token is treated
-     * as though it were on every channel.</p>
-     */
-    virtual ssize_t previousTokenOnChannel(size_t i, size_t channel);
-
-    virtual std::vector<Token *> filterForChannel(size_t from, size_t to, ssize_t channel);
-
-    bool isInitialized() const;
-
-  private:
-    bool _needSetup;
-    void InitializeInstanceFields();
-  };
-
-} // namespace antlr4

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

@@ -1,11 +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 "CharStream.h"
-
-using namespace antlr4;
-
-CharStream::~CharStream() {
-}

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

@@ -1,37 +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 "IntStream.h"
-#include "misc/Interval.h"
-
-namespace antlr4 {
-
-  /// A source of characters for an ANTLR lexer.
-  class ANTLR4CPP_PUBLIC CharStream : public IntStream {
-  public:
-    virtual ~CharStream();
-
-    /// This method returns the text for a range of characters within this input
-    /// stream. This method is guaranteed to not throw an exception if the
-    /// specified interval lies entirely within a marked range. For more
-    /// information about marked ranges, see IntStream::mark.
-    ///
-    /// <param name="interval"> an interval within the stream </param>
-    /// <returns> the text of the specified interval
-    /// </returns>
-    /// <exception cref="NullPointerException"> if {@code interval} is {@code null} </exception>
-    /// <exception cref="IllegalArgumentException"> if {@code interval.a < 0}, or if
-    /// {@code interval.b < interval.a - 1}, or if {@code interval.b} lies at or
-    /// past the end of the stream </exception>
-    /// <exception cref="UnsupportedOperationException"> if the stream does not support
-    /// getting the text of the specified interval </exception>
-    virtual std::string getText(const misc::Interval &interval) = 0;
-
-    virtual std::string toString() const = 0;
-  };
-
-} // namespace antlr4