expressir 0.2.4-x64-mingw32 → 0.2.10-x64-mingw32

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

@@ -1,84 +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/PredictionContext.h"
-#include "atn/ATNConfig.h"
-#include "atn/ATNConfigSet.h"
-#include "Parser.h"
-#include "misc/Interval.h"
-#include "dfa/DFA.h"
-
-#include "DiagnosticErrorListener.h"
-
-using namespace antlr4;
-
-DiagnosticErrorListener::DiagnosticErrorListener() : DiagnosticErrorListener(true) {
-}
-
-DiagnosticErrorListener::DiagnosticErrorListener(bool exactOnly_) : exactOnly(exactOnly_) {
-}
-
-void DiagnosticErrorListener::reportAmbiguity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex,
-   bool exact, const antlrcpp::BitSet &ambigAlts, atn::ATNConfigSet *configs) {
-  if (exactOnly && !exact) {
-    return;
-  }
-
-  std::string decision = getDecisionDescription(recognizer, dfa);
-  antlrcpp::BitSet conflictingAlts = getConflictingAlts(ambigAlts, configs);
-  std::string text = recognizer->getTokenStream()->getText(misc::Interval(startIndex, stopIndex));
-  std::string message = "reportAmbiguity d=" + decision + ": ambigAlts=" + conflictingAlts.toString() +
-    ", input='" + text + "'";
-
-  recognizer->notifyErrorListeners(message);
-}
-
-void DiagnosticErrorListener::reportAttemptingFullContext(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex,
-  size_t stopIndex, const antlrcpp::BitSet &/*conflictingAlts*/, atn::ATNConfigSet * /*configs*/) {
-  std::string decision = getDecisionDescription(recognizer, dfa);
-  std::string text = recognizer->getTokenStream()->getText(misc::Interval(startIndex, stopIndex));
-  std::string message = "reportAttemptingFullContext d=" + decision + ", input='" + text + "'";
-  recognizer->notifyErrorListeners(message);
-}
-
-void DiagnosticErrorListener::reportContextSensitivity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex,
-  size_t stopIndex, size_t /*prediction*/, atn::ATNConfigSet * /*configs*/) {
-  std::string decision = getDecisionDescription(recognizer, dfa);
-  std::string text = recognizer->getTokenStream()->getText(misc::Interval(startIndex, stopIndex));
-  std::string message = "reportContextSensitivity d=" + decision + ", input='" + text + "'";
-  recognizer->notifyErrorListeners(message);
-}
-
-std::string DiagnosticErrorListener::getDecisionDescription(Parser *recognizer, const dfa::DFA &dfa) {
-  size_t decision = dfa.decision;
-  size_t ruleIndex = (reinterpret_cast<atn::ATNState*>(dfa.atnStartState))->ruleIndex;
-
-  const std::vector<std::string>& ruleNames = recognizer->getRuleNames();
-  if (ruleIndex == INVALID_INDEX || ruleIndex >= ruleNames.size()) {
-    return std::to_string(decision);
-  }
-
-  std::string ruleName = ruleNames[ruleIndex];
-  if (ruleName == "" || ruleName.empty())  {
-    return std::to_string(decision);
-  }
-
-  return std::to_string(decision) + " (" + ruleName + ")";
-}
-
-antlrcpp::BitSet DiagnosticErrorListener::getConflictingAlts(const antlrcpp::BitSet &reportedAlts,
-                                                             atn::ATNConfigSet *configs) {
-  if (reportedAlts.count() > 0) { // Not exactly like the original Java code, but this listener is only used
-                                  // in the TestRig (where it never provides a good alt set), so it's probably ok so.
-    return reportedAlts;
-  }
-
-  antlrcpp::BitSet result;
-  for (auto &config : configs->configs) {
-    result.set(config->alt);
-  }
-
-  return result;
-}

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

@@ -1,80 +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 "BaseErrorListener.h"
-
-namespace antlr4 {
-
-  /// <summary>
-  /// This implementation of <seealso cref="ANTLRErrorListener"/> can be used to identify
-  /// certain potential correctness and performance problems in grammars. "Reports"
-  /// are made by calling <seealso cref="Parser#notifyErrorListeners"/> with the appropriate
-  /// message.
-  ///
-  /// <ul>
-  /// <li><b>Ambiguities</b>: These are cases where more than one path through the
-  /// grammar can match the input.</li>
-  /// <li><b>Weak context sensitivity</b>: These are cases where full-context
-  /// prediction resolved an SLL conflict to a unique alternative which equaled the
-  /// minimum alternative of the SLL conflict.</li>
-  /// <li><b>Strong (forced) context sensitivity</b>: These are cases where the
-  /// full-context prediction resolved an SLL conflict to a unique alternative,
-  /// <em>and</em> the minimum alternative of the SLL conflict was found to not be
-  /// a truly viable alternative. Two-stage parsing cannot be used for inputs where
-  /// this situation occurs.</li>
-  /// </ul>
-  ///
-  /// @author Sam Harwell
-  /// </summary>
-  class ANTLR4CPP_PUBLIC DiagnosticErrorListener : public BaseErrorListener {
-    /// <summary>
-    /// When {@code true}, only exactly known ambiguities are reported.
-    /// </summary>
-  protected:
-    const bool exactOnly;
-
-    /// <summary>
-    /// Initializes a new instance of <seealso cref="DiagnosticErrorListener"/> which only
-    /// reports exact ambiguities.
-    /// </summary>
-  public:
-    DiagnosticErrorListener();
-
-    /// <summary>
-    /// Initializes a new instance of <seealso cref="DiagnosticErrorListener"/>, specifying
-    /// whether all ambiguities or only exact ambiguities are reported.
-    /// </summary>
-    /// <param name="exactOnly"> {@code true} to report only exact ambiguities, otherwise
-    /// {@code false} to report all ambiguities. </param>
-    DiagnosticErrorListener(bool exactOnly);
-
-    virtual void reportAmbiguity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex, bool exact,
-      const antlrcpp::BitSet &ambigAlts, atn::ATNConfigSet *configs) override;
-
-    virtual void reportAttemptingFullContext(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex,
-      const antlrcpp::BitSet &conflictingAlts, atn::ATNConfigSet *configs) override;
-
-    virtual void reportContextSensitivity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex,
-      size_t prediction, atn::ATNConfigSet *configs) override;
-
-  protected:
-    virtual std::string getDecisionDescription(Parser *recognizer, const dfa::DFA &dfa);
-
-    /// <summary>
-    /// Computes the set of conflicting or ambiguous alternatives from a
-    /// configuration set, if that information was not already provided by the
-    /// parser.
-    /// </summary>
-    /// <param name="reportedAlts"> The set of conflicting or ambiguous alternatives, as
-    /// reported by the parser. </param>
-    /// <param name="configs"> The conflicting or ambiguous configuration set. </param>
-    /// <returns> Returns {@code reportedAlts} if it is not {@code null}, otherwise
-    /// returns the set of alternatives represented in {@code configs}. </returns>
-    virtual antlrcpp::BitSet getConflictingAlts(const antlrcpp::BitSet &reportedAlts, atn::ATNConfigSet *configs);
-  };
-
-} // namespace antlr4

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

@@ -1,64 +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 "Exceptions.h"
-
-using namespace antlr4;
-
-RuntimeException::RuntimeException(const std::string &msg) : std::exception(), _message(msg) {
-}
-
-const char* RuntimeException::what() const NOEXCEPT {
-  return _message.c_str();
-}
-
-//------------------ IOException ---------------------------------------------------------------------------------------
-
-IOException::IOException(const std::string &msg) : std::exception(), _message(msg) {
-}
-
-const char* IOException::what() const NOEXCEPT {
-  return _message.c_str();
-}
-
-//------------------ IllegalStateException -----------------------------------------------------------------------------
-
-IllegalStateException::~IllegalStateException() {
-}
-
-//------------------ IllegalArgumentException --------------------------------------------------------------------------
-
-IllegalArgumentException::~IllegalArgumentException() {
-}
-
-//------------------ NullPointerException ------------------------------------------------------------------------------
-
-NullPointerException::~NullPointerException() {
-}
-
-//------------------ IndexOutOfBoundsException -------------------------------------------------------------------------
-
-IndexOutOfBoundsException::~IndexOutOfBoundsException() {
-}
-
-//------------------ UnsupportedOperationException ---------------------------------------------------------------------
-
-UnsupportedOperationException::~UnsupportedOperationException() {
-}
-
-//------------------ EmptyStackException -------------------------------------------------------------------------------
-
-EmptyStackException::~EmptyStackException() {
-}
-
-//------------------ CancellationException -----------------------------------------------------------------------------
-
-CancellationException::~CancellationException() {
-}
-
-//------------------ ParseCancellationException ------------------------------------------------------------------------
-
-ParseCancellationException::~ParseCancellationException() {
-}

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

@@ -1,99 +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 "antlr4-common.h"
-
-namespace antlr4 {
-
-  // An exception hierarchy modelled loosely after java.lang.* exceptions.
-  class ANTLR4CPP_PUBLIC RuntimeException : public std::exception {
-  private:
-    std::string _message;
-  public:
-    RuntimeException(const std::string &msg = "");
-
-    virtual const char* what() const NOEXCEPT override;
-  };
-
-  class ANTLR4CPP_PUBLIC IllegalStateException : public RuntimeException {
-  public:
-    IllegalStateException(const std::string &msg = "") : RuntimeException(msg) {}
-    IllegalStateException(IllegalStateException const&) = default;
-    ~IllegalStateException();
-    IllegalStateException& operator=(IllegalStateException const&) = default;
-  };
-
-  class ANTLR4CPP_PUBLIC IllegalArgumentException : public RuntimeException {
-  public:
-    IllegalArgumentException(IllegalArgumentException const&) = default;
-    IllegalArgumentException(const std::string &msg = "") : RuntimeException(msg) {}
-    ~IllegalArgumentException();
-    IllegalArgumentException& operator=(IllegalArgumentException const&) = default;
-  };
-
-  class ANTLR4CPP_PUBLIC NullPointerException : public RuntimeException {
-  public:
-    NullPointerException(const std::string &msg = "") : RuntimeException(msg) {}
-    NullPointerException(NullPointerException const&) = default;
-    ~NullPointerException();
-    NullPointerException& operator=(NullPointerException const&) = default;
-  };
-
-  class ANTLR4CPP_PUBLIC IndexOutOfBoundsException : public RuntimeException {
-  public:
-    IndexOutOfBoundsException(const std::string &msg = "") : RuntimeException(msg) {}
-    IndexOutOfBoundsException(IndexOutOfBoundsException const&) = default;
-    ~IndexOutOfBoundsException();
-    IndexOutOfBoundsException& operator=(IndexOutOfBoundsException const&) = default;
-  };
-
-  class ANTLR4CPP_PUBLIC UnsupportedOperationException : public RuntimeException {
-  public:
-    UnsupportedOperationException(const std::string &msg = "") : RuntimeException(msg) {}
-    UnsupportedOperationException(UnsupportedOperationException const&) = default;
-    ~UnsupportedOperationException();
-    UnsupportedOperationException& operator=(UnsupportedOperationException const&) = default;
-
-  };
-
-  class ANTLR4CPP_PUBLIC EmptyStackException : public RuntimeException {
-  public:
-    EmptyStackException(const std::string &msg = "") : RuntimeException(msg) {}
-    EmptyStackException(EmptyStackException const&) = default;
-    ~EmptyStackException();
-    EmptyStackException& operator=(EmptyStackException const&) = default;
-  };
-
-  // IOException is not a runtime exception (in the java hierarchy).
-  // Hence we have to duplicate the RuntimeException implementation.
-  class ANTLR4CPP_PUBLIC IOException : public std::exception {
-  private:
-    std::string _message;
-
-  public:
-    IOException(const std::string &msg = "");
-
-    virtual const char* what() const NOEXCEPT override;
-  };
-
-  class ANTLR4CPP_PUBLIC CancellationException : public IllegalStateException {
-  public:
-    CancellationException(const std::string &msg = "") : IllegalStateException(msg) {}
-    CancellationException(CancellationException const&) = default;
-    ~CancellationException();
-    CancellationException& operator=(CancellationException const&) = default;
-  };
-
-  class ANTLR4CPP_PUBLIC ParseCancellationException : public CancellationException {
-  public:
-    ParseCancellationException(const std::string &msg = "") : CancellationException(msg) {}
-    ParseCancellationException(ParseCancellationException const&) = default;
-    ~ParseCancellationException();
-    ParseCancellationException& operator=(ParseCancellationException const&) = default;
-  };
-
-} // namespace antlr4

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

@@ -1,51 +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/ParserATNSimulator.h"
-#include "Parser.h"
-#include "atn/PredicateTransition.h"
-#include "atn/ATN.h"
-#include "atn/ATNState.h"
-#include "support/CPPUtils.h"
-
-#include "FailedPredicateException.h"
-
-using namespace antlr4;
-using namespace antlrcpp;
-
-FailedPredicateException::FailedPredicateException(Parser *recognizer) : FailedPredicateException(recognizer, "", "") {
-}
-
-FailedPredicateException::FailedPredicateException(Parser *recognizer, const std::string &predicate): FailedPredicateException(recognizer, predicate, "") {
-}
-
-FailedPredicateException::FailedPredicateException(Parser *recognizer, const std::string &predicate, const std::string &message)
-  : RecognitionException(!message.empty() ? message : "failed predicate: " + predicate + "?", recognizer,
-                         recognizer->getInputStream(), recognizer->getContext(), recognizer->getCurrentToken()) {
-
-  atn::ATNState *s = recognizer->getInterpreter<atn::ATNSimulator>()->atn.states[recognizer->getState()];
-  atn::Transition *transition = s->transitions[0];
-  if (is<atn::PredicateTransition*>(transition)) {
-    _ruleIndex = static_cast<atn::PredicateTransition *>(transition)->ruleIndex;
-    _predicateIndex = static_cast<atn::PredicateTransition *>(transition)->predIndex;
-  } else {
-    _ruleIndex = 0;
-    _predicateIndex = 0;
-  }
-
-  _predicate = predicate;
-}
-
-size_t FailedPredicateException::getRuleIndex() {
-  return _ruleIndex;
-}
-
-size_t FailedPredicateException::getPredIndex() {
-  return _predicateIndex;
-}
-
-std::string FailedPredicateException::getPredicate() {
-  return _predicate;
-}

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

@@ -1,32 +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 "RecognitionException.h"
-
-namespace antlr4 {
-
-  /// A semantic predicate failed during validation.  Validation of predicates
-  /// occurs when normally parsing the alternative just like matching a token.
-  /// Disambiguating predicate evaluation occurs when we test a predicate during
-  /// prediction.
-  class ANTLR4CPP_PUBLIC FailedPredicateException : public RecognitionException {
-  public:
-    FailedPredicateException(Parser *recognizer);
-    FailedPredicateException(Parser *recognizer, const std::string &predicate);
-    FailedPredicateException(Parser *recognizer, const std::string &predicate, const std::string &message);
-
-    virtual size_t getRuleIndex();
-    virtual size_t getPredIndex();
-    virtual std::string getPredicate();
-
-  private:
-    size_t _ruleIndex;
-    size_t _predicateIndex;
-    std::string _predicate;
-  };
-
-} // namespace antlr4

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

@@ -1,18 +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 "Parser.h"
-
-#include "InputMismatchException.h"
-
-using namespace antlr4;
-
-InputMismatchException::InputMismatchException(Parser *recognizer)
-  : RecognitionException(recognizer, recognizer->getInputStream(), recognizer->getContext(),
-                         recognizer->getCurrentToken()) {
-}
-
-InputMismatchException::~InputMismatchException() {
-}

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

@@ -1,24 +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 "RecognitionException.h"
-
-namespace antlr4 {
-
-  /// <summary>
-  /// This signifies any kind of mismatched input exceptions such as
-  ///  when the current input does not match the expected token.
-  /// </summary>
-  class ANTLR4CPP_PUBLIC InputMismatchException : public RecognitionException {
-  public:
-    InputMismatchException(Parser *recognizer);
-    InputMismatchException(InputMismatchException const&) = default;
-    ~InputMismatchException();
-    InputMismatchException& operator=(InputMismatchException const&) = default;
-  };
-
-} // namespace antlr4