expressir 0.2.5-x64-mingw32 → 0.2.11-x64-mingw32

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:
-    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<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,30 +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(target), from(from), to(to) {
-}
-
-Transition::SerializationType RangeTransition::getSerializationType() const {
-  return RANGE;
-}
-
-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,29 +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:
-    const size_t from;
-    const size_t to;
-
-    RangeTransition(ATNState *target, size_t from, size_t to);
-
-    virtual SerializationType getSerializationType() const override;
-
-    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.cpp

@@ -1,16 +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"
-
-using namespace antlr4::atn;
-
-RuleStartState::RuleStartState() {
-  isLeftRecursiveRule = false;
-}
-
-size_t RuleStartState::getStateType() {
-  return RULE_START;
-}

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/RuleStartState.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 RuleStartState final : public ATNState {
-  public:
-    RuleStartState();
-
-    RuleStopState *stopState = nullptr;
-    bool isLeftRecursiveRule = false;
-
-    virtual size_t getStateType() override;
-
-  };
-
-} // namespace atn
-} // namespace antlr4

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

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

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/RuleStopState.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 {
-
-  /// 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:
-    virtual size_t getStateType() override;
-
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -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.
- */
-
-#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(ruleStart), ruleIndex(ruleIndex), precedence(precedence) {
-  this->followState = followState;
-}
-
-Transition::SerializationType RuleTransition::getSerializationType() const {
-  return RULE;
-}
-
-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,40 +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 : public Transition {
-  public:
-    /// 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 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;
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,377 +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/MurmurHash.h"
-#include "support/CPPUtils.h"
-#include "support/Arrays.h"
-
-#include "SemanticContext.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlrcpp;
-
-//------------------ Predicate -----------------------------------------------------------------------------------------
-
-SemanticContext::Predicate::Predicate() : Predicate(INVALID_INDEX, INVALID_INDEX, false) {
-}
-
-SemanticContext::Predicate::Predicate(size_t ruleIndex, size_t predIndex, bool isCtxDependent)
-: ruleIndex(ruleIndex), predIndex(predIndex), isCtxDependent(isCtxDependent) {
-}
-
-
-bool SemanticContext::Predicate::eval(Recognizer *parser, RuleContext *parserCallStack) {
-  RuleContext *localctx = nullptr;
-  if (isCtxDependent)
-    localctx = parserCallStack;
-  return parser->sempred(localctx, ruleIndex, predIndex);
-}
-
-size_t SemanticContext::Predicate::hashCode() const {
-  size_t hashCode = misc::MurmurHash::initialize();
-  hashCode = misc::MurmurHash::update(hashCode, ruleIndex);
-  hashCode = misc::MurmurHash::update(hashCode, predIndex);
-  hashCode = misc::MurmurHash::update(hashCode, isCtxDependent ? 1 : 0);
-  hashCode = misc::MurmurHash::finish(hashCode, 3);
-  return hashCode;
-}
-
-bool SemanticContext::Predicate::operator == (const SemanticContext &other) const {
-  if (this == &other)
-    return true;
-
-  const Predicate *p = dynamic_cast<const Predicate*>(&other);
-  if (p == nullptr)
-    return false;
-
-  return ruleIndex == p->ruleIndex && predIndex == p->predIndex && isCtxDependent == p->isCtxDependent;
-}
-
-std::string SemanticContext::Predicate::toString() const {
-  return std::string("{") + std::to_string(ruleIndex) + std::string(":") + std::to_string(predIndex) + std::string("}?");
-}
-
-//------------------ PrecedencePredicate -------------------------------------------------------------------------------
-
-SemanticContext::PrecedencePredicate::PrecedencePredicate() : precedence(0) {
-}
-
-SemanticContext::PrecedencePredicate::PrecedencePredicate(int precedence) : precedence(precedence) {
-}
-
-bool SemanticContext::PrecedencePredicate::eval(Recognizer *parser, RuleContext *parserCallStack) {
-  return parser->precpred(parserCallStack, precedence);
-}
-
-Ref<SemanticContext> SemanticContext::PrecedencePredicate::evalPrecedence(Recognizer *parser,
-  RuleContext *parserCallStack) {
-  if (parser->precpred(parserCallStack, precedence)) {
-    return SemanticContext::NONE;
-  }
-  else {
-    return nullptr;
-  }
-}
-
-int SemanticContext::PrecedencePredicate::compareTo(PrecedencePredicate *o) {
-  return precedence - o->precedence;
-}
-
-size_t SemanticContext::PrecedencePredicate::hashCode() const {
-  size_t hashCode = 1;
-  hashCode = 31 * hashCode + static_cast<size_t>(precedence);
-  return hashCode;
-}
-
-bool SemanticContext::PrecedencePredicate::operator == (const SemanticContext &other) const {
-  if (this == &other)
-    return true;
-
-  const PrecedencePredicate *predicate = dynamic_cast<const PrecedencePredicate *>(&other);
-  if (predicate == nullptr)
-    return false;
-
-  return precedence == predicate->precedence;
-}
-
-std::string SemanticContext::PrecedencePredicate::toString() const {
-  return "{" + std::to_string(precedence) + ">=prec}?";
-}
-
-//------------------ AND -----------------------------------------------------------------------------------------------
-
-SemanticContext::AND::AND(Ref<SemanticContext> const& a, Ref<SemanticContext> const& b) {
-  Set operands;
-
-  if (is<AND>(a)) {
-    for (auto operand : std::dynamic_pointer_cast<AND>(a)->opnds) {
-      operands.insert(operand);
-    }
-  } else {
-    operands.insert(a);
-  }
-
-  if (is<AND>(b)) {
-    for (auto operand : std::dynamic_pointer_cast<AND>(b)->opnds) {
-      operands.insert(operand);
-    }
-  } else {
-    operands.insert(b);
-  }
-
-  std::vector<Ref<PrecedencePredicate>> precedencePredicates = filterPrecedencePredicates(operands);
-
-  if (!precedencePredicates.empty()) {
-    // interested in the transition with the lowest precedence
-    auto predicate = [](Ref<PrecedencePredicate> const& a, Ref<PrecedencePredicate> const& b) {
-      return a->precedence < b->precedence;
-    };
-
-    auto reduced = std::min_element(precedencePredicates.begin(), precedencePredicates.end(), predicate);
-    operands.insert(*reduced);
-  }
-
-  std::copy(operands.begin(), operands.end(), std::back_inserter(opnds));
-}
-
-std::vector<Ref<SemanticContext>> SemanticContext::AND::getOperands() const {
-  return opnds;
-}
-
-bool SemanticContext::AND::operator == (const SemanticContext &other) const {
-  if (this == &other)
-    return true;
-
-  const AND *context = dynamic_cast<const AND *>(&other);
-  if (context == nullptr)
-    return false;
-
-  return Arrays::equals(opnds, context->opnds);
-}
-
-size_t SemanticContext::AND::hashCode() const {
-  return misc::MurmurHash::hashCode(opnds, typeid(AND).hash_code());
-}
-
-bool SemanticContext::AND::eval(Recognizer *parser, RuleContext *parserCallStack) {
-  for (auto opnd : opnds) {
-    if (!opnd->eval(parser, parserCallStack)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-Ref<SemanticContext> SemanticContext::AND::evalPrecedence(Recognizer *parser, RuleContext *parserCallStack) {
-  bool differs = false;
-  std::vector<Ref<SemanticContext>> operands;
-  for (auto context : opnds) {
-    Ref<SemanticContext> evaluated = context->evalPrecedence(parser, parserCallStack);
-    differs |= (evaluated != context);
-    if (evaluated == nullptr) {
-      // The AND context is false if any element is false.
-      return nullptr;
-    } else if (evaluated != NONE) {
-      // Reduce the result by skipping true elements.
-      operands.push_back(evaluated);
-    }
-  }
-
-  if (!differs) {
-    return shared_from_this();
-  }
-
-  if (operands.empty()) {
-    // All elements were true, so the AND context is true.
-    return NONE;
-  }
-
-  Ref<SemanticContext> result = operands[0];
-  for (size_t i = 1; i < operands.size(); ++i) {
-    result = SemanticContext::And(result, operands[i]);
-  }
-
-  return result;
-}
-
-std::string SemanticContext::AND::toString() const {
-  std::string tmp;
-  for (auto var : opnds) {
-    tmp += var->toString() + " && ";
-  }
-  return tmp;
-}
-
-//------------------ OR ------------------------------------------------------------------------------------------------
-
-SemanticContext::OR::OR(Ref<SemanticContext> const& a, Ref<SemanticContext> const& b) {
-  Set operands;
-
-  if (is<OR>(a)) {
-    for (auto operand : std::dynamic_pointer_cast<OR>(a)->opnds) {
-      operands.insert(operand);
-    }
-  } else {
-    operands.insert(a);
-  }
-
-  if (is<OR>(b)) {
-    for (auto operand : std::dynamic_pointer_cast<OR>(b)->opnds) {
-      operands.insert(operand);
-    }
-  } else {
-    operands.insert(b);
-  }
-
-  std::vector<Ref<PrecedencePredicate>> precedencePredicates = filterPrecedencePredicates(operands);
-  if (!precedencePredicates.empty()) {
-    // interested in the transition with the highest precedence
-    auto predicate = [](Ref<PrecedencePredicate> const& a, Ref<PrecedencePredicate> const& b) {
-      return a->precedence < b->precedence;
-    };
-    auto reduced = std::max_element(precedencePredicates.begin(), precedencePredicates.end(), predicate);
-    operands.insert(*reduced);
-  }
-
-  std::copy(operands.begin(), operands.end(), std::back_inserter(opnds));
-}
-
-std::vector<Ref<SemanticContext>> SemanticContext::OR::getOperands() const {
-  return opnds;
-}
-
-bool SemanticContext::OR::operator == (const SemanticContext &other) const {
-  if (this == &other)
-    return true;
-
-  const OR *context = dynamic_cast<const OR *>(&other);
-  if (context == nullptr)
-    return false;
-
-  return Arrays::equals(opnds, context->opnds);
-}
-
-size_t SemanticContext::OR::hashCode() const {
-  return misc::MurmurHash::hashCode(opnds, typeid(OR).hash_code());
-}
-
-bool SemanticContext::OR::eval(Recognizer *parser, RuleContext *parserCallStack) {
-  for (auto opnd : opnds) {
-    if (opnd->eval(parser, parserCallStack)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-Ref<SemanticContext> SemanticContext::OR::evalPrecedence(Recognizer *parser, RuleContext *parserCallStack) {
-  bool differs = false;
-  std::vector<Ref<SemanticContext>> operands;
-  for (auto context : opnds) {
-    Ref<SemanticContext> evaluated = context->evalPrecedence(parser, parserCallStack);
-    differs |= (evaluated != context);
-    if (evaluated == NONE) {
-      // The OR context is true if any element is true.
-      return NONE;
-    } else if (evaluated != nullptr) {
-      // Reduce the result by skipping false elements.
-      operands.push_back(evaluated);
-    }
-  }
-
-  if (!differs) {
-    return shared_from_this();
-  }
-
-  if (operands.empty()) {
-    // All elements were false, so the OR context is false.
-    return nullptr;
-  }
-
-  Ref<SemanticContext> result = operands[0];
-  for (size_t i = 1; i < operands.size(); ++i) {
-    result = SemanticContext::Or(result, operands[i]);
-  }
-
-  return result;
-}
-
-std::string SemanticContext::OR::toString() const {
-  std::string tmp;
-  for(auto var : opnds) {
-    tmp += var->toString() + " || ";
-  }
-  return tmp;
-}
-
-//------------------ SemanticContext -----------------------------------------------------------------------------------
-
-const Ref<SemanticContext> SemanticContext::NONE = std::make_shared<Predicate>(INVALID_INDEX, INVALID_INDEX, false);
-
-SemanticContext::~SemanticContext() {
-}
-
-bool SemanticContext::operator != (const SemanticContext &other) const {
-  return !(*this == other);
-}
-
-Ref<SemanticContext> SemanticContext::evalPrecedence(Recognizer * /*parser*/, RuleContext * /*parserCallStack*/) {
-  return shared_from_this();
-}
-
-Ref<SemanticContext> SemanticContext::And(Ref<SemanticContext> const& a, Ref<SemanticContext> const& b) {
-  if (!a || a == NONE) {
-    return b;
-  }
-
-  if (!b || b == NONE) {
-    return a;
-  }
-
-  Ref<AND> result = std::make_shared<AND>(a, b);
-  if (result->opnds.size() == 1) {
-    return result->opnds[0];
-  }
-
-  return result;
-}
-
-Ref<SemanticContext> SemanticContext::Or(Ref<SemanticContext> const& a, Ref<SemanticContext> const& b) {
-  if (!a) {
-    return b;
-  }
-  if (!b) {
-    return a;
-  }
-
-  if (a == NONE || b == NONE) {
-    return NONE;
-  }
-
-  Ref<OR> result = std::make_shared<OR>(a, b);
-  if (result->opnds.size() == 1) {
-    return result->opnds[0];
-  }
-
-  return result;
-}
-
-std::vector<Ref<SemanticContext::PrecedencePredicate>> SemanticContext::filterPrecedencePredicates(const Set &collection) {
-  std::vector<Ref<SemanticContext::PrecedencePredicate>> result;
-  for (auto context : collection) {
-    if (antlrcpp::is<PrecedencePredicate>(context)) {
-      result.push_back(std::dynamic_pointer_cast<PrecedencePredicate>(context));
-    }
-  }
-
-  return result;
-}
-
-
-//------------------ Operator -----------------------------------------------------------------------------------------
-
-SemanticContext::Operator::~Operator() {
-}