expressir 0.2.3 → 0.2.8

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

@@ -0,0 +1,47 @@
+/* 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 "Lexer.h"
+
+#include "atn/LexerSkipAction.h"
+
+using namespace antlr4;
+using namespace antlr4::atn;
+using namespace antlr4::misc;
+
+const Ref<LexerSkipAction> LexerSkipAction::getInstance() {
+  static Ref<LexerSkipAction> instance(new LexerSkipAction());
+  return instance;
+}
+
+LexerSkipAction::LexerSkipAction() {
+}
+
+LexerActionType LexerSkipAction::getActionType() const {
+  return LexerActionType::SKIP;
+}
+
+bool LexerSkipAction::isPositionDependent() const {
+  return false;
+}
+
+void LexerSkipAction::execute(Lexer *lexer) {
+  lexer->skip();
+}
+
+size_t LexerSkipAction::hashCode() const {
+  size_t hash = MurmurHash::initialize();
+  hash = MurmurHash::update(hash, static_cast<size_t>(getActionType()));
+  return MurmurHash::finish(hash, 1);
+}
+
+bool LexerSkipAction::operator == (const LexerAction &obj) const {
+  return &obj == this;
+}
+
+std::string LexerSkipAction::toString() const {
+  return "skip";
+}

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

@@ -0,0 +1,55 @@
+/* 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/LexerAction.h"
+#include "atn/LexerActionType.h"
+
+namespace antlr4 {
+namespace atn {
+
+  /// <summary>
+  /// Implements the {@code skip} lexer action by calling <seealso cref="Lexer#skip"/>.
+  ///
+  /// <para>The {@code skip} command does not have any parameters, so this action is
+  /// implemented as a singleton instance exposed by <seealso cref="#INSTANCE"/>.</para>
+  ///
+  /// @author Sam Harwell
+  /// @since 4.2
+  /// </summary>
+  class ANTLR4CPP_PUBLIC LexerSkipAction final : public LexerAction {
+  public:
+    /// Provides a singleton instance of this parameterless lexer action.
+    static const Ref<LexerSkipAction> getInstance();
+
+    /// <summary>
+    /// {@inheritDoc} </summary>
+    /// <returns> This method returns <seealso cref="LexerActionType#SKIP"/>. </returns>
+    virtual LexerActionType getActionType() const override;
+
+    /// <summary>
+    /// {@inheritDoc} </summary>
+    /// <returns> This method returns {@code false}. </returns>
+    virtual bool isPositionDependent() const override;
+
+    /// <summary>
+    /// {@inheritDoc}
+    ///
+    /// <para>This action is implemented by calling <seealso cref="Lexer#skip"/>.</para>
+    /// </summary>
+    virtual void execute(Lexer *lexer) override;
+
+    virtual size_t hashCode() const override;
+    virtual bool operator == (const LexerAction &obj) const override;
+    virtual std::string toString() const override;
+
+  private:
+    /// Constructs the singleton instance of the lexer {@code skip} command.
+    LexerSkipAction();
+  };
+
+} // namespace atn
+} // namespace antlr4

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

@@ -0,0 +1,56 @@
+/* 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 "Lexer.h"
+
+#include "atn/LexerTypeAction.h"
+
+using namespace antlr4;
+using namespace antlr4::atn;
+using namespace antlr4::misc;
+
+LexerTypeAction::LexerTypeAction(int type) : _type(type) {
+}
+
+int LexerTypeAction::getType() const {
+  return _type;
+}
+
+LexerActionType LexerTypeAction::getActionType() const {
+  return LexerActionType::TYPE;
+}
+
+bool LexerTypeAction::isPositionDependent() const {
+  return false;
+}
+
+void LexerTypeAction::execute(Lexer *lexer) {
+  lexer->setType(_type);
+}
+
+size_t LexerTypeAction::hashCode() const {
+  size_t hash = MurmurHash::initialize();
+  hash = MurmurHash::update(hash, static_cast<size_t>(getActionType()));
+  hash = MurmurHash::update(hash, _type);
+  return MurmurHash::finish(hash, 2);
+}
+
+bool LexerTypeAction::operator == (const LexerAction &obj) const {
+  if (&obj == this) {
+    return true;
+  }
+
+  const LexerTypeAction *action = dynamic_cast<const LexerTypeAction *>(&obj);
+  if (action == nullptr) {
+    return false;
+  }
+
+  return _type == action->_type;
+}
+
+std::string LexerTypeAction::toString() const {
+  return "type(" + std::to_string(_type) + ")";
+}

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

@@ -0,0 +1,55 @@
+/* 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/LexerActionType.h"
+#include "atn/LexerAction.h"
+
+namespace antlr4 {
+namespace atn {
+
+  /// Implements the {@code type} lexer action by calling <seealso cref="Lexer#setType"/>
+  /// with the assigned type.
+  class ANTLR4CPP_PUBLIC LexerTypeAction : public LexerAction {
+  public:
+    /// <summary>
+    /// Constructs a new {@code type} action with the specified token type value. </summary>
+    /// <param name="type"> The type to assign to the token using <seealso cref="Lexer#setType"/>. </param>
+    LexerTypeAction(int type);
+
+    /// <summary>
+    /// Gets the type to assign to a token created by the lexer. </summary>
+    /// <returns> The type to assign to a token created by the lexer. </returns>
+    virtual int getType() const;
+
+    /// <summary>
+    /// {@inheritDoc} </summary>
+    /// <returns> This method returns <seealso cref="LexerActionType#TYPE"/>. </returns>
+    virtual LexerActionType getActionType() const override;
+
+    /// <summary>
+    /// {@inheritDoc} </summary>
+    /// <returns> This method returns {@code false}. </returns>
+    virtual bool isPositionDependent() const override;
+
+    /// <summary>
+    /// {@inheritDoc}
+    ///
+    /// <para>This action is implemented by calling <seealso cref="Lexer#setType"/> with the
+    /// value provided by <seealso cref="#getType"/>.</para>
+    /// </summary>
+    virtual void execute(Lexer *lexer) override;
+
+    virtual size_t hashCode() const override;
+    virtual bool operator == (const LexerAction &obj) const override;
+    virtual std::string toString() const override;
+
+  private:
+    const int _type;
+  };
+
+} // namespace atn
+} // namespace antlr4

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

@@ -0,0 +1,16 @@
+/* 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/LookaheadEventInfo.h"
+
+using namespace antlr4;
+using namespace antlr4::atn;
+
+LookaheadEventInfo::LookaheadEventInfo(size_t decision, ATNConfigSet *configs, size_t predictedAlt,
+  TokenStream *input, size_t startIndex, size_t stopIndex, bool fullCtx)
+  : DecisionEventInfo(decision, configs, input, startIndex, stopIndex, fullCtx) {
+
+  this->predictedAlt = predictedAlt;
+}

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

@@ -0,0 +1,42 @@
+/* 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"
+
+namespace antlr4 {
+namespace atn {
+
+  /// This class represents profiling event information for tracking the lookahead
+  /// depth required in order to make a prediction.
+  class ANTLR4CPP_PUBLIC LookaheadEventInfo : public DecisionEventInfo {
+  public:
+    /// The alternative chosen by adaptivePredict(), not necessarily
+    ///  the outermost alt shown for a rule; left-recursive rules have
+    ///  user-level alts that differ from the rewritten rule with a (...) block
+    ///  and a (..)* loop.
+    size_t predictedAlt = 0;
+
+    /// <summary>
+    /// Constructs a new instance of the <seealso cref="LookaheadEventInfo"/> class with
+    /// the specified detailed lookahead information.
+    /// </summary>
+    /// <param name="decision"> The decision number </param>
+    /// <param name="configs"> The final configuration set containing the necessary
+    /// information to determine the result of a prediction, or {@code null} if
+    /// the final configuration set is not available </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 prediction was finally made </param>
+    /// <param name="fullCtx"> {@code true} if the current lookahead is part of an LL
+    /// prediction; otherwise, {@code false} if the current lookahead is part of
+    /// an SLL prediction </param>
+    LookaheadEventInfo(size_t decision, ATNConfigSet *configs, size_t predictedAlt, TokenStream *input, size_t startIndex,
+                       size_t stopIndex, bool fullCtx);
+  };
+
+} // namespace atn
+} // namespace antlr4

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

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

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

@@ -0,0 +1,22 @@
+/* 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 {
+
+  /// Mark the end of a * or + loop.
+  class ANTLR4CPP_PUBLIC LoopEndState final : public ATNState {
+  public:
+    ATNState *loopBackState = nullptr;
+
+    virtual size_t getStateType() override;
+  };
+
+} // namespace atn
+} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/Makefile

@@ -0,0 +1,67 @@
+
+CXXFLAGS += -g -std=c++0x -Wall #-Wextra
+CXXFLAGS += -I. -I../ -I../misc/ -I../tree/ -I../dfa/ \
+	-I../../../../../antlrcpp/
+
+#TODO LDFLAGS += ?
+
+ALL_CXXFLAGS = $(CPPFLAGS) $(CXXFLAGS)
+ALL_LDFLAGS = $(LDFLAGS)
+
+# Escote's files
+SRCS = \
+    AbstractPredicateTransition.cpp \
+	ActionTransition.cpp \
+	ArrayPredictionContext.cpp \
+	ATNDeserializationOptions.cpp \
+	ATNDeserializer.cpp \
+	ATNState.cpp \
+	ATNType.cpp \
+	AtomTransition.cpp \
+	BasicBlockStartState.cpp \
+	BasicState.cpp \
+	BlockEndState.cpp \
+	BlockStartState.cpp \
+	DecisionState.cpp \
+	EmptyPredictionContext.cpp \
+	EpsilonTransition.cpp \
+	LexerATNConfig.cpp \
+	LoopEndState.cpp
+# Escote's TODO: LL1Analyzer.cpp LexerATNSimulator.cpp ATNSimulator.cpp \
+	ATNSerializer.cpp ATNConfigSet.cpp ATNConfig.cpp \
+	ATN.cpp
+
+# Alejandro's files
+SRCS += \
+	NotSetTransition.cpp \
+	OrderedATNConfigSet.cpp \
+	PlusBlockStartState.cpp \
+	PlusLoopbackState.cpp \
+	PredicateTransition.cpp \
+	PredictionMode.cpp \
+	RangeTransition.cpp \
+	RuleStartState.cpp \
+	RuleStopState.cpp \
+	RuleTransition.cpp \
+	SemanticContext.cpp \
+	SetTransition.cpp \
+	SingletonPredictionContext.cpp \
+	StarBlockStartState.cpp \
+	StarLoopbackState.cpp \
+	StarLoopEntryState.cpp \
+	TokensStartState.cpp \
+	Transition.cpp \
+	WildcardTransition.cpp
+# Alejandro's TODO: PredictionContext.cpp PredictionContextCache.cpp \
+	PrecedencePredicateTransition.cpp ParserATNSimulator.cpp
+
+OBJS = $(SRCS:.cpp=.o)
+
+all: $(OBJS)
+
+%.o: %.cpp
+	$(CXX) -c $(ALL_CXXFLAGS) $< -o $@ 
+
+clean:
+	$(RM) $(OBJS)
+

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

@@ -0,0 +1,27 @@
+/* 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/NotSetTransition.h"
+#include "atn/ATNState.h"
+#include "misc/IntervalSet.h"
+
+using namespace antlr4;
+using namespace antlr4::atn;
+
+NotSetTransition::NotSetTransition(ATNState *target, const misc::IntervalSet &set) : SetTransition(target, set) {
+}
+
+Transition::SerializationType NotSetTransition::getSerializationType() const {
+  return NOT_SET;
+}
+
+bool NotSetTransition::matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const {
+  return symbol >= minVocabSymbol && symbol <= maxVocabSymbol
+    && !SetTransition::matches(symbol, minVocabSymbol, maxVocabSymbol);
+}
+
+std::string NotSetTransition::toString() const {
+  return "NOT_SET " + Transition::toString() + " { " + SetTransition::toString() + " }";
+}

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

@@ -0,0 +1,25 @@
+/* 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/SetTransition.h"
+
+namespace antlr4 {
+namespace atn {
+
+  class ANTLR4CPP_PUBLIC NotSetTransition final : public SetTransition {
+  public:
+    NotSetTransition(ATNState *target, const misc::IntervalSet &set);
+
+    virtual SerializationType getSerializationType() 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/OrderedATNConfigSet.cpp

@@ -0,0 +1,12 @@
+/* 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/OrderedATNConfigSet.h"
+
+using namespace antlr4::atn;
+
+size_t OrderedATNConfigSet::getHash(ATNConfig *c) {
+  return c->hashCode();
+}