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

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

@@ -1,23 +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 "Token.h"
-
-namespace antlr4 {
-
-  class ANTLR4CPP_PUBLIC WritableToken : public Token {
-  public:
-    virtual ~WritableToken();
-    virtual void setText(const std::string &text) = 0;
-    virtual void setType(size_t ttype) = 0;
-    virtual void setLine(size_t line) = 0;
-    virtual void setCharPositionInLine(size_t pos) = 0;
-    virtual void setChannel(size_t channel) = 0;
-    virtual void setTokenIndex(size_t index) = 0;
-  };
-
-} // namespace antlr4

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

@@ -1,137 +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 <algorithm>
-#include <assert.h>
-#include <atomic>
-#include <codecvt>
-#include <chrono>
-#include <fstream>
-#include <iostream>
-#include <iterator>
-#include <limits>
-#include <limits.h>
-#include <list>
-#include <map>
-#include <memory>
-#include <set>
-#include <stdarg.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <sstream>
-#include <stack>
-#include <string>
-#include <typeinfo>
-#include <type_traits>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-#include <mutex>
-#include <exception>
-#include <bitset>
-#include <condition_variable>
-#include <functional>
-
-// Defines for the Guid class and other platform dependent stuff.
-#ifdef _WIN32
-  #ifdef _MSC_VER
-    #pragma warning (disable: 4250) // Class inherits by dominance.
-    #pragma warning (disable: 4512) // assignment operator could not be generated
-
-    #if _MSC_VER < 1900
-      // Before VS 2015 code like "while (true)" will create a (useless) warning in level 4.
-      #pragma warning (disable: 4127) // conditional expression is constant
-    #endif
-  #endif
-
-  #define GUID_WINDOWS
-
-  #ifdef _WIN64
-    typedef __int64 ssize_t;
-  #else
-    typedef __int32 ssize_t;
-  #endif
-
-  #if _MSC_VER >= 1900 && _MSC_VER < 2000
-    // VS 2015 has a known bug when using std::codecvt_utf8<char32_t>
-    // so we have to temporarily use __int32 instead.
-    // https://connect.microsoft.com/VisualStudio/feedback/details/1403302/unresolved-external-when-using-codecvt-utf8
-    typedef std::basic_string<__int32> i32string;
-
-    typedef i32string UTF32String;
-  #else
-    typedef std::u32string UTF32String;
-  #endif
-
-  #ifdef ANTLR4CPP_EXPORTS
-    #define ANTLR4CPP_PUBLIC __declspec(dllexport)
-  #else
-    #ifdef ANTLR4CPP_STATIC
-      #define ANTLR4CPP_PUBLIC
-    #else
-      #define ANTLR4CPP_PUBLIC __declspec(dllimport)
-    #endif
-  #endif
-
-  #if defined(_MSC_VER) && !defined(__clang__)
-    // clang-cl should escape this to prevent [ignored-attributes].
-    namespace std {
-      class ANTLR4CPP_PUBLIC exception; // Prevents warning C4275 from MSVC.
-    } // namespace std
-  #endif
-
-#elif defined(__APPLE__)
-  typedef std::u32string UTF32String;
-
-  #define GUID_CFUUID
-  #if __GNUC__ >= 4
-    #define ANTLR4CPP_PUBLIC __attribute__ ((visibility ("default")))
-  #else
-    #define ANTLR4CPP_PUBLIC
-  #endif
-#else
-  typedef std::u32string UTF32String;
-
-  #define GUID_LIBUUID
-  #if __GNUC__ >= 6
-    #define ANTLR4CPP_PUBLIC __attribute__ ((visibility ("default")))
-  #else
-    #define ANTLR4CPP_PUBLIC
-  #endif
-#endif
-
-#include "support/guid.h"
-#include "support/Declarations.h"
-
-#if !defined(HAS_NOEXCEPT)
-  #if defined(__clang__)
-    #if __has_feature(cxx_noexcept)
-      #define HAS_NOEXCEPT
-    #endif
-  #else
-    #if defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ * 10 + __GNUC_MINOR__ >= 46 || \
-      defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026
-      #define HAS_NOEXCEPT
-    #endif
-  #endif
-
-  #ifdef HAS_NOEXCEPT
-    #define NOEXCEPT noexcept
-  #else
-    #define NOEXCEPT
-  #endif
-#endif
-
-// We have to undefine this symbol as ANTLR will use this name for own members and even
-// generated functions. Because EOF is a global macro we cannot use e.g. a namespace scope to disambiguate.
-#ifdef EOF
-#undef EOF
-#endif
-
-#define INVALID_INDEX std::numeric_limits<size_t>::max()
-template<class T> using Ref = std::shared_ptr<T>;

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

@@ -1,167 +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
-
-// This is the umbrella header for all ANTLR4 C++ runtime headers.
-
-#include "antlr4-common.h"
-
-#include "ANTLRErrorListener.h"
-#include "ANTLRErrorStrategy.h"
-#include "ANTLRFileStream.h"
-#include "ANTLRInputStream.h"
-#include "BailErrorStrategy.h"
-#include "BaseErrorListener.h"
-#include "BufferedTokenStream.h"
-#include "CharStream.h"
-#include "CommonToken.h"
-#include "CommonTokenFactory.h"
-#include "CommonTokenStream.h"
-#include "ConsoleErrorListener.h"
-#include "DefaultErrorStrategy.h"
-#include "DiagnosticErrorListener.h"
-#include "Exceptions.h"
-#include "FailedPredicateException.h"
-#include "InputMismatchException.h"
-#include "IntStream.h"
-#include "InterpreterRuleContext.h"
-#include "Lexer.h"
-#include "LexerInterpreter.h"
-#include "LexerNoViableAltException.h"
-#include "ListTokenSource.h"
-#include "NoViableAltException.h"
-#include "Parser.h"
-#include "ParserInterpreter.h"
-#include "ParserRuleContext.h"
-#include "ProxyErrorListener.h"
-#include "RecognitionException.h"
-#include "Recognizer.h"
-#include "RuleContext.h"
-#include "RuleContextWithAltNum.h"
-#include "RuntimeMetaData.h"
-#include "Token.h"
-#include "TokenFactory.h"
-#include "TokenSource.h"
-#include "TokenStream.h"
-#include "TokenStreamRewriter.h"
-#include "UnbufferedCharStream.h"
-#include "UnbufferedTokenStream.h"
-#include "Vocabulary.h"
-#include "Vocabulary.h"
-#include "WritableToken.h"
-#include "atn/ATN.h"
-#include "atn/ATNConfig.h"
-#include "atn/ATNConfigSet.h"
-#include "atn/ATNDeserializationOptions.h"
-#include "atn/ATNDeserializer.h"
-#include "atn/ATNSerializer.h"
-#include "atn/ATNSimulator.h"
-#include "atn/ATNState.h"
-#include "atn/ATNType.h"
-#include "atn/AbstractPredicateTransition.h"
-#include "atn/ActionTransition.h"
-#include "atn/AmbiguityInfo.h"
-#include "atn/ArrayPredictionContext.h"
-#include "atn/AtomTransition.h"
-#include "atn/BasicBlockStartState.h"
-#include "atn/BasicState.h"
-#include "atn/BlockEndState.h"
-#include "atn/BlockStartState.h"
-#include "atn/ContextSensitivityInfo.h"
-#include "atn/DecisionEventInfo.h"
-#include "atn/DecisionInfo.h"
-#include "atn/DecisionState.h"
-#include "atn/EmptyPredictionContext.h"
-#include "atn/EpsilonTransition.h"
-#include "atn/ErrorInfo.h"
-#include "atn/LL1Analyzer.h"
-#include "atn/LexerATNConfig.h"
-#include "atn/LexerATNSimulator.h"
-#include "atn/LexerAction.h"
-#include "atn/LexerActionExecutor.h"
-#include "atn/LexerActionType.h"
-#include "atn/LexerChannelAction.h"
-#include "atn/LexerCustomAction.h"
-#include "atn/LexerIndexedCustomAction.h"
-#include "atn/LexerModeAction.h"
-#include "atn/LexerMoreAction.h"
-#include "atn/LexerPopModeAction.h"
-#include "atn/LexerPushModeAction.h"
-#include "atn/LexerSkipAction.h"
-#include "atn/LexerTypeAction.h"
-#include "atn/LookaheadEventInfo.h"
-#include "atn/LoopEndState.h"
-#include "atn/NotSetTransition.h"
-#include "atn/OrderedATNConfigSet.h"
-#include "atn/ParseInfo.h"
-#include "atn/ParserATNSimulator.h"
-#include "atn/PlusBlockStartState.h"
-#include "atn/PlusLoopbackState.h"
-#include "atn/PrecedencePredicateTransition.h"
-#include "atn/PredicateEvalInfo.h"
-#include "atn/PredicateTransition.h"
-#include "atn/PredictionContext.h"
-#include "atn/PredictionMode.h"
-#include "atn/ProfilingATNSimulator.h"
-#include "atn/RangeTransition.h"
-#include "atn/RuleStartState.h"
-#include "atn/RuleStopState.h"
-#include "atn/RuleTransition.h"
-#include "atn/SemanticContext.h"
-#include "atn/SetTransition.h"
-#include "atn/SingletonPredictionContext.h"
-#include "atn/StarBlockStartState.h"
-#include "atn/StarLoopEntryState.h"
-#include "atn/StarLoopbackState.h"
-#include "atn/TokensStartState.h"
-#include "atn/Transition.h"
-#include "atn/WildcardTransition.h"
-#include "dfa/DFA.h"
-#include "dfa/DFASerializer.h"
-#include "dfa/DFAState.h"
-#include "dfa/LexerDFASerializer.h"
-#include "misc/InterpreterDataReader.h"
-#include "misc/Interval.h"
-#include "misc/IntervalSet.h"
-#include "misc/MurmurHash.h"
-#include "misc/Predicate.h"
-#include "support/Any.h"
-#include "support/Arrays.h"
-#include "support/BitSet.h"
-#include "support/CPPUtils.h"
-#include "support/StringUtils.h"
-#include "support/guid.h"
-#include "tree/AbstractParseTreeVisitor.h"
-#include "tree/ErrorNode.h"
-#include "tree/ErrorNodeImpl.h"
-#include "tree/ParseTree.h"
-#include "tree/ParseTreeListener.h"
-#include "tree/ParseTreeProperty.h"
-#include "tree/ParseTreeVisitor.h"
-#include "tree/ParseTreeWalker.h"
-#include "tree/TerminalNode.h"
-#include "tree/TerminalNodeImpl.h"
-#include "tree/Trees.h"
-#include "tree/pattern/Chunk.h"
-#include "tree/pattern/ParseTreeMatch.h"
-#include "tree/pattern/ParseTreePattern.h"
-#include "tree/pattern/ParseTreePatternMatcher.h"
-#include "tree/pattern/RuleTagToken.h"
-#include "tree/pattern/TagChunk.h"
-#include "tree/pattern/TextChunk.h"
-#include "tree/pattern/TokenTagToken.h"
-#include "tree/xpath/XPath.h"
-#include "tree/xpath/XPathElement.h"
-#include "tree/xpath/XPathLexer.h"
-#include "tree/xpath/XPathLexerErrorListener.h"
-#include "tree/xpath/XPathRuleAnywhereElement.h"
-#include "tree/xpath/XPathRuleElement.h"
-#include "tree/xpath/XPathTokenAnywhereElement.h"
-#include "tree/xpath/XPathTokenElement.h"
-#include "tree/xpath/XPathWildcardAnywhereElement.h"
-#include "tree/xpath/XPathWildcardElement.h"
-
-

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

@@ -1,209 +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/LL1Analyzer.h"
-#include "Token.h"
-#include "atn/RuleTransition.h"
-#include "misc/IntervalSet.h"
-#include "RuleContext.h"
-#include "atn/DecisionState.h"
-#include "Recognizer.h"
-#include "atn/ATNType.h"
-#include "Exceptions.h"
-#include "support/CPPUtils.h"
-
-#include "atn/ATN.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlrcpp;
-
-ATN::ATN() : ATN(ATNType::LEXER, 0) {
-}
-
-ATN::ATN(ATN &&other) {
-  // All source vectors are implicitly cleared by the moves.
-  states = std::move(other.states);
-  decisionToState = std::move(other.decisionToState);
-  ruleToStartState = std::move(other.ruleToStartState);
-  ruleToStopState = std::move(other.ruleToStopState);
-  grammarType = std::move(other.grammarType);
-  maxTokenType = std::move(other.maxTokenType);
-  ruleToTokenType = std::move(other.ruleToTokenType);
-  lexerActions = std::move(other.lexerActions);
-  modeToStartState = std::move(other.modeToStartState);
-}
-
-ATN::ATN(ATNType grammarType_, size_t maxTokenType_) : grammarType(grammarType_), maxTokenType(maxTokenType_) {
-}
-
-ATN::~ATN() {
-  for (ATNState *state : states) {
-    delete state;
-  }
-}
-
-/**
- * Required to be defined (even though not used) as we have an explicit move assignment operator.
- */
-ATN& ATN::operator = (ATN &other) NOEXCEPT {
-  states = other.states;
-  decisionToState = other.decisionToState;
-  ruleToStartState = other.ruleToStartState;
-  ruleToStopState = other.ruleToStopState;
-  grammarType = other.grammarType;
-  maxTokenType = other.maxTokenType;
-  ruleToTokenType = other.ruleToTokenType;
-  lexerActions = other.lexerActions;
-  modeToStartState = other.modeToStartState;
-
-  return *this;
-}
-
-/**
- * Explicit move assignment operator to make this the preferred assignment. With implicit copy/move assignment
- * operators it seems the copy operator is preferred causing trouble when releasing the allocated ATNState instances.
- */
-ATN& ATN::operator = (ATN &&other) NOEXCEPT {
-  // All source vectors are implicitly cleared by the moves.
-  states = std::move(other.states);
-  decisionToState = std::move(other.decisionToState);
-  ruleToStartState = std::move(other.ruleToStartState);
-  ruleToStopState = std::move(other.ruleToStopState);
-  grammarType = std::move(other.grammarType);
-  maxTokenType = std::move(other.maxTokenType);
-  ruleToTokenType = std::move(other.ruleToTokenType);
-  lexerActions = std::move(other.lexerActions);
-  modeToStartState = std::move(other.modeToStartState);
-
-  return *this;
-}
-
-misc::IntervalSet ATN::nextTokens(ATNState *s, RuleContext *ctx) const {
-  LL1Analyzer analyzer(*this);
-  return analyzer.LOOK(s, ctx);
-
-}
-
-misc::IntervalSet const& ATN::nextTokens(ATNState *s) const {
-  if (!s->_nextTokenUpdated) {
-    std::unique_lock<std::mutex> lock { _mutex };
-    if (!s->_nextTokenUpdated) {
-      s->_nextTokenWithinRule = nextTokens(s, nullptr);
-      s->_nextTokenUpdated = true;
-    }
-  }
-  return s->_nextTokenWithinRule;
-}
-
-void ATN::addState(ATNState *state) {
-  if (state != nullptr) {
-    //state->atn = this;
-    state->stateNumber = static_cast<int>(states.size());
-  }
-
-  states.push_back(state);
-}
-
-void ATN::removeState(ATNState *state) {
-  delete states.at(state->stateNumber);// just free mem, don't shift states in list
-  states.at(state->stateNumber) = nullptr;
-}
-
-int ATN::defineDecisionState(DecisionState *s) {
-  decisionToState.push_back(s);
-  s->decision = static_cast<int>(decisionToState.size() - 1);
-  return s->decision;
-}
-
-DecisionState *ATN::getDecisionState(size_t decision) const {
-  if (!decisionToState.empty()) {
-    return decisionToState[decision];
-  }
-  return nullptr;
-}
-
-size_t ATN::getNumberOfDecisions() const {
-  return decisionToState.size();
-}
-
-misc::IntervalSet ATN::getExpectedTokens(size_t stateNumber, RuleContext *context) const {
-  if (stateNumber == ATNState::INVALID_STATE_NUMBER || stateNumber >= states.size()) {
-    throw IllegalArgumentException("Invalid state number.");
-  }
-
-  RuleContext *ctx = context;
-  ATNState *s = states.at(stateNumber);
-  misc::IntervalSet following = nextTokens(s);
-  if (!following.contains(Token::EPSILON)) {
-    return following;
-  }
-
-  misc::IntervalSet expected;
-  expected.addAll(following);
-  expected.remove(Token::EPSILON);
-  while (ctx && ctx->invokingState != ATNState::INVALID_STATE_NUMBER && following.contains(Token::EPSILON)) {
-    ATNState *invokingState = states.at(ctx->invokingState);
-    RuleTransition *rt = static_cast<RuleTransition*>(invokingState->transitions[0]);
-    following = nextTokens(rt->followState);
-    expected.addAll(following);
-    expected.remove(Token::EPSILON);
-
-    if (ctx->parent == nullptr) {
-      break;
-    }
-    ctx = static_cast<RuleContext *>(ctx->parent);
-  }
-
-  if (following.contains(Token::EPSILON)) {
-    expected.add(Token::EOF);
-  }
-
-  return expected;
-}
-
-std::string ATN::toString() const {
-  std::stringstream ss;
-  std::string type;
-  switch (grammarType) {
-    case ATNType::LEXER:
-      type = "LEXER ";
-      break;
-
-    case ATNType::PARSER:
-      type = "PARSER ";
-      break;
-
-    default:
-      break;
-  }
-  ss << "(" << type << "ATN " << std::hex << this << std::dec << ") maxTokenType: " << maxTokenType << std::endl;
-  ss << "states (" << states.size() << ") {" << std::endl;
-
-  size_t index = 0;
-  for (auto state : states) {
-    if (state == nullptr) {
-      ss << "  " << index++ << ": nul" << std::endl;
-    } else {
-      std::string text = state->toString();
-      ss << "  " << index++ << ": " << indent(text, "  ", false) << std::endl;
-    }
-  }
-
-  index = 0;
-  for (auto state : decisionToState) {
-    if (state == nullptr) {
-      ss << "  " << index++ << ": nul" << std::endl;
-    } else {
-      std::string text = state->toString();
-      ss << "  " << index++ << ": " << indent(text, "  ", false) << std::endl;
-    }
-  }
-
-  ss << "}";
-
-  return ss.str();
-}
-

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

@@ -1,112 +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 "RuleContext.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTLR4CPP_PUBLIC ATN {
-  public:
-    static const size_t INVALID_ALT_NUMBER = 0;
-
-    /// Used for runtime deserialization of ATNs from strings.
-    ATN();
-    ATN(ATN &&other);
-    ATN(ATNType grammarType, size_t maxTokenType);
-    virtual ~ATN();
-
-    std::vector<ATNState *> states;
-
-    /// Each subrule/rule is a decision point and we must track them so we
-    /// can go back later and build DFA predictors for them.  This includes
-    /// all the rules, subrules, optional blocks, ()+, ()* etc...
-    std::vector<DecisionState *> decisionToState;
-
-    /// Maps from rule index to starting state number.
-    std::vector<RuleStartState *> ruleToStartState;
-
-    /// Maps from rule index to stop state number.
-    std::vector<RuleStopState *> ruleToStopState;
-
-    /// The type of the ATN.
-    ATNType grammarType;
-
-    /// The maximum value for any symbol recognized by a transition in the ATN.
-    size_t maxTokenType;
-
-    /// <summary>
-    /// For lexer ATNs, this maps the rule index to the resulting token type.
-    /// For parser ATNs, this maps the rule index to the generated bypass token
-    /// type if the
-    /// <seealso cref="ATNDeserializationOptions#isGenerateRuleBypassTransitions"/>
-    /// deserialization option was specified; otherwise, this is {@code null}.
-    /// </summary>
-    std::vector<size_t> ruleToTokenType;
-
-    /// For lexer ATNs, this is an array of {@link LexerAction} objects which may
-    /// be referenced by action transitions in the ATN.
-    std::vector<Ref<LexerAction>> lexerActions;
-
-    std::vector<TokensStartState *> modeToStartState;
-
-    ATN& operator = (ATN &other) NOEXCEPT;
-    ATN& operator = (ATN &&other) NOEXCEPT;
-
-    /// <summary>
-    /// Compute the set of valid tokens that can occur starting in state {@code s}.
-    ///  If {@code ctx} is null, the set of tokens will not include what can follow
-    ///  the rule surrounding {@code s}. In other words, the set will be
-    ///  restricted to tokens reachable staying within {@code s}'s rule.
-    /// </summary>
-    virtual misc::IntervalSet nextTokens(ATNState *s, RuleContext *ctx) const;
-
-    /// <summary>
-    /// Compute the set of valid tokens that can occur starting in {@code s} and
-    /// staying in same rule. <seealso cref="Token#EPSILON"/> is in set if we reach end of
-    /// rule.
-    /// </summary>
-    virtual misc::IntervalSet const& nextTokens(ATNState *s) const;
-
-    virtual void addState(ATNState *state);
-
-    virtual void removeState(ATNState *state);
-
-    virtual int defineDecisionState(DecisionState *s);
-
-    virtual DecisionState *getDecisionState(size_t decision) const;
-
-    virtual size_t getNumberOfDecisions() const;
-
-    /// <summary>
-    /// Computes the set of input symbols which could follow ATN state number
-    /// {@code stateNumber} in the specified full {@code context}. This method
-    /// considers the complete parser context, but does not evaluate semantic
-    /// predicates (i.e. all predicates encountered during the calculation are
-    /// assumed true). If a path in the ATN exists from the starting state to the
-    /// <seealso cref="RuleStopState"/> of the outermost context without matching any
-    /// symbols, <seealso cref="Token#EOF"/> is added to the returned set.
-    /// <p/>
-    /// If {@code context} is {@code null}, it is treated as
-    /// <seealso cref="ParserRuleContext#EMPTY"/>.
-    /// </summary>
-    /// <param name="stateNumber"> the ATN state number </param>
-    /// <param name="context"> the full parse context </param>
-    /// <returns> The set of potentially valid input symbols which could follow the
-    /// specified state in the specified context. </returns>
-    /// <exception cref="IllegalArgumentException"> if the ATN does not contain a state with
-    /// number {@code stateNumber} </exception>
-    virtual misc::IntervalSet getExpectedTokens(size_t stateNumber, RuleContext *context) const;
-
-    std::string toString() const;
-
-  private:
-    mutable std::mutex _mutex;
-  };
-
-} // namespace atn
-} // namespace antlr4