expressir 1.4.3 → 2.0.0

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

@@ -1,270 +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 "Exceptions.h"
-#include "assert.h"
-#include "TokenSource.h"
-#include "support/Arrays.h"
-#include "misc/Interval.h"
-#include "RuleContext.h"
-#include "WritableToken.h"
-
-#include "UnbufferedTokenStream.h"
-
-using namespace antlr4;
-
-UnbufferedTokenStream::UnbufferedTokenStream(TokenSource *tokenSource) : UnbufferedTokenStream(tokenSource, 256) {
-}
-
-UnbufferedTokenStream::UnbufferedTokenStream(TokenSource *tokenSource, int /*bufferSize*/)
-  : _tokenSource(tokenSource), _lastToken(nullptr), _lastTokenBufferStart(nullptr)
-{
-  InitializeInstanceFields();
-  fill(1); // prime the pump
-}
-
-UnbufferedTokenStream::~UnbufferedTokenStream() {
-}
-
-Token* UnbufferedTokenStream::get(size_t i) const
-{ // get absolute index
-  size_t bufferStartIndex = getBufferStartIndex();
-  if (i < bufferStartIndex || i >= bufferStartIndex + _tokens.size()) {
-    throw IndexOutOfBoundsException(std::string("get(") + std::to_string(i) + std::string(") outside buffer: ")
-      + std::to_string(bufferStartIndex) + std::string("..") + std::to_string(bufferStartIndex + _tokens.size()));
-  }
-  return _tokens[i - bufferStartIndex].get();
-}
-
-Token* UnbufferedTokenStream::LT(ssize_t i)
-{
-  if (i == -1) {
-    return _lastToken;
-  }
-
-  sync(i);
-  ssize_t index = static_cast<ssize_t>(_p) + i - 1;
-  if (index < 0) {
-    throw IndexOutOfBoundsException(std::string("LT(") + std::to_string(i) + std::string(") gives negative index"));
-  }
-
-  if (index >= static_cast<ssize_t>(_tokens.size())) {
-    assert(_tokens.size() > 0 && _tokens.back()->getType() == EOF);
-    return _tokens.back().get();
-  }
-
-  return _tokens[static_cast<size_t>(index)].get();
-}
-
-size_t UnbufferedTokenStream::LA(ssize_t i)
-{
-  return LT(i)->getType();
-}
-
-TokenSource* UnbufferedTokenStream::getTokenSource() const
-{
-  return _tokenSource;
-}
-
-std::string UnbufferedTokenStream::getText()
-{
-  return "";
-}
-
-std::string UnbufferedTokenStream::getText(RuleContext* ctx)
-{
-  return getText(ctx->getSourceInterval());
-}
-
-std::string UnbufferedTokenStream::getText(Token *start, Token *stop)
-{
-  return getText(misc::Interval(start->getTokenIndex(), stop->getTokenIndex()));
-}
-
-void UnbufferedTokenStream::consume()
-{
-  if (LA(1) == EOF) {
-    throw IllegalStateException("cannot consume EOF");
-  }
-
-  // buf always has at least tokens[p==0] in this method due to ctor
-  _lastToken = _tokens[_p].get(); // track last token for LT(-1)
-
-  // if we're at last token and no markers, opportunity to flush buffer
-  if (_p == _tokens.size() - 1 && _numMarkers == 0) {
-    _tokens.clear();
-    _p = 0;
-    _lastTokenBufferStart = _lastToken;
-  } else {
-    ++_p;
-  }
-
-  ++_currentTokenIndex;
-  sync(1);
-}
-
-/// <summary>
-/// Make sure we have 'need' elements from current position <seealso cref="#p p"/>. Last valid
-///  {@code p} index is {@code tokens.length-1}.  {@code p+need-1} is the tokens index 'need' elements
-///  ahead.  If we need 1 element, {@code (p+1-1)==p} must be less than {@code tokens.length}.
-/// </summary>
-void UnbufferedTokenStream::sync(ssize_t want)
-{
-  ssize_t need = (static_cast<ssize_t>(_p) + want - 1) - static_cast<ssize_t>(_tokens.size()) + 1; // how many more elements we need?
-  if (need > 0) {
-    fill(static_cast<size_t>(need));
-  }
-}
-
-/// <summary>
-/// Add {@code n} elements to the buffer. Returns the number of tokens
-/// actually added to the buffer. If the return value is less than {@code n},
-/// then EOF was reached before {@code n} tokens could be added.
-/// </summary>
-size_t UnbufferedTokenStream::fill(size_t n)
-{
-  for (size_t i = 0; i < n; i++) {
-    if (_tokens.size() > 0 && _tokens.back()->getType() == EOF) {
-      return i;
-    }
-
-    add(_tokenSource->nextToken());
-  }
-
-  return n;
-}
-
-void UnbufferedTokenStream::add(std::unique_ptr<Token> t)
-{
-  WritableToken *writable = dynamic_cast<WritableToken *>(t.get());
-  if (writable != nullptr) {
-    writable->setTokenIndex(int(getBufferStartIndex() + _tokens.size()));
-  }
-
-  _tokens.push_back(std::move(t));
-}
-
-/// <summary>
-/// Return a marker that we can release later.
-/// <p/>
-/// The specific marker value used for this class allows for some level of
-/// protection against misuse where {@code seek()} is called on a mark or
-/// {@code release()} is called in the wrong order.
-/// </summary>
-ssize_t UnbufferedTokenStream::mark()
-{
-  if (_numMarkers == 0) {
-    _lastTokenBufferStart = _lastToken;
-  }
-
-  int mark = -_numMarkers - 1;
-  _numMarkers++;
-  return mark;
-}
-
-void UnbufferedTokenStream::release(ssize_t marker)
-{
-  ssize_t expectedMark = -_numMarkers;
-  if (marker != expectedMark) {
-    throw IllegalStateException("release() called with an invalid marker.");
-  }
-
-  _numMarkers--;
-  if (_numMarkers == 0) { // can we release buffer?
-    if (_p > 0) {
-      // Copy tokens[p]..tokens[n-1] to tokens[0]..tokens[(n-1)-p], reset ptrs
-      // p is last valid token; move nothing if p==n as we have no valid char
-      _tokens.erase(_tokens.begin(), _tokens.begin() + static_cast<ssize_t>(_p));
-      _p = 0;
-    }
-
-    _lastTokenBufferStart = _lastToken;
-  }
-}
-
-size_t UnbufferedTokenStream::index()
-{
-  return _currentTokenIndex;
-}
-
-void UnbufferedTokenStream::seek(size_t index)
-{ // seek to absolute index
-  if (index == _currentTokenIndex) {
-    return;
-  }
-
-  if (index > _currentTokenIndex) {
-    sync(ssize_t(index - _currentTokenIndex));
-    index = std::min(index, getBufferStartIndex() + _tokens.size() - 1);
-  }
-
-  size_t bufferStartIndex = getBufferStartIndex();
-  if (bufferStartIndex > index) {
-    throw IllegalArgumentException(std::string("cannot seek to negative index ") + std::to_string(index));
-  }
-
-  size_t i = index - bufferStartIndex;
-  if (i >= _tokens.size()) {
-    throw UnsupportedOperationException(std::string("seek to index outside buffer: ") + std::to_string(index) +
-      " not in " + std::to_string(bufferStartIndex) + ".." + std::to_string(bufferStartIndex + _tokens.size()));
-  }
-
-  _p = i;
-  _currentTokenIndex = index;
-  if (_p == 0) {
-    _lastToken = _lastTokenBufferStart;
-  } else {
-    _lastToken = _tokens[_p - 1].get();
-  }
-}
-
-size_t UnbufferedTokenStream::size()
-{
-  throw UnsupportedOperationException("Unbuffered stream cannot know its size");
-}
-
-std::string UnbufferedTokenStream::getSourceName() const
-{
-  return _tokenSource->getSourceName();
-}
-
-std::string UnbufferedTokenStream::getText(const misc::Interval &interval)
-{
-  size_t bufferStartIndex = getBufferStartIndex();
-  size_t bufferStopIndex = bufferStartIndex + _tokens.size() - 1;
-
-  size_t start = interval.a;
-  size_t stop = interval.b;
-  if (start < bufferStartIndex || stop > bufferStopIndex) {
-    throw UnsupportedOperationException(std::string("interval ") + interval.toString() +
-      " not in token buffer window: " + std::to_string(bufferStartIndex) + ".." + std::to_string(bufferStopIndex));
-  }
-
-  size_t a = start - bufferStartIndex;
-  size_t b = stop - bufferStartIndex;
-
-  std::stringstream ss;
-  for (size_t i = a; i <= b; i++) {
-    Token *t = _tokens[i].get();
-    if (i > 0)
-      ss << ", ";
-    ss << t->getText();
-  }
-
-  return ss.str();
-}
-
-size_t UnbufferedTokenStream::getBufferStartIndex() const
-{
-  return _currentTokenIndex - _p;
-}
-
-void UnbufferedTokenStream::InitializeInstanceFields()
-{
-  _p = 0;
-  _numMarkers = 0;
-  _currentTokenIndex = 0;
-}

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

@@ -1,115 +0,0 @@
-/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
- * Use of this file is governed by the BSD 3-clause license that
- * can be found in the LICENSE.txt file in the project root.
- */
-
-#pragma once
-
-#include "TokenStream.h"
-
-namespace antlr4 {
-
-  class ANTLR4CPP_PUBLIC UnbufferedTokenStream : public TokenStream {
-  public:
-    UnbufferedTokenStream(TokenSource *tokenSource);
-    UnbufferedTokenStream(TokenSource *tokenSource, int bufferSize);
-    UnbufferedTokenStream(const UnbufferedTokenStream& other) = delete;
-    virtual ~UnbufferedTokenStream();
-
-    UnbufferedTokenStream& operator = (const UnbufferedTokenStream& other) = delete;
-
-    virtual Token* get(size_t i) const override;
-    virtual Token* LT(ssize_t i) override;
-    virtual size_t LA(ssize_t i) override;
-
-    virtual TokenSource* getTokenSource() const override;
-
-    virtual std::string getText(const misc::Interval &interval) override;
-    virtual std::string getText() override;
-    virtual std::string getText(RuleContext *ctx) override;
-    virtual std::string getText(Token *start, Token *stop) override;
-
-    virtual void consume() override;
-
-    /// <summary>
-    /// Return a marker that we can release later.
-    /// <p/>
-    /// The specific marker value used for this class allows for some level of
-    /// protection against misuse where {@code seek()} is called on a mark or
-    /// {@code release()} is called in the wrong order.
-    /// </summary>
-    virtual ssize_t mark() override;
-    virtual void release(ssize_t marker) override;
-    virtual size_t index() override;
-    virtual void seek(size_t index) override;
-    virtual size_t size() override;
-    virtual std::string getSourceName() const override;
-
-  protected:
-    /// Make sure we have 'need' elements from current position p. Last valid
-    /// p index is tokens.length - 1.  p + need - 1 is the tokens index 'need' elements
-    /// ahead.  If we need 1 element, (p+1-1)==p must be less than tokens.length.
-    TokenSource *_tokenSource;
-
-    /// <summary>
-    /// A moving window buffer of the data being scanned. While there's a marker,
-    /// we keep adding to buffer. Otherwise, <seealso cref="#consume consume()"/> resets so
-    /// we start filling at index 0 again.
-    /// </summary>
-
-    std::vector<std::unique_ptr<Token>> _tokens;
-
-    /// <summary>
-    /// 0..n-1 index into <seealso cref="#tokens tokens"/> of next token.
-    /// <p/>
-    /// The {@code LT(1)} token is {@code tokens[p]}. If {@code p == n}, we are
-    /// out of buffered tokens.
-    /// </summary>
-    size_t _p;
-
-    /// <summary>
-    /// Count up with <seealso cref="#mark mark()"/> and down with
-    /// <seealso cref="#release release()"/>. When we {@code release()} the last mark,
-    /// {@code numMarkers} reaches 0 and we reset the buffer. Copy
-    /// {@code tokens[p]..tokens[n-1]} to {@code tokens[0]..tokens[(n-1)-p]}.
-    /// </summary>
-    int _numMarkers;
-
-    /// <summary>
-    /// This is the {@code LT(-1)} token for the current position.
-    /// </summary>
-    Token *_lastToken;
-
-    /// <summary>
-    /// When {@code numMarkers > 0}, this is the {@code LT(-1)} token for the
-    /// first token in <seealso cref="#tokens"/>. Otherwise, this is {@code null}.
-    /// </summary>
-    Token *_lastTokenBufferStart;
-
-    /// <summary>
-    /// Absolute token index. It's the index of the token about to be read via
-    /// {@code LT(1)}. Goes from 0 to the number of tokens in the entire stream,
-    /// although the stream size is unknown before the end is reached.
-    /// <p/>
-    /// This value is used to set the token indexes if the stream provides tokens
-    /// that implement <seealso cref="WritableToken"/>.
-    /// </summary>
-    size_t _currentTokenIndex;
-
-    virtual void sync(ssize_t want);
-
-    /// <summary>
-    /// Add {@code n} elements to the buffer. Returns the number of tokens
-    /// actually added to the buffer. If the return value is less than {@code n},
-    /// then EOF was reached before {@code n} tokens could be added.
-    /// </summary>
-    virtual size_t fill(size_t n);
-    virtual void add(std::unique_ptr<Token> t);
-
-    size_t getBufferStartIndex() const;
-
-  private:
-    void InitializeInstanceFields();
-  };
-
-} // namespace antlr4

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

@@ -1,42 +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"
-
-#define ANTLRCPP_VERSION_MAJOR 4
-#define ANTLRCPP_VERSION_MINOR 13
-#define ANTLRCPP_VERSION_PATCH 1
-
-#define ANTLRCPP_MAKE_VERSION(major, minor, patch) ((major) * 100000 + (minor) * 1000 + (patch))
-
-#define ANTLRCPP_VERSION \
-  ANTLRCPP_MAKE_VERSION(ANTLR4CPP_VERSION_MAJOR, ANTLR4CPP_VERSION_MINOR, ANTLR4CPP_VERSION_PATCH)
-
-#define ANTLRCPP_VERSION_STRING \
-  ANTLR4CPP_STRINGIFY(ANTLR4CPP_VERSION_MAJOR) "." \
-  ANTLR4CPP_STRINGIFY(ANTLR4CPP_VERSION_MINOR) "." \
-  ANTLR4CPP_STRINGIFY(ANTLR4CPP_VERSION_PATCH)

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/Vocabulary.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 "Token.h"
-
-#include "Vocabulary.h"
-
-using namespace antlr4::dfa;
-
-const Vocabulary Vocabulary::EMPTY_VOCABULARY;
-
-Vocabulary::Vocabulary(std::vector<std::string> literalNames, std::vector<std::string> symbolicNames)
-: Vocabulary(std::move(literalNames), std::move(symbolicNames), {}) {
-}
-
-Vocabulary::Vocabulary(std::vector<std::string> literalNames,
-  std::vector<std::string> symbolicNames, std::vector<std::string> displayNames)
-  : _literalNames(std::move(literalNames)), _symbolicNames(std::move(symbolicNames)), _displayNames(std::move(displayNames)),
-    _maxTokenType(std::max(_displayNames.size(), std::max(_literalNames.size(), _symbolicNames.size())) - 1) {
-  // See note here on -1 part: https://github.com/antlr/antlr4/pull/1146
-}
-
-std::string_view Vocabulary::getLiteralName(size_t tokenType) const {
-  if (tokenType < _literalNames.size()) {
-    return _literalNames[tokenType];
-  }
-
-  return "";
-}
-
-std::string_view Vocabulary::getSymbolicName(size_t tokenType) const {
-  if (tokenType == Token::EOF) {
-    return "EOF";
-  }
-
-  if (tokenType < _symbolicNames.size()) {
-    return _symbolicNames[tokenType];
-  }
-
-  return "";
-}
-
-std::string Vocabulary::getDisplayName(size_t tokenType) const {
-  if (tokenType < _displayNames.size()) {
-    std::string_view displayName = _displayNames[tokenType];
-    if (!displayName.empty()) {
-      return std::string(displayName);
-    }
-  }
-
-  std::string_view literalName = getLiteralName(tokenType);
-  if (!literalName.empty()) {
-    return std::string(literalName);
-  }
-
-  std::string_view symbolicName = getSymbolicName(tokenType);
-  if (!symbolicName.empty()) {
-    return std::string(symbolicName);
-  }
-
-  return std::to_string(tokenType);
-}

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

@@ -1,177 +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 {
-namespace dfa {
-
-  /// This class provides a default implementation of the <seealso cref="Vocabulary"/>
-  /// interface.
-  class ANTLR4CPP_PUBLIC Vocabulary final {
-  public:
-    /// Gets an empty <seealso cref="Vocabulary"/> instance.
-    ///
-    /// <para>
-    /// No literal or symbol names are assigned to token types, so
-    /// <seealso cref="#getDisplayName(int)"/> returns the numeric value for all tokens
-    /// except <seealso cref="Token#EOF"/>.</para>
-    [[deprecated("Use the default constructor of Vocabulary instead.")]] static const Vocabulary EMPTY_VOCABULARY;
-
-    Vocabulary() {}
-
-    Vocabulary(const Vocabulary&) = default;
-
-    /// <summary>
-    /// Constructs a new instance of <seealso cref="Vocabulary"/> from the specified
-    /// literal and symbolic token names.
-    /// </summary>
-    /// <param name="literalNames"> The literal names assigned to tokens, or {@code null}
-    /// if no literal names are assigned. </param>
-    /// <param name="symbolicNames"> The symbolic names assigned to tokens, or
-    /// {@code null} if no symbolic names are assigned.
-    /// </param>
-    /// <seealso cref= #getLiteralName(int) </seealso>
-    /// <seealso cref= #getSymbolicName(int) </seealso>
-    Vocabulary(std::vector<std::string> literalNames, std::vector<std::string> symbolicNames);
-
-    /// <summary>
-    /// Constructs a new instance of <seealso cref="Vocabulary"/> from the specified
-    /// literal, symbolic, and display token names.
-    /// </summary>
-    /// <param name="literalNames"> The literal names assigned to tokens, or {@code null}
-    /// if no literal names are assigned. </param>
-    /// <param name="symbolicNames"> The symbolic names assigned to tokens, or
-    /// {@code null} if no symbolic names are assigned. </param>
-    /// <param name="displayNames"> The display names assigned to tokens, or {@code null}
-    /// to use the values in {@code literalNames} and {@code symbolicNames} as
-    /// the source of display names, as described in
-    /// <seealso cref="#getDisplayName(int)"/>.
-    /// </param>
-    /// <seealso cref= #getLiteralName(int) </seealso>
-    /// <seealso cref= #getSymbolicName(int) </seealso>
-    /// <seealso cref= #getDisplayName(int) </seealso>
-    Vocabulary(std::vector<std::string> literalNames, std::vector<std::string> symbolicNames,
-               std::vector<std::string> displayNames);
-
-    /// <summary>
-    /// Returns the highest token type value. It can be used to iterate from
-    /// zero to that number, inclusively, thus querying all stored entries. </summary>
-    /// <returns> the highest token type value </returns>
-    constexpr size_t getMaxTokenType() const { return _maxTokenType; }
-
-    /// <summary>
-    /// Gets the string literal associated with a token type. The string returned
-    /// by this method, when not {@code null}, can be used unaltered in a parser
-    /// grammar to represent this token type.
-    ///
-    /// <para>The following table shows examples of lexer rules and the literal
-    /// names assigned to the corresponding token types.</para>
-    ///
-    /// <table>
-    ///  <tr>
-    ///   <th>Rule</th>
-    ///   <th>Literal Name</th>
-    ///   <th>Java String Literal</th>
-    ///  </tr>
-    ///  <tr>
-    ///   <td>{@code THIS : 'this';}</td>
-    ///   <td>{@code 'this'}</td>
-    ///   <td>{@code "'this'"}</td>
-    ///  </tr>
-    ///  <tr>
-    ///   <td>{@code SQUOTE : '\'';}</td>
-    ///   <td>{@code '\''}</td>
-    ///   <td>{@code "'\\''"}</td>
-    ///  </tr>
-    ///  <tr>
-    ///   <td>{@code ID : [A-Z]+;}</td>
-    ///   <td>n/a</td>
-    ///   <td>{@code null}</td>
-    ///  </tr>
-    /// </table>
-    /// </summary>
-    /// <param name="tokenType"> The token type.
-    /// </param>
-    /// <returns> The string literal associated with the specified token type, or
-    /// {@code null} if no string literal is associated with the type. </returns>
-    std::string_view getLiteralName(size_t tokenType) const;
-
-    /// <summary>
-    /// Gets the symbolic name associated with a token type. The string returned
-    /// by this method, when not {@code null}, can be used unaltered in a parser
-    /// grammar to represent this token type.
-    ///
-    /// <para>This method supports token types defined by any of the following
-    /// methods:</para>
-    ///
-    /// <ul>
-    ///  <li>Tokens created by lexer rules.</li>
-    ///  <li>Tokens defined in a <code>tokens{}</code> block in a lexer or parser
-    ///  grammar.</li>
-    ///  <li>The implicitly defined {@code EOF} token, which has the token type
-    ///  <seealso cref="Token#EOF"/>.</li>
-    /// </ul>
-    ///
-    /// <para>The following table shows examples of lexer rules and the literal
-    /// names assigned to the corresponding token types.</para>
-    ///
-    /// <table>
-    ///  <tr>
-    ///   <th>Rule</th>
-    ///   <th>Symbolic Name</th>
-    ///  </tr>
-    ///  <tr>
-    ///   <td>{@code THIS : 'this';}</td>
-    ///   <td>{@code THIS}</td>
-    ///  </tr>
-    ///  <tr>
-    ///   <td>{@code SQUOTE : '\'';}</td>
-    ///   <td>{@code SQUOTE}</td>
-    ///  </tr>
-    ///  <tr>
-    ///   <td>{@code ID : [A-Z]+;}</td>
-    ///   <td>{@code ID}</td>
-    ///  </tr>
-    /// </table>
-    /// </summary>
-    /// <param name="tokenType"> The token type.
-    /// </param>
-    /// <returns> The symbolic name associated with the specified token type, or
-    /// {@code null} if no symbolic name is associated with the type. </returns>
-    std::string_view getSymbolicName(size_t tokenType) const;
-
-    /// <summary>
-    /// Gets the display name of a token type.
-    ///
-    /// <para>ANTLR provides a default implementation of this method, but
-    /// applications are free to override the behavior in any manner which makes
-    /// sense for the application. The default implementation returns the first
-    /// result from the following list which produces a non-{@code null}
-    /// result.</para>
-    ///
-    /// <ol>
-    ///  <li>The result of <seealso cref="#getLiteralName"/></li>
-    ///  <li>The result of <seealso cref="#getSymbolicName"/></li>
-    ///  <li>The result of <seealso cref="Integer#toString"/></li>
-    /// </ol>
-    /// </summary>
-    /// <param name="tokenType"> The token type.
-    /// </param>
-    /// <returns> The display name of the token type, for use in error reporting or
-    /// other user-visible messages which reference specific token types. </returns>
-    std::string getDisplayName(size_t tokenType) const;
-
-  private:
-    std::vector<std::string> const _literalNames;
-    std::vector<std::string> const _symbolicNames;
-    std::vector<std::string> const _displayNames;
-    const size_t _maxTokenType = 0;
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,9 +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 "WritableToken.h"
-
-antlr4::WritableToken::~WritableToken() {
-}