expressir 0.2.0 → 0.2.5

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

@@ -0,0 +1,167 @@
+/* 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

@@ -0,0 +1,209 @@
+/* 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

@@ -0,0 +1,112 @@
+/* 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