expressir 0.2.3 → 0.2.8

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

@@ -0,0 +1,198 @@
+/* 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/Interval.h"
+#include "Exceptions.h"
+
+namespace antlr4 {
+namespace misc {
+
+  /**
+   * This class implements the {@link IntSet} backed by a sorted array of
+   * non-overlapping intervals. It is particularly efficient for representing
+   * large collections of numbers, where the majority of elements appear as part
+   * of a sequential range of numbers that are all part of the set. For example,
+   * the set { 1, 2, 3, 4, 7, 8 } may be represented as { [1, 4], [7, 8] }.
+   *
+   * <p>
+   * This class is able to represent sets containing any combination of values in
+   * the range {@link Integer#MIN_VALUE} to {@link Integer#MAX_VALUE}
+   * (inclusive).</p>
+   */
+  class ANTLR4CPP_PUBLIC IntervalSet {
+  public:
+    static IntervalSet const COMPLETE_CHAR_SET;
+    static IntervalSet const EMPTY_SET;
+
+  private:
+    /// The list of sorted, disjoint intervals.
+    std::vector<Interval> _intervals;
+
+    explicit IntervalSet(std::vector<Interval>&& intervals);
+
+  public:
+    IntervalSet();
+    IntervalSet(IntervalSet const& set);
+    IntervalSet(IntervalSet&& set);
+
+    template<typename T1, typename... T_NEXT>
+    IntervalSet(int, T1 t1, T_NEXT&&... next) : IntervalSet() {
+      // The first int argument is an ignored count for compatibility
+      // with the previous varargs based interface.
+      addItems(t1, std::forward<T_NEXT>(next)...);
+    }
+
+    IntervalSet& operator=(IntervalSet const& set);
+    IntervalSet& operator=(IntervalSet&& set);
+
+    /// Create a set with a single element, el.
+    static IntervalSet of(ssize_t a);
+
+    /// Create a set with all ints within range [a..b] (inclusive)
+    static IntervalSet of(ssize_t a, ssize_t b);
+
+    void clear();
+
+    /// Add a single element to the set.  An isolated element is stored
+    /// as a range el..el.
+    void add(ssize_t el);
+
+    /// Add interval; i.e., add all integers from a to b to set.
+    /// If b<a, do nothing.
+    /// Keep list in sorted order (by left range value).
+    /// If overlap, combine ranges.  For example,
+    /// If this is {1..5, 10..20}, adding 6..7 yields
+    /// {1..5, 6..7, 10..20}.  Adding 4..8 yields {1..8, 10..20}.
+    void add(ssize_t a, ssize_t b);
+
+    /// combine all sets in the array returned the or'd value
+    static IntervalSet Or(const std::vector<IntervalSet> &sets);
+
+    // Copy on write so we can cache a..a intervals and sets of that.
+    void add(const Interval &addition);
+    IntervalSet& addAll(const IntervalSet &set);
+
+    template<typename T1, typename... T_NEXT>
+    void addItems(T1 t1, T_NEXT&&... next) {
+      add(t1);
+      addItems(std::forward<T_NEXT>(next)...);
+    }
+
+    IntervalSet complement(ssize_t minElement, ssize_t maxElement) const;
+
+    /// Given the set of possible values (rather than, say UNICODE or MAXINT),
+    /// return a new set containing all elements in vocabulary, but not in
+    /// this.  The computation is (vocabulary - this).
+    ///
+    /// 'this' is assumed to be either a subset or equal to vocabulary.
+    IntervalSet complement(const IntervalSet &vocabulary) const;
+
+    /// Compute this-other via this&~other.
+    /// Return a new set containing all elements in this but not in other.
+    /// other is assumed to be a subset of this;
+    /// anything that is in other but not in this will be ignored.
+    IntervalSet subtract(const IntervalSet &other) const;
+
+    /**
+     * Compute the set difference between two interval sets. The specific
+     * operation is {@code left - right}. If either of the input sets is
+     * {@code null}, it is treated as though it was an empty set.
+     */
+    static IntervalSet subtract(const IntervalSet &left, const IntervalSet &right);
+
+    IntervalSet Or(const IntervalSet &a) const;
+
+    /// Return a new set with the intersection of this set with other.  Because
+    /// the intervals are sorted, we can use an iterator for each list and
+    /// just walk them together.  This is roughly O(min(n,m)) for interval
+    /// list lengths n and m.
+    IntervalSet And(const IntervalSet &other) const;
+
+    /// Is el in any range of this set?
+    bool contains(size_t el) const; // For mapping of e.g. Token::EOF to -1 etc.
+    bool contains(ssize_t el) const;
+
+    /// return true if this set has no members
+    bool isEmpty() const;
+
+    /// If this set is a single integer, return it otherwise Token.INVALID_TYPE.
+    ssize_t getSingleElement() const;
+
+    /**
+     * Returns the maximum value contained in the set.
+     *
+     * @return the maximum value contained in the set. If the set is empty, this
+     * method returns {@link Token#INVALID_TYPE}.
+     */
+    ssize_t getMaxElement() const;
+
+    /**
+     * Returns the minimum value contained in the set.
+     *
+     * @return the minimum value contained in the set. If the set is empty, this
+     * method returns {@link Token#INVALID_TYPE}.
+     */
+    ssize_t getMinElement() const;
+
+    /// <summary>
+    /// Return a list of Interval objects. </summary>
+    std::vector<Interval> const& getIntervals() const;
+
+    size_t hashCode() const;
+
+    /// Are two IntervalSets equal?  Because all intervals are sorted
+    ///  and disjoint, equals is a simple linear walk over both lists
+    ///  to make sure they are the same.
+    bool operator == (const IntervalSet &other) const;
+    std::string toString() const;
+    std::string toString(bool elemAreChar) const;
+
+    /**
+     * @deprecated Use {@link #toString(Vocabulary)} instead.
+     */
+    std::string toString(const std::vector<std::string> &tokenNames) const;
+    std::string toString(const dfa::Vocabulary &vocabulary) const;
+
+  protected:
+    /**
+     * @deprecated Use {@link #elementName(Vocabulary, int)} instead.
+     */
+    std::string elementName(const std::vector<std::string> &tokenNames, ssize_t a) const;
+    std::string elementName(const dfa::Vocabulary &vocabulary, ssize_t a) const;
+
+  public:
+    size_t size() const;
+    std::vector<ssize_t> toList() const;
+    std::set<ssize_t> toSet() const;
+
+    /// Get the ith element of ordered set.  Used only by RandomPhrase so
+    /// don't bother to implement if you're not doing that for a new
+    /// ANTLR code gen target.
+    ssize_t get(size_t i) const;
+    void remove(size_t el); // For mapping of e.g. Token::EOF to -1 etc.
+    void remove(ssize_t el);
+
+  private:
+    void addItems() { /* No-op */ }
+  };
+
+} // namespace atn
+} // namespace antlr4
+
+// Hash function for IntervalSet.
+
+namespace std {
+  using antlr4::misc::IntervalSet;
+
+  template <> struct hash<IntervalSet>
+  {
+    size_t operator() (const IntervalSet &x) const
+    {
+      return x.hashCode();
+    }
+  };
+}

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

@@ -0,0 +1,134 @@
+/* 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"
+
+using namespace antlr4::misc;
+
+// A variation of the MurmurHash3 implementation (https://github.com/aappleby/smhasher/blob/master/src/MurmurHash3.cpp)
+// Here we unrolled the loop used there into individual calls to update(), as we usually hash object fields
+// instead of entire buffers.
+
+// Platform-specific functions and macros
+
+// Microsoft Visual Studio
+
+#if defined(_MSC_VER)
+
+#define FORCE_INLINE	__forceinline
+
+#include <stdlib.h>
+
+#define ROTL32(x,y)	_rotl(x,y)
+#define ROTL64(x,y)	_rotl64(x,y)
+
+#define BIG_CONSTANT(x) (x)
+
+#else	// defined(_MSC_VER)
+
+// Other compilers
+
+#define	FORCE_INLINE inline __attribute__((always_inline))
+
+inline uint32_t rotl32 (uint32_t x, int8_t r)
+{
+  return (x << r) | (x >> (32 - r));
+}
+
+inline uint64_t rotl64 (uint64_t x, int8_t r)
+{
+  return (x << r) | (x >> (64 - r));
+}
+
+#define	ROTL32(x,y)	rotl32(x,y)
+#define ROTL64(x,y)	rotl64(x,y)
+
+#define BIG_CONSTANT(x) (x##LLU)
+
+#endif // !defined(_MSC_VER)
+
+size_t MurmurHash::initialize() {
+  return initialize(DEFAULT_SEED);
+}
+
+size_t MurmurHash::initialize(size_t seed) {
+  return seed;
+}
+
+#if defined(_WIN32) || defined(_WIN64)
+  #if _WIN64
+    #define ENVIRONMENT64
+  #else
+    #define ENVIRONMENT32
+  #endif
+#endif
+
+#if defined(__GNUC__)
+  #if defined(__x86_64__) || defined(__ppc64__)
+    #define ENVIRONMENT64
+  #else
+    #define ENVIRONMENT32
+  #endif
+#endif
+
+#if defined(ENVIRONMENT32)
+
+size_t MurmurHash::update(size_t hash, size_t value) {
+  static const size_t c1 = 0xCC9E2D51;
+  static const size_t c2 = 0x1B873593;
+
+  size_t k1 = value;
+  k1 *= c1;
+  k1 = ROTL32(k1, 15);
+  k1 *= c2;
+
+  hash ^= k1;
+  hash = ROTL32(hash, 13);
+  hash = hash * 5 + 0xE6546B64;
+
+  return hash;
+}
+
+
+size_t MurmurHash::finish(size_t hash, size_t entryCount) {
+  hash ^= entryCount * 4;
+  hash ^= hash >> 16;
+  hash *= 0x85EBCA6B;
+  hash ^= hash >> 13;
+  hash *= 0xC2B2AE35;
+  hash ^= hash >> 16;
+  return hash;
+}
+
+#else
+
+size_t MurmurHash::update(size_t hash, size_t value) {
+  static const size_t c1 = BIG_CONSTANT(0x87c37b91114253d5);
+  static const size_t c2 = BIG_CONSTANT(0x4cf5ad432745937f);
+
+  size_t k1 = value;
+  k1 *= c1;
+  k1 = ROTL64(k1, 31);
+  k1 *= c2;
+
+  hash ^= k1;
+  hash = ROTL64(hash, 27);
+  hash = hash * 5 + 0x52dce729;
+
+  return hash;
+}
+
+
+size_t MurmurHash::finish(size_t hash, size_t entryCount) {
+  hash ^= entryCount * 8;
+  hash ^= hash >> 33;
+  hash *= 0xff51afd7ed558ccd;
+  hash ^= hash >> 33;
+  hash *= 0xc4ceb9fe1a85ec53;
+  hash ^= hash >> 33;
+  return hash;
+}
+
+#endif

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

@@ -0,0 +1,76 @@
+/* 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 misc {
+
+  class ANTLR4CPP_PUBLIC MurmurHash {
+
+  private:
+    static const size_t DEFAULT_SEED = 0;
+
+    /// Initialize the hash using the default seed value.
+    /// Returns the intermediate hash value.
+  public:
+    static size_t initialize();
+
+    /// Initialize the hash using the specified seed.
+    static size_t initialize(size_t seed);
+
+    /// Update the intermediate hash value for the next input {@code value}.
+    /// <param name="hash"> the intermediate hash value </param>
+    /// <param name="value"> the value to add to the current hash </param>
+    /// Returns the updated intermediate hash value.
+    static size_t update(size_t hash, size_t value);
+
+    /**
+     * Update the intermediate hash value for the next input {@code value}.
+     *
+     * @param hash the intermediate hash value
+     * @param value the value to add to the current hash
+     * @return the updated intermediate hash value
+     */
+    template <class T>
+    static size_t update(size_t hash, Ref<T> const& value) {
+      return update(hash, value != nullptr ? value->hashCode() : 0);
+    }
+
+    template <class T>
+    static size_t update(size_t hash, T *value) {
+      return update(hash, value != nullptr ? value->hashCode() : 0);
+    }
+
+    /// <summary>
+    /// Apply the final computation steps to the intermediate value {@code hash}
+    /// to form the final result of the MurmurHash 3 hash function.
+    /// </summary>
+    /// <param name="hash"> the intermediate hash value </param>
+    /// <param name="entryCount"> the number of calls to update() before calling finish() </param>
+    /// <returns> the final hash result </returns>
+    static size_t finish(size_t hash, size_t entryCount);
+
+    /// Utility function to compute the hash code of an array using the MurmurHash3 algorithm.
+    ///
+    /// @param <T> the array element type </param>
+    /// <param name="data"> the array data </param>
+    /// <param name="seed"> the seed for the MurmurHash algorithm </param>
+    /// <returns> the hash code of the data </returns>
+    template<typename T> // where T is C array type
+    static size_t hashCode(const std::vector<Ref<T>> &data, size_t seed) {
+      size_t hash = initialize(seed);
+      for (auto entry : data) {
+        hash = update(hash, entry->hashCode());
+      }
+
+      return finish(hash, data.size());
+    }
+  };
+
+} // namespace atn
+} // namespace antlr4

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

@@ -0,0 +1,4 @@
+#include "misc/Predicate.h"
+
+antlr4::misc::Predicate::~Predicate() {
+}

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

@@ -0,0 +1,21 @@
+/* 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 misc {
+
+  class ANTLR4CPP_PUBLIC Predicate {
+  public:
+    virtual ~Predicate();
+
+    virtual bool test(tree::ParseTree *t) = 0;
+  };
+
+} // namespace tree
+} // namespace antlr4

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

@@ -0,0 +1,13 @@
+/* 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 "Any.h"
+
+using namespace antlrcpp;
+
+Any::~Any()
+{
+    delete _ptr;
+}