expressir 0.2.5-x64-mingw32 → 0.2.7-x64-mingw32

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

@@ -1,61 +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
-
-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

@@ -1,63 +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/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

@@ -1,87 +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/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

@@ -1,72 +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/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

@@ -1,133 +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 "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

@@ -1,20 +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 {
-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

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

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/AbstractPredicateTransition.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 "atn/Transition.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTState;
-
-  class ANTLR4CPP_PUBLIC AbstractPredicateTransition : public Transition {
-
-  public:
-    AbstractPredicateTransition(ATNState *target);
-    ~AbstractPredicateTransition();
-
-  };
-
-} // namespace atn
-} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/ActionTransition.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/ActionTransition.h"
-
-using namespace antlr4::atn;
-
-ActionTransition::ActionTransition(ATNState *target, size_t ruleIndex)
-  : Transition(target), ruleIndex(ruleIndex), actionIndex(INVALID_INDEX), isCtxDependent(false) {
-}
-
-ActionTransition::ActionTransition(ATNState *target, size_t ruleIndex, size_t actionIndex, bool isCtxDependent)
-  : Transition(target), ruleIndex(ruleIndex), actionIndex(actionIndex), isCtxDependent(isCtxDependent) {
-}
-
-Transition::SerializationType ActionTransition::getSerializationType() const {
-  return ACTION;
-}
-
-bool ActionTransition::isEpsilon() const {
-  return true; // we are to be ignored by analysis 'cept for predicates
-}
-
-bool ActionTransition::matches(size_t /*symbol*/, size_t /*minVocabSymbol*/, size_t /*maxVocabSymbol*/) const {
-  return false;
-}
-
-std::string ActionTransition::toString() const {
-  return " ACTION " + Transition::toString() + " { ruleIndex: " + std::to_string(ruleIndex) + ", actionIndex: " +
-  std::to_string(actionIndex) + ", isCtxDependent: " + std::to_string(isCtxDependent) + " }";
-}

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

@@ -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.
- */
-
-#pragma once
-
-#include "atn/Transition.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTLR4CPP_PUBLIC ActionTransition final : public Transition {
-  public:
-    const size_t ruleIndex;
-    const size_t actionIndex;
-    const bool isCtxDependent; // e.g., $i ref in action
-
-    ActionTransition(ATNState *target, size_t ruleIndex);
-
-    ActionTransition(ATNState *target, size_t ruleIndex, size_t actionIndex, bool isCtxDependent);
-
-    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/AmbiguityInfo.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/AmbiguityInfo.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-
-AmbiguityInfo::AmbiguityInfo(size_t decision, ATNConfigSet *configs, const antlrcpp::BitSet &ambigAlts,
-                             TokenStream *input, size_t startIndex, size_t stopIndex, bool fullCtx)
-  : DecisionEventInfo(decision, configs, input, startIndex, stopIndex, fullCtx) {
-
-  this->ambigAlts = ambigAlts;
-}

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

@@ -1,68 +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/DecisionEventInfo.h"
-#include "support/BitSet.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// <summary>
-  /// This class represents profiling event information for an ambiguity.
-  /// Ambiguities are decisions where a particular input resulted in an SLL
-  /// conflict, followed by LL prediction also reaching a conflict state
-  /// (indicating a true ambiguity in the grammar).
-  ///
-  /// <para>
-  /// This event may be reported during SLL prediction in cases where the
-  /// conflicting SLL configuration set provides sufficient information to
-  /// determine that the SLL conflict is truly an ambiguity. For example, if none
-  /// of the ATN configurations in the conflicting SLL configuration set have
-  /// traversed a global follow transition (i.e.
-  /// <seealso cref="ATNConfig#reachesIntoOuterContext"/> is 0 for all configurations), then
-  /// the result of SLL prediction for that input is known to be equivalent to the
-  /// result of LL prediction for that input.</para>
-  ///
-  /// <para>
-  /// In some cases, the minimum represented alternative in the conflicting LL
-  /// configuration set is not equal to the minimum represented alternative in the
-  /// conflicting SLL configuration set. Grammars and inputs which result in this
-  /// scenario are unable to use <seealso cref="PredictionMode#SLL"/>, which in turn means
-  /// they cannot use the two-stage parsing strategy to improve parsing performance
-  /// for that input.</para>
-  /// </summary>
-  /// <seealso cref= ParserATNSimulator#reportAmbiguity </seealso>
-  /// <seealso cref= ANTLRErrorListener#reportAmbiguity
-  ///
-  /// @since 4.3 </seealso>
-  class ANTLR4CPP_PUBLIC AmbiguityInfo : public DecisionEventInfo {
-  public:
-    /// The set of alternative numbers for this decision event that lead to a valid parse.
-    antlrcpp::BitSet ambigAlts;
-
-    /// <summary>
-    /// Constructs a new instance of the <seealso cref="AmbiguityInfo"/> class with the
-    /// specified detailed ambiguity information.
-    /// </summary>
-    /// <param name="decision"> The decision number </param>
-    /// <param name="configs"> The final configuration set identifying the ambiguous
-    /// alternatives for the current input </param>
-    /// <param name="ambigAlts"> The set of alternatives in the decision that lead to a valid parse.
-    ///                  The predicted alt is the min(ambigAlts) </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 ambiguity was identified during
-    /// prediction </param>
-    /// <param name="fullCtx"> {@code true} if the ambiguity was identified during LL
-    /// prediction; otherwise, {@code false} if the ambiguity was identified
-    /// during SLL prediction </param>
-    AmbiguityInfo(size_t decision, ATNConfigSet *configs, const antlrcpp::BitSet &ambigAlts, TokenStream *input,
-                  size_t startIndex, size_t stopIndex, bool fullCtx);
-  };
-
-} // namespace atn
-} // namespace antlr4