expressir 1.4.2 → 2.0.0

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

@@ -1,64 +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 "Exceptions.h"
-
-using namespace antlr4;
-
-RuntimeException::RuntimeException(const std::string &msg) : std::exception(), _message(msg) {
-}
-
-const char* RuntimeException::what() const noexcept {
-  return _message.c_str();
-}
-
-//------------------ IOException ---------------------------------------------------------------------------------------
-
-IOException::IOException(const std::string &msg) : std::exception(), _message(msg) {
-}
-
-const char* IOException::what() const noexcept {
-  return _message.c_str();
-}
-
-//------------------ IllegalStateException -----------------------------------------------------------------------------
-
-IllegalStateException::~IllegalStateException() {
-}
-
-//------------------ IllegalArgumentException --------------------------------------------------------------------------
-
-IllegalArgumentException::~IllegalArgumentException() {
-}
-
-//------------------ NullPointerException ------------------------------------------------------------------------------
-
-NullPointerException::~NullPointerException() {
-}
-
-//------------------ IndexOutOfBoundsException -------------------------------------------------------------------------
-
-IndexOutOfBoundsException::~IndexOutOfBoundsException() {
-}
-
-//------------------ UnsupportedOperationException ---------------------------------------------------------------------
-
-UnsupportedOperationException::~UnsupportedOperationException() {
-}
-
-//------------------ EmptyStackException -------------------------------------------------------------------------------
-
-EmptyStackException::~EmptyStackException() {
-}
-
-//------------------ CancellationException -----------------------------------------------------------------------------
-
-CancellationException::~CancellationException() {
-}
-
-//------------------ ParseCancellationException ------------------------------------------------------------------------
-
-ParseCancellationException::~ParseCancellationException() {
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/Exceptions.h

@@ -1,99 +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 "antlr4-common.h"
-
-namespace antlr4 {
-
-  // An exception hierarchy modelled loosely after java.lang.* exceptions.
-  class ANTLR4CPP_PUBLIC RuntimeException : public std::exception {
-  private:
-    std::string _message;
-  public:
-    RuntimeException(const std::string &msg = "");
-
-    virtual const char* what() const noexcept override;
-  };
-
-  class ANTLR4CPP_PUBLIC IllegalStateException : public RuntimeException {
-  public:
-    IllegalStateException(const std::string &msg = "") : RuntimeException(msg) {}
-    IllegalStateException(IllegalStateException const&) = default;
-    ~IllegalStateException();
-    IllegalStateException& operator=(IllegalStateException const&) = default;
-  };
-
-  class ANTLR4CPP_PUBLIC IllegalArgumentException : public RuntimeException {
-  public:
-    IllegalArgumentException(IllegalArgumentException const&) = default;
-    IllegalArgumentException(const std::string &msg = "") : RuntimeException(msg) {}
-    ~IllegalArgumentException();
-    IllegalArgumentException& operator=(IllegalArgumentException const&) = default;
-  };
-
-  class ANTLR4CPP_PUBLIC NullPointerException : public RuntimeException {
-  public:
-    NullPointerException(const std::string &msg = "") : RuntimeException(msg) {}
-    NullPointerException(NullPointerException const&) = default;
-    ~NullPointerException();
-    NullPointerException& operator=(NullPointerException const&) = default;
-  };
-
-  class ANTLR4CPP_PUBLIC IndexOutOfBoundsException : public RuntimeException {
-  public:
-    IndexOutOfBoundsException(const std::string &msg = "") : RuntimeException(msg) {}
-    IndexOutOfBoundsException(IndexOutOfBoundsException const&) = default;
-    ~IndexOutOfBoundsException();
-    IndexOutOfBoundsException& operator=(IndexOutOfBoundsException const&) = default;
-  };
-
-  class ANTLR4CPP_PUBLIC UnsupportedOperationException : public RuntimeException {
-  public:
-    UnsupportedOperationException(const std::string &msg = "") : RuntimeException(msg) {}
-    UnsupportedOperationException(UnsupportedOperationException const&) = default;
-    ~UnsupportedOperationException();
-    UnsupportedOperationException& operator=(UnsupportedOperationException const&) = default;
-
-  };
-
-  class ANTLR4CPP_PUBLIC EmptyStackException : public RuntimeException {
-  public:
-    EmptyStackException(const std::string &msg = "") : RuntimeException(msg) {}
-    EmptyStackException(EmptyStackException const&) = default;
-    ~EmptyStackException();
-    EmptyStackException& operator=(EmptyStackException const&) = default;
-  };
-
-  // IOException is not a runtime exception (in the java hierarchy).
-  // Hence we have to duplicate the RuntimeException implementation.
-  class ANTLR4CPP_PUBLIC IOException : public std::exception {
-  private:
-    std::string _message;
-
-  public:
-    IOException(const std::string &msg = "");
-
-    virtual const char* what() const noexcept override;
-  };
-
-  class ANTLR4CPP_PUBLIC CancellationException : public IllegalStateException {
-  public:
-    CancellationException(const std::string &msg = "") : IllegalStateException(msg) {}
-    CancellationException(CancellationException const&) = default;
-    ~CancellationException();
-    CancellationException& operator=(CancellationException const&) = default;
-  };
-
-  class ANTLR4CPP_PUBLIC ParseCancellationException : public CancellationException {
-  public:
-    ParseCancellationException(const std::string &msg = "") : CancellationException(msg) {}
-    ParseCancellationException(ParseCancellationException const&) = default;
-    ~ParseCancellationException();
-    ParseCancellationException& operator=(ParseCancellationException const&) = default;
-  };
-
-} // namespace antlr4

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

@@ -1,52 +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 "atn/ParserATNSimulator.h"
-#include "Parser.h"
-#include "atn/PredicateTransition.h"
-#include "atn/ATN.h"
-#include "atn/ATNState.h"
-#include "support/Casts.h"
-#include "support/CPPUtils.h"
-
-#include "FailedPredicateException.h"
-
-using namespace antlr4;
-using namespace antlrcpp;
-
-FailedPredicateException::FailedPredicateException(Parser *recognizer) : FailedPredicateException(recognizer, "", "") {
-}
-
-FailedPredicateException::FailedPredicateException(Parser *recognizer, const std::string &predicate): FailedPredicateException(recognizer, predicate, "") {
-}
-
-FailedPredicateException::FailedPredicateException(Parser *recognizer, const std::string &predicate, const std::string &message)
-  : RecognitionException(!message.empty() ? message : "failed predicate: " + predicate + "?", recognizer,
-                         recognizer->getInputStream(), recognizer->getContext(), recognizer->getCurrentToken()) {
-
-  atn::ATNState *s = recognizer->getInterpreter<atn::ATNSimulator>()->atn.states[recognizer->getState()];
-  const atn::Transition *transition = s->transitions[0].get();
-  if (transition->getTransitionType() == atn::TransitionType::PREDICATE) {
-    _ruleIndex = downCast<const atn::PredicateTransition&>(*transition).getRuleIndex();
-    _predicateIndex = downCast<const atn::PredicateTransition&>(*transition).getPredIndex();
-  } else {
-    _ruleIndex = 0;
-    _predicateIndex = 0;
-  }
-
-  _predicate = predicate;
-}
-
-size_t FailedPredicateException::getRuleIndex() {
-  return _ruleIndex;
-}
-
-size_t FailedPredicateException::getPredIndex() {
-  return _predicateIndex;
-}
-
-std::string FailedPredicateException::getPredicate() {
-  return _predicate;
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/FailedPredicateException.h

@@ -1,32 +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 "RecognitionException.h"
-
-namespace antlr4 {
-
-  /// A semantic predicate failed during validation.  Validation of predicates
-  /// occurs when normally parsing the alternative just like matching a token.
-  /// Disambiguating predicate evaluation occurs when we test a predicate during
-  /// prediction.
-  class ANTLR4CPP_PUBLIC FailedPredicateException : public RecognitionException {
-  public:
-    explicit FailedPredicateException(Parser *recognizer);
-    FailedPredicateException(Parser *recognizer, const std::string &predicate);
-    FailedPredicateException(Parser *recognizer, const std::string &predicate, const std::string &message);
-
-    virtual size_t getRuleIndex();
-    virtual size_t getPredIndex();
-    virtual std::string getPredicate();
-
-  private:
-    size_t _ruleIndex;
-    size_t _predicateIndex;
-    std::string _predicate;
-  };
-
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/FlatHashMap.h

@@ -1,57 +0,0 @@
-// Copyright 2012-2022 The ANTLR Project
-//
-// Redistribution and use in source and binary forms, with or without modification, are permitted
-// provided that the following conditions are met:
-//
-// 1. Redistributions of source code must retain the above copyright notice, this list of conditions
-//    and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright notice, this list of
-//    conditions and the following disclaimer in the documentation and/or other materials provided
-//    with the distribution.
-//
-// 3. Neither the name of the copyright holder nor the names of its contributors may be used to
-//    endorse or promote products derived from this software without specific prior written
-//    permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
-// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
-// WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#pragma once
-
-#include "antlr4-common.h"
-
-#if ANTLR4CPP_USING_ABSEIL
-#include "absl/container/flat_hash_map.h"
-#else
-#include <unordered_map>
-#endif
-
-// By default ANTLRv4 uses containers provided by the C++ standard library. In most deployments this
-// is fine, however in some using custom containers may be preferred. This header allows that by
-// optionally supporting some alternative implementations and allowing for more easier patching of
-// other alternatives.
-
-namespace antlr4 {
-
-#if ANTLR4CPP_USING_ABSEIL
-  template <typename Key, typename Value,
-            typename Hash = typename absl::flat_hash_map<Key, Value>::hasher,
-            typename Equal = typename absl::flat_hash_map<Key, Value>::key_equal,
-            typename Allocator = typename absl::flat_hash_map<Key, Value>::allocator_type>
-  using FlatHashMap = absl::flat_hash_map<Key, Value, Hash, Equal, Allocator>;
-#else
-  template <typename Key, typename Value,
-            typename Hash = std::hash<Key>,
-            typename Equal = std::equal_to<Key>,
-            typename Allocator = std::allocator<std::pair<const Key, Value>>>
-  using FlatHashMap = std::unordered_map<Key, Value, Hash, Equal, Allocator>;
-#endif
-
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/FlatHashSet.h

@@ -1,57 +0,0 @@
-// Copyright 2012-2022 The ANTLR Project
-//
-// Redistribution and use in source and binary forms, with or without modification, are permitted
-// provided that the following conditions are met:
-//
-// 1. Redistributions of source code must retain the above copyright notice, this list of conditions
-//    and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright notice, this list of
-//    conditions and the following disclaimer in the documentation and/or other materials provided
-//    with the distribution.
-//
-// 3. Neither the name of the copyright holder nor the names of its contributors may be used to
-//    endorse or promote products derived from this software without specific prior written
-//    permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
-// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
-// WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#pragma once
-
-#include "antlr4-common.h"
-
-#if ANTLR4CPP_USING_ABSEIL
-#include "absl/container/flat_hash_set.h"
-#else
-#include <unordered_set>
-#endif
-
-// By default ANTLRv4 uses containers provided by the C++ standard library. In most deployments this
-// is fine, however in some using custom containers may be preferred. This header allows that by
-// optionally supporting some alternative implementations and allowing for more easier patching of
-// other alternatives.
-
-namespace antlr4 {
-
-#if ANTLR4CPP_USING_ABSEIL
-  template <typename Key,
-            typename Hash = typename absl::flat_hash_set<Key>::hasher,
-            typename Equal = typename absl::flat_hash_set<Key>::key_equal,
-            typename Allocator = typename absl::flat_hash_set<Key>::allocator_type>
-  using FlatHashSet = absl::flat_hash_set<Key, Hash, Equal, Allocator>;
-#else
-  template <typename Key,
-            typename Hash = std::hash<Key>,
-            typename Equal = std::equal_to<Key>,
-            typename Allocator = std::allocator<Key>>
-  using FlatHashSet = std::unordered_set<Key, Hash, Equal, Allocator>;
-#endif
-
-} // namespace antlr4

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

@@ -1,18 +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 "Parser.h"
-
-#include "InputMismatchException.h"
-
-using namespace antlr4;
-
-InputMismatchException::InputMismatchException(Parser *recognizer)
-  : RecognitionException(recognizer, recognizer->getInputStream(), recognizer->getContext(),
-                         recognizer->getCurrentToken()) {
-}
-
-InputMismatchException::~InputMismatchException() {
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/InputMismatchException.h

@@ -1,24 +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 "RecognitionException.h"
-
-namespace antlr4 {
-
-  /// <summary>
-  /// This signifies any kind of mismatched input exceptions such as
-  ///  when the current input does not match the expected token.
-  /// </summary>
-  class ANTLR4CPP_PUBLIC InputMismatchException : public RecognitionException {
-  public:
-    InputMismatchException(Parser *recognizer);
-    InputMismatchException(InputMismatchException const&) = default;
-    ~InputMismatchException();
-    InputMismatchException& operator=(InputMismatchException const&) = default;
-  };
-
-} // namespace antlr4

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

@@ -1,12 +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 "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

@@ -1,218 +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 "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 constexpr size_t EOF = std::numeric_limits<size_t>::max();
-
-    /// 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

@@ -1,19 +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 "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;
-}