expressir 1.4.2 → 2.0.0

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

@@ -1,179 +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/PredicateEvalInfo.h"
-#include "atn/LookaheadEventInfo.h"
-#include "Parser.h"
-#include "atn/ATNConfigSet.h"
-#include "support/CPPUtils.h"
-
-#include "atn/ProfilingATNSimulator.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlr4::dfa;
-using namespace antlrcpp;
-
-using namespace std::chrono;
-
-ProfilingATNSimulator::ProfilingATNSimulator(Parser *parser)
-  : ParserATNSimulator(parser, parser->getInterpreter<ParserATNSimulator>()->atn,
-                       parser->getInterpreter<ParserATNSimulator>()->decisionToDFA,
-                       parser->getInterpreter<ParserATNSimulator>()->getSharedContextCache()) {
-  for (size_t i = 0; i < atn.decisionToState.size(); i++) {
-    _decisions.push_back(DecisionInfo(i));
-  }
-}
-
-size_t ProfilingATNSimulator::adaptivePredict(TokenStream *input, size_t decision, ParserRuleContext *outerContext) {
-  auto onExit = finally([this](){
-    _currentDecision = 0; // Originally -1, but that makes no sense (index into a vector and init value is also 0).
-  });
-
-  _sllStopIndex = -1;
-  _llStopIndex = -1;
-  _currentDecision = decision;
-  high_resolution_clock::time_point start = high_resolution_clock::now();
-  size_t alt = ParserATNSimulator::adaptivePredict(input, decision, outerContext);
-  high_resolution_clock::time_point stop = high_resolution_clock::now();
-  _decisions[decision].timeInPrediction += duration_cast<nanoseconds>(stop - start).count();
-  _decisions[decision].invocations++;
-
-  long long SLL_k = _sllStopIndex - _startIndex + 1;
-  _decisions[decision].SLL_TotalLook += SLL_k;
-  _decisions[decision].SLL_MinLook = _decisions[decision].SLL_MinLook == 0 ? SLL_k : std::min(_decisions[decision].SLL_MinLook, SLL_k);
-  if (SLL_k > _decisions[decision].SLL_MaxLook) {
-    _decisions[decision].SLL_MaxLook = SLL_k;
-    _decisions[decision].SLL_MaxLookEvent = std::make_shared<LookaheadEventInfo>(decision, nullptr, alt, input, _startIndex, _sllStopIndex, false);
-  }
-
-  if (_llStopIndex >= 0) {
-    long long LL_k = _llStopIndex - _startIndex + 1;
-    _decisions[decision].LL_TotalLook += LL_k;
-    _decisions[decision].LL_MinLook = _decisions[decision].LL_MinLook == 0 ? LL_k : std::min(_decisions[decision].LL_MinLook, LL_k);
-    if (LL_k > _decisions[decision].LL_MaxLook) {
-      _decisions[decision].LL_MaxLook = LL_k;
-      _decisions[decision].LL_MaxLookEvent = std::make_shared<LookaheadEventInfo>(decision, nullptr, alt, input, _startIndex, _llStopIndex, true);
-    }
-  }
-
-  return alt;
-}
-
-DFAState* ProfilingATNSimulator::getExistingTargetState(DFAState *previousD, size_t t) {
-  // this method is called after each time the input position advances
-  // during SLL prediction
-  _sllStopIndex = (int)_input->index();
-
-  DFAState *existingTargetState = ParserATNSimulator::getExistingTargetState(previousD, t);
-  if (existingTargetState != nullptr) {
-    _decisions[_currentDecision].SLL_DFATransitions++; // count only if we transition over a DFA state
-    if (existingTargetState == ERROR.get()) {
-      _decisions[_currentDecision].errors.push_back(
-        ErrorInfo(_currentDecision, previousD->configs.get(), _input, _startIndex, _sllStopIndex, false)
-      );
-    }
-  }
-
-  _currentState = existingTargetState;
-  return existingTargetState;
-}
-
-DFAState* ProfilingATNSimulator::computeTargetState(DFA &dfa, DFAState *previousD, size_t t) {
-  DFAState *state = ParserATNSimulator::computeTargetState(dfa, previousD, t);
-  _currentState = state;
-  return state;
-}
-
-std::unique_ptr<ATNConfigSet> ProfilingATNSimulator::computeReachSet(ATNConfigSet *closure, size_t t, bool fullCtx) {
-  if (fullCtx) {
-    // this method is called after each time the input position advances
-    // during full context prediction
-    _llStopIndex = (int)_input->index();
-  }
-
-  std::unique_ptr<ATNConfigSet> reachConfigs = ParserATNSimulator::computeReachSet(closure, t, fullCtx);
-  if (fullCtx) {
-    _decisions[_currentDecision].LL_ATNTransitions++; // count computation even if error
-    if (reachConfigs != nullptr) {
-    } else { // no reach on current lookahead symbol. ERROR.
-      // TODO: does not handle delayed errors per getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule()
-      _decisions[_currentDecision].errors.push_back(ErrorInfo(_currentDecision, closure, _input, _startIndex, _llStopIndex, true));
-    }
-  } else {
-    ++_decisions[_currentDecision].SLL_ATNTransitions;
-    if (reachConfigs != nullptr) {
-    } else { // no reach on current lookahead symbol. ERROR.
-      _decisions[_currentDecision].errors.push_back(ErrorInfo(_currentDecision, closure, _input, _startIndex, _sllStopIndex, false));
-    }
-  }
-  return reachConfigs;
-}
-
-bool ProfilingATNSimulator::evalSemanticContext(Ref<const SemanticContext> const& pred, ParserRuleContext *parserCallStack,
-                                                size_t alt, bool fullCtx) {
-  bool result = ParserATNSimulator::evalSemanticContext(pred, parserCallStack, alt, fullCtx);
-  if (!(std::dynamic_pointer_cast<const SemanticContext::PrecedencePredicate>(pred) != nullptr)) {
-    bool fullContext = _llStopIndex >= 0;
-    int stopIndex = fullContext ? _llStopIndex : _sllStopIndex;
-    _decisions[_currentDecision].predicateEvals.push_back(
-      PredicateEvalInfo(_currentDecision, _input, _startIndex, stopIndex, pred, result, alt, fullCtx));
-  }
-
-  return result;
-}
-
-void ProfilingATNSimulator::reportAttemptingFullContext(DFA &dfa, const BitSet &conflictingAlts, ATNConfigSet *configs,
-                                                        size_t startIndex, size_t stopIndex) {
-  if (conflictingAlts.count() > 0) {
-    conflictingAltResolvedBySLL = conflictingAlts.nextSetBit(0);
-  } else {
-    conflictingAltResolvedBySLL = configs->getAlts().nextSetBit(0);
-  }
-  _decisions[_currentDecision].LL_Fallback++;
-  ParserATNSimulator::reportAttemptingFullContext(dfa, conflictingAlts, configs, startIndex, stopIndex);
-}
-
-void ProfilingATNSimulator::reportContextSensitivity(DFA &dfa, size_t prediction, ATNConfigSet *configs,
-                                                     size_t startIndex, size_t stopIndex) {
-  if (prediction != conflictingAltResolvedBySLL) {
-    _decisions[_currentDecision].contextSensitivities.push_back(
-      ContextSensitivityInfo(_currentDecision, configs, _input, startIndex, stopIndex)
-    );
-  }
-  ParserATNSimulator::reportContextSensitivity(dfa, prediction, configs, startIndex, stopIndex);
-}
-
-void ProfilingATNSimulator::reportAmbiguity(DFA &dfa, DFAState *D, size_t startIndex, size_t stopIndex, bool exact,
-                                            const BitSet &ambigAlts, ATNConfigSet *configs) {
-  size_t prediction;
-  if (ambigAlts.count() > 0) {
-    prediction = ambigAlts.nextSetBit(0);
-  } else {
-    prediction = configs->getAlts().nextSetBit(0);
-  }
-  if (configs->fullCtx && prediction != conflictingAltResolvedBySLL) {
-    // Even though this is an ambiguity we are reporting, we can
-    // still detect some context sensitivities.  Both SLL and LL
-    // are showing a conflict, hence an ambiguity, but if they resolve
-    // to different minimum alternatives we have also identified a
-    // context sensitivity.
-    _decisions[_currentDecision].contextSensitivities.push_back(
-      ContextSensitivityInfo(_currentDecision, configs, _input, startIndex, stopIndex)
-    );
-  }
-  _decisions[_currentDecision].ambiguities.push_back(
-    AmbiguityInfo(_currentDecision, configs, ambigAlts, _input, startIndex, stopIndex, configs->fullCtx)
-  );
-  ParserATNSimulator::reportAmbiguity(dfa, D, startIndex, stopIndex, exact, ambigAlts, configs);
-}
-
-std::vector<DecisionInfo> ProfilingATNSimulator::getDecisionInfo() const {
-  return _decisions;
-}
-
-DFAState* ProfilingATNSimulator::getCurrentState() const {
-  return _currentState;
-}

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

@@ -1,60 +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/ParserATNSimulator.h"
-#include "atn/DecisionInfo.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTLR4CPP_PUBLIC ProfilingATNSimulator : public ParserATNSimulator {
-  public:
-    explicit ProfilingATNSimulator(Parser *parser);
-
-    virtual size_t adaptivePredict(TokenStream *input, size_t decision, ParserRuleContext *outerContext) override;
-
-    virtual std::vector<DecisionInfo> getDecisionInfo() const;
-    virtual dfa::DFAState* getCurrentState() const;
-
-  protected:
-    std::vector<DecisionInfo> _decisions;
-
-    int _sllStopIndex = 0;
-    int _llStopIndex = 0;
-
-    size_t _currentDecision = 0;
-    dfa::DFAState *_currentState;
-
-    /// <summary>
-    /// At the point of LL failover, we record how SLL would resolve the conflict so that
-    ///  we can determine whether or not a decision / input pair is context-sensitive.
-    ///  If LL gives a different result than SLL's predicted alternative, we have a
-    ///  context sensitivity for sure. The converse is not necessarily true, however.
-    ///  It's possible that after conflict resolution chooses minimum alternatives,
-    ///  SLL could get the same answer as LL. Regardless of whether or not the result indicates
-    ///  an ambiguity, it is not treated as a context sensitivity because LL prediction
-    ///  was not required in order to produce a correct prediction for this decision and input sequence.
-    ///  It may in fact still be a context sensitivity but we don't know by looking at the
-    ///  minimum alternatives for the current input.
-    /// </summary>
-    size_t conflictingAltResolvedBySLL = 0;
-
-    virtual dfa::DFAState* getExistingTargetState(dfa::DFAState *previousD, size_t t) override;
-    virtual dfa::DFAState* computeTargetState(dfa::DFA &dfa, dfa::DFAState *previousD, size_t t) override;
-    virtual std::unique_ptr<ATNConfigSet> computeReachSet(ATNConfigSet *closure, size_t t, bool fullCtx) override;
-    virtual bool evalSemanticContext(Ref<const SemanticContext> const& pred, ParserRuleContext *parserCallStack,
-                                     size_t alt, bool fullCtx) override;
-    virtual void reportAttemptingFullContext(dfa::DFA &dfa, const antlrcpp::BitSet &conflictingAlts, ATNConfigSet *configs,
-                                             size_t startIndex, size_t stopIndex) override;
-    virtual void reportContextSensitivity(dfa::DFA &dfa, size_t prediction, ATNConfigSet *configs,
-                                          size_t startIndex, size_t stopIndex) override;
-    virtual void reportAmbiguity(dfa::DFA &dfa, dfa::DFAState *D, size_t startIndex, size_t stopIndex, bool exact,
-                                 const antlrcpp::BitSet &ambigAlts, ATNConfigSet *configs) override;
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,26 +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/IntervalSet.h"
-
-#include "atn/RangeTransition.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-
-RangeTransition::RangeTransition(ATNState *target, size_t from, size_t to) : Transition(TransitionType::RANGE, target), from(from), to(to) {
-}
-
-misc::IntervalSet RangeTransition::label() const {
-  return misc::IntervalSet::of((int)from, (int)to);
-}
-
-bool RangeTransition::matches(size_t symbol, size_t /*minVocabSymbol*/, size_t /*maxVocabSymbol*/) const {
-  return symbol >= from && symbol <= to;
-}
-
-std::string RangeTransition::toString() const {
-  return "RANGE " + Transition::toString() + " { from: " + std::to_string(from) + ", to: " + std::to_string(to) + " }";
-}

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

@@ -1,31 +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 RangeTransition final : public Transition {
-  public:
-    static bool is(const Transition &transition) { return transition.getTransitionType() == TransitionType::RANGE; }
-
-    static bool is(const Transition *transition) { return transition != nullptr && is(*transition); }
-
-    const size_t from;
-    const size_t to;
-
-    RangeTransition(ATNState *target, size_t from, size_t to);
-
-    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;
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,26 +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 RuleStartState final : public ATNState {
-  public:
-    static bool is(const ATNState &atnState) { return atnState.getStateType() == ATNStateType::RULE_START; }
-
-    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
-
-    RuleStopState *stopState = nullptr;
-    bool isLeftRecursiveRule = false;
-
-    RuleStartState() : ATNState(ATNStateType::RULE_START) {}
-  };
-
-} // namespace atn
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/RuleStopState.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/ATNState.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// The last node in the ATN for a rule, unless that rule is the start symbol.
-  /// In that case, there is one transition to EOF. Later, we might encode
-  /// references to all calls to this rule to compute FOLLOW sets for
-  /// error handling.
-  class ANTLR4CPP_PUBLIC RuleStopState final : public ATNState {
-  public:
-    static bool is(const ATNState &atnState) { return atnState.getStateType() == ATNStateType::RULE_STOP; }
-
-    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
-
-    RuleStopState() : ATNState(ATNStateType::RULE_STOP) {}
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -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.
- */
-
-#include "atn/RuleStartState.h"
-#include "atn/RuleTransition.h"
-
-using namespace antlr4::atn;
-
-RuleTransition::RuleTransition(RuleStartState *ruleStart, size_t ruleIndex, ATNState *followState)
-  : RuleTransition(ruleStart, ruleIndex, 0, followState) {
-}
-
-RuleTransition::RuleTransition(RuleStartState *ruleStart, size_t ruleIndex, int precedence, ATNState *followState)
-  : Transition(TransitionType::RULE, ruleStart), ruleIndex(ruleIndex), precedence(precedence) {
-  this->followState = followState;
-}
-
-bool RuleTransition::isEpsilon() const {
-  return true;
-}
-
-bool RuleTransition::matches(size_t /*symbol*/, size_t /*minVocabSymbol*/, size_t /*maxVocabSymbol*/) const {
-  return false;
-}
-
-std::string RuleTransition::toString() const {
-  std::stringstream ss;
-  ss << "RULE " << Transition::toString() << " { ruleIndex: " << ruleIndex << ", precedence: " << precedence <<
-    ", followState: " << std::hex << followState << " }";
-  return ss.str();
-}

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

@@ -1,42 +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 RuleTransition final : public Transition {
-  public:
-    static bool is(const Transition &transition) { return transition.getTransitionType() == TransitionType::RULE; }
-
-    static bool is(const Transition *transition) { return transition != nullptr && is(*transition); }
-
-    /// Ptr to the rule definition object for this rule ref.
-    const size_t ruleIndex; // no Rule object at runtime
-
-    const int precedence;
-
-    /// What node to begin computations following ref to rule.
-    ATNState *followState;
-
-    /// @deprecated Use
-    /// <seealso cref="#RuleTransition(RuleStartState, size_t, int, ATNState)"/> instead.
-    RuleTransition(RuleStartState *ruleStart, size_t ruleIndex, ATNState *followState);
-
-    RuleTransition(RuleStartState *ruleStart, size_t ruleIndex, int precedence, ATNState *followState);
-    RuleTransition(RuleTransition const&) = delete;
-    RuleTransition& operator=(RuleTransition const&) = delete;
-
-    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;
-  };
-
-} // namespace atn
-} // namespace antlr4