expressir 1.4.3 → 2.1.0

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

@@ -1,101 +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 <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <iterator>
-#include <vector>
-
-#include "antlr4-common.h"
-#include "misc/MurmurHash.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTLR4CPP_PUBLIC SerializedATNView final {
-  public:
-    using value_type = int32_t;
-    using size_type = size_t;
-    using difference_type = ptrdiff_t;
-    using reference = int32_t&;
-    using const_reference = const int32_t&;
-    using pointer = int32_t*;
-    using const_pointer = const int32_t*;
-    using iterator = const_pointer;
-    using const_iterator = const_pointer;
-    using reverse_iterator = std::reverse_iterator<iterator>;
-    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-
-    SerializedATNView() = default;
-
-    SerializedATNView(const_pointer data, size_type size) : _data(data), _size(size) {}
-
-    SerializedATNView(const std::vector<int32_t> &serializedATN) : _data(serializedATN.data()), _size(serializedATN.size()) {}
-
-    SerializedATNView(const SerializedATNView&) = default;
-
-    SerializedATNView& operator=(const SerializedATNView&) = default;
-
-    const_iterator begin() const { return data(); }
-
-    const_iterator cbegin() const { return data(); }
-
-    const_iterator end() const { return data() + size(); }
-
-    const_iterator cend() const { return data() + size(); }
-
-    const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
-
-    const_reverse_iterator crbegin() const { return const_reverse_iterator(cend()); }
-
-    const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
-
-    const_reverse_iterator crend() const { return const_reverse_iterator(cbegin()); }
-
-    bool empty() const { return size() == 0; }
-
-    const_pointer data() const { return _data; }
-
-    size_type size() const { return _size; }
-
-    size_type size_bytes() const { return size() * sizeof(value_type); }
-
-    const_reference operator[](size_type index) const { return _data[index]; }
-
-  private:
-    const_pointer _data = nullptr;
-    size_type _size = 0;
-  };
-
-  inline bool operator==(const SerializedATNView &lhs, const SerializedATNView &rhs) {
-    return (lhs.data() == rhs.data() && lhs.size() == rhs.size()) ||
-           (lhs.size() == rhs.size() && std::memcmp(lhs.data(), rhs.data(), lhs.size_bytes()) == 0);
-  }
-
-  inline bool operator!=(const SerializedATNView &lhs, const SerializedATNView &rhs) {
-    return !operator==(lhs, rhs);
-  }
-
-  inline bool operator<(const SerializedATNView &lhs, const SerializedATNView &rhs) {
-    int diff = std::memcmp(lhs.data(), rhs.data(), std::min(lhs.size_bytes(), rhs.size_bytes()));
-    return diff < 0 || (diff == 0 && lhs.size() < rhs.size());
-  }
-
-}  // namespace atn
-}  // namespace antlr4
-
-namespace std {
-
-  template <>
-  struct hash<::antlr4::atn::SerializedATNView> {
-    size_t operator()(const ::antlr4::atn::SerializedATNView &serializedATNView) const {
-      return ::antlr4::misc::MurmurHash::hashCode(serializedATNView.data(), serializedATNView.size());
-    }
-  };
-
-}  // namespace std

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

@@ -1,28 +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 "misc/IntervalSet.h"
-
-#include "atn/SetTransition.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-
-SetTransition::SetTransition(TransitionType transitionType, ATNState *target, misc::IntervalSet aSet)
-  : Transition(transitionType, target), set(aSet.isEmpty() ? misc::IntervalSet::of(Token::INVALID_TYPE) : std::move(aSet)) {
-}
-
-misc::IntervalSet SetTransition::label() const {
-  return set;
-}
-
-bool SetTransition::matches(size_t symbol, size_t /*minVocabSymbol*/, size_t /*maxVocabSymbol*/) const {
-  return set.contains(symbol);
-}
-
-std::string SetTransition::toString() const {
-  return "SET " + Transition::toString() + " { set: " + set.toString() + "}";
-}

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

@@ -1,38 +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/Transition.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// <summary>
-  /// A transition containing a set of values. </summary>
-  class ANTLR4CPP_PUBLIC SetTransition : public Transition {
-  public:
-    static bool is(const Transition &transition) {
-      const auto transitionType = transition.getTransitionType();
-      return transitionType == TransitionType::SET || transitionType == TransitionType::NOT_SET;
-    }
-
-    static bool is(const Transition *transition) { return transition != nullptr && is(*transition); }
-
-    const misc::IntervalSet set;
-
-    SetTransition(ATNState *target, misc::IntervalSet set) : SetTransition(TransitionType::SET, target, std::move(set)) {}
-
-    virtual misc::IntervalSet label() const override;
-    virtual bool matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const override;
-
-    virtual std::string toString() const override;
-
-  protected:
-    SetTransition(TransitionType transitionType, ATNState *target, misc::IntervalSet set);
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,79 +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/SingletonPredictionContext.h"
-
-#include "support/Casts.h"
-#include "misc/MurmurHash.h"
-#include "atn/HashUtils.h"
-
-using namespace antlr4::atn;
-using namespace antlrcpp;
-
-SingletonPredictionContext::SingletonPredictionContext(Ref<const PredictionContext> parent, size_t returnState)
-    : PredictionContext(PredictionContextType::SINGLETON), parent(std::move(parent)), returnState(returnState) {
-  assert(returnState != ATNState::INVALID_STATE_NUMBER);
-}
-
-Ref<const SingletonPredictionContext> SingletonPredictionContext::create(Ref<const PredictionContext> parent, size_t returnState) {
-  if (returnState == EMPTY_RETURN_STATE && parent == nullptr) {
-    // someone can pass in the bits of an array ctx that mean $
-    return std::dynamic_pointer_cast<const SingletonPredictionContext>(EMPTY);
-  }
-  return std::make_shared<SingletonPredictionContext>(std::move(parent), returnState);
-}
-
-bool SingletonPredictionContext::isEmpty() const {
-  return parent == nullptr && returnState == EMPTY_RETURN_STATE;
-}
-
-size_t SingletonPredictionContext::size() const {
-  return 1;
-}
-
-const Ref<const PredictionContext>& SingletonPredictionContext::getParent(size_t index) const {
-  assert(index == 0);
-  static_cast<void>(index);
-  return parent;
-}
-
-size_t SingletonPredictionContext::getReturnState(size_t index) const {
-  assert(index == 0);
-  static_cast<void>(index);
-  return returnState;
-}
-
-size_t SingletonPredictionContext::hashCodeImpl() const {
-  size_t hash = misc::MurmurHash::initialize();
-  hash = misc::MurmurHash::update(hash, static_cast<size_t>(getContextType()));
-  hash = misc::MurmurHash::update(hash, parent);
-  hash = misc::MurmurHash::update(hash, returnState);
-  return misc::MurmurHash::finish(hash, 3);
-}
-
-bool SingletonPredictionContext::equals(const PredictionContext &other) const {
-  if (this == std::addressof(other)) {
-    return true;
-  }
-  if (getContextType() != other.getContextType()) {
-    return false;
-  }
-  const auto &singleton = downCast<const SingletonPredictionContext&>(other);
-  return returnState == singleton.returnState &&
-         cachedHashCodeEqual(cachedHashCode(), singleton.cachedHashCode()) &&
-         (parent == singleton.parent || (parent != nullptr && singleton.parent != nullptr && *parent == *singleton.parent));
-}
-
-std::string SingletonPredictionContext::toString() const {
-  //std::string up = !parent.expired() ? parent.lock()->toString() : "";
-  std::string up = parent != nullptr ? parent->toString() : "";
-  if (up.length() == 0) {
-    if (returnState == EMPTY_RETURN_STATE) {
-      return "$";
-    }
-    return std::to_string(returnState);
-  }
-  return std::to_string(returnState) + " " + up;
-}

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

@@ -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.
- */
-
-#pragma once
-
-#include "atn/PredictionContext.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTLR4CPP_PUBLIC SingletonPredictionContext final : public PredictionContext {
-  public:
-    static bool is(const PredictionContext &predictionContext) { return predictionContext.getContextType() == PredictionContextType::SINGLETON; }
-
-    static bool is(const PredictionContext *predictionContext) { return predictionContext != nullptr && is(*predictionContext); }
-
-    static Ref<const SingletonPredictionContext> create(Ref<const PredictionContext> parent, size_t returnState);
-
-    // Usually a parent is linked via a weak ptr. Not so here as we have kinda reverse reference chain.
-    // There are no child contexts stored here and often the parent context is left dangling when it's
-    // owning ATNState is released. In order to avoid having this context released as well (leaving all other contexts
-    // which got this one as parent with a null reference) we use a shared_ptr here instead, to keep those left alone
-    // parent contexts alive.
-    const Ref<const PredictionContext> parent;
-    const size_t returnState;
-
-    SingletonPredictionContext(Ref<const PredictionContext> parent, size_t returnState);
-
-    bool isEmpty() const override;
-    size_t size() const override;
-    const Ref<const PredictionContext>& getParent(size_t index) const override;
-    size_t getReturnState(size_t index) const override;
-    bool equals(const PredictionContext &other) const override;
-    std::string toString() const override;
-
-  protected:
-    size_t hashCodeImpl() const override;
-  };
-
-} // namespace atn
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/StarBlockStartState.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 "atn/BlockStartState.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// The block that begins a closure loop.
-  class ANTLR4CPP_PUBLIC StarBlockStartState final : public BlockStartState {
-  public:
-    static bool is(const ATNState &atnState) { return atnState.getStateType() == ATNStateType::STAR_BLOCK_START; }
-
-    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
-
-    StarBlockStartState() : BlockStartState(ATNStateType::STAR_BLOCK_START) {}
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,37 +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/DecisionState.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTLR4CPP_PUBLIC StarLoopEntryState final : public DecisionState {
-  public:
-    static bool is(const ATNState &atnState) { return atnState.getStateType() == ATNStateType::STAR_LOOP_ENTRY; }
-
-    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
-
-    /**
-     * Indicates whether this state can benefit from a precedence DFA during SLL
-     * decision making.
-     *
-     * <p>This is a computed property that is calculated during ATN deserialization
-     * and stored for use in {@link ParserATNSimulator} and
-     * {@link ParserInterpreter}.</p>
-     *
-     * @see DFA#isPrecedenceDfa()
-     */
-    bool isPrecedenceDecision = false;
-
-    StarLoopbackState *loopBackState = nullptr;
-
-    StarLoopEntryState() : DecisionState(ATNStateType::STAR_LOOP_ENTRY) {}
-  };
-
-} // namespace atn
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/StarLoopbackState.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 "atn/StarLoopEntryState.h"
-#include "atn/Transition.h"
-#include "support/Casts.h"
-
-#include "atn/StarLoopbackState.h"
-
-using namespace antlr4::atn;
-
-StarLoopEntryState *StarLoopbackState::getLoopEntryState() const {
-  if (transitions[0]->target != nullptr && transitions[0]->target->getStateType() == ATNStateType::STAR_LOOP_ENTRY) {
-    return antlrcpp::downCast<StarLoopEntryState*>(transitions[0]->target);
-  }
-  return nullptr;
-}

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

@@ -1,25 +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/ATNState.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTLR4CPP_PUBLIC StarLoopbackState final : public ATNState {
-  public:
-    static bool is(const ATNState &atnState) { return atnState.getStateType() == ATNStateType::STAR_LOOP_BACK; }
-
-    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
-
-    StarLoopbackState() : ATNState(ATNStateType::STAR_LOOP_BACK) {}
-
-    StarLoopEntryState *getLoopEntryState() const;
-  };
-
-} // namespace atn
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/TokensStartState.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 "atn/DecisionState.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// The Tokens rule start state linking to each lexer rule start state.
-  class ANTLR4CPP_PUBLIC TokensStartState final : public DecisionState {
-  public:
-    static bool is(const ATNState &atnState) { return atnState.getStateType() == ATNStateType::TOKEN_START; }
-
-    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
-
-    TokensStartState() : DecisionState(ATNStateType::TOKEN_START) {}
-  };
-
-} // namespace atn
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/Transition.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 "Exceptions.h"
-#include "support/Arrays.h"
-
-#include "atn/Transition.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlrcpp;
-
-Transition::Transition(TransitionType transitionType, ATNState *target) : _transitionType(transitionType) {
-  if (target == nullptr) {
-    throw NullPointerException("target cannot be null.");
-  }
-
-  this->target = target;
-}
-
-bool Transition::isEpsilon() const {
-  return false;
-}
-
-misc::IntervalSet Transition::label() const {
-  return misc::IntervalSet::EMPTY_SET;
-}
-
-std::string Transition::toString() const {
-  std::stringstream ss;
-  ss << "(Transition " << std::hex << this << ", target: " << std::hex << target << ')';
-
-  return ss.str();
-}

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

@@ -1,65 +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 "misc/IntervalSet.h"
-#include "atn/TransitionType.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// <summary>
-  /// An ATN transition between any two ATN states.  Subclasses define
-  ///  atom, set, epsilon, action, predicate, rule transitions.
-  /// <p/>
-  ///  This is a one way link.  It emanates from a state (usually via a list of
-  ///  transitions) and has a target state.
-  /// <p/>
-  ///  Since we never have to change the ATN transitions once we construct it,
-  ///  we can fix these transitions as specific classes. The DFA transitions
-  ///  on the other hand need to update the labels as it adds transitions to
-  ///  the states. We'll use the term Edge for the DFA to distinguish them from
-  ///  ATN transitions.
-  /// </summary>
-  class ANTLR4CPP_PUBLIC Transition {
-  public:
-    /// The target of this transition.
-    // ml: this is a reference into the ATN.
-    ATNState *target;
-
-    virtual ~Transition() = default;
-
-    TransitionType getTransitionType() const { return _transitionType; }
-
-    /**
-     * Determines if the transition is an "epsilon" transition.
-     *
-     * <p>The default implementation returns {@code false}.</p>
-     *
-     * @return {@code true} if traversing this transition in the ATN does not
-     * consume an input symbol; otherwise, {@code false} if traversing this
-     * transition consumes (matches) an input symbol.
-     */
-    virtual bool isEpsilon() const;
-    virtual misc::IntervalSet label() const;
-    virtual bool matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const = 0;
-
-    virtual std::string toString() const;
-
-    Transition(Transition const&) = delete;
-    Transition& operator=(Transition const&) = delete;
-
-  protected:
-    Transition(TransitionType transitionType, ATNState *target);
-
-  private:
-    const TransitionType _transitionType;
-  };
-
-  using ConstTransitionPtr = std::unique_ptr<const Transition>;
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,27 +0,0 @@
-#include "atn/TransitionType.h"
-
-std::string antlr4::atn::transitionTypeName(TransitionType transitionType) {
-  switch (transitionType) {
-    case TransitionType::EPSILON:
-      return "EPSILON";
-    case TransitionType::RANGE:
-      return "RANGE";
-    case TransitionType::RULE:
-      return "RULE";
-    case TransitionType::PREDICATE:
-      return "PREDICATE";
-    case TransitionType::ATOM:
-      return "ATOM";
-    case TransitionType::ACTION:
-      return "ACTION";
-    case TransitionType::SET:
-      return "SET";
-    case TransitionType::NOT_SET:
-      return "NOT_SET";
-    case TransitionType::WILDCARD:
-      return "WILDCARD";
-    case TransitionType::PRECEDENCE:
-      return "PRECEDENCE";
-  }
-  return "UNKNOWN";
-}

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

@@ -1,33 +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 <cstddef>
-#include <string>
-
-#include "antlr4-common.h"
-
-namespace antlr4 {
-namespace atn {
-
-  // Constants for transition serialization.
-  enum class TransitionType : size_t {
-    EPSILON = 1,
-    RANGE = 2,
-    RULE = 3,
-    PREDICATE = 4, // e.g., {isType(input.LT(1))}?
-    ATOM = 5,
-    ACTION = 6,
-    SET = 7, // ~(A|B) or ~atom, wildcard, which convert to next 2
-    NOT_SET = 8,
-    WILDCARD = 9,
-    PRECEDENCE = 10,
-  };
-
-  ANTLR4CPP_PUBLIC std::string transitionTypeName(TransitionType transitionType);
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,21 +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/ATNState.h"
-
-#include "atn/WildcardTransition.h"
-
-using namespace antlr4::atn;
-
-WildcardTransition::WildcardTransition(ATNState *target) : Transition(TransitionType::WILDCARD, target) {
-}
-
-bool WildcardTransition::matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const {
-  return symbol >= minVocabSymbol && symbol <= maxVocabSymbol;
-}
-
-std::string WildcardTransition::toString() const {
-  return "WILDCARD " + Transition::toString() + " {}";
-}

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

@@ -1,27 +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/Transition.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTLR4CPP_PUBLIC WildcardTransition final : public Transition {
-  public:
-    static bool is(const Transition &transition) { return transition.getTransitionType() == TransitionType::WILDCARD; }
-
-    static bool is(const Transition *transition) { return transition != nullptr && is(*transition); }
-
-    explicit WildcardTransition(ATNState *target);
-
-    virtual bool matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const override;
-
-    virtual std::string toString() const override;
-  };
-
-} // namespace atn
-} // namespace antlr4