expressir 0.2.4 → 0.2.5

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

@@ -0,0 +1,12 @@
+/* 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 "IntStream.h"
+
+using namespace antlr4;
+
+const std::string IntStream::UNKNOWN_SOURCE_NAME = "<unknown>";
+
+IntStream::~IntStream() = default;

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

@@ -0,0 +1,218 @@
+/* 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 "antlr4-common.h"
+
+namespace antlr4 {
+
+  /// <summary>
+  /// A simple stream of symbols whose values are represented as integers. This
+  /// interface provides <em>marked ranges</em> with support for a minimum level
+  /// of buffering necessary to implement arbitrary lookahead during prediction.
+  /// For more information on marked ranges, see <seealso cref="#mark"/>.
+  /// <p/>
+  /// <strong>Initializing Methods:</strong> Some methods in this interface have
+  /// unspecified behavior if no call to an initializing method has occurred after
+  /// the stream was constructed. The following is a list of initializing methods:
+  ///
+  /// <ul>
+  ///   <li><seealso cref="#LA"/></li>
+  ///   <li><seealso cref="#consume"/></li>
+  ///   <li><seealso cref="#size"/></li>
+  /// </ul>
+  /// </summary>
+  class ANTLR4CPP_PUBLIC IntStream {
+  public:
+    static const size_t EOF = static_cast<size_t>(-1); // std::numeric_limits<size_t>::max(); doesn't work in VS 2013
+
+    /// The value returned by <seealso cref="#LA LA()"/> when the end of the stream is
+    /// reached.
+    /// No explicit EOF definition. We got EOF on all platforms.
+    //static const size_t _EOF = std::ios::eofbit;
+
+    /// <summary>
+    /// The value returned by <seealso cref="#getSourceName"/> when the actual name of the
+    /// underlying source is not known.
+    /// </summary>
+    static const std::string UNKNOWN_SOURCE_NAME;
+
+    virtual ~IntStream();
+
+    /// <summary>
+    /// Consumes the current symbol in the stream. This method has the following
+    /// effects:
+    ///
+    /// <ul>
+    ///   <li><strong>Forward movement:</strong> The value of <seealso cref="#index index()"/>
+    ///		before calling this method is less than the value of {@code index()}
+    ///		after calling this method.</li>
+    ///   <li><strong>Ordered lookahead:</strong> The value of {@code LA(1)} before
+    ///		calling this method becomes the value of {@code LA(-1)} after calling
+    ///		this method.</li>
+    /// </ul>
+    ///
+    /// Note that calling this method does not guarantee that {@code index()} is
+    /// incremented by exactly 1, as that would preclude the ability to implement
+    /// filtering streams (e.g. <seealso cref="CommonTokenStream"/> which distinguishes
+    /// between "on-channel" and "off-channel" tokens).
+    /// </summary>
+    /// <exception cref="IllegalStateException"> if an attempt is made to consume the the
+    /// end of the stream (i.e. if {@code LA(1)==}<seealso cref="#EOF EOF"/> before calling
+    /// {@code consume}). </exception>
+    virtual void consume() = 0;
+
+    /// <summary>
+    /// Gets the value of the symbol at offset {@code i} from the current
+    /// position. When {@code i==1}, this method returns the value of the current
+    /// symbol in the stream (which is the next symbol to be consumed). When
+    /// {@code i==-1}, this method returns the value of the previously read
+    /// symbol in the stream. It is not valid to call this method with
+    /// {@code i==0}, but the specific behavior is unspecified because this
+    /// method is frequently called from performance-critical code.
+    /// <p/>
+    /// This method is guaranteed to succeed if any of the following are true:
+    ///
+    /// <ul>
+    ///   <li>{@code i>0}</li>
+    ///   <li>{@code i==-1} and <seealso cref="#index index()"/> returns a value greater
+    ///     than the value of {@code index()} after the stream was constructed
+    ///     and {@code LA(1)} was called in that order. Specifying the current
+    ///     {@code index()} relative to the index after the stream was created
+    ///     allows for filtering implementations that do not return every symbol
+    ///     from the underlying source. Specifying the call to {@code LA(1)}
+    ///     allows for lazily initialized streams.</li>
+    ///   <li>{@code LA(i)} refers to a symbol consumed within a marked region
+    ///     that has not yet been released.</li>
+    /// </ul>
+    ///
+    /// If {@code i} represents a position at or beyond the end of the stream,
+    /// this method returns <seealso cref="#EOF"/>.
+    /// <p/>
+    /// The return value is unspecified if {@code i<0} and fewer than {@code -i}
+    /// calls to <seealso cref="#consume consume()"/> have occurred from the beginning of
+    /// the stream before calling this method.
+    /// </summary>
+    /// <exception cref="UnsupportedOperationException"> if the stream does not support
+    /// retrieving the value of the specified symbol </exception>
+    virtual size_t LA(ssize_t i) = 0;
+
+    /// <summary>
+    /// A mark provides a guarantee that <seealso cref="#seek seek()"/> operations will be
+    /// valid over a "marked range" extending from the index where {@code mark()}
+    /// was called to the current <seealso cref="#index index()"/>. This allows the use of
+    /// streaming input sources by specifying the minimum buffering requirements
+    /// to support arbitrary lookahead during prediction.
+    /// <p/>
+    /// The returned mark is an opaque handle (type {@code int}) which is passed
+    /// to <seealso cref="#release release()"/> when the guarantees provided by the marked
+    /// range are no longer necessary. When calls to
+    /// {@code mark()}/{@code release()} are nested, the marks must be released
+    /// in reverse order of which they were obtained. Since marked regions are
+    /// used during performance-critical sections of prediction, the specific
+    /// behavior of invalid usage is unspecified (i.e. a mark is not released, or
+    /// a mark is released twice, or marks are not released in reverse order from
+    /// which they were created).
+    /// <p/>
+    /// The behavior of this method is unspecified if no call to an
+    /// <seealso cref="IntStream initializing method"/> has occurred after this stream was
+    /// constructed.
+    /// <p/>
+    /// This method does not change the current position in the input stream.
+    /// <p/>
+    /// The following example shows the use of <seealso cref="#mark mark()"/>,
+    /// <seealso cref="#release release(mark)"/>, <seealso cref="#index index()"/>, and
+    /// <seealso cref="#seek seek(index)"/> as part of an operation to safely work within a
+    /// marked region, then restore the stream position to its original value and
+    /// release the mark.
+    /// <pre>
+    /// IntStream stream = ...;
+    /// int index = -1;
+    /// int mark = stream.mark();
+    /// try {
+    ///   index = stream.index();
+    ///   // perform work here...
+    /// } finally {
+    ///   if (index != -1) {
+    ///     stream.seek(index);
+    ///   }
+    ///   stream.release(mark);
+    /// }
+    /// </pre>
+    /// </summary>
+    /// <returns> An opaque marker which should be passed to
+    /// <seealso cref="#release release()"/> when the marked range is no longer required. </returns>
+    virtual ssize_t mark() = 0;
+
+    /// <summary>
+    /// This method releases a marked range created by a call to
+    /// <seealso cref="#mark mark()"/>. Calls to {@code release()} must appear in the
+    /// reverse order of the corresponding calls to {@code mark()}. If a mark is
+    /// released twice, or if marks are not released in reverse order of the
+    /// corresponding calls to {@code mark()}, the behavior is unspecified.
+    /// <p/>
+    /// For more information and an example, see <seealso cref="#mark"/>.
+    /// </summary>
+    /// <param name="marker"> A marker returned by a call to {@code mark()}. </param>
+    /// <seealso cref= #mark </seealso>
+    virtual void release(ssize_t marker) = 0;
+
+    /// <summary>
+    /// Return the index into the stream of the input symbol referred to by
+    /// {@code LA(1)}.
+    /// <p/>
+    /// The behavior of this method is unspecified if no call to an
+    /// <seealso cref="IntStream initializing method"/> has occurred after this stream was
+    /// constructed.
+    /// </summary>
+    virtual size_t index() = 0;
+
+    /// <summary>
+    /// Set the input cursor to the position indicated by {@code index}. If the
+    /// specified index lies past the end of the stream, the operation behaves as
+    /// though {@code index} was the index of the EOF symbol. After this method
+    /// returns without throwing an exception, the at least one of the following
+    /// will be true.
+    ///
+    /// <ul>
+    ///   <li><seealso cref="#index index()"/> will return the index of the first symbol
+    ///     appearing at or after the specified {@code index}. Specifically,
+    ///     implementations which filter their sources should automatically
+    ///     adjust {@code index} forward the minimum amount required for the
+    ///     operation to target a non-ignored symbol.</li>
+    ///   <li>{@code LA(1)} returns <seealso cref="#EOF"/></li>
+    /// </ul>
+    ///
+    /// This operation is guaranteed to not throw an exception if {@code index}
+    /// lies within a marked region. For more information on marked regions, see
+    /// <seealso cref="#mark"/>. The behavior of this method is unspecified if no call to
+    /// an <seealso cref="IntStream initializing method"/> has occurred after this stream
+    /// was constructed.
+    /// </summary>
+    /// <param name="index"> The absolute index to seek to.
+    /// </param>
+    /// <exception cref="IllegalArgumentException"> if {@code index} is less than 0 </exception>
+    /// <exception cref="UnsupportedOperationException"> if the stream does not support
+    /// seeking to the specified index </exception>
+    virtual void seek(size_t index) = 0;
+
+    /// <summary>
+    /// Returns the total number of symbols in the stream, including a single EOF
+    /// symbol.
+    /// </summary>
+    /// <exception cref="UnsupportedOperationException"> if the size of the stream is
+    /// unknown. </exception>
+    virtual size_t size() = 0;
+
+    /// <summary>
+    /// Gets the name of the underlying symbol source. This method returns a
+    /// non-null, non-empty string. If such a name is not known, this method
+    /// returns <seealso cref="#UNKNOWN_SOURCE_NAME"/>.
+    /// </summary>
+    virtual std::string getSourceName() const = 0;
+  };
+
+} // namespace antlr4

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

@@ -0,0 +1,19 @@
+/* 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 "InterpreterRuleContext.h"
+
+using namespace antlr4;
+
+InterpreterRuleContext::InterpreterRuleContext() : ParserRuleContext() {
+}
+
+InterpreterRuleContext::InterpreterRuleContext(ParserRuleContext *parent, size_t invokingStateNumber, size_t ruleIndex)
+  : ParserRuleContext(parent, invokingStateNumber), _ruleIndex(ruleIndex) {
+}
+
+size_t InterpreterRuleContext::getRuleIndex() const {
+  return _ruleIndex;
+}

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

@@ -0,0 +1,45 @@
+/* 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 "ParserRuleContext.h"
+
+namespace antlr4 {
+
+  /**
+   * This class extends {@link ParserRuleContext} by allowing the value of
+   * {@link #getRuleIndex} to be explicitly set for the context.
+   *
+   * <p>
+   * {@link ParserRuleContext} does not include field storage for the rule index
+   * since the context classes created by the code generator override the
+   * {@link #getRuleIndex} method to return the correct value for that context.
+   * Since the parser interpreter does not use the context classes generated for a
+   * parser, this class (with slightly more memory overhead per node) is used to
+   * provide equivalent functionality.</p>
+   */
+  class ANTLR4CPP_PUBLIC InterpreterRuleContext : public ParserRuleContext {
+  public:
+    InterpreterRuleContext();
+
+    /**
+     * Constructs a new {@link InterpreterRuleContext} with the specified
+     * parent, invoking state, and rule index.
+     *
+     * @param parent The parent context.
+     * @param invokingStateNumber The invoking state number.
+     * @param ruleIndex The rule index for the current context.
+     */
+    InterpreterRuleContext(ParserRuleContext *parent, size_t invokingStateNumber, size_t ruleIndex);
+
+    virtual size_t getRuleIndex() const override;
+
+  protected:
+    /** This is the backing field for {@link #getRuleIndex}. */
+    const size_t _ruleIndex = INVALID_INDEX;
+};
+
+} // namespace antlr4

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

@@ -0,0 +1,295 @@
+/* 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/LexerATNSimulator.h"
+#include "Exceptions.h"
+#include "misc/Interval.h"
+#include "CommonTokenFactory.h"
+#include "LexerNoViableAltException.h"
+#include "ANTLRErrorListener.h"
+#include "support/CPPUtils.h"
+#include "CommonToken.h"
+#include "support/StringUtils.h"
+
+#include "Lexer.h"
+
+#define DEBUG_LEXER 0
+
+using namespace antlrcpp;
+using namespace antlr4;
+
+Lexer::Lexer() : Recognizer() {
+  InitializeInstanceFields();
+  _input = nullptr;
+}
+
+Lexer::Lexer(CharStream *input) : Recognizer(), _input(input) {
+  InitializeInstanceFields();
+}
+
+void Lexer::reset() {
+  // wack Lexer state variables
+  _input->seek(0); // rewind the input
+
+  _syntaxErrors = 0;
+  token.reset();
+  type = Token::INVALID_TYPE;
+  channel = Token::DEFAULT_CHANNEL;
+  tokenStartCharIndex = INVALID_INDEX;
+  tokenStartCharPositionInLine = 0;
+  tokenStartLine = 0;
+  type = 0;
+  _text = "";
+
+  hitEOF = false;
+  mode = Lexer::DEFAULT_MODE;
+  modeStack.clear();
+
+  getInterpreter<atn::LexerATNSimulator>()->reset();
+}
+
+std::unique_ptr<Token> Lexer::nextToken() {
+  // Mark start location in char stream so unbuffered streams are
+  // guaranteed at least have text of current token
+  ssize_t tokenStartMarker = _input->mark();
+
+  auto onExit = finally([this, tokenStartMarker]{
+    // make sure we release marker after match or
+    // unbuffered char stream will keep buffering
+    _input->release(tokenStartMarker);
+  });
+
+  while (true) {
+  outerContinue:
+    if (hitEOF) {
+      emitEOF();
+      return std::move(token);
+    }
+
+    token.reset();
+    channel = Token::DEFAULT_CHANNEL;
+    tokenStartCharIndex = _input->index();
+    tokenStartCharPositionInLine = getInterpreter<atn::LexerATNSimulator>()->getCharPositionInLine();
+    tokenStartLine = getInterpreter<atn::LexerATNSimulator>()->getLine();
+    _text = "";
+    do {
+      type = Token::INVALID_TYPE;
+      size_t ttype;
+      try {
+        ttype = getInterpreter<atn::LexerATNSimulator>()->match(_input, mode);
+      } catch (LexerNoViableAltException &e) {
+        notifyListeners(e); // report error
+        recover(e);
+        ttype = SKIP;
+      }
+      if (_input->LA(1) == EOF) {
+        hitEOF = true;
+      }
+      if (type == Token::INVALID_TYPE) {
+        type = ttype;
+      }
+      if (type == SKIP) {
+        goto outerContinue;
+      }
+    } while (type == MORE);
+    if (token == nullptr) {
+      emit();
+    }
+    return std::move(token);
+  }
+}
+
+void Lexer::skip() {
+  type = SKIP;
+}
+
+void Lexer::more() {
+  type = MORE;
+}
+
+void Lexer::setMode(size_t m) {
+  mode = m;
+}
+
+void Lexer::pushMode(size_t m) {
+#if DEBUG_LEXER == 1
+    std::cout << "pushMode " << m << std::endl;
+#endif
+
+  modeStack.push_back(mode);
+  setMode(m);
+}
+
+size_t Lexer::popMode() {
+  if (modeStack.empty()) {
+    throw EmptyStackException();
+  }
+#if DEBUG_LEXER == 1
+    std::cout << std::string("popMode back to ") << modeStack.back() << std::endl;
+#endif
+
+  setMode(modeStack.back());
+  modeStack.pop_back();
+  return mode;
+}
+
+
+Ref<TokenFactory<CommonToken>> Lexer::getTokenFactory() {
+  return _factory;
+}
+
+void Lexer::setInputStream(IntStream *input) {
+  reset();
+  _input = dynamic_cast<CharStream*>(input);
+}
+
+std::string Lexer::getSourceName() {
+  return _input->getSourceName();
+}
+
+CharStream* Lexer::getInputStream() {
+  return _input;
+}
+
+void Lexer::emit(std::unique_ptr<Token> newToken) {
+  token = std::move(newToken);
+}
+
+Token* Lexer::emit() {
+  emit(_factory->create({ this, _input }, type, _text, channel,
+    tokenStartCharIndex, getCharIndex() - 1, tokenStartLine, tokenStartCharPositionInLine));
+  return token.get();
+}
+
+Token* Lexer::emitEOF() {
+  size_t cpos = getCharPositionInLine();
+  size_t line = getLine();
+  emit(_factory->create({ this, _input }, EOF, "", Token::DEFAULT_CHANNEL, _input->index(), _input->index() - 1, line, cpos));
+  return token.get();
+}
+
+size_t Lexer::getLine() const {
+  return getInterpreter<atn::LexerATNSimulator>()->getLine();
+}
+
+size_t Lexer::getCharPositionInLine() {
+  return getInterpreter<atn::LexerATNSimulator>()->getCharPositionInLine();
+}
+
+void Lexer::setLine(size_t line) {
+  getInterpreter<atn::LexerATNSimulator>()->setLine(line);
+}
+
+void Lexer::setCharPositionInLine(size_t charPositionInLine) {
+  getInterpreter<atn::LexerATNSimulator>()->setCharPositionInLine(charPositionInLine);
+}
+
+size_t Lexer::getCharIndex() {
+  return _input->index();
+}
+
+std::string Lexer::getText() {
+  if (!_text.empty()) {
+    return _text;
+  }
+  return getInterpreter<atn::LexerATNSimulator>()->getText(_input);
+}
+
+void Lexer::setText(const std::string &text) {
+  _text = text;
+}
+
+std::unique_ptr<Token> Lexer::getToken() {
+  return std::move(token);
+}
+
+void Lexer::setToken(std::unique_ptr<Token> newToken) {
+  token = std::move(newToken);
+}
+
+void Lexer::setType(size_t ttype) {
+  type = ttype;
+}
+
+size_t Lexer::getType() {
+  return type;
+}
+
+void Lexer::setChannel(size_t newChannel) {
+  channel = newChannel;
+}
+
+size_t Lexer::getChannel() {
+  return channel;
+}
+
+std::vector<std::unique_ptr<Token>> Lexer::getAllTokens() {
+  std::vector<std::unique_ptr<Token>> tokens;
+  std::unique_ptr<Token> t = nextToken();
+  while (t->getType() != EOF) {
+    tokens.push_back(std::move(t));
+    t = nextToken();
+  }
+  return tokens;
+}
+
+void Lexer::recover(const LexerNoViableAltException &/*e*/) {
+  if (_input->LA(1) != EOF) {
+    // skip a char and try again
+    getInterpreter<atn::LexerATNSimulator>()->consume(_input);
+  }
+}
+
+void Lexer::notifyListeners(const LexerNoViableAltException & /*e*/) {
+  ++_syntaxErrors;
+  std::string text = _input->getText(misc::Interval(tokenStartCharIndex, _input->index()));
+  std::string msg = std::string("token recognition error at: '") + getErrorDisplay(text) + std::string("'");
+
+  ProxyErrorListener &listener = getErrorListenerDispatch();
+  listener.syntaxError(this, nullptr, tokenStartLine, tokenStartCharPositionInLine, msg, std::current_exception());
+}
+
+std::string Lexer::getErrorDisplay(const std::string &s) {
+  std::stringstream ss;
+  for (auto c : s) {
+    switch (c) {
+    case '\n':
+      ss << "\\n";
+      break;
+    case '\t':
+      ss << "\\t";
+      break;
+    case '\r':
+      ss << "\\r";
+      break;
+    default:
+      ss << c;
+      break;
+    }
+  }
+  return ss.str();
+}
+
+void Lexer::recover(RecognitionException * /*re*/) {
+  // TODO: Do we lose character or line position information?
+  _input->consume();
+}
+
+size_t Lexer::getNumberOfSyntaxErrors() {
+  return _syntaxErrors;
+}
+
+void Lexer::InitializeInstanceFields() {
+  _syntaxErrors = 0;
+  token = nullptr;
+  _factory = CommonTokenFactory::DEFAULT;
+  tokenStartCharIndex = INVALID_INDEX;
+  tokenStartLine = 0;
+  tokenStartCharPositionInLine = 0;
+  hitEOF = false;
+  channel = 0;
+  type = 0;
+  mode = Lexer::DEFAULT_MODE;
+}