expressir 1.4.3 → 2.0.0

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/misc/IntervalSet.cpp

@@ -1,508 +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 "misc/MurmurHash.h"
-#include "Lexer.h"
-#include "Exceptions.h"
-#include "Vocabulary.h"
-
-#include "misc/IntervalSet.h"
-
-using namespace antlr4;
-using namespace antlr4::misc;
-
-IntervalSet const IntervalSet::COMPLETE_CHAR_SET =
-    IntervalSet::of(Lexer::MIN_CHAR_VALUE, Lexer::MAX_CHAR_VALUE);
-
-IntervalSet const IntervalSet::EMPTY_SET;
-
-IntervalSet::IntervalSet() : _intervals() {
-}
-
-IntervalSet::IntervalSet(const IntervalSet &set) : IntervalSet() {
-  _intervals = set._intervals;
-}
-
-IntervalSet::IntervalSet(IntervalSet&& set) : IntervalSet(std::move(set._intervals)) {
-}
-
-IntervalSet::IntervalSet(std::vector<Interval>&& intervals) : _intervals(std::move(intervals)) {
-}
-
-IntervalSet& IntervalSet::operator=(const IntervalSet& other) {
-  _intervals = other._intervals;
-  return *this;
-}
-
-IntervalSet& IntervalSet::operator=(IntervalSet&& other) {
-  _intervals = std::move(other._intervals);
-  return *this;
-}
-
-IntervalSet IntervalSet::of(ssize_t a) {
-  return IntervalSet({ Interval(a, a) });
-}
-
-IntervalSet IntervalSet::of(ssize_t a, ssize_t b) {
-  return IntervalSet({ Interval(a, b) });
-}
-
-void IntervalSet::clear() {
-  _intervals.clear();
-}
-
-void IntervalSet::add(ssize_t el) {
-  add(el, el);
-}
-
-void IntervalSet::add(ssize_t a, ssize_t b) {
-  add(Interval(a, b));
-}
-
-void IntervalSet::add(const Interval &addition) {
-  if (addition.b < addition.a) {
-    return;
-  }
-
-  // find position in list
-  for (auto iterator = _intervals.begin(); iterator != _intervals.end(); ++iterator) {
-    Interval r = *iterator;
-    if (addition == r) {
-      return;
-    }
-
-    if (addition.adjacent(r) || !addition.disjoint(r)) {
-      // next to each other, make a single larger interval
-      Interval bigger = addition.Union(r);
-      *iterator = bigger;
-
-      // make sure we didn't just create an interval that
-      // should be merged with next interval in list
-      while (iterator + 1 != _intervals.end()) {
-        Interval next = *++iterator;
-        if (!bigger.adjacent(next) && bigger.disjoint(next)) {
-          break;
-        }
-
-        // if we bump up against or overlap next, merge
-        iterator = _intervals.erase(iterator);// remove this one
-        --iterator; // move backwards to what we just set
-        *iterator = bigger.Union(next); // set to 3 merged ones
-        // ml: no need to advance iterator, we do that in the next round anyway. ++iterator; // first call to next after previous duplicates the result
-      }
-      return;
-    }
-
-    if (addition.startsBeforeDisjoint(r)) {
-      // insert before r
-      //--iterator;
-      _intervals.insert(iterator, addition);
-      return;
-    }
-
-    // if disjoint and after r, a future iteration will handle it
-  }
-
-  // ok, must be after last interval (and disjoint from last interval)
-  // just add it
-  _intervals.push_back(addition);
-}
-
-IntervalSet IntervalSet::Or(const std::vector<IntervalSet> &sets) {
-  IntervalSet result;
-  for (const auto &s : sets) {
-    result.addAll(s);
-  }
-  return result;
-}
-
-IntervalSet& IntervalSet::addAll(const IntervalSet &set) {
-  // walk set and add each interval
-  for (auto const& interval : set._intervals) {
-    add(interval);
-  }
-  return *this;
-}
-
-IntervalSet IntervalSet::complement(ssize_t minElement, ssize_t maxElement) const {
-  return complement(IntervalSet::of(minElement, maxElement));
-}
-
-IntervalSet IntervalSet::complement(const IntervalSet &vocabulary) const {
-  return vocabulary.subtract(*this);
-}
-
-IntervalSet IntervalSet::subtract(const IntervalSet &other) const {
-  return subtract(*this, other);
-}
-
-IntervalSet IntervalSet::subtract(const IntervalSet &left, const IntervalSet &right) {
-  if (left.isEmpty()) {
-    return IntervalSet();
-  }
-
-  if (right.isEmpty()) {
-    // right set has no elements; just return the copy of the current set
-    return left;
-  }
-
-  IntervalSet result(left);
-  size_t resultI = 0;
-  size_t rightI = 0;
-  while (resultI < result._intervals.size() && rightI < right._intervals.size()) {
-    Interval &resultInterval = result._intervals[resultI];
-    const Interval &rightInterval = right._intervals[rightI];
-
-    // operation: (resultInterval - rightInterval) and update indexes
-
-    if (rightInterval.b < resultInterval.a) {
-      rightI++;
-      continue;
-    }
-
-    if (rightInterval.a > resultInterval.b) {
-      resultI++;
-      continue;
-    }
-
-    Interval beforeCurrent;
-    Interval afterCurrent;
-    if (rightInterval.a > resultInterval.a) {
-      beforeCurrent = Interval(resultInterval.a, rightInterval.a - 1);
-    }
-
-    if (rightInterval.b < resultInterval.b) {
-      afterCurrent = Interval(rightInterval.b + 1, resultInterval.b);
-    }
-
-    if (beforeCurrent.a > -1) { // -1 is the default value
-      if (afterCurrent.a > -1) {
-        // split the current interval into two
-        result._intervals[resultI] = beforeCurrent;
-        result._intervals.insert(result._intervals.begin() + resultI + 1, afterCurrent);
-        resultI++;
-        rightI++;
-      } else {
-        // replace the current interval
-        result._intervals[resultI] = beforeCurrent;
-        resultI++;
-      }
-    } else {
-      if (afterCurrent.a > -1) {
-        // replace the current interval
-        result._intervals[resultI] = afterCurrent;
-        rightI++;
-      } else {
-        // remove the current interval (thus no need to increment resultI)
-        result._intervals.erase(result._intervals.begin() + resultI);
-      }
-    }
-  }
-
-  // If rightI reached right.intervals.size(), no more intervals to subtract from result.
-  // If resultI reached result.intervals.size(), we would be subtracting from an empty set.
-  // Either way, we are done.
-  return result;
-}
-
-IntervalSet IntervalSet::Or(const IntervalSet &a) const {
-  IntervalSet result;
-  result.addAll(*this);
-  result.addAll(a);
-  return result;
-}
-
-IntervalSet IntervalSet::And(const IntervalSet &other) const {
-  IntervalSet intersection;
-  size_t i = 0;
-  size_t j = 0;
-
-  // iterate down both interval lists looking for nondisjoint intervals
-  while (i < _intervals.size() && j < other._intervals.size()) {
-    Interval mine = _intervals[i];
-    Interval theirs = other._intervals[j];
-
-    if (mine.startsBeforeDisjoint(theirs)) {
-      // move this iterator looking for interval that might overlap
-      i++;
-    } else if (theirs.startsBeforeDisjoint(mine)) {
-      // move other iterator looking for interval that might overlap
-      j++;
-    } else if (mine.properlyContains(theirs)) {
-      // overlap, add intersection, get next theirs
-      intersection.add(mine.intersection(theirs));
-      j++;
-    } else if (theirs.properlyContains(mine)) {
-      // overlap, add intersection, get next mine
-      intersection.add(mine.intersection(theirs));
-      i++;
-    } else if (!mine.disjoint(theirs)) {
-      // overlap, add intersection
-      intersection.add(mine.intersection(theirs));
-
-      // Move the iterator of lower range [a..b], but not
-      // the upper range as it may contain elements that will collide
-      // with the next iterator. So, if mine=[0..115] and
-      // theirs=[115..200], then intersection is 115 and move mine
-      // but not theirs as theirs may collide with the next range
-      // in thisIter.
-      // move both iterators to next ranges
-      if (mine.startsAfterNonDisjoint(theirs)) {
-        j++;
-      } else if (theirs.startsAfterNonDisjoint(mine)) {
-        i++;
-      }
-    }
-  }
-
-  return intersection;
-}
-
-bool IntervalSet::contains(size_t el) const {
-  return contains(symbolToNumeric(el));
-}
-
-bool IntervalSet::contains(ssize_t el) const {
-  if (_intervals.empty() || el < _intervals.front().a || el > _intervals.back().b) {
-    return false;
-  }
-
-  return std::binary_search(_intervals.begin(), _intervals.end(), Interval(el, el), [](const Interval &lhs, const Interval &rhs) {
-    return lhs.b < rhs.a;
-  });
-}
-
-bool IntervalSet::isEmpty() const {
-  return _intervals.empty();
-}
-
-ssize_t IntervalSet::getSingleElement() const {
-  if (_intervals.size() == 1) {
-    if (_intervals[0].a == _intervals[0].b) {
-      return _intervals[0].a;
-    }
-  }
-
-  return Token::INVALID_TYPE; // XXX: this value is 0, but 0 is a valid interval range, how can that work?
-}
-
-ssize_t IntervalSet::getMaxElement() const {
-  if (_intervals.empty()) {
-    return Token::INVALID_TYPE;
-  }
-
-  return _intervals.back().b;
-}
-
-ssize_t IntervalSet::getMinElement() const {
-  if (_intervals.empty()) {
-    return Token::INVALID_TYPE;
-  }
-
-  return _intervals.front().a;
-}
-
-std::vector<Interval> const& IntervalSet::getIntervals() const {
-  return _intervals;
-}
-
-size_t IntervalSet::hashCode() const {
-  size_t hash = MurmurHash::initialize();
-  for (const auto &interval : _intervals) {
-    hash = MurmurHash::update(hash, interval.a);
-    hash = MurmurHash::update(hash, interval.b);
-  }
-
-  return MurmurHash::finish(hash, _intervals.size() * 2);
-}
-
-bool IntervalSet::operator == (const IntervalSet &other) const {
-  if (_intervals.empty() && other._intervals.empty())
-    return true;
-
-  if (_intervals.size() != other._intervals.size())
-    return false;
-
-  return std::equal(_intervals.begin(), _intervals.end(), other._intervals.begin());
-}
-
-std::string IntervalSet::toString() const {
-  return toString(false);
-}
-
-std::string IntervalSet::toString(bool elemAreChar) const {
-  if (_intervals.empty()) {
-    return "{}";
-  }
-
-  std::stringstream ss;
-  size_t effectiveSize = size();
-  if (effectiveSize > 1) {
-    ss << "{";
-  }
-
-  bool firstEntry = true;
-  for (const auto &interval : _intervals) {
-    if (!firstEntry)
-      ss << ", ";
-    firstEntry = false;
-
-    ssize_t a = interval.a;
-    ssize_t b = interval.b;
-    if (a == b) {
-      if (a == -1) {
-        ss << "<EOF>";
-      } else if (elemAreChar) {
-        ss << "'" << static_cast<char>(a) << "'";
-      } else {
-        ss << a;
-      }
-    } else {
-      if (elemAreChar) {
-        ss << "'" << static_cast<char>(a) << "'..'" << static_cast<char>(b) << "'";
-      } else {
-        ss << a << ".." << b;
-      }
-    }
-  }
-  if (effectiveSize > 1) {
-    ss << "}";
-  }
-
-  return ss.str();
-}
-
-std::string IntervalSet::toString(const dfa::Vocabulary &vocabulary) const {
-  if (_intervals.empty()) {
-    return "{}";
-  }
-
-  std::stringstream ss;
-  size_t effectiveSize = size();
-  if (effectiveSize > 1) {
-    ss << "{";
-  }
-
-  bool firstEntry = true;
-  for (const auto &interval : _intervals) {
-    if (!firstEntry)
-      ss << ", ";
-    firstEntry = false;
-
-    ssize_t a = interval.a;
-    ssize_t b = interval.b;
-    if (a == b) {
-      ss << elementName(vocabulary, a);
-    } else {
-      for (ssize_t i = a; i <= b; i++) {
-        if (i > a) {
-          ss << ", ";
-        }
-        ss << elementName(vocabulary, i);
-      }
-    }
-  }
-  if (effectiveSize > 1) {
-    ss << "}";
-  }
-
-  return ss.str();
-}
-
-std::string IntervalSet::elementName(const dfa::Vocabulary &vocabulary, ssize_t a) const {
-  if (a == -1) {
-    return "<EOF>";
-  } else if (a == -2) {
-    return "<EPSILON>";
-  } else {
-    return vocabulary.getDisplayName(a);
-  }
-}
-
-size_t IntervalSet::size() const {
-  size_t result = 0;
-  for (const auto &interval : _intervals) {
-    result += size_t(interval.b - interval.a + 1);
-  }
-  return result;
-}
-
-std::vector<ssize_t> IntervalSet::toList() const {
-  std::vector<ssize_t> result;
-  for (const auto &interval : _intervals) {
-    ssize_t a = interval.a;
-    ssize_t b = interval.b;
-    for (ssize_t v = a; v <= b; v++) {
-      result.push_back(v);
-    }
-  }
-  return result;
-}
-
-std::set<ssize_t> IntervalSet::toSet() const {
-  std::set<ssize_t> result;
-  for (const auto &interval : _intervals) {
-    ssize_t a = interval.a;
-    ssize_t b = interval.b;
-    for (ssize_t v = a; v <= b; v++) {
-      result.insert(v);
-    }
-  }
-  return result;
-}
-
-ssize_t IntervalSet::get(size_t i) const {
-  size_t index = 0;
-  for (const auto &interval : _intervals) {
-    ssize_t a = interval.a;
-    ssize_t b = interval.b;
-    for (ssize_t v = a; v <= b; v++) {
-      if (index == i) {
-        return v;
-      }
-      index++;
-    }
-  }
-  return -1;
-}
-
-void IntervalSet::remove(size_t el) {
-  remove(symbolToNumeric(el));
-}
-
-void IntervalSet::remove(ssize_t el) {
-  for (size_t i = 0; i < _intervals.size(); ++i) {
-    Interval &interval = _intervals[i];
-    ssize_t a = interval.a;
-    ssize_t b = interval.b;
-    if (el < a) {
-      break; // list is sorted and el is before this interval; not here
-    }
-
-    // if whole interval x..x, rm
-    if (el == a && el == b) {
-      _intervals.erase(_intervals.begin() + (long)i);
-      break;
-    }
-    // if on left edge x..b, adjust left
-    if (el == a) {
-      interval.a++;
-      break;
-    }
-    // if on right edge a..x, adjust right
-    if (el == b) {
-      interval.b--;
-      break;
-    }
-    // if in middle a..x..b, split interval
-    if (el > a && el < b) { // found in this interval
-      ssize_t oldb = interval.b;
-      interval.b = el - 1; // [a..x-1]
-      add(el + 1, oldb); // add [x+1..b]
-
-      break; // ml: not in the Java code but I believe we also should stop searching here, as we found x.
-    }
-  }
-}

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

@@ -1,190 +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/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 final {
-  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;
-
-    std::string toString(const dfa::Vocabulary &vocabulary) const;
-
-  protected:
-    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();
-    }
-  };
-}