Changeset 5727

Timestamp:

Nov 7, 2017, 6:12:56 PM (18 months ago)

Author:

cameron

Message:

Small fixes, constructing/testing full UnicodeSets?.

Location:

icGREP/icgrep-devel/icgrep

Files:

• UCD/unicode_set.cpp (modified) (9 diffs)
• UCD/unicode_set.h (modified) (3 diffs)
• cc/multiplex_CCs.cpp (modified) (2 diffs)
• re/re_analysis.cpp (modified) (1 diff)

icGREP/icgrep-devel/icgrep/UCD/unicode_set.cpp

@@ -32 +32 @@
 //
 // Select the correct built-in scan function, dependent on whatever
-// bitquad_t resolves to, when scan_forwrad_zeroes<bitquad_t> is called.
+// bitquad_t resolves to, when scan_forward_zeroes<bitquad_t> is called.
 template <typename T> int scan_forward_zeroes(T x);
 template <> inline int scan_forward_zeroes<unsigned int>(unsigned int x){return __builtin_ctz(x);}
@@ -126 +126 @@
 bool UnicodeSet::empty() const {
     return (mRuns.size() == 1) && typeOf(mRuns.front()) == Empty;
+}
+
+/** ------------------------------------------------------------------------------------------------------------- *
+ * @brief full
+ ** ------------------------------------------------------------------------------------------------------------- */
+bool UnicodeSet::full() const {
+    return (mRuns.size() == 1) && typeOf(mRuns.front()) == Full;
 }
 
@@ -424 +431 @@
 void UnicodeSet::insert(const codepoint_t cp) {
 
-    if (LLVM_UNLIKELY(cp >= UNICODE_MAX)) {
+    if (LLVM_UNLIKELY(cp > UNICODE_MAX)) {
         throw std::runtime_error(std::to_string(cp) + " exceeds maximum code point.");
     }
@@ -696 +703 @@
     assert (n == 1);
 
-    if (LLVM_UNLIKELY(mMinCodePoint >= 0x110000)) {
+    if (LLVM_UNLIKELY(mMinCodePoint > UNICODE_MAX)) {
         throw std::runtime_error("UnicodeSet iterator exceeded maximum code point.");
     }
@@ -702 +709 @@
     bool found = false;
     // Find the start of our interval
-    while ( mBaseCodePoint < 0x110000 ) {
+    while ( mBaseCodePoint <= UNICODE_MAX ) {
         // Find the first non-empty block
         if (typeOf(*mRunIterator) != Mixed) {            
@@ -738 +745 @@
 
     if (!found) {
-        assert (mBaseCodePoint == 0x110000);
-        mMinCodePoint = 0x110000;
+        assert (mBaseCodePoint == (UNICODE_MAX+1));
+        mMinCodePoint = (UNICODE_MAX+1);
         return;
     }
@@ -747 +754 @@
     found = false;
     // Find the end of our interval
-    while ( mBaseCodePoint < 0x110000 ) {
+    while ( mBaseCodePoint <= UNICODE_MAX ) {
 
         // Find the first non-Full block
@@ -783 +790 @@
         }
     }
-    // if the very last block is a mixed block and we go past it, the last code point of the range is 0x10FFFF
+    // if the very last block is a mixed block and we go past it, the last code point of the range is UNICODE_MAX
     if (!found) {
-        assert (mBaseCodePoint == 0x110000);
-        mMaxCodePoint = 0x10FFFF;
+        assert (mBaseCodePoint == (UNICODE_MAX+1));
+        mMaxCodePoint = UNICODE_MAX;
     }
 
     assert (mMinCodePoint <= mMaxCodePoint);
 }
-
-/** ------------------------------------------------------------------------------------------------------------- *
- * @brief Empty Set Constructor
- ** ------------------------------------------------------------------------------------------------------------- */
-UnicodeSet::UnicodeSet()
+    
+/** ------------------------------------------------------------------------------------------------------------- *
+ * @brief Empty/Full Set Constructor
+ ** ------------------------------------------------------------------------------------------------------------- */
+UnicodeSet::UnicodeSet(run_type_t emptyOrFull)
 : mRuns(mAllocator)
 , mQuads(mAllocator)
 {
-    append_run(Empty, UNICODE_QUAD_COUNT, mRuns);
+    assert((emptyOrFull == Empty) || (emptyOrFull == Full));
+    append_run(emptyOrFull, UNICODE_QUAD_COUNT, mRuns);
     assert (verify(mRuns, mQuads));
 }
-
+           
 /** ------------------------------------------------------------------------------------------------------------- *
  * @brief Singleton Set Constructor
@@ -850 +858 @@
     assert (std::is_sorted(begin, end, [](const interval_t l, const interval_t r) {
         assert (l.first <= l.second);
-        assert (l.second < UNICODE_MAX);
+        assert (l.second <= UNICODE_MAX);
         assert (r.first <= r.second);
-        assert (r.second < UNICODE_MAX);
+        assert (r.second <= UNICODE_MAX);
         return l.second < r.first;
     }));

icGREP/icgrep-devel/icgrep/UCD/unicode_set.h

@@ -98 +98 @@
 
     inline iterator end() const {
-        return iterator(mRuns.cend(), mQuads.cend(), 0x110000);
-    }
-
-    bool empty() const;
-
+        return iterator(mRuns.cend(), mQuads.cend(), UNICODE_MAX+1);
+    }
+
+    bool empty() const; // The set has no members
+    
+    bool full() const;  // The set has the full set of possible Unicode codepoints.
+    
     bool contains(const codepoint_t codepoint) const;
 
@@ -134 +136 @@
     bool operator<(const UnicodeSet & other) const;
 
-    UnicodeSet();
+    UnicodeSet(run_type_t emptyOrFull = Empty);
     UnicodeSet(const codepoint_t codepoint);
     UnicodeSet(const codepoint_t lo, const codepoint_t hi);
@@ -141 +143 @@
     UnicodeSet(std::initializer_list<interval_t>::iterator begin, std::initializer_list<interval_t>::iterator end);
     UnicodeSet(const std::vector<interval_t>::iterator begin, const std::vector<interval_t>::iterator end);
-
+    
     inline void swap(UnicodeSet & other);
     inline void swap(UnicodeSet && other);

icGREP/icgrep-devel/icgrep/cc/multiplex_CCs.cpp

@@ -16 +16 @@
 // The breakpoints may be determined by iterating through the interval
 // representation of each CC.   For each interval (lo, hi), lo and hi+1 
-// are breakpoints.
+// are breakpoints. 
 //
 // For each breakpoint, a bitset is computed identifying the source CCs whose
@@ -79 +79 @@
         // Start a new range.
         range_lo = bkpt_entry.first;
+        if (range_lo > UCD::UNICODE_MAX) continue; 
         current_set ^= bkpt_entry.second;
         auto idx_iter = CC_set_to_exclusive_set_map.find(current_set);

icGREP/icgrep-devel/icgrep/re/re_analysis.cpp

@@ -89 +89 @@
         return subtractCC(matchableCodepoints(diff->getLH()), matchableCodepoints(diff->getRH()));
     } else if (const Intersect * e = dyn_cast<Intersect>(re)) {
-        return intersectCC(matchableCodepoints(diff->getLH()), matchableCodepoints(diff->getRH()));
+        return intersectCC(matchableCodepoints(e->getLH()), matchableCodepoints(e->getRH()));
     } else if (isa<Any>(re)) {
         return makeCC(0, 0x10FFFF);