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

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

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

@@ -1,39 +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 "CommonToken.h"
-#include "CharStream.h"
-
-#include "CommonTokenFactory.h"
-
-using namespace antlr4;
-
-const Ref<TokenFactory<CommonToken>> CommonTokenFactory::DEFAULT = std::make_shared<CommonTokenFactory>();
-
-CommonTokenFactory::CommonTokenFactory(bool copyText_) : copyText(copyText_) {
-}
-
-CommonTokenFactory::CommonTokenFactory() : CommonTokenFactory(false) {
-}
-
-std::unique_ptr<CommonToken> CommonTokenFactory::create(std::pair<TokenSource*, CharStream*> source, size_t type,
-  const std::string &text, size_t channel, size_t start, size_t stop, size_t line, size_t charPositionInLine) {
-
-  std::unique_ptr<CommonToken> t(new CommonToken(source, type, channel, start, stop));
-  t->setLine(line);
-  t->setCharPositionInLine(charPositionInLine);
-  if (text != "") {
-    t->setText(text);
-  } else if (copyText && source.second != nullptr) {
-    t->setText(source.second->getText(misc::Interval(start, stop)));
-  }
-
-  return t;
-}
-
-std::unique_ptr<CommonToken> CommonTokenFactory::create(size_t type, const std::string &text) {
-  return std::unique_ptr<CommonToken>(new CommonToken(type, text));
-}

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

@@ -1,74 +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 "TokenFactory.h"
-
-namespace antlr4 {
-
-  /**
-   * This default implementation of {@link TokenFactory} creates
-   * {@link CommonToken} objects.
-   */
-  class ANTLR4CPP_PUBLIC CommonTokenFactory : public TokenFactory<CommonToken> {
-  public:
-    /**
-     * The default {@link CommonTokenFactory} instance.
-     *
-     * <p>
-     * This token factory does not explicitly copy token text when constructing
-     * tokens.</p>
-     */
-    static const Ref<TokenFactory<CommonToken>> DEFAULT;
-
-  protected:
-    /**
-     * Indicates whether {@link CommonToken#setText} should be called after
-     * constructing tokens to explicitly set the text. This is useful for cases
-     * where the input stream might not be able to provide arbitrary substrings
-     * of text from the input after the lexer creates a token (e.g. the
-     * implementation of {@link CharStream#getText} in
-     * {@link UnbufferedCharStream} throws an
-     * {@link UnsupportedOperationException}). Explicitly setting the token text
-     * allows {@link Token#getText} to be called at any time regardless of the
-     * input stream implementation.
-     *
-     * <p>
-     * The default value is {@code false} to avoid the performance and memory
-     * overhead of copying text for every token unless explicitly requested.</p>
-     */
-    const bool copyText;
-
-  public:
-    /**
-     * Constructs a {@link CommonTokenFactory} with the specified value for
-     * {@link #copyText}.
-     *
-     * <p>
-     * When {@code copyText} is {@code false}, the {@link #DEFAULT} instance
-     * should be used instead of constructing a new instance.</p>
-     *
-     * @param copyText The value for {@link #copyText}.
-     */
-    CommonTokenFactory(bool copyText);
-
-    /**
-     * Constructs a {@link CommonTokenFactory} with {@link #copyText} set to
-     * {@code false}.
-     *
-     * <p>
-     * The {@link #DEFAULT} instance should be used instead of calling this
-     * directly.</p>
-     */
-    CommonTokenFactory();
-
-    virtual std::unique_ptr<CommonToken> create(std::pair<TokenSource*, CharStream*> source, size_t type,
-      const std::string &text, size_t channel, size_t start, size_t stop, size_t line, size_t charPositionInLine) override;
-
-    virtual std::unique_ptr<CommonToken> create(size_t type, const std::string &text) override;
-  };
-
-} // namespace antlr4

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

@@ -1,78 +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 "CommonTokenStream.h"
-
-using namespace antlr4;
-
-CommonTokenStream::CommonTokenStream(TokenSource *tokenSource) : CommonTokenStream(tokenSource, Token::DEFAULT_CHANNEL) {
-}
-
-CommonTokenStream::CommonTokenStream(TokenSource *tokenSource, size_t channel_)
-: BufferedTokenStream(tokenSource), channel(channel_) {
-}
-
-ssize_t CommonTokenStream::adjustSeekIndex(size_t i) {
-  return nextTokenOnChannel(i, channel);
-}
-
-Token* CommonTokenStream::LB(size_t k) {
-  if (k == 0 || k > _p) {
-    return nullptr;
-  }
-
-  ssize_t i = static_cast<ssize_t>(_p);
-  size_t n = 1;
-  // find k good tokens looking backwards
-  while (n <= k) {
-    // skip off-channel tokens
-    i = previousTokenOnChannel(i - 1, channel);
-    n++;
-  }
-  if (i < 0) {
-    return nullptr;
-  }
-
-  return _tokens[i].get();
-}
-
-Token* CommonTokenStream::LT(ssize_t k) {
-  lazyInit();
-  if (k == 0) {
-    return nullptr;
-  }
-  if (k < 0) {
-    return LB(static_cast<size_t>(-k));
-  }
-  size_t i = _p;
-  ssize_t n = 1; // we know tokens[p] is a good one
-                 // find k good tokens
-  while (n < k) {
-    // skip off-channel tokens, but make sure to not look past EOF
-    if (sync(i + 1)) {
-      i = nextTokenOnChannel(i + 1, channel);
-    }
-    n++;
-  }
-
-  return _tokens[i].get();
-}
-
-int CommonTokenStream::getNumberOfOnChannelTokens() {
-  int n = 0;
-  fill();
-  for (size_t i = 0; i < _tokens.size(); i++) {
-    Token *t = _tokens[i].get();
-    if (t->getChannel() == channel) {
-      n++;
-    }
-    if (t->getType() == Token::EOF) {
-      break;
-    }
-  }
-  return n;
-}

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

@@ -1,79 +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 "BufferedTokenStream.h"
-
-namespace antlr4 {
-
-  /**
-   * This class extends {@link BufferedTokenStream} with functionality to filter
-   * token streams to tokens on a particular channel (tokens where
-   * {@link Token#getChannel} returns a particular value).
-   *
-   * <p>
-   * This token stream provides access to all tokens by index or when calling
-   * methods like {@link #getText}. The channel filtering is only used for code
-   * accessing tokens via the lookahead methods {@link #LA}, {@link #LT}, and
-   * {@link #LB}.</p>
-   *
-   * <p>
-   * By default, tokens are placed on the default channel
-   * ({@link Token#DEFAULT_CHANNEL}), but may be reassigned by using the
-   * {@code ->channel(HIDDEN)} lexer command, or by using an embedded action to
-   * call {@link Lexer#setChannel}.
-   * </p>
-   *
-   * <p>
-   * Note: lexer rules which use the {@code ->skip} lexer command or call
-   * {@link Lexer#skip} do not produce tokens at all, so input text matched by
-   * such a rule will not be available as part of the token stream, regardless of
-   * channel.</p>
-   */
-  class ANTLR4CPP_PUBLIC CommonTokenStream : public BufferedTokenStream {
-  public:
-    /**
-     * Constructs a new {@link CommonTokenStream} using the specified token
-     * source and the default token channel ({@link Token#DEFAULT_CHANNEL}).
-     *
-     * @param tokenSource The token source.
-     */
-    CommonTokenStream(TokenSource *tokenSource);
-
-    /**
-     * Constructs a new {@link CommonTokenStream} using the specified token
-     * source and filtering tokens to the specified channel. Only tokens whose
-     * {@link Token#getChannel} matches {@code channel} or have the
-     * {@link Token#getType} equal to {@link Token#EOF} will be returned by the
-     * token stream lookahead methods.
-     *
-     * @param tokenSource The token source.
-     * @param channel The channel to use for filtering tokens.
-     */
-    CommonTokenStream(TokenSource *tokenSource, size_t channel);
-
-    virtual Token* LT(ssize_t k) override;
-
-    /// Count EOF just once.
-    virtual int getNumberOfOnChannelTokens();
-    
-  protected:
-    /**
-     * Specifies the channel to use for filtering tokens.
-     *
-     * <p>
-     * The default value is {@link Token#DEFAULT_CHANNEL}, which matches the
-     * default channel assigned to tokens created by the lexer.</p>
-     */
-    size_t channel;
-
-    virtual ssize_t adjustSeekIndex(size_t i) override;
-
-    virtual Token* LB(size_t k) override;
-
-  };
-
-} // namespace antlr4

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

@@ -1,15 +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"
-
-using namespace antlr4;
-
-ConsoleErrorListener ConsoleErrorListener::INSTANCE;
-
-void ConsoleErrorListener::syntaxError(Recognizer * /*recognizer*/, Token * /*offendingSymbol*/,
-  size_t line, size_t charPositionInLine, const std::string &msg, std::exception_ptr /*e*/)  {
-  std::cerr << "line " << line << ":" << charPositionInLine << " " << msg << std::endl;
-}

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

@@ -1,35 +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 "BaseErrorListener.h"
-
-namespace antlr4 {
-
-  class ANTLR4CPP_PUBLIC ConsoleErrorListener : public BaseErrorListener {
-  public:
-    /**
-     * Provides a default instance of {@link ConsoleErrorListener}.
-     */
-    static ConsoleErrorListener INSTANCE;
-
-    /**
-     * {@inheritDoc}
-     *
-     * <p>
-     * This implementation prints messages to {@link System#err} containing the
-     * values of {@code line}, {@code charPositionInLine}, and {@code msg} using
-     * the following format.</p>
-     *
-     * <pre>
-     * line <em>line</em>:<em>charPositionInLine</em> <em>msg</em>
-     * </pre>
-     */
-    virtual void syntaxError(Recognizer *recognizer, Token * offendingSymbol, size_t line, size_t charPositionInLine,
-                             const std::string &msg, std::exception_ptr e) override;
-  };
-
-} // namespace antlr4