expressir 0.2.4-x64-mingw32

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

@@ -0,0 +1,61 @@
+/* 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
+
+namespace antlr4 {
+namespace atn {
+
+  class ANTLR4CPP_PUBLIC ATNSerializer {
+  public:
+    ATN *atn;
+
+    ATNSerializer(ATN *atn);
+    ATNSerializer(ATN *atn, const std::vector<std::string> &tokenNames);
+    virtual ~ATNSerializer();
+
+    /// <summary>
+    /// Serialize state descriptors, edge descriptors, and decision->state map
+    ///  into list of ints:
+    ///
+    /// 		grammar-type, (ANTLRParser.LEXER, ...)
+    ///  	max token type,
+    ///  	num states,
+    ///  	state-0-type ruleIndex, state-1-type ruleIndex, ... state-i-type
+    ///  ruleIndex optional-arg ...
+    ///  	num rules,
+    ///  	rule-1-start-state rule-1-args, rule-2-start-state  rule-2-args, ...
+    ///  	(args are token type,actionIndex in lexer else 0,0)
+    ///      num modes,
+    ///      mode-0-start-state, mode-1-start-state, ... (parser has 0 modes)
+    ///      num sets
+    ///      set-0-interval-count intervals, set-1-interval-count intervals, ...
+    ///  	num total edges,
+    ///      src, trg, edge-type, edge arg1, optional edge arg2 (present always),
+    ///      ...
+    ///      num decisions,
+    ///      decision-0-start-state, decision-1-start-state, ...
+    ///
+    ///  Convenient to pack into unsigned shorts to make as Java string.
+    /// </summary>
+    virtual std::vector<size_t> serialize();
+
+    virtual std::string decode(const std::wstring& data);
+    virtual std::string getTokenName(size_t t);
+
+    /// Used by Java target to encode short/int array as chars in string.
+    static std::wstring getSerializedAsString(ATN *atn);
+    static std::vector<size_t> getSerialized(ATN *atn);
+
+    static std::string getDecoded(ATN *atn, std::vector<std::string> &tokenNames);
+
+  private:
+    std::vector<std::string> _tokenNames;
+
+    void serializeUUID(std::vector<size_t> &data, Guid uuid);
+  };
+
+} // namespace atn
+} // namespace antlr4

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

@@ -0,0 +1,63 @@
+/* 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/ATNType.h"
+#include "atn/ATNConfigSet.h"
+#include "dfa/DFAState.h"
+#include "atn/ATNDeserializer.h"
+#include "atn/EmptyPredictionContext.h"
+
+#include "atn/ATNSimulator.h"
+
+using namespace antlr4;
+using namespace antlr4::dfa;
+using namespace antlr4::atn;
+
+const Ref<DFAState> ATNSimulator::ERROR = std::make_shared<DFAState>(INT32_MAX);
+antlrcpp::SingleWriteMultipleReadLock ATNSimulator::_stateLock;
+antlrcpp::SingleWriteMultipleReadLock ATNSimulator::_edgeLock;
+
+ATNSimulator::ATNSimulator(const ATN &atn, PredictionContextCache &sharedContextCache)
+: atn(atn), _sharedContextCache(sharedContextCache) {
+}
+
+ATNSimulator::~ATNSimulator() {
+}
+
+void ATNSimulator::clearDFA() {
+  throw UnsupportedOperationException("This ATN simulator does not support clearing the DFA.");
+}
+
+PredictionContextCache& ATNSimulator::getSharedContextCache() {
+  return _sharedContextCache;
+}
+
+Ref<PredictionContext> ATNSimulator::getCachedContext(Ref<PredictionContext> const& context) {
+  // This function must only be called with an active state lock, as we are going to change a shared structure.
+  std::map<Ref<PredictionContext>, Ref<PredictionContext>> visited;
+  return PredictionContext::getCachedContext(context, _sharedContextCache, visited);
+}
+
+ATN ATNSimulator::deserialize(const std::vector<uint16_t> &data) {
+  ATNDeserializer deserializer;
+  return deserializer.deserialize(data);
+}
+
+void ATNSimulator::checkCondition(bool condition) {
+  ATNDeserializer::checkCondition(condition);
+}
+
+void ATNSimulator::checkCondition(bool condition, const std::string &message) {
+  ATNDeserializer::checkCondition(condition, message);
+}
+
+Transition *ATNSimulator::edgeFactory(const ATN &atn, int type, int src, int trg, int arg1, int arg2, int arg3,
+                                      const std::vector<misc::IntervalSet> &sets) {
+  return ATNDeserializer::edgeFactory(atn, type, src, trg, arg1, arg2, arg3, sets);
+}
+
+ATNState *ATNSimulator::stateFactory(int type, int ruleIndex) {
+  return ATNDeserializer::stateFactory(type, ruleIndex);
+}

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

@@ -0,0 +1,87 @@
+/* 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/ATN.h"
+#include "misc/IntervalSet.h"
+#include "support/CPPUtils.h"
+#include "atn/PredictionContext.h"
+
+namespace antlr4 {
+namespace atn {
+
+  class ANTLR4CPP_PUBLIC ATNSimulator {
+  public:
+    /// Must distinguish between missing edge and edge we know leads nowhere.
+    static const Ref<dfa::DFAState> ERROR;
+    const ATN &atn;
+
+    ATNSimulator(const ATN &atn, PredictionContextCache &sharedContextCache);
+    virtual ~ATNSimulator();
+
+    virtual void reset() = 0;
+
+    /**
+     * Clear the DFA cache used by the current instance. Since the DFA cache may
+     * be shared by multiple ATN simulators, this method may affect the
+     * performance (but not accuracy) of other parsers which are being used
+     * concurrently.
+     *
+     * @throws UnsupportedOperationException if the current instance does not
+     * support clearing the DFA.
+     *
+     * @since 4.3
+     */
+    virtual void clearDFA();
+    virtual PredictionContextCache& getSharedContextCache();
+    virtual Ref<PredictionContext> getCachedContext(Ref<PredictionContext> const& context);
+
+    /// @deprecated Use <seealso cref="ATNDeserializer#deserialize"/> instead.
+    static ATN deserialize(const std::vector<uint16_t> &data);
+
+    /// @deprecated Use <seealso cref="ATNDeserializer#checkCondition(boolean)"/> instead.
+    static void checkCondition(bool condition);
+
+    /// @deprecated Use <seealso cref="ATNDeserializer#checkCondition(boolean, String)"/> instead.
+    static void checkCondition(bool condition, const std::string &message);
+
+    /// @deprecated Use <seealso cref="ATNDeserializer#edgeFactory"/> instead.
+    static Transition *edgeFactory(const ATN &atn, int type, int src, int trg, int arg1, int arg2, int arg3,
+                                   const std::vector<misc::IntervalSet> &sets);
+
+    /// @deprecated Use <seealso cref="ATNDeserializer#stateFactory"/> instead.
+    static ATNState *stateFactory(int type, int ruleIndex);
+
+  protected:
+    static antlrcpp::SingleWriteMultipleReadLock _stateLock; // Lock for DFA states.
+    static antlrcpp::SingleWriteMultipleReadLock _edgeLock; // Lock for the sparse edge map in DFA states.
+
+    /// <summary>
+    /// The context cache maps all PredictionContext objects that are equals()
+    ///  to a single cached copy. This cache is shared across all contexts
+    ///  in all ATNConfigs in all DFA states.  We rebuild each ATNConfigSet
+    ///  to use only cached nodes/graphs in addDFAState(). We don't want to
+    ///  fill this during closure() since there are lots of contexts that
+    ///  pop up but are not used ever again. It also greatly slows down closure().
+    ///  <p/>
+    ///  This cache makes a huge difference in memory and a little bit in speed.
+    ///  For the Java grammar on java.*, it dropped the memory requirements
+    ///  at the end from 25M to 16M. We don't store any of the full context
+    ///  graphs in the DFA because they are limited to local context only,
+    ///  but apparently there's a lot of repetition there as well. We optimize
+    ///  the config contexts before storing the config set in the DFA states
+    ///  by literally rebuilding them with cached subgraphs only.
+    ///  <p/>
+    ///  I tried a cache for use during closure operations, that was
+    ///  whacked after each adaptivePredict(). It cost a little bit
+    ///  more time I think and doesn't save on the overall footprint
+    ///  so it's not worth the complexity.
+    /// </summary>
+    PredictionContextCache &_sharedContextCache;
+  };
+
+} // namespace atn
+} // namespace antlr4

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

@@ -0,0 +1,72 @@
+/* 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/ATN.h"
+#include "atn/Transition.h"
+#include "misc/IntervalSet.h"
+#include "support/CPPUtils.h"
+
+#include "atn/ATNState.h"
+
+using namespace antlr4::atn;
+using namespace antlrcpp;
+
+ATNState::ATNState() {
+}
+
+ATNState::~ATNState() {
+  for (auto transition : transitions) {
+    delete transition;
+  }
+}
+
+const std::vector<std::string> ATNState::serializationNames = {
+  "INVALID", "BASIC", "RULE_START", "BLOCK_START",
+  "PLUS_BLOCK_START", "STAR_BLOCK_START", "TOKEN_START", "RULE_STOP",
+  "BLOCK_END", "STAR_LOOP_BACK", "STAR_LOOP_ENTRY", "PLUS_LOOP_BACK", "LOOP_END"
+};
+
+size_t ATNState::hashCode() {
+  return stateNumber;
+}
+
+bool ATNState::operator == (const ATNState &other) {
+  return stateNumber == other.stateNumber;
+}
+
+bool ATNState::isNonGreedyExitState() {
+  return false;
+}
+
+std::string ATNState::toString() const {
+  return std::to_string(stateNumber);
+}
+
+void ATNState::addTransition(Transition *e) {
+  addTransition(transitions.size(), e);
+}
+
+void ATNState::addTransition(size_t index, Transition *e) {
+  for (Transition *transition : transitions)
+    if (transition->target->stateNumber == e->target->stateNumber) {
+      delete e;
+      return;
+    }
+
+  if (transitions.empty()) {
+    epsilonOnlyTransitions = e->isEpsilon();
+  } else if (epsilonOnlyTransitions != e->isEpsilon()) {
+    std::cerr << "ATN state %d has both epsilon and non-epsilon transitions.\n" << stateNumber;
+    epsilonOnlyTransitions = false;
+  }
+
+  transitions.insert(transitions.begin() + index, e);
+}
+
+Transition *ATNState::removeTransition(size_t index) {
+  Transition *result = transitions[index];
+  transitions.erase(transitions.begin() + index);
+  return result;
+}

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

@@ -0,0 +1,133 @@
+/* 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>
+  /// The following images show the relation of states and
+  /// <seealso cref="ATNState#transitions"/> for various grammar constructs.
+  ///
+  /// <ul>
+  ///
+  /// <li>Solid edges marked with an &#0949; indicate a required
+  /// <seealso cref="EpsilonTransition"/>.</li>
+  ///
+  /// <li>Dashed edges indicate locations where any transition derived from
+  /// <seealso cref="Transition"/> might appear.</li>
+  ///
+  /// <li>Dashed nodes are place holders for either a sequence of linked
+  /// <seealso cref="BasicState"/> states or the inclusion of a block representing a nested
+  /// construct in one of the forms below.</li>
+  ///
+  /// <li>Nodes showing multiple outgoing alternatives with a {@code ...} support
+  /// any number of alternatives (one or more). Nodes without the {@code ...} only
+  /// support the exact number of alternatives shown in the diagram.</li>
+  ///
+  /// </ul>
+  ///
+  /// <h2>Basic Blocks</h2>
+  ///
+  /// <h3>Rule</h3>
+  ///
+  /// <embed src="images/Rule.svg" type="image/svg+xml"/>
+  ///
+  /// <h3>Block of 1 or more alternatives</h3>
+  ///
+  /// <embed src="images/Block.svg" type="image/svg+xml"/>
+  ///
+  /// <h2>Greedy Loops</h2>
+  ///
+  /// <h3>Greedy Closure: {@code (...)*}</h3>
+  ///
+  /// <embed src="images/ClosureGreedy.svg" type="image/svg+xml"/>
+  ///
+  /// <h3>Greedy Positive Closure: {@code (...)+}</h3>
+  ///
+  /// <embed src="images/PositiveClosureGreedy.svg" type="image/svg+xml"/>
+  ///
+  /// <h3>Greedy Optional: {@code (...)?}</h3>
+  ///
+  /// <embed src="images/OptionalGreedy.svg" type="image/svg+xml"/>
+  ///
+  /// <h2>Non-Greedy Loops</h2>
+  ///
+  /// <h3>Non-Greedy Closure: {@code (...)*?}</h3>
+  ///
+  /// <embed src="images/ClosureNonGreedy.svg" type="image/svg+xml"/>
+  ///
+  /// <h3>Non-Greedy Positive Closure: {@code (...)+?}</h3>
+  ///
+  /// <embed src="images/PositiveClosureNonGreedy.svg" type="image/svg+xml"/>
+  ///
+  /// <h3>Non-Greedy Optional: {@code (...)??}</h3>
+  ///
+  /// <embed src="images/OptionalNonGreedy.svg" type="image/svg+xml"/>
+  /// </summary>
+  class ANTLR4CPP_PUBLIC ATN;
+
+  class ANTLR4CPP_PUBLIC ATNState {
+  public:
+    ATNState();
+    ATNState(ATNState const&) = delete;
+
+    virtual ~ATNState();
+
+    ATNState& operator=(ATNState const&) = delete;
+
+    static const size_t INITIAL_NUM_TRANSITIONS = 4;
+    static const size_t INVALID_STATE_NUMBER = static_cast<size_t>(-1); // std::numeric_limits<size_t>::max();
+
+    enum {
+      ATN_INVALID_TYPE = 0,
+      BASIC = 1,
+      RULE_START = 2,
+      BLOCK_START = 3,
+      PLUS_BLOCK_START = 4,
+      STAR_BLOCK_START = 5,
+      TOKEN_START = 6,
+      RULE_STOP = 7,
+      BLOCK_END = 8,
+      STAR_LOOP_BACK = 9,
+      STAR_LOOP_ENTRY = 10,
+      PLUS_LOOP_BACK = 11,
+      LOOP_END = 12
+    };
+
+    static const std::vector<std::string> serializationNames;
+
+    size_t stateNumber = INVALID_STATE_NUMBER;
+    size_t ruleIndex = 0; // at runtime, we don't have Rule objects
+    bool epsilonOnlyTransitions = false;
+
+  public:
+    virtual size_t hashCode();
+    bool operator == (const ATNState &other);
+
+    /// Track the transitions emanating from this ATN state.
+    std::vector<Transition*> transitions;
+
+    virtual bool isNonGreedyExitState();
+    virtual std::string toString() const;
+    virtual void addTransition(Transition *e);
+    virtual void addTransition(size_t index, Transition *e);
+    virtual Transition* removeTransition(size_t index);
+    virtual size_t getStateType() = 0;
+
+  private:
+    /// Used to cache lookahead during parsing, not used during construction.
+
+    misc::IntervalSet _nextTokenWithinRule;
+    std::atomic<bool> _nextTokenUpdated { false };
+
+    friend class ATN;
+  };
+
+} // namespace atn
+} // namespace antlr4

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

@@ -0,0 +1,20 @@
+/* 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 atn {
+
+  /// Represents the type of recognizer an ATN applies to.
+  enum class ATNType {
+    LEXER = 0,
+    PARSER = 1,
+  };
+
+} // namespace atn
+} // namespace antlr4

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

@@ -0,0 +1,14 @@
+/* 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/AbstractPredicateTransition.h"
+
+using namespace antlr4::atn;
+
+AbstractPredicateTransition::AbstractPredicateTransition(ATNState *target) : Transition(target) {
+}
+
+AbstractPredicateTransition::~AbstractPredicateTransition() {
+}