expressir 1.4.2 → 2.0.0

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

@@ -1,155 +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>
-  /// This class provides access to the current version of the ANTLR 4 runtime
-  /// library as compile-time and runtime constants, along with methods for
-  /// checking for matching version numbers and notifying listeners in the case
-  /// where a version mismatch is detected.
-  ///
-  /// <para>
-  /// The runtime version information is provided by <seealso cref="#VERSION"/> and
-  /// <seealso cref="#getRuntimeVersion()"/>. Detailed information about these values is
-  /// provided in the documentation for each member.</para>
-  ///
-  /// <para>
-  /// The runtime version check is implemented by <seealso cref="#checkVersion"/>. Detailed
-  /// information about incorporating this call into user code, as well as its use
-  /// in generated code, is provided in the documentation for the method.</para>
-  ///
-  /// <para>
-  /// Version strings x.y and x.y.z are considered "compatible" and no error
-  /// would be generated. Likewise, version strings x.y-SNAPSHOT and x.y.z are
-  /// considered "compatible" because the major and minor components x.y
-  /// are the same in each.</para>
-  ///
-  /// <para>
-  /// To trap any error messages issued by this code, use System.setErr()
-  /// in your main() startup code.
-  /// </para>
-  ///
-  /// @since 4.3
-  /// </summary>
-  class ANTLR4CPP_PUBLIC RuntimeMetaData {
-  public:
-    /// A compile-time constant containing the current version of the ANTLR 4
-    /// runtime library.
-    ///
-    /// <para>
-    /// This compile-time constant value allows generated parsers and other
-    /// libraries to include a literal reference to the version of the ANTLR 4
-    /// runtime library the code was compiled against. At each release, we
-    /// change this value.</para>
-    ///
-    /// <para>Version numbers are assumed to have the form
-    ///
-    /// <em>major</em>.<em>minor</em>.<em>patch</em>.<em>revision</em>-<em>suffix</em>,
-    ///
-    /// with the individual components defined as follows.</para>
-    ///
-    /// <ul>
-    /// <li><em>major</em> is a required non-negative integer, and is equal to
-    /// {@code 4} for ANTLR 4.</li>
-    /// <li><em>minor</em> is a required non-negative integer.</li>
-    /// <li><em>patch</em> is an optional non-negative integer. When
-    /// <em>patch</em> is omitted, the {@code .} (dot) appearing before it is
-    /// also omitted.</li>
-    /// <li><em>revision</em> is an optional non-negative integer, and may only
-    /// be included when <em>patch</em> is also included. When <em>revision</em>
-    /// is omitted, the {@code .} (dot) appearing before it is also omitted.</li>
-    /// <li><em>suffix</em> is an optional string. When <em>suffix</em> is
-    /// omitted, the {@code -} (hyphen-minus) appearing before it is also
-    /// omitted.</li>
-    /// </ul>
-    static const std::string VERSION;
-
-    /// <summary>
-    /// Gets the currently executing version of the ANTLR 4 runtime library.
-    ///
-    /// <para>
-    /// This method provides runtime access to the <seealso cref="#VERSION"/> field, as
-    /// opposed to directly referencing the field as a compile-time constant.</para>
-    /// </summary>
-    /// <returns> The currently executing version of the ANTLR 4 library </returns>
-
-    static std::string getRuntimeVersion();
-
-    /// <summary>
-    /// This method provides the ability to detect mismatches between the version
-    /// of ANTLR 4 used to generate a parser, the version of the ANTLR runtime a
-    /// parser was compiled against, and the version of the ANTLR runtime which
-    /// is currently executing.
-    ///
-    /// <para>
-    /// The version check is designed to detect the following two specific
-    /// scenarios.</para>
-    ///
-    /// <ul>
-    /// <li>The ANTLR Tool version used for code generation does not match the
-    /// currently executing runtime version.</li>
-    /// <li>The ANTLR Runtime version referenced at the time a parser was
-    /// compiled does not match the currently executing runtime version.</li>
-    /// </ul>
-    ///
-    /// <para>
-    /// Starting with ANTLR 4.3, the code generator emits a call to this method
-    /// using two constants in each generated lexer and parser: a hard-coded
-    /// constant indicating the version of the tool used to generate the parser
-    /// and a reference to the compile-time constant <seealso cref="#VERSION"/>. At
-    /// runtime, this method is called during the initialization of the generated
-    /// parser to detect mismatched versions, and notify the registered listeners
-    /// prior to creating instances of the parser.</para>
-    ///
-    /// <para>
-    /// This method does not perform any detection or filtering of semantic
-    /// changes between tool and runtime versions. It simply checks for a
-    /// version match and emits an error to stderr if a difference
-    /// is detected.</para>
-    ///
-    /// <para>
-    /// Note that some breaking changes between releases could result in other
-    /// types of runtime exceptions, such as a <seealso cref="LinkageError"/>, prior to
-    /// calling this method. In these cases, the underlying version mismatch will
-    /// not be reported here. This method is primarily intended to
-    /// notify users of potential semantic changes between releases that do not
-    /// result in binary compatibility problems which would be detected by the
-    /// class loader. As with semantic changes, changes that break binary
-    /// compatibility between releases are mentioned in the release notes
-    /// accompanying the affected release.</para>
-    ///
-    /// <para>
-    /// <strong>Additional note for target developers:</strong> The version check
-    /// implemented by this class is designed to address specific compatibility
-    /// concerns that may arise during the execution of Java applications. Other
-    /// targets should consider the implementation of this method in the context
-    /// of that target's known execution environment, which may or may not
-    /// resemble the design provided for the Java target.</para>
-    /// </summary>
-    /// <param name="generatingToolVersion"> The version of the tool used to generate a parser.
-    /// This value may be null when called from user code that was not generated
-    /// by, and does not reference, the ANTLR 4 Tool itself. </param>
-    /// <param name="compileTimeVersion"> The version of the runtime the parser was
-    /// compiled against. This should always be passed using a direct reference
-    /// to <seealso cref="#VERSION"/>. </param>
-    static void checkVersion(const std::string &generatingToolVersion, const std::string &compileTimeVersion);
-
-    /// <summary>
-    /// Gets the major and minor version numbers from a version string. For
-    /// details about the syntax of the input {@code version}.
-    /// E.g., from x.y.z return x.y.
-    /// </summary>
-    /// <param name="version"> The complete version string. </param>
-    /// <returns> A string of the form <em>major</em>.<em>minor</em> containing
-    /// only the major and minor components of the version string. </returns>
-    static std::string getMajorMinorVersion(const std::string &version);
-  };
-
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/Token.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 "Token.h"
-
-antlr4::Token::~Token() {
-}

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

@@ -1,92 +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 "IntStream.h"
-
-namespace antlr4 {
-
-  /// A token has properties: text, type, line, character position in the line
-  /// (so we can ignore tabs), token channel, index, and source from which
-  /// we obtained this token.
-  class ANTLR4CPP_PUBLIC Token {
-  public:
-    static constexpr size_t INVALID_TYPE = 0;
-
-    /// During lookahead operations, this "token" signifies we hit rule end ATN state
-    /// and did not follow it despite needing to.
-    static constexpr size_t EPSILON = std::numeric_limits<size_t>::max() - 1;
-    static constexpr size_t MIN_USER_TOKEN_TYPE = 1;
-    static constexpr size_t EOF = IntStream::EOF;
-
-    virtual ~Token();
-
-    /// All tokens go to the parser (unless skip() is called in that rule)
-    /// on a particular "channel".  The parser tunes to a particular channel
-    /// so that whitespace etc... can go to the parser on a "hidden" channel.
-    static constexpr size_t DEFAULT_CHANNEL = 0;
-
-    /// Anything on different channel than DEFAULT_CHANNEL is not parsed
-    /// by parser.
-    static constexpr size_t HIDDEN_CHANNEL = 1;
-
-    /**
-     * This is the minimum constant value which can be assigned to a
-     * user-defined token channel.
-     *
-     * <p>
-     * The non-negative numbers less than {@link #MIN_USER_CHANNEL_VALUE} are
-     * assigned to the predefined channels {@link #DEFAULT_CHANNEL} and
-     * {@link #HIDDEN_CHANNEL}.</p>
-     *
-     * @see Token#getChannel()
-     */
-    static constexpr size_t MIN_USER_CHANNEL_VALUE = 2;
-
-    /// Get the text of the token.
-    virtual std::string getText() const = 0;
-
-    /// Get the token type of the token
-    virtual size_t getType() const = 0;
-
-    /// The line number on which the 1st character of this token was matched,  line=1..n
-    virtual size_t getLine() const = 0;
-
-    /// The index of the first character of this token relative to the
-    /// beginning of the line at which it occurs, 0..n-1
-    virtual size_t getCharPositionInLine() const = 0;
-
-    /// Return the channel this token. Each token can arrive at the parser
-    /// on a different channel, but the parser only "tunes" to a single channel.
-    /// The parser ignores everything not on DEFAULT_CHANNEL.
-    virtual size_t getChannel() const = 0;
-
-    /// An index from 0..n-1 of the token object in the input stream.
-    /// This must be valid in order to print token streams and
-    /// use TokenRewriteStream.
-    ///
-    /// Return INVALID_INDEX to indicate that this token was conjured up since
-    /// it doesn't have a valid index.
-    virtual size_t getTokenIndex() const = 0;
-
-    /// The starting character index of the token
-    /// This method is optional; return INVALID_INDEX if not implemented.
-    virtual size_t getStartIndex() const = 0;
-
-    /// The last character index of the token.
-    /// This method is optional; return INVALID_INDEX if not implemented.
-    virtual size_t getStopIndex() const = 0;
-
-    /// Gets the <seealso cref="TokenSource"/> which created this token.
-    virtual TokenSource *getTokenSource() const = 0;
-
-    /// Gets the <seealso cref="CharStream"/> from which this token was derived.
-    virtual CharStream *getInputStream() const = 0;
-
-    virtual std::string toString() const = 0;
-  };
-
-} // namespace antlr4

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

@@ -1,30 +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 {
-
-  /// The default mechanism for creating tokens. It's used by default in Lexer and
-  ///  the error handling strategy (to create missing tokens).  Notifying the parser
-  ///  of a new factory means that it notifies it's token source and error strategy.
-  template<typename Symbol>
-  class ANTLR4CPP_PUBLIC TokenFactory {
-  public:
-    virtual ~TokenFactory() {}
-
-    /// This is the method used to create tokens in the lexer and in the
-    /// error handling strategy. If text!=null, than the start and stop positions
-    /// are wiped to -1 in the text override is set in the CommonToken.
-    virtual std::unique_ptr<Symbol> 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) = 0;
-
-    /// Generically useful
-    virtual std::unique_ptr<Symbol> create(size_t type, const std::string &text) = 0;
-  };
-
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/TokenSource.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 "TokenSource.h"
-
-antlr4::TokenSource::~TokenSource() {
-}

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

@@ -1,85 +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 {
-
-  /// <summary>
-  /// A source of tokens must provide a sequence of tokens via <seealso cref="#nextToken()"/>
-  /// and also must reveal it's source of characters; <seealso cref="CommonToken"/>'s text is
-  /// computed from a <seealso cref="CharStream"/>; it only store indices into the char
-  /// stream.
-  /// <p/>
-  /// Errors from the lexer are never passed to the parser. Either you want to keep
-  /// going or you do not upon token recognition error. If you do not want to
-  /// continue lexing then you do not want to continue parsing. Just throw an
-  /// exception not under <seealso cref="RecognitionException"/> and Java will naturally toss
-  /// you all the way out of the recognizers. If you want to continue lexing then
-  /// you should not throw an exception to the parser--it has already requested a
-  /// token. Keep lexing until you get a valid one. Just report errors and keep
-  /// going, looking for a valid token.
-  /// </summary>
-  class ANTLR4CPP_PUBLIC TokenSource {
-  public:
-    virtual ~TokenSource();
-
-    /// Return a <seealso cref="Token"/> object from your input stream (usually a
-    /// <seealso cref="CharStream"/>). Do not fail/return upon lexing error; keep chewing
-    /// on the characters until you get a good one; errors are not passed through
-    /// to the parser.
-    virtual std::unique_ptr<Token> nextToken() = 0;
-
-    /// <summary>
-    /// Get the line number for the current position in the input stream. The
-    /// first line in the input is line 1.
-    /// </summary>
-    /// <returns> The line number for the current position in the input stream, or
-    /// 0 if the current token source does not track line numbers. </returns>
-    virtual size_t getLine() const = 0;
-
-    /// <summary>
-    /// Get the index into the current line for the current position in the input
-    /// stream. The first character on a line has position 0.
-    /// </summary>
-    /// <returns> The line number for the current position in the input stream, or
-    /// (sze_t)-1 if the current token source does not track character positions. </returns>
-    virtual size_t getCharPositionInLine() = 0;
-
-    /// <summary>
-    /// Get the <seealso cref="CharStream"/> from which this token source is currently
-    /// providing tokens.
-    /// </summary>
-    /// <returns> The <seealso cref="CharStream"/> associated with the current position in
-    /// the input, or {@code null} if no input stream is available for the token
-    /// source. </returns>
-    virtual CharStream* getInputStream() = 0;
-
-    /// <summary>
-    /// Gets the name of the underlying input source. This method returns a
-    /// non-null, non-empty string. If such a name is not known, this method
-    /// returns <seealso cref="IntStream#UNKNOWN_SOURCE_NAME"/>.
-    /// </summary>
-    virtual std::string getSourceName() = 0;
-
-    /// <summary>
-    /// Set the <seealso cref="TokenFactory"/> this token source should use for creating
-    /// <seealso cref="Token"/> objects from the input.
-    /// </summary>
-    /// <param name="factory"> The <seealso cref="TokenFactory"/> to use for creating tokens. </param>
-    template<typename T1>
-    void setTokenFactory(TokenFactory<T1> * /*factory*/) {}
-
-    /// <summary>
-    /// Gets the <seealso cref="TokenFactory"/> this token source is currently using for
-    /// creating <seealso cref="Token"/> objects from the input.
-    /// </summary>
-    /// <returns> The <seealso cref="TokenFactory"/> currently used by this token source. </returns>
-    virtual TokenFactory<CommonToken>* getTokenFactory() = 0;
-  };
-
-} // namespace antlr4

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

@@ -1,11 +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 "TokenStream.h"
-
-using namespace antlr4;
-
-TokenStream::~TokenStream() {
-}

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

@@ -1,137 +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 "IntStream.h"
-
-namespace antlr4 {
-
-  /// <summary>
-  /// An <seealso cref="IntStream"/> whose symbols are <seealso cref="Token"/> instances.
-  /// </summary>
-  class ANTLR4CPP_PUBLIC TokenStream : public IntStream {
-    /// <summary>
-    /// Get the <seealso cref="Token"/> instance associated with the value returned by
-    /// <seealso cref="#LA LA(k)"/>. This method has the same pre- and post-conditions as
-    /// <seealso cref="IntStream#LA"/>. In addition, when the preconditions of this method
-    /// are met, the return value is non-null and the value of
-    /// {@code LT(k).getType()==LA(k)}.
-    /// </summary>
-    /// <seealso cref= IntStream#LA </seealso>
-  public:
-    virtual ~TokenStream();
-
-    virtual Token* LT(ssize_t k) = 0;
-
-    /// <summary>
-    /// Gets the <seealso cref="Token"/> at the specified {@code index} in the stream. When
-    /// the preconditions of this method are met, the return value is non-null.
-    /// <p/>
-    /// The preconditions for this method are the same as the preconditions of
-    /// <seealso cref="IntStream#seek"/>. If the behavior of {@code seek(index)} is
-    /// unspecified for the current state and given {@code index}, then the
-    /// behavior of this method is also unspecified.
-    /// <p/>
-    /// The symbol referred to by {@code index} differs from {@code seek()} only
-    /// in the case of filtering streams where {@code index} lies before the end
-    /// of the stream. Unlike {@code seek()}, this method does not adjust
-    /// {@code index} to point to a non-ignored symbol.
-    /// </summary>
-    /// <exception cref="IllegalArgumentException"> if {code index} is less than 0 </exception>
-    /// <exception cref="UnsupportedOperationException"> if the stream does not support
-    /// retrieving the token at the specified index </exception>
-    virtual Token* get(size_t index) const = 0;
-
-    /// Gets the underlying TokenSource which provides tokens for this stream.
-    virtual TokenSource* getTokenSource() const = 0;
-
-    /// <summary>
-    /// Return the text of all tokens within the specified {@code interval}. This
-    /// method behaves like the following code (including potential exceptions
-    /// for violating preconditions of <seealso cref="#get"/>, but may be optimized by the
-    /// specific implementation.
-    ///
-    /// <pre>
-    /// TokenStream stream = ...;
-    /// String text = "";
-    /// for (int i = interval.a; i <= interval.b; i++) {
-    ///   text += stream.get(i).getText();
-    /// }
-    /// </pre>
-    /// </summary>
-    /// <param name="interval"> The interval of tokens within this stream to get text
-    /// for. </param>
-    /// <returns> The text of all tokens within the specified interval in this
-    /// stream.
-    /// </returns>
-    /// <exception cref="NullPointerException"> if {@code interval} is {@code null} </exception>
-    virtual std::string getText(const misc::Interval &interval) = 0;
-
-    /// <summary>
-    /// Return the text of all tokens in the stream. This method behaves like the
-    /// following code, including potential exceptions from the calls to
-    /// <seealso cref="IntStream#size"/> and <seealso cref="#getText(Interval)"/>, but may be
-    /// optimized by the specific implementation.
-    ///
-    /// <pre>
-    /// TokenStream stream = ...;
-    /// String text = stream.getText(new Interval(0, stream.size()));
-    /// </pre>
-    /// </summary>
-    /// <returns> The text of all tokens in the stream. </returns>
-    virtual std::string getText() = 0;
-
-    /// <summary>
-    /// Return the text of all tokens in the source interval of the specified
-    /// context. This method behaves like the following code, including potential
-    /// exceptions from the call to <seealso cref="#getText(Interval)"/>, but may be
-    /// optimized by the specific implementation.
-    /// </p>
-    /// If {@code ctx.getSourceInterval()} does not return a valid interval of
-    /// tokens provided by this stream, the behavior is unspecified.
-    ///
-    /// <pre>
-    /// TokenStream stream = ...;
-    /// String text = stream.getText(ctx.getSourceInterval());
-    /// </pre>
-    /// </summary>
-    /// <param name="ctx"> The context providing the source interval of tokens to get
-    /// text for. </param>
-    /// <returns> The text of all tokens within the source interval of {@code ctx}. </returns>
-    virtual std::string getText(RuleContext *ctx) = 0;
-
-    /// <summary>
-    /// Return the text of all tokens in this stream between {@code start} and
-    /// {@code stop} (inclusive).
-    /// <p/>
-    /// If the specified {@code start} or {@code stop} token was not provided by
-    /// this stream, or if the {@code stop} occurred before the {@code start}
-    /// token, the behavior is unspecified.
-    /// <p/>
-    /// For streams which ensure that the <seealso cref="Token#getTokenIndex"/> method is
-    /// accurate for all of its provided tokens, this method behaves like the
-    /// following code. Other streams may implement this method in other ways
-    /// provided the behavior is consistent with this at a high level.
-    ///
-    /// <pre>
-    /// TokenStream stream = ...;
-    /// String text = "";
-    /// for (int i = start.getTokenIndex(); i <= stop.getTokenIndex(); i++) {
-    ///   text += stream.get(i).getText();
-    /// }
-    /// </pre>
-    /// </summary>
-    /// <param name="start"> The first token in the interval to get text for. </param>
-    /// <param name="stop"> The last token in the interval to get text for (inclusive). </param>
-    /// <returns> The text of all tokens lying between the specified {@code start}
-    /// and {@code stop} tokens.
-    /// </returns>
-    /// <exception cref="UnsupportedOperationException"> if this stream does not support
-    /// this method for the specified tokens </exception>
-    virtual std::string getText(Token *start, Token *stop) = 0;
-  };
-
-} // namespace antlr4