expressir 0.2.0 → 0.2.5

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

@@ -0,0 +1,17 @@
+/* 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/DecisionState.h"
+
+using namespace antlr4::atn;
+
+void DecisionState::InitializeInstanceFields() {
+  decision = -1;
+  nonGreedy = false;
+}
+
+std::string DecisionState::toString() const {
+  return "DECISION " + ATNState::toString();
+}

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

@@ -0,0 +1,30 @@
+/* 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 DecisionState : public ATNState {
+  public:
+    int decision;
+    bool nonGreedy;
+
+  private:
+    void InitializeInstanceFields();
+
+  public:
+    DecisionState() {
+      InitializeInstanceFields();
+    }
+
+    virtual std::string toString() const override;
+  };
+
+} // namespace atn
+} // namespace antlr4

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

@@ -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.
+ */
+
+#include "atn/EmptyPredictionContext.h"
+
+using namespace antlr4::atn;
+
+EmptyPredictionContext::EmptyPredictionContext() : SingletonPredictionContext(nullptr, EMPTY_RETURN_STATE) {
+}
+
+bool EmptyPredictionContext::isEmpty() const {
+  return true;
+}
+
+size_t EmptyPredictionContext::size() const {
+  return 1;
+}
+
+Ref<PredictionContext> EmptyPredictionContext::getParent(size_t /*index*/) const {
+  return nullptr;
+}
+
+size_t EmptyPredictionContext::getReturnState(size_t /*index*/) const {
+  return returnState;
+}
+
+bool EmptyPredictionContext::operator == (const PredictionContext &o) const {
+  return this == &o;
+}
+
+std::string EmptyPredictionContext::toString() const {
+  return "$";
+}

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

@@ -0,0 +1,27 @@
+/* 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/SingletonPredictionContext.h"
+
+namespace antlr4 {
+namespace atn {
+
+  class ANTLR4CPP_PUBLIC EmptyPredictionContext : public SingletonPredictionContext {
+  public:
+    EmptyPredictionContext();
+
+    virtual bool isEmpty() const override;
+    virtual size_t size() const override;
+    virtual Ref<PredictionContext> getParent(size_t index) const override;
+    virtual size_t getReturnState(size_t index) const override;
+    virtual std::string toString() const override;
+
+    virtual bool operator == (const PredictionContext &o) const override;
+  };
+
+} // namespace atn
+} // namespace antlr4

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

@@ -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.
+ */
+
+#include "atn/EpsilonTransition.h"
+
+using namespace antlr4::atn;
+
+EpsilonTransition::EpsilonTransition(ATNState *target) : EpsilonTransition(target, INVALID_INDEX) {
+}
+
+EpsilonTransition::EpsilonTransition(ATNState *target, size_t outermostPrecedenceReturn)
+  : Transition(target), _outermostPrecedenceReturn(outermostPrecedenceReturn) {
+}
+
+size_t EpsilonTransition::outermostPrecedenceReturn() {
+  return _outermostPrecedenceReturn;
+}
+
+Transition::SerializationType EpsilonTransition::getSerializationType() const {
+  return EPSILON;
+}
+
+bool EpsilonTransition::isEpsilon() const {
+  return true;
+}
+
+bool EpsilonTransition::matches(size_t /*symbol*/, size_t /*minVocabSymbol*/, size_t /*maxVocabSymbol*/) const {
+  return false;
+}
+
+std::string EpsilonTransition::toString() const {
+  return "EPSILON " + Transition::toString() + " {}";
+}

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

@@ -0,0 +1,39 @@
+/* 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 EpsilonTransition final : public Transition {
+  public:
+    EpsilonTransition(ATNState *target);
+    EpsilonTransition(ATNState *target, size_t outermostPrecedenceReturn);
+
+    /**
+     * @return the rule index of a precedence rule for which this transition is
+     * returning from, where the precedence value is 0; otherwise, INVALID_INDEX.
+     *
+     * @see ATNConfig#isPrecedenceFilterSuppressed()
+     * @see ParserATNSimulator#applyPrecedenceFilter(ATNConfigSet)
+     * @since 4.4.1
+     */
+    size_t outermostPrecedenceReturn();
+    virtual SerializationType getSerializationType() const override;
+
+    virtual bool isEpsilon() const override;
+    virtual bool matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const override;
+
+    virtual std::string toString() const override;
+
+  private:
+    const size_t _outermostPrecedenceReturn; // A rule index.
+  };
+
+} // namespace atn
+} // namespace antlr4

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

@@ -0,0 +1,15 @@
+/* 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/ATNConfigSet.h"
+
+#include "atn/ErrorInfo.h"
+
+using namespace antlr4;
+using namespace antlr4::atn;
+
+ErrorInfo::ErrorInfo(size_t decision, ATNConfigSet *configs, TokenStream *input, size_t startIndex, size_t stopIndex, bool fullCtx)
+  : DecisionEventInfo(decision, configs, input, startIndex, stopIndex, fullCtx) {
+}

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

@@ -0,0 +1,43 @@
+/* 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/DecisionEventInfo.h"
+
+namespace antlr4 {
+namespace atn {
+
+  /// <summary>
+  /// This class represents profiling event information for a syntax error
+  /// identified during prediction. Syntax errors occur when the prediction
+  /// algorithm is unable to identify an alternative which would lead to a
+  /// successful parse.
+  /// </summary>
+  /// <seealso cref= Parser#notifyErrorListeners(Token, String, RecognitionException) </seealso>
+  /// <seealso cref= ANTLRErrorListener#syntaxError
+  ///
+  /// @since 4.3 </seealso>
+  class ANTLR4CPP_PUBLIC ErrorInfo : public DecisionEventInfo {
+  public:
+    /// <summary>
+    /// Constructs a new instance of the <seealso cref="ErrorInfo"/> class with the
+    /// specified detailed syntax error information.
+    /// </summary>
+    /// <param name="decision"> The decision number </param>
+    /// <param name="configs"> The final configuration set reached during prediction
+    /// prior to reaching the <seealso cref="ATNSimulator#ERROR"/> state </param>
+    /// <param name="input"> The input token stream </param>
+    /// <param name="startIndex"> The start index for the current prediction </param>
+    /// <param name="stopIndex"> The index at which the syntax error was identified </param>
+    /// <param name="fullCtx"> {@code true} if the syntax error was identified during LL
+    /// prediction; otherwise, {@code false} if the syntax error was identified
+    /// during SLL prediction </param>
+    ErrorInfo(size_t decision, ATNConfigSet *configs, TokenStream *input, size_t startIndex, size_t stopIndex,
+              bool fullCtx);
+  };
+
+} // namespace atn
+} // namespace antlr4

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

@@ -0,0 +1,158 @@
+/* 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/RuleStopState.h"
+#include "atn/Transition.h"
+#include "atn/RuleTransition.h"
+#include "atn/SingletonPredictionContext.h"
+#include "atn/AbstractPredicateTransition.h"
+#include "atn/WildcardTransition.h"
+#include "atn/NotSetTransition.h"
+#include "misc/IntervalSet.h"
+#include "atn/ATNConfig.h"
+#include "atn/EmptyPredictionContext.h"
+
+#include "support/CPPUtils.h"
+
+#include "atn/LL1Analyzer.h"
+
+using namespace antlr4;
+using namespace antlr4::atn;
+using namespace antlrcpp;
+
+LL1Analyzer::LL1Analyzer(const ATN &atn) : _atn(atn) {
+}
+
+LL1Analyzer::~LL1Analyzer() {
+}
+
+std::vector<misc::IntervalSet> LL1Analyzer::getDecisionLookahead(ATNState *s) const {
+  std::vector<misc::IntervalSet> look;
+
+  if (s == nullptr) {
+    return look;
+  }
+
+  look.resize(s->transitions.size()); // Fills all interval sets with defaults.
+  for (size_t alt = 0; alt < s->transitions.size(); alt++) {
+    bool seeThruPreds = false; // fail to get lookahead upon pred
+
+    ATNConfig::Set lookBusy;
+    antlrcpp::BitSet callRuleStack;
+    _LOOK(s->transitions[alt]->target, nullptr, PredictionContext::EMPTY,
+          look[alt], lookBusy, callRuleStack, seeThruPreds, false);
+
+    // Wipe out lookahead for this alternative if we found nothing
+    // or we had a predicate when we !seeThruPreds
+    if (look[alt].size() == 0 || look[alt].contains(HIT_PRED)) {
+      look[alt].clear();
+    }
+  }
+  return look;
+}
+
+misc::IntervalSet LL1Analyzer::LOOK(ATNState *s, RuleContext *ctx) const {
+  return LOOK(s, nullptr, ctx);
+}
+
+misc::IntervalSet LL1Analyzer::LOOK(ATNState *s, ATNState *stopState, RuleContext *ctx) const {
+  misc::IntervalSet r;
+  bool seeThruPreds = true; // ignore preds; get all lookahead
+  Ref<PredictionContext> lookContext = ctx != nullptr ? PredictionContext::fromRuleContext(_atn, ctx) : nullptr;
+
+  ATNConfig::Set lookBusy;
+  antlrcpp::BitSet callRuleStack;
+  _LOOK(s, stopState, lookContext, r, lookBusy, callRuleStack, seeThruPreds, true);
+
+  return r;
+}
+
+void LL1Analyzer::_LOOK(ATNState *s, ATNState *stopState, Ref<PredictionContext> const& ctx, misc::IntervalSet &look,
+  ATNConfig::Set &lookBusy, antlrcpp::BitSet &calledRuleStack, bool seeThruPreds, bool addEOF) const {
+
+  Ref<ATNConfig> c = std::make_shared<ATNConfig>(s, 0, ctx);
+
+  if (lookBusy.count(c) > 0) // Keep in mind comparison is based on members of the class, not the actual instance.
+    return;
+
+  lookBusy.insert(c);
+
+  // ml: s can never be null, hence no need to check if stopState is != null.
+  if (s == stopState) {
+    if (ctx == nullptr) {
+      look.add(Token::EPSILON);
+      return;
+    } else if (ctx->isEmpty() && addEOF) {
+      look.add(Token::EOF);
+      return;
+    }
+  }
+
+  if (s->getStateType() == ATNState::RULE_STOP) {
+    if (ctx == nullptr) {
+      look.add(Token::EPSILON);
+      return;
+    } else if (ctx->isEmpty() && addEOF) {
+      look.add(Token::EOF);
+      return;
+    }
+
+    if (ctx != PredictionContext::EMPTY) {
+      // run thru all possible stack tops in ctx
+      for (size_t i = 0; i < ctx->size(); i++) {
+        ATNState *returnState = _atn.states[ctx->getReturnState(i)];
+
+        bool removed = calledRuleStack.test(returnState->ruleIndex);
+        auto onExit = finally([removed, &calledRuleStack, returnState] {
+          if (removed) {
+            calledRuleStack.set(returnState->ruleIndex);
+          }
+        });
+
+        calledRuleStack[returnState->ruleIndex] = false;
+        _LOOK(returnState, stopState, ctx->getParent(i), look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
+      }
+      return;
+    }
+  }
+
+  size_t n = s->transitions.size();
+  for (size_t i = 0; i < n; i++) {
+    Transition *t = s->transitions[i];
+
+    if (t->getSerializationType() == Transition::RULE) {
+      if (calledRuleStack[(static_cast<RuleTransition*>(t))->target->ruleIndex]) {
+        continue;
+      }
+
+      Ref<PredictionContext> newContext = SingletonPredictionContext::create(ctx, (static_cast<RuleTransition*>(t))->followState->stateNumber);
+      auto onExit = finally([t, &calledRuleStack] {
+        calledRuleStack[(static_cast<RuleTransition*>(t))->target->ruleIndex] = false;
+      });
+
+      calledRuleStack.set((static_cast<RuleTransition*>(t))->target->ruleIndex);
+      _LOOK(t->target, stopState, newContext, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
+
+    } else if (is<AbstractPredicateTransition *>(t)) {
+      if (seeThruPreds) {
+        _LOOK(t->target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
+      } else {
+        look.add(HIT_PRED);
+      }
+    } else if (t->isEpsilon()) {
+      _LOOK(t->target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
+    } else if (t->getSerializationType() == Transition::WILDCARD) {
+      look.addAll(misc::IntervalSet::of(Token::MIN_USER_TOKEN_TYPE, static_cast<ssize_t>(_atn.maxTokenType)));
+    } else {
+      misc::IntervalSet set = t->label();
+      if (!set.isEmpty()) {
+        if (is<NotSetTransition*>(t)) {
+          set = set.complement(misc::IntervalSet::of(Token::MIN_USER_TOKEN_TYPE, static_cast<ssize_t>(_atn.maxTokenType)));
+        }
+        look.addAll(set);
+      }
+    }
+  }
+}

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

@@ -0,0 +1,109 @@
+/* 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 "Token.h"
+#include "support/BitSet.h"
+#include "atn/PredictionContext.h"
+#include "atn/ATNConfig.h"
+
+namespace antlr4 {
+namespace atn {
+
+  class ANTLR4CPP_PUBLIC LL1Analyzer {
+  public:
+    /// Special value added to the lookahead sets to indicate that we hit
+    ///  a predicate during analysis if {@code seeThruPreds==false}.
+    static const size_t HIT_PRED = Token::INVALID_TYPE;
+
+    const atn::ATN &_atn;
+
+    LL1Analyzer(const atn::ATN &atn);
+    virtual ~LL1Analyzer();
+
+    /// <summary>
+    /// Calculates the SLL(1) expected lookahead set for each outgoing transition
+    /// of an <seealso cref="ATNState"/>. The returned array has one element for each
+    /// outgoing transition in {@code s}. If the closure from transition
+    /// <em>i</em> leads to a semantic predicate before matching a symbol, the
+    /// element at index <em>i</em> of the result will be {@code null}.
+    /// </summary>
+    /// <param name="s"> the ATN state </param>
+    /// <returns> the expected symbols for each outgoing transition of {@code s}. </returns>
+    virtual std::vector<misc::IntervalSet> getDecisionLookahead(ATNState *s) const;
+
+    /// <summary>
+    /// Compute set of tokens that can follow {@code s} in the ATN in the
+    /// specified {@code ctx}.
+    /// <p/>
+    /// If {@code ctx} is {@code null} and the end of the rule containing
+    /// {@code s} is reached, <seealso cref="Token#EPSILON"/> is added to the result set.
+    /// If {@code ctx} is not {@code null} and the end of the outermost rule is
+    /// reached, <seealso cref="Token#EOF"/> is added to the result set.
+    /// </summary>
+    /// <param name="s"> the ATN state </param>
+    /// <param name="ctx"> the complete parser context, or {@code null} if the context
+    /// should be ignored
+    /// </param>
+    /// <returns> The set of tokens that can follow {@code s} in the ATN in the
+    /// specified {@code ctx}. </returns>
+    virtual misc::IntervalSet LOOK(ATNState *s, RuleContext *ctx) const;
+
+    /// <summary>
+    /// Compute set of tokens that can follow {@code s} in the ATN in the
+    /// specified {@code ctx}.
+    /// <p/>
+    /// If {@code ctx} is {@code null} and the end of the rule containing
+    /// {@code s} is reached, <seealso cref="Token#EPSILON"/> is added to the result set.
+    /// If {@code ctx} is not {@code null} and the end of the outermost rule is
+    /// reached, <seealso cref="Token#EOF"/> is added to the result set.
+    /// </summary>
+    /// <param name="s"> the ATN state </param>
+    /// <param name="stopState"> the ATN state to stop at. This can be a
+    /// <seealso cref="BlockEndState"/> to detect epsilon paths through a closure. </param>
+    /// <param name="ctx"> the complete parser context, or {@code null} if the context
+    /// should be ignored
+    /// </param>
+    /// <returns> The set of tokens that can follow {@code s} in the ATN in the
+    /// specified {@code ctx}. </returns>
+    virtual misc::IntervalSet LOOK(ATNState *s, ATNState *stopState, RuleContext *ctx) const;
+
+    /// <summary>
+    /// Compute set of tokens that can follow {@code s} in the ATN in the
+    /// specified {@code ctx}.
+    /// <p/>
+    /// If {@code ctx} is {@code null} and {@code stopState} or the end of the
+    /// rule containing {@code s} is reached, <seealso cref="Token#EPSILON"/> is added to
+    /// the result set. If {@code ctx} is not {@code null} and {@code addEOF} is
+    /// {@code true} and {@code stopState} or the end of the outermost rule is
+    /// reached, <seealso cref="Token#EOF"/> is added to the result set.
+    /// </summary>
+    /// <param name="s"> the ATN state. </param>
+    /// <param name="stopState"> the ATN state to stop at. This can be a
+    /// <seealso cref="BlockEndState"/> to detect epsilon paths through a closure. </param>
+    /// <param name="ctx"> The outer context, or {@code null} if the outer context should
+    /// not be used. </param>
+    /// <param name="look"> The result lookahead set. </param>
+    /// <param name="lookBusy"> A set used for preventing epsilon closures in the ATN
+    /// from causing a stack overflow. Outside code should pass
+    /// {@code new HashSet<ATNConfig>} for this argument. </param>
+    /// <param name="calledRuleStack"> A set used for preventing left recursion in the
+    /// ATN from causing a stack overflow. Outside code should pass
+    /// {@code new BitSet()} for this argument. </param>
+    /// <param name="seeThruPreds"> {@code true} to true semantic predicates as
+    /// implicitly {@code true} and "see through them", otherwise {@code false}
+    /// to treat semantic predicates as opaque and add <seealso cref="#HIT_PRED"/> to the
+    /// result if one is encountered. </param>
+    /// <param name="addEOF"> Add <seealso cref="Token#EOF"/> to the result if the end of the
+    /// outermost context is reached. This parameter has no effect if {@code ctx}
+    /// is {@code null}. </param>
+  protected:
+    virtual void _LOOK(ATNState *s, ATNState *stopState, Ref<PredictionContext> const& ctx, misc::IntervalSet &look,
+      ATNConfig::Set &lookBusy, antlrcpp::BitSet &calledRuleStack, bool seeThruPreds, bool addEOF) const;
+  };
+
+} // namespace atn
+} // namespace antlr4