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

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

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

@@ -1,195 +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 "TokenSource.h"
-#include "CharStream.h"
-#include "Recognizer.h"
-#include "Vocabulary.h"
-
-#include "misc/Interval.h"
-
-#include "support/StringUtils.h"
-#include "support/CPPUtils.h"
-
-#include "CommonToken.h"
-
-using namespace antlr4;
-using namespace antlr4::misc;
-
-using namespace antlrcpp;
-
-const std::pair<TokenSource*, CharStream*> CommonToken::EMPTY_SOURCE;
-
-CommonToken::CommonToken(size_t type) {
-  InitializeInstanceFields();
-  _type = type;
-}
-
-CommonToken::CommonToken(std::pair<TokenSource*, CharStream*> source, size_t type, size_t channel, size_t start, size_t stop) {
-  InitializeInstanceFields();
-  _source = source;
-  _type = type;
-  _channel = channel;
-  _start = start;
-  _stop = stop;
-  if (_source.first != nullptr) {
-    _line = static_cast<int>(source.first->getLine());
-    _charPositionInLine = source.first->getCharPositionInLine();
-  }
-}
-
-CommonToken::CommonToken(size_t type, const std::string &text) {
-  InitializeInstanceFields();
-  _type = type;
-  _channel = DEFAULT_CHANNEL;
-  _text = text;
-  _source = EMPTY_SOURCE;
-}
-
-CommonToken::CommonToken(Token *oldToken) {
-  InitializeInstanceFields();
-  _type = oldToken->getType();
-  _line = oldToken->getLine();
-  _index = oldToken->getTokenIndex();
-  _charPositionInLine = oldToken->getCharPositionInLine();
-  _channel = oldToken->getChannel();
-  _start = oldToken->getStartIndex();
-  _stop = oldToken->getStopIndex();
-
-  if (is<CommonToken *>(oldToken)) {
-    _text = (static_cast<CommonToken *>(oldToken))->_text;
-    _source = (static_cast<CommonToken *>(oldToken))->_source;
-  } else {
-    _text = oldToken->getText();
-    _source = { oldToken->getTokenSource(), oldToken->getInputStream() };
-  }
-}
-
-size_t CommonToken::getType() const {
-  return _type;
-}
-
-void CommonToken::setLine(size_t line) {
-  _line = line;
-}
-
-std::string CommonToken::getText() const {
-  if (!_text.empty()) {
-    return _text;
-  }
-
-  CharStream *input = getInputStream();
-  if (input == nullptr) {
-    return "";
-  }
-  size_t n = input->size();
-  if (_start < n && _stop < n) {
-    return input->getText(misc::Interval(_start, _stop));
-  } else {
-    return "<EOF>";
-  }
-}
-
-void CommonToken::setText(const std::string &text) {
-  _text = text;
-}
-
-size_t CommonToken::getLine() const {
-  return _line;
-}
-
-size_t CommonToken::getCharPositionInLine() const {
-  return _charPositionInLine;
-}
-
-void CommonToken::setCharPositionInLine(size_t charPositionInLine) {
-  _charPositionInLine = charPositionInLine;
-}
-
-size_t CommonToken::getChannel() const {
-  return _channel;
-}
-
-void CommonToken::setChannel(size_t channel) {
-  _channel = channel;
-}
-
-void CommonToken::setType(size_t type) {
-  _type = type;
-}
-
-size_t CommonToken::getStartIndex() const {
-  return _start;
-}
-
-void CommonToken::setStartIndex(size_t start) {
-  _start = start;
-}
-
-size_t CommonToken::getStopIndex() const {
-  return _stop;
-}
-
-void CommonToken::setStopIndex(size_t stop) {
-  _stop = stop;
-}
-
-size_t CommonToken::getTokenIndex() const {
-  return _index;
-}
-
-void CommonToken::setTokenIndex(size_t index) {
-  _index = index;
-}
-
-antlr4::TokenSource *CommonToken::getTokenSource() const {
-  return _source.first;
-}
-
-antlr4::CharStream *CommonToken::getInputStream() const {
-  return _source.second;
-}
-
-std::string CommonToken::toString() const {
-  return toString(nullptr);
-}
-
-std::string CommonToken::toString(Recognizer *r) const {
-  std::stringstream ss;
-
-  std::string channelStr;
-  if (_channel > 0) {
-    channelStr = ",channel=" + std::to_string(_channel);
-  }
-  std::string txt = getText();
-  if (!txt.empty()) {
-    antlrcpp::replaceAll(txt, "\n", "\\n");
-    antlrcpp::replaceAll(txt, "\r", "\\r");
-    antlrcpp::replaceAll(txt, "\t", "\\t");
-  } else {
-    txt = "<no text>";
-  }
-
-  std::string typeString = std::to_string(symbolToNumeric(_type));
-  if (r != nullptr)
-    typeString = r->getVocabulary().getDisplayName(_type);
-
-  ss << "[@" << symbolToNumeric(getTokenIndex()) << "," << symbolToNumeric(_start) << ":" << symbolToNumeric(_stop)
-    << "='" << txt << "',<" << typeString << ">" << channelStr << "," << _line << ":"
-    << getCharPositionInLine() << "]";
-
-  return ss.str();
-}
-
-void CommonToken::InitializeInstanceFields() {
-  _type = 0;
-  _line = 0;
-  _charPositionInLine = INVALID_INDEX;
-  _channel = DEFAULT_CHANNEL;
-  _index = INVALID_INDEX;
-  _start = 0;
-  _stop = 0;
-  _source = EMPTY_SOURCE;
-}

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

@@ -1,158 +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 "WritableToken.h"
-
-namespace antlr4 {
-
-  class ANTLR4CPP_PUBLIC CommonToken : public WritableToken {
-  protected:
-    /**
-     * An empty {@link Pair} which is used as the default value of
-     * {@link #source} for tokens that do not have a source.
-     */
-    static const std::pair<TokenSource *, CharStream *> EMPTY_SOURCE;
-
-    /**
-     * This is the backing field for {@link #getType} and {@link #setType}.
-     */
-    size_t _type;
-
-    /**
-     * This is the backing field for {@link #getLine} and {@link #setLine}.
-     */
-    size_t _line;
-
-    /**
-     * This is the backing field for {@link #getCharPositionInLine} and
-     * {@link #setCharPositionInLine}.
-     */
-    size_t _charPositionInLine; // set to invalid position
-
-    /**
-     * This is the backing field for {@link #getChannel} and
-     * {@link #setChannel}.
-     */
-    size_t _channel;
-
-    /**
-     * This is the backing field for {@link #getTokenSource} and
-     * {@link #getInputStream}.
-     *
-     * <p>
-     * These properties share a field to reduce the memory footprint of
-     * {@link CommonToken}. Tokens created by a {@link CommonTokenFactory} from
-     * the same source and input stream share a reference to the same
-     * {@link Pair} containing these values.</p>
-     */
-
-    std::pair<TokenSource *, CharStream *> _source; // ml: pure references, usually from statically allocated classes.
-
-    /**
-     * This is the backing field for {@link #getText} when the token text is
-     * explicitly set in the constructor or via {@link #setText}.
-     *
-     * @see #getText()
-     */
-    std::string _text;
-
-    /**
-     * This is the backing field for {@link #getTokenIndex} and
-     * {@link #setTokenIndex}.
-     */
-    size_t _index;
-
-    /**
-     * This is the backing field for {@link #getStartIndex} and
-     * {@link #setStartIndex}.
-     */
-    size_t _start;
-
-    /**
-     * This is the backing field for {@link #getStopIndex} and
-     * {@link #setStopIndex}.
-     */
-    size_t _stop;
-
-  public:
-    /**
-     * Constructs a new {@link CommonToken} with the specified token type.
-     *
-     * @param type The token type.
-     */
-    CommonToken(size_t type);
-    CommonToken(std::pair<TokenSource*, CharStream*> source, size_t type, size_t channel, size_t start, size_t stop);
-
-    /**
-     * Constructs a new {@link CommonToken} with the specified token type and
-     * text.
-     *
-     * @param type The token type.
-     * @param text The text of the token.
-     */
-    CommonToken(size_t type, const std::string &text);
-
-    /**
-     * Constructs a new {@link CommonToken} as a copy of another {@link Token}.
-     *
-     * <p>
-     * If {@code oldToken} is also a {@link CommonToken} instance, the newly
-     * constructed token will share a reference to the {@link #text} field and
-     * the {@link Pair} stored in {@link #source}. Otherwise, {@link #text} will
-     * be assigned the result of calling {@link #getText}, and {@link #source}
-     * will be constructed from the result of {@link Token#getTokenSource} and
-     * {@link Token#getInputStream}.</p>
-     *
-     * @param oldToken The token to copy.
-     */
-    CommonToken(Token *oldToken);
-
-    virtual size_t getType() const override;
-
-    /**
-     * Explicitly set the text for this token. If {code text} is not
-     * {@code null}, then {@link #getText} will return this value rather than
-     * extracting the text from the input.
-     *
-     * @param text The explicit text of the token, or {@code null} if the text
-     * should be obtained from the input along with the start and stop indexes
-     * of the token.
-     */
-    virtual void setText(const std::string &text) override;
-    virtual std::string getText() const override;
-
-    virtual void setLine(size_t line) override;
-    virtual size_t getLine() const override;
-
-    virtual size_t getCharPositionInLine() const override;
-    virtual void setCharPositionInLine(size_t charPositionInLine) override;
-
-    virtual size_t getChannel() const override;
-    virtual void setChannel(size_t channel) override;
-
-    virtual void setType(size_t type) override;
-
-    virtual size_t getStartIndex() const override;
-    virtual void setStartIndex(size_t start);
-
-    virtual size_t getStopIndex() const override;
-    virtual void setStopIndex(size_t stop);
-
-    virtual size_t getTokenIndex() const override;
-    virtual void setTokenIndex(size_t index) override;
-
-    virtual TokenSource *getTokenSource() const override;
-    virtual CharStream *getInputStream() const override;
-
-    virtual std::string toString() const override;
-
-    virtual std::string toString(Recognizer *r) const;
-  private:
-    void InitializeInstanceFields();
-  };
-
-} // namespace antlr4