expressir 1.4.2 → 2.0.0

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 std::unique_ptr<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

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

@@ -1,336 +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 "NoViableAltException.h"
-#include "misc/IntervalSet.h"
-#include "atn/ParserATNSimulator.h"
-#include "InputMismatchException.h"
-#include "FailedPredicateException.h"
-#include "ParserRuleContext.h"
-#include "atn/RuleTransition.h"
-#include "atn/ATN.h"
-#include "atn/ATNState.h"
-#include "support/StringUtils.h"
-#include "support/Casts.h"
-#include "Parser.h"
-#include "CommonToken.h"
-#include "Vocabulary.h"
-
-#include "DefaultErrorStrategy.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-
-using namespace antlrcpp;
-
-DefaultErrorStrategy::DefaultErrorStrategy() {
-  InitializeInstanceFields();
-}
-
-DefaultErrorStrategy::~DefaultErrorStrategy() {
-}
-
-void DefaultErrorStrategy::reset(Parser *recognizer) {
-  _errorSymbols.clear();
-  endErrorCondition(recognizer);
-}
-
-void DefaultErrorStrategy::beginErrorCondition(Parser * /*recognizer*/) {
-  errorRecoveryMode = true;
-}
-
-bool DefaultErrorStrategy::inErrorRecoveryMode(Parser * /*recognizer*/) {
-  return errorRecoveryMode;
-}
-
-void DefaultErrorStrategy::endErrorCondition(Parser * /*recognizer*/) {
-  errorRecoveryMode = false;
-  lastErrorIndex = -1;
-}
-
-void DefaultErrorStrategy::reportMatch(Parser *recognizer) {
-  endErrorCondition(recognizer);
-}
-
-void DefaultErrorStrategy::reportError(Parser *recognizer, const RecognitionException &e) {
-  // If we've already reported an error and have not matched a token
-  // yet successfully, don't report any errors.
-  if (inErrorRecoveryMode(recognizer)) {
-    return; // don't report spurious errors
-  }
-
-  beginErrorCondition(recognizer);
-  if (is<const NoViableAltException *>(&e)) {
-    reportNoViableAlternative(recognizer, static_cast<const NoViableAltException &>(e));
-  } else if (is<const InputMismatchException *>(&e)) {
-    reportInputMismatch(recognizer, static_cast<const InputMismatchException &>(e));
-  } else if (is<const FailedPredicateException *>(&e)) {
-    reportFailedPredicate(recognizer, static_cast<const FailedPredicateException &>(e));
-  } else if (is<const RecognitionException *>(&e)) {
-    recognizer->notifyErrorListeners(e.getOffendingToken(), e.what(), std::current_exception());
-  }
-}
-
-void DefaultErrorStrategy::recover(Parser *recognizer, std::exception_ptr /*e*/) {
-  if (lastErrorIndex == static_cast<int>(recognizer->getInputStream()->index()) &&
-      lastErrorStates.contains(recognizer->getState())) {
-
-    // uh oh, another error at same token index and previously-visited
-    // state in ATN; must be a case where LT(1) is in the recovery
-    // token set so nothing got consumed. Consume a single token
-    // at least to prevent an infinite loop; this is a failsafe.
-    recognizer->consume();
-  }
-  lastErrorIndex = static_cast<int>(recognizer->getInputStream()->index());
-  lastErrorStates.add(recognizer->getState());
-  misc::IntervalSet followSet = getErrorRecoverySet(recognizer);
-  consumeUntil(recognizer, followSet);
-}
-
-void DefaultErrorStrategy::sync(Parser *recognizer) {
-  atn::ATNState *s = recognizer->getInterpreter<atn::ATNSimulator>()->atn.states[recognizer->getState()];
-
-  // If already recovering, don't try to sync
-  if (inErrorRecoveryMode(recognizer)) {
-    return;
-  }
-
-  TokenStream *tokens = recognizer->getTokenStream();
-  size_t la = tokens->LA(1);
-
-  // try cheaper subset first; might get lucky. seems to shave a wee bit off
-  auto nextTokens = recognizer->getATN().nextTokens(s);
-  if (nextTokens.contains(Token::EPSILON) || nextTokens.contains(la)) {
-    return;
-  }
-
-  switch (s->getStateType()) {
-    case atn::ATNStateType::BLOCK_START:
-    case atn::ATNStateType::STAR_BLOCK_START:
-    case atn::ATNStateType::PLUS_BLOCK_START:
-    case atn::ATNStateType::STAR_LOOP_ENTRY:
-      // report error and recover if possible
-      if (singleTokenDeletion(recognizer) != nullptr) {
-        return;
-      }
-
-      throw InputMismatchException(recognizer);
-
-    case atn::ATNStateType::PLUS_LOOP_BACK:
-    case atn::ATNStateType::STAR_LOOP_BACK: {
-      reportUnwantedToken(recognizer);
-      misc::IntervalSet expecting = recognizer->getExpectedTokens();
-      misc::IntervalSet whatFollowsLoopIterationOrRule = expecting.Or(getErrorRecoverySet(recognizer));
-      consumeUntil(recognizer, whatFollowsLoopIterationOrRule);
-    }
-      break;
-
-    default:
-      // do nothing if we can't identify the exact kind of ATN state
-      break;
-  }
-}
-
-void DefaultErrorStrategy::reportNoViableAlternative(Parser *recognizer, const NoViableAltException &e) {
-  TokenStream *tokens = recognizer->getTokenStream();
-  std::string input;
-  if (tokens != nullptr) {
-    if (e.getStartToken()->getType() == Token::EOF) {
-      input = "<EOF>";
-    } else {
-      input = tokens->getText(e.getStartToken(), e.getOffendingToken());
-    }
-  } else {
-    input = "<unknown input>";
-  }
-  std::string msg = "no viable alternative at input " + escapeWSAndQuote(input);
-  recognizer->notifyErrorListeners(e.getOffendingToken(), msg, std::make_exception_ptr(e));
-}
-
-void DefaultErrorStrategy::reportInputMismatch(Parser *recognizer, const InputMismatchException &e) {
-  std::string msg = "mismatched input " + getTokenErrorDisplay(e.getOffendingToken()) +
-  " expecting " + e.getExpectedTokens().toString(recognizer->getVocabulary());
-  recognizer->notifyErrorListeners(e.getOffendingToken(), msg, std::make_exception_ptr(e));
-}
-
-void DefaultErrorStrategy::reportFailedPredicate(Parser *recognizer, const FailedPredicateException &e) {
-  const std::string& ruleName = recognizer->getRuleNames()[recognizer->getContext()->getRuleIndex()];
-  std::string msg = "rule " + ruleName + " " + e.what();
-  recognizer->notifyErrorListeners(e.getOffendingToken(), msg, std::make_exception_ptr(e));
-}
-
-void DefaultErrorStrategy::reportUnwantedToken(Parser *recognizer) {
-  if (inErrorRecoveryMode(recognizer)) {
-    return;
-  }
-
-  beginErrorCondition(recognizer);
-
-  Token *t = recognizer->getCurrentToken();
-  std::string tokenName = getTokenErrorDisplay(t);
-  misc::IntervalSet expecting = getExpectedTokens(recognizer);
-
-  std::string msg = "extraneous input " + tokenName + " expecting " + expecting.toString(recognizer->getVocabulary());
-  recognizer->notifyErrorListeners(t, msg, nullptr);
-}
-
-void DefaultErrorStrategy::reportMissingToken(Parser *recognizer) {
-  if (inErrorRecoveryMode(recognizer)) {
-    return;
-  }
-
-  beginErrorCondition(recognizer);
-
-  Token *t = recognizer->getCurrentToken();
-  misc::IntervalSet expecting = getExpectedTokens(recognizer);
-  std::string expectedText = expecting.toString(recognizer->getVocabulary());
-  std::string msg = "missing " + expectedText + " at " + getTokenErrorDisplay(t);
-
-  recognizer->notifyErrorListeners(t, msg, nullptr);
-}
-
-Token* DefaultErrorStrategy::recoverInline(Parser *recognizer) {
-  // Single token deletion.
-  Token *matchedSymbol = singleTokenDeletion(recognizer);
-  if (matchedSymbol) {
-    // We have deleted the extra token.
-    // Now, move past ttype token as if all were ok.
-    recognizer->consume();
-    return matchedSymbol;
-  }
-
-  // Single token insertion.
-  if (singleTokenInsertion(recognizer)) {
-    return getMissingSymbol(recognizer);
-  }
-
-  // Even that didn't work; must throw the exception.
-  throw InputMismatchException(recognizer);
-}
-
-bool DefaultErrorStrategy::singleTokenInsertion(Parser *recognizer) {
-  ssize_t currentSymbolType = recognizer->getInputStream()->LA(1);
-
-  // if current token is consistent with what could come after current
-  // ATN state, then we know we're missing a token; error recovery
-  // is free to conjure up and insert the missing token
-  atn::ATNState *currentState = recognizer->getInterpreter<atn::ATNSimulator>()->atn.states[recognizer->getState()];
-  atn::ATNState *next = currentState->transitions[0]->target;
-  const atn::ATN &atn = recognizer->getInterpreter<atn::ATNSimulator>()->atn;
-  misc::IntervalSet expectingAtLL2 = atn.nextTokens(next, recognizer->getContext());
-  if (expectingAtLL2.contains(currentSymbolType)) {
-    reportMissingToken(recognizer);
-    return true;
-  }
-  return false;
-}
-
-Token* DefaultErrorStrategy::singleTokenDeletion(Parser *recognizer) {
-  size_t nextTokenType = recognizer->getInputStream()->LA(2);
-  misc::IntervalSet expecting = getExpectedTokens(recognizer);
-  if (expecting.contains(nextTokenType)) {
-    reportUnwantedToken(recognizer);
-    recognizer->consume(); // simply delete extra token
-                           // we want to return the token we're actually matching
-    Token *matchedSymbol = recognizer->getCurrentToken();
-    reportMatch(recognizer); // we know current token is correct
-    return matchedSymbol;
-  }
-  return nullptr;
-}
-
-Token* DefaultErrorStrategy::getMissingSymbol(Parser *recognizer) {
-  Token *currentSymbol = recognizer->getCurrentToken();
-  misc::IntervalSet expecting = getExpectedTokens(recognizer);
-  size_t expectedTokenType = expecting.getMinElement(); // get any element
-  std::string tokenText;
-  if (expectedTokenType == Token::EOF) {
-    tokenText = "<missing EOF>";
-  } else {
-    tokenText = "<missing " + recognizer->getVocabulary().getDisplayName(expectedTokenType) + ">";
-  }
-  Token *current = currentSymbol;
-  Token *lookback = recognizer->getTokenStream()->LT(-1);
-  if (current->getType() == Token::EOF && lookback != nullptr) {
-    current = lookback;
-  }
-
-  _errorSymbols.push_back(recognizer->getTokenFactory()->create(
-    { current->getTokenSource(), current->getTokenSource()->getInputStream() },
-    expectedTokenType, tokenText, Token::DEFAULT_CHANNEL, INVALID_INDEX, INVALID_INDEX,
-    current->getLine(), current->getCharPositionInLine()));
-
-  return _errorSymbols.back().get();
-}
-
-misc::IntervalSet DefaultErrorStrategy::getExpectedTokens(Parser *recognizer) {
-  return recognizer->getExpectedTokens();
-}
-
-std::string DefaultErrorStrategy::getTokenErrorDisplay(Token *t) {
-  if (t == nullptr) {
-    return "<no Token>";
-  }
-  std::string s = getSymbolText(t);
-  if (s == "") {
-    if (getSymbolType(t) == Token::EOF) {
-      s = "<EOF>";
-    } else {
-      s = "<" + std::to_string(getSymbolType(t)) + ">";
-    }
-  }
-  return escapeWSAndQuote(s);
-}
-
-std::string DefaultErrorStrategy::getSymbolText(Token *symbol) {
-  return symbol->getText();
-}
-
-size_t DefaultErrorStrategy::getSymbolType(Token *symbol) {
-  return symbol->getType();
-}
-
-std::string DefaultErrorStrategy::escapeWSAndQuote(const std::string &s) const {
-  std::string result;
-  result.reserve(s.size() + 2);
-  result.push_back('\'');
-  antlrcpp::escapeWhitespace(result, s);
-  result.push_back('\'');
-  result.shrink_to_fit();
-  return result;
-}
-
-misc::IntervalSet DefaultErrorStrategy::getErrorRecoverySet(Parser *recognizer) {
-  const atn::ATN &atn = recognizer->getInterpreter<atn::ATNSimulator>()->atn;
-  RuleContext *ctx = recognizer->getContext();
-  misc::IntervalSet recoverSet;
-  while (ctx->invokingState != ATNState::INVALID_STATE_NUMBER) {
-    // compute what follows who invoked us
-    atn::ATNState *invokingState = atn.states[ctx->invokingState];
-    const atn::RuleTransition *rt = downCast<const atn::RuleTransition*>(invokingState->transitions[0].get());
-    misc::IntervalSet follow = atn.nextTokens(rt->followState);
-    recoverSet.addAll(follow);
-
-    if (ctx->parent == nullptr)
-      break;
-    ctx = static_cast<RuleContext *>(ctx->parent);
-  }
-  recoverSet.remove(Token::EPSILON);
-
-  return recoverSet;
-}
-
-void DefaultErrorStrategy::consumeUntil(Parser *recognizer, const misc::IntervalSet &set) {
-  size_t ttype = recognizer->getInputStream()->LA(1);
-  while (ttype != Token::EOF && !set.contains(ttype)) {
-    recognizer->consume();
-    ttype = recognizer->getInputStream()->LA(1);
-  }
-}
-
-void DefaultErrorStrategy::InitializeInstanceFields() {
-  errorRecoveryMode = false;
-  lastErrorIndex = -1;
-}