expressir 1.4.2 → 2.0.0

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

@@ -1,59 +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 "atn/LexerAction.h"
-#include "atn/LexerActionType.h"
-
-namespace antlr4 {
-namespace atn {
-
-  using antlr4::Lexer;
-
-  /// <summary>
-  /// Implements the {@code channel} lexer action by calling
-  /// <seealso cref="Lexer#setChannel"/> with the assigned channel.
-  ///
-  /// @author Sam Harwell
-  /// @since 4.2
-  /// </summary>
-  class ANTLR4CPP_PUBLIC LexerChannelAction final : public LexerAction {
-  public:
-    static bool is(const LexerAction &lexerAction) { return lexerAction.getActionType() == LexerActionType::CHANNEL; }
-
-    static bool is(const LexerAction *lexerAction) { return lexerAction != nullptr && is(*lexerAction); }
-
-    /// <summary>
-    /// Constructs a new {@code channel} action with the specified channel value. </summary>
-    /// <param name="channel"> The channel value to pass to <seealso cref="Lexer#setChannel"/>. </param>
-    explicit LexerChannelAction(int channel);
-
-    /// <summary>
-    /// Gets the channel to use for the <seealso cref="Token"/> created by the lexer.
-    /// </summary>
-    /// <returns> The channel to use for the <seealso cref="Token"/> created by the lexer. </returns>
-    int getChannel() const { return _channel; }
-
-    /// <summary>
-    /// {@inheritDoc}
-    ///
-    /// <para>This action is implemented by calling <seealso cref="Lexer#setChannel"/> with the
-    /// value provided by <seealso cref="#getChannel"/>.</para>
-    /// </summary>
-    void execute(Lexer *lexer) const override;
-
-    bool equals(const LexerAction &other) const override;
-    std::string toString() const override;
-
-  protected:
-    size_t hashCodeImpl() const override;
-
-  private:
-    const int _channel;
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,45 +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 "misc/MurmurHash.h"
-#include "Lexer.h"
-#include "support/Casts.h"
-
-#include "atn/LexerCustomAction.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlr4::misc;
-using namespace antlrcpp;
-
-LexerCustomAction::LexerCustomAction(size_t ruleIndex, size_t actionIndex)
-    : LexerAction(LexerActionType::CUSTOM, true), _ruleIndex(ruleIndex), _actionIndex(actionIndex) {}
-
-void LexerCustomAction::execute(Lexer *lexer) const {
-  lexer->action(nullptr, getRuleIndex(), getActionIndex());
-}
-
-size_t LexerCustomAction::hashCodeImpl() const {
-  size_t hash = MurmurHash::initialize();
-  hash = MurmurHash::update(hash, static_cast<size_t>(getActionType()));
-  hash = MurmurHash::update(hash, getRuleIndex());
-  hash = MurmurHash::update(hash, getActionIndex());
-  return MurmurHash::finish(hash, 3);
-}
-
-bool LexerCustomAction::equals(const LexerAction &other) const {
-  if (this == std::addressof(other)) {
-    return true;
-  }
-  if (getActionType() != other.getActionType()) {
-    return false;
-  }
-  const auto &lexerAction = downCast<const LexerCustomAction&>(other);
-  return getRuleIndex() == lexerAction.getRuleIndex() && getActionIndex() == lexerAction.getActionIndex();
-}
-
-std::string LexerCustomAction::toString() const {
-  return "custom(" + std::to_string(getRuleIndex()) + ", " + std::to_string(getActionIndex()) + ")";
-}

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

@@ -1,75 +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 "atn/LexerAction.h"
-#include "atn/LexerActionType.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// <summary>
-  /// Executes a custom lexer action by calling <seealso cref="Recognizer#action"/> with the
-  /// rule and action indexes assigned to the custom action. The implementation of
-  /// a custom action is added to the generated code for the lexer in an override
-  /// of <seealso cref="Recognizer#action"/> when the grammar is compiled.
-  ///
-  /// <para>This class may represent embedded actions created with the <code>{...}</code>
-  /// syntax in ANTLR 4, as well as actions created for lexer commands where the
-  /// command argument could not be evaluated when the grammar was compiled.</para>
-  ///
-  /// @author Sam Harwell
-  /// @since 4.2
-  /// </summary>
-  class ANTLR4CPP_PUBLIC LexerCustomAction final : public LexerAction {
-  public:
-    static bool is(const LexerAction &lexerAction) { return lexerAction.getActionType() == LexerActionType::CUSTOM; }
-
-    static bool is(const LexerAction *lexerAction) { return lexerAction != nullptr && is(*lexerAction); }
-
-    /// <summary>
-    /// Constructs a custom lexer action with the specified rule and action
-    /// indexes.
-    /// </summary>
-    /// <param name="ruleIndex"> The rule index to use for calls to
-    /// <seealso cref="Recognizer#action"/>. </param>
-    /// <param name="actionIndex"> The action index to use for calls to
-    /// <seealso cref="Recognizer#action"/>. </param>
-    LexerCustomAction(size_t ruleIndex, size_t actionIndex);
-
-    /// <summary>
-    /// Gets the rule index to use for calls to <seealso cref="Recognizer#action"/>.
-    /// </summary>
-    /// <returns> The rule index for the custom action. </returns>
-    size_t getRuleIndex() const { return _ruleIndex; }
-
-    /// <summary>
-    /// Gets the action index to use for calls to <seealso cref="Recognizer#action"/>.
-    /// </summary>
-    /// <returns> The action index for the custom action. </returns>
-    size_t getActionIndex() const { return _actionIndex; }
-
-    /// <summary>
-    /// {@inheritDoc}
-    ///
-    /// <para>Custom actions are implemented by calling <seealso cref="Lexer#action"/> with the
-    /// appropriate rule and action indexes.</para>
-    /// </summary>
-    void execute(Lexer *lexer) const override;
-
-    bool equals(const LexerAction &other) const override;
-    std::string toString() const override;
-
-  protected:
-    size_t hashCodeImpl() const override;
-
-  private:
-    const size_t _ruleIndex;
-    const size_t _actionIndex;
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,50 +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/HashUtils.h"
-#include "misc/MurmurHash.h"
-#include "Lexer.h"
-#include "support/CPPUtils.h"
-#include "support/Casts.h"
-
-#include "atn/LexerIndexedCustomAction.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlr4::misc;
-using namespace antlrcpp;
-
-LexerIndexedCustomAction::LexerIndexedCustomAction(int offset, Ref<const LexerAction> action)
-    : LexerAction(LexerActionType::INDEXED_CUSTOM, true), _action(std::move(action)), _offset(offset) {}
-
-void LexerIndexedCustomAction::execute(Lexer *lexer) const {
-  // assume the input stream position was properly set by the calling code
-  getAction()->execute(lexer);
-}
-
-size_t LexerIndexedCustomAction::hashCodeImpl() const {
-  size_t hash = MurmurHash::initialize();
-  hash = MurmurHash::update(hash, static_cast<size_t>(getActionType()));
-  hash = MurmurHash::update(hash, getOffset());
-  hash = MurmurHash::update(hash, getAction());
-  return MurmurHash::finish(hash, 3);
-}
-
-bool LexerIndexedCustomAction::equals(const LexerAction &other) const {
-  if (this == std::addressof(other)) {
-    return true;
-  }
-  if (getActionType() != other.getActionType()) {
-    return false;
-  }
-  const auto &lexerAction = downCast<const LexerIndexedCustomAction&>(other);
-  return getOffset() == lexerAction.getOffset() &&
-         cachedHashCodeEqual(cachedHashCode(), lexerAction.cachedHashCode()) &&
-         *getAction() == *lexerAction.getAction();
-}
-
-std::string LexerIndexedCustomAction::toString() const {
-  return "indexedCustom(" + std::to_string(getOffset()) + ", " + getAction()->toString() + ")";
-}

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

@@ -1,76 +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 "RuleContext.h"
-#include "atn/LexerAction.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// <summary>
-  /// This implementation of <seealso cref="LexerAction"/> is used for tracking input offsets
-  /// for position-dependent actions within a <seealso cref="LexerActionExecutor"/>.
-  ///
-  /// <para>This action is not serialized as part of the ATN, and is only required for
-  /// position-dependent lexer actions which appear at a location other than the
-  /// end of a rule. For more information about DFA optimizations employed for
-  /// lexer actions, see <seealso cref="LexerActionExecutor#append"/> and
-  /// <seealso cref="LexerActionExecutor#fixOffsetBeforeMatch"/>.</para>
-  ///
-  /// @author Sam Harwell
-  /// @since 4.2
-  /// </summary>
-  class ANTLR4CPP_PUBLIC LexerIndexedCustomAction final : public LexerAction {
-  public:
-    static bool is(const LexerAction &lexerAction) { return lexerAction.getActionType() == LexerActionType::INDEXED_CUSTOM; }
-
-    static bool is(const LexerAction *lexerAction) { return lexerAction != nullptr && is(*lexerAction); }
-
-    /// <summary>
-    /// Constructs a new indexed custom action by associating a character offset
-    /// with a <seealso cref="LexerAction"/>.
-    ///
-    /// <para>Note: This class is only required for lexer actions for which
-    /// <seealso cref="LexerAction#isPositionDependent"/> returns {@code true}.</para>
-    /// </summary>
-    /// <param name="offset"> The offset into the input <seealso cref="CharStream"/>, relative to
-    /// the token start index, at which the specified lexer action should be
-    /// executed. </param>
-    /// <param name="action"> The lexer action to execute at a particular offset in the
-    /// input <seealso cref="CharStream"/>. </param>
-    LexerIndexedCustomAction(int offset, Ref<const LexerAction> action);
-
-    /// <summary>
-    /// Gets the location in the input <seealso cref="CharStream"/> at which the lexer
-    /// action should be executed. The value is interpreted as an offset relative
-    /// to the token start index.
-    /// </summary>
-    /// <returns> The location in the input <seealso cref="CharStream"/> at which the lexer
-    /// action should be executed. </returns>
-    int getOffset() const { return _offset; }
-
-    /// <summary>
-    /// Gets the lexer action to execute.
-    /// </summary>
-    /// <returns> A <seealso cref="LexerAction"/> object which executes the lexer action. </returns>
-    const Ref<const LexerAction>& getAction() const { return _action; }
-
-    void execute(Lexer *lexer) const override;
-    bool equals(const LexerAction &other) const override;
-    std::string toString() const override;
-
-  protected:
-    size_t hashCodeImpl() const override;
-
-  private:
-    const Ref<const LexerAction> _action;
-    const int _offset;
-  };
-
-} // namespace atn
-} // namespace antlr4
-

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

@@ -1,43 +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 "misc/MurmurHash.h"
-#include "Lexer.h"
-#include "support/Casts.h"
-
-#include "atn/LexerModeAction.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlr4::misc;
-using namespace antlrcpp;
-
-LexerModeAction::LexerModeAction(int mode) : LexerAction(LexerActionType::MODE, false), _mode(mode) {}
-
-void LexerModeAction::execute(Lexer *lexer) const {
-  lexer->setMode(getMode());
-}
-
-size_t LexerModeAction::hashCodeImpl() const {
-  size_t hash = MurmurHash::initialize();
-  hash = MurmurHash::update(hash, static_cast<size_t>(getActionType()));
-  hash = MurmurHash::update(hash, getMode());
-  return MurmurHash::finish(hash, 2);
-}
-
-bool LexerModeAction::equals(const LexerAction &other) const {
-  if (this == std::addressof(other)) {
-    return true;
-  }
-  if (getActionType() != other.getActionType()) {
-    return false;
-  }
-  const auto &lexerAction = downCast<const LexerModeAction&>(other);
-  return getMode() == lexerAction.getMode();
-}
-
-std::string LexerModeAction::toString() const {
-  return "mode(" + std::to_string(getMode()) + ")";
-}

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

@@ -1,57 +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 "atn/LexerAction.h"
-#include "atn/LexerActionType.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// <summary>
-  /// Implements the {@code mode} lexer action by calling <seealso cref="Lexer#mode"/> with
-  /// the assigned mode.
-  ///
-  /// @author Sam Harwell
-  /// @since 4.2
-  /// </summary>
-  class ANTLR4CPP_PUBLIC LexerModeAction final : public LexerAction {
-  public:
-    static bool is(const LexerAction &lexerAction) { return lexerAction.getActionType() == LexerActionType::MODE; }
-
-    static bool is(const LexerAction *lexerAction) { return lexerAction != nullptr && is(*lexerAction); }
-
-    /// <summary>
-    /// Constructs a new {@code mode} action with the specified mode value. </summary>
-    /// <param name="mode"> The mode value to pass to <seealso cref="Lexer#mode"/>. </param>
-    explicit LexerModeAction(int mode);
-
-    /// <summary>
-    /// Get the lexer mode this action should transition the lexer to.
-    /// </summary>
-    /// <returns> The lexer mode for this {@code mode} command. </returns>
-    int getMode() const { return _mode; }
-
-    /// <summary>
-    /// {@inheritDoc}
-    ///
-    /// <para>This action is implemented by calling <seealso cref="Lexer#mode"/> with the
-    /// value provided by <seealso cref="#getMode"/>.</para>
-    /// </summary>
-    void execute(Lexer *lexer) const override;
-
-    bool equals(const LexerAction &obj) const override;
-    std::string toString() const override;
-
-  protected:
-    size_t hashCodeImpl() const override;
-
-  private:
-    const int _mode;
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,36 +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 "misc/MurmurHash.h"
-#include "Lexer.h"
-
-#include "atn/LexerMoreAction.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlr4::misc;
-
-const Ref<const LexerMoreAction>& LexerMoreAction::getInstance() {
-  static const Ref<const LexerMoreAction> instance(new LexerMoreAction());
-  return instance;
-}
-
-void LexerMoreAction::execute(Lexer *lexer) const {
-  lexer->more();
-}
-
-size_t LexerMoreAction::hashCodeImpl() const {
-  size_t hash = MurmurHash::initialize();
-  hash = MurmurHash::update(hash, static_cast<size_t>(getActionType()));
-  return MurmurHash::finish(hash, 1);
-}
-
-bool LexerMoreAction::equals(const LexerAction &other) const {
-  return this == std::addressof(other);
-}
-
-std::string LexerMoreAction::toString() const {
-  return "more";
-}

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

@@ -1,53 +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 "atn/LexerAction.h"
-#include "atn/LexerActionType.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// <summary>
-  /// Implements the {@code more} lexer action by calling <seealso cref="Lexer#more"/>.
-  ///
-  /// <para>The {@code more} command does not have any parameters, so this action is
-  /// implemented as a singleton instance exposed by <seealso cref="#INSTANCE"/>.</para>
-  ///
-  /// @author Sam Harwell
-  /// @since 4.2
-  /// </summary>
-  class ANTLR4CPP_PUBLIC LexerMoreAction final : public LexerAction {
-  public:
-    static bool is(const LexerAction &lexerAction) { return lexerAction.getActionType() == LexerActionType::MORE; }
-
-    static bool is(const LexerAction *lexerAction) { return lexerAction != nullptr && is(*lexerAction); }
-
-    /// <summary>
-    /// Provides a singleton instance of this parameterless lexer action.
-    /// </summary>
-    static const Ref<const LexerMoreAction>& getInstance();
-
-    /// <summary>
-    /// {@inheritDoc}
-    ///
-    /// <para>This action is implemented by calling <seealso cref="Lexer#more"/>.</para>
-    /// </summary>
-    void execute(Lexer *lexer) const override;
-
-    bool equals(const LexerAction &obj) const override;
-    std::string toString() const override;
-
-  protected:
-    size_t hashCodeImpl() const override;
-
-  private:
-    /// Constructs the singleton instance of the lexer {@code more} command.
-    LexerMoreAction() : LexerAction(LexerActionType::MORE, false) {}
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,36 +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 "misc/MurmurHash.h"
-#include "Lexer.h"
-
-#include "atn/LexerPopModeAction.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlr4::misc;
-
-const Ref<const LexerPopModeAction>& LexerPopModeAction::getInstance() {
-  static const Ref<const LexerPopModeAction> instance(new LexerPopModeAction());
-  return instance;
-}
-
-void LexerPopModeAction::execute(Lexer *lexer) const {
-  lexer->popMode();
-}
-
-size_t LexerPopModeAction::hashCodeImpl() const {
-  size_t hash = MurmurHash::initialize();
-  hash = MurmurHash::update(hash, static_cast<size_t>(getActionType()));
-  return MurmurHash::finish(hash, 1);
-}
-
-bool LexerPopModeAction::equals(const LexerAction &other) const {
-  return this == std::addressof(other);
-}
-
-std::string LexerPopModeAction::toString() const {
-  return "popMode";
-}

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

@@ -1,53 +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 "atn/LexerAction.h"
-#include "atn/LexerActionType.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// <summary>
-  /// Implements the {@code popMode} lexer action by calling <seealso cref="Lexer#popMode"/>.
-  ///
-  /// <para>The {@code popMode} command does not have any parameters, so this action is
-  /// implemented as a singleton instance exposed by <seealso cref="#INSTANCE"/>.</para>
-  ///
-  /// @author Sam Harwell
-  /// @since 4.2
-  /// </summary>
-  class ANTLR4CPP_PUBLIC LexerPopModeAction final : public LexerAction {
-  public:
-    static bool is(const LexerAction &lexerAction) { return lexerAction.getActionType() == LexerActionType::POP_MODE; }
-
-    static bool is(const LexerAction *lexerAction) { return lexerAction != nullptr && is(*lexerAction); }
-
-    /// <summary>
-    /// Provides a singleton instance of this parameterless lexer action.
-    /// </summary>
-    static const Ref<const LexerPopModeAction>& getInstance();
-
-    /// <summary>
-    /// {@inheritDoc}
-    ///
-    /// <para>This action is implemented by calling <seealso cref="Lexer#popMode"/>.</para>
-    /// </summary>
-    void execute(Lexer *lexer) const override;
-
-    bool equals(const LexerAction &other) const override;
-    std::string toString() const override;
-
-  protected:
-    size_t hashCodeImpl() const override;
-
-  private:
-    /// Constructs the singleton instance of the lexer {@code popMode} command.
-    LexerPopModeAction() : LexerAction(LexerActionType::POP_MODE, false) {}
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,43 +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 "misc/MurmurHash.h"
-#include "Lexer.h"
-#include "support/Casts.h"
-
-#include "atn/LexerPushModeAction.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlr4::misc;
-using namespace antlrcpp;
-
-LexerPushModeAction::LexerPushModeAction(int mode) : LexerAction(LexerActionType::PUSH_MODE, false), _mode(mode) {}
-
-void LexerPushModeAction::execute(Lexer *lexer) const {
-  lexer->pushMode(getMode());
-}
-
-size_t LexerPushModeAction::hashCodeImpl() const {
-  size_t hash = MurmurHash::initialize();
-  hash = MurmurHash::update(hash, static_cast<size_t>(getActionType()));
-  hash = MurmurHash::update(hash, getMode());
-  return MurmurHash::finish(hash, 2);
-}
-
-bool LexerPushModeAction::equals(const LexerAction &other) const {
-  if (this == std::addressof(other)) {
-    return true;
-  }
-  if (getActionType() != other.getActionType()) {
-    return false;
-  }
-  const auto &lexerAction = downCast<const LexerPushModeAction&>(other);
-  return getMode() == lexerAction.getMode();
-}
-
-std::string LexerPushModeAction::toString() const {
-  return "pushMode(" + std::to_string(getMode()) + ")";
-}