expressir 0.2.1 → 0.2.6

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

@@ -0,0 +1,35 @@
+/* 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:
+    StarLoopEntryState();
+
+    /**
+     * 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;
+
+    virtual size_t getStateType() override;
+  };
+
+} // namespace atn
+} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/StarLoopbackState.cpp

@@ -0,0 +1,19 @@
+/* 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 "atn/StarLoopbackState.h"
+
+using namespace antlr4::atn;
+
+StarLoopEntryState *StarLoopbackState::getLoopEntryState() {
+  return dynamic_cast<StarLoopEntryState *>(transitions[0]->target);
+}
+
+size_t StarLoopbackState::getStateType() {
+  return STAR_LOOP_BACK;
+}

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

@@ -0,0 +1,21 @@
+/* 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:
+    StarLoopEntryState *getLoopEntryState();
+
+    virtual size_t getStateType() override;
+  };
+
+} // namespace atn
+} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/TokensStartState.cpp

@@ -0,0 +1,12 @@
+/* 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/TokensStartState.h"
+
+using namespace antlr4::atn;
+
+size_t TokensStartState::getStateType() {
+  return TOKEN_START;
+}

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/TokensStartState.h

@@ -0,0 +1,21 @@
+/* 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:
+    virtual size_t getStateType() override;
+  };
+
+} // namespace atn
+} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/Transition.cpp

@@ -0,0 +1,44 @@
+/* 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;
+
+const std::vector<std::string> Transition::serializationNames = {
+  "INVALID", "EPSILON", "RANGE", "RULE", "PREDICATE", "ATOM", "ACTION", "SET", "NOT_SET", "WILDCARD", "PRECEDENCE"
+};
+
+Transition::Transition(ATNState *target) {
+  if (target == nullptr) {
+    throw NullPointerException("target cannot be null.");
+  }
+
+  this->target = target;
+}
+
+Transition::~Transition() {
+}
+
+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

@@ -0,0 +1,76 @@
+/* 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"
+
+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:
+    // constants for serialization
+    enum SerializationType {
+      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,
+    };
+
+    static const std::vector<std::string> serializationNames;
+
+    /// The target of this transition.
+    // ml: this is a reference into the ATN.
+    ATNState *target;
+
+    virtual ~Transition();
+
+  protected:
+    Transition(ATNState *target);
+
+  public:
+    virtual SerializationType getSerializationType() const = 0;
+
+    /**
+     * 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;
+  };
+
+} // namespace atn
+} // namespace antlr4

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

@@ -0,0 +1,25 @@
+/* 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(target) {
+}
+
+Transition::SerializationType WildcardTransition::getSerializationType() const {
+  return WILDCARD;
+}
+
+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

@@ -0,0 +1,25 @@
+/* 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:
+    WildcardTransition(ATNState *target);
+
+    virtual SerializationType getSerializationType() const override;
+
+    virtual bool matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const override;
+
+    virtual std::string toString() const override;
+  };
+
+} // namespace atn
+} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/dfa/DFA.cpp

@@ -0,0 +1,127 @@
+/* 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 "dfa/DFASerializer.h"
+#include "dfa/LexerDFASerializer.h"
+#include "support/CPPUtils.h"
+#include "atn/StarLoopEntryState.h"
+#include "atn/ATNConfigSet.h"
+
+#include "dfa/DFA.h"
+
+using namespace antlr4;
+using namespace antlr4::dfa;
+using namespace antlrcpp;
+
+DFA::DFA(atn::DecisionState *atnStartState) : DFA(atnStartState, 0) {
+}
+
+DFA::DFA(atn::DecisionState *atnStartState, size_t decision)
+  : atnStartState(atnStartState), s0(nullptr), decision(decision) {
+
+  _precedenceDfa = false;
+  if (is<atn::StarLoopEntryState *>(atnStartState)) {
+    if (static_cast<atn::StarLoopEntryState *>(atnStartState)->isPrecedenceDecision) {
+      _precedenceDfa = true;
+      s0 = new DFAState(std::unique_ptr<atn::ATNConfigSet>(new atn::ATNConfigSet()));
+      s0->isAcceptState = false;
+      s0->requiresFullContext = false;
+    }
+  }
+}
+
+DFA::DFA(DFA &&other) : atnStartState(other.atnStartState), decision(other.decision) {
+  // Source states are implicitly cleared by the move.
+  states = std::move(other.states);
+
+  other.atnStartState = nullptr;
+  other.decision = 0;
+  s0 = other.s0;
+  other.s0 = nullptr;
+  _precedenceDfa = other._precedenceDfa;
+  other._precedenceDfa = false;
+}
+
+DFA::~DFA() {
+  bool s0InList = (s0 == nullptr);
+  for (auto state : states) {
+    if (state == s0)
+      s0InList = true;
+    delete state;
+  }
+
+  if (!s0InList)
+    delete s0;
+}
+
+bool DFA::isPrecedenceDfa() const {
+  return _precedenceDfa;
+}
+
+DFAState* DFA::getPrecedenceStartState(int precedence) const {
+  assert(_precedenceDfa); // Only precedence DFAs may contain a precedence start state.
+
+  auto iterator = s0->edges.find(precedence);
+  if (iterator == s0->edges.end())
+    return nullptr;
+
+  return iterator->second;
+}
+
+void DFA::setPrecedenceStartState(int precedence, DFAState *startState, SingleWriteMultipleReadLock &lock) {
+  if (!isPrecedenceDfa()) {
+    throw IllegalStateException("Only precedence DFAs may contain a precedence start state.");
+  }
+
+  if (precedence < 0) {
+    return;
+  }
+
+  {
+    lock.writeLock();
+    s0->edges[precedence] = startState;
+    lock.writeUnlock();
+  }
+}
+
+std::vector<DFAState *> DFA::getStates() const {
+  std::vector<DFAState *> result;
+  for (auto state : states)
+    result.push_back(state);
+
+  std::sort(result.begin(), result.end(), [](DFAState *o1, DFAState *o2) -> bool {
+    return o1->stateNumber < o2->stateNumber;
+  });
+
+  return result;
+}
+
+std::string DFA::toString(const std::vector<std::string> &tokenNames) {
+  if (s0 == nullptr) {
+    return "";
+  }
+  DFASerializer serializer(this, tokenNames);
+
+  return serializer.toString();
+}
+
+std::string DFA::toString(const Vocabulary &vocabulary) const {
+  if (s0 == nullptr) {
+    return "";
+  }
+
+  DFASerializer serializer(this, vocabulary);
+  return serializer.toString();
+}
+
+std::string DFA::toLexerString() {
+  if (s0 == nullptr) {
+    return "";
+  }
+  LexerDFASerializer serializer(this);
+
+  return serializer.toString();
+}
+

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/dfa/DFA.h

@@ -0,0 +1,91 @@
+/* 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 "dfa/DFAState.h"
+
+namespace antlrcpp {
+  class SingleWriteMultipleReadLock;
+}
+
+namespace antlr4 {
+namespace dfa {
+
+  class ANTLR4CPP_PUBLIC DFA {
+  public:
+    /// A set of all DFA states. Use a map so we can get old state back.
+    /// Set only allows you to see if it's there.
+
+    /// From which ATN state did we create this DFA?
+    atn::DecisionState *atnStartState;
+    std::unordered_set<DFAState *, DFAState::Hasher, DFAState::Comparer> states; // States are owned by this class.
+    DFAState *s0;
+    size_t decision;
+
+    DFA(atn::DecisionState *atnStartState);
+    DFA(atn::DecisionState *atnStartState, size_t decision);
+    DFA(const DFA &other) = delete;
+    DFA(DFA &&other);
+    virtual ~DFA();
+
+    /**
+     * Gets whether this DFA is a precedence DFA. Precedence DFAs use a special
+     * start state {@link #s0} which is not stored in {@link #states}. The
+     * {@link DFAState#edges} array for this start state contains outgoing edges
+     * supplying individual start states corresponding to specific precedence
+     * values.
+     *
+     * @return {@code true} if this is a precedence DFA; otherwise,
+     * {@code false}.
+     * @see Parser#getPrecedence()
+     */
+    bool isPrecedenceDfa() const;
+
+    /**
+     * Get the start state for a specific precedence value.
+     *
+     * @param precedence The current precedence.
+     * @return The start state corresponding to the specified precedence, or
+     * {@code null} if no start state exists for the specified precedence.
+     *
+     * @throws IllegalStateException if this is not a precedence DFA.
+     * @see #isPrecedenceDfa()
+     */
+    DFAState* getPrecedenceStartState(int precedence) const;
+
+    /**
+     * Set the start state for a specific precedence value.
+     *
+     * @param precedence The current precedence.
+     * @param startState The start state corresponding to the specified
+     * precedence.
+     *
+     * @throws IllegalStateException if this is not a precedence DFA.
+     * @see #isPrecedenceDfa()
+     */
+    void setPrecedenceStartState(int precedence, DFAState *startState, antlrcpp::SingleWriteMultipleReadLock &lock);
+
+    /// Return a list of all states in this DFA, ordered by state number.
+    virtual std::vector<DFAState *> getStates() const;
+
+    /**
+     * @deprecated Use {@link #toString(Vocabulary)} instead.
+     */
+    virtual std::string toString(const std::vector<std::string>& tokenNames);
+    std::string toString(const Vocabulary &vocabulary) const;
+
+    virtual std::string toLexerString();
+
+  private:
+    /**
+     * {@code true} if this DFA is for a precedence decision; otherwise,
+     * {@code false}. This is the backing field for {@link #isPrecedenceDfa}.
+     */
+    bool _precedenceDfa;
+  };
+
+} // namespace atn
+} // namespace antlr4