Changeset 4835

Timestamp:

Oct 14, 2015, 11:04:15 AM (2 years ago)

Author:

nmedfort

Message:

Minor changes to add grapheme boundary processing to RE analysis.

Location:

icGREP/icgrep-devel/icgrep

Files:

• pablo/optimizers/pablo_simplifier.cpp (modified) (1 diff)
• re/re_analysis.cpp (modified) (4 diffs)
• re/re_compiler.cpp (modified) (1 diff)

icGREP/icgrep-devel/icgrep/pablo/optimizers/pablo_simplifier.cpp

@@ -265 +265 @@
         if (isa<If>(stmt)) {
             eliminateRedundantEquations(cast<If>(stmt)->getBody());
-        }
-        else if (isa<While>(stmt)) {
+        } else if (isa<While>(stmt)) {
             eliminateRedundantEquations(cast<While>(stmt)->getBody());
         } else if (isa<Advance>(stmt)) {

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

@@ -1 +1 @@
 #include "re_analysis.h"
-#include "re_cc.h"
-#include "re_name.h"
-#include "re_start.h"
-#include "re_end.h"
-#include "re_any.h"
-#include "re_seq.h"
-#include "re_alt.h"
-#include "re_rep.h"
-#include "re_diff.h"
-#include "re_intersect.h"
-#include "re_assertion.h"
+#include <re/re_cc.h>
+#include <re/re_name.h>
+#include <re/re_start.h>
+#include <re/re_end.h>
+#include <re/re_any.h>
+#include <re/re_seq.h>
+#include <re/re_alt.h>
+#include <re/re_rep.h>
+#include <re/re_diff.h>
+#include <re/re_intersect.h>
+#include <re/re_assertion.h>
+#include <re/re_grapheme_boundary.hpp>
 #include <iostream>
 #include <re/printer_re.h>
@@ -25 +26 @@
         }
         return true;
-    }
-    else if (const Seq * seq = dyn_cast<Seq>(re)) {
+    } else if (const Seq * seq = dyn_cast<Seq>(re)) {
         return (seq->size() == 1) && isByteLength(&seq[0]);
-    }
-    else if (const Rep * rep = dyn_cast<Rep>(re)) {
+    } else if (const Rep * rep = dyn_cast<Rep>(re)) {
         return (rep->getLB() == 1) && (rep->getUB() == 1) && isByteLength(rep->getRE());
-    }
-    else if (isa<Assertion>(re)) {
-        return false;
-    }
-    else if (const Diff * diff = dyn_cast<Diff>(re)) {
+    } else if (const Diff * diff = dyn_cast<Diff>(re)) {
         return isByteLength(diff->getLH()) && isByteLength(diff->getRH());
-    }
-    else if (const Intersect * e = dyn_cast<Intersect>(re)) {
+    } else if (const Intersect * e = dyn_cast<Intersect>(re)) {
         return isByteLength(e->getLH()) && isByteLength(e->getRH());
-    }
-    else if (isa<Any>(re)) {
-        return false;
-    }
-    else if (const Name * n = dyn_cast<Name>(re)) {
+    } else if (const Name * n = dyn_cast<Name>(re)) {
         return (n->getType() == Name::Type::Byte);
     }
@@ -58 +48 @@
         }
         return true;
-    }
-    else if (const Seq * seq = dyn_cast<Seq>(re)) {
+    } else if (const Seq * seq = dyn_cast<Seq>(re)) {
         return (seq->size() == 1) && isUnicodeUnitLength(&seq[0]);
-    }
-    else if (const Rep * rep = dyn_cast<Rep>(re)) {
+    } else if (const Rep * rep = dyn_cast<Rep>(re)) {
         return (rep->getLB() == 1) && (rep->getUB() == 1) && isUnicodeUnitLength(rep->getRE());
-    }
-    else if (isa<Assertion>(re)) {
+    } else if (isa<Assertion>(re)) {
         return false;
-    }
-    else if (const Diff * diff = dyn_cast<Diff>(re)) {
+    } else if (const Diff * diff = dyn_cast<Diff>(re)) {
         return isUnicodeUnitLength(diff->getLH()) && isUnicodeUnitLength(diff->getRH());
-    }
-    else if (const Intersect * e = dyn_cast<Intersect>(re)) {
+    } else if (const Intersect * e = dyn_cast<Intersect>(re)) {
         return isUnicodeUnitLength(e->getLH()) && isUnicodeUnitLength(e->getRH());
-    }
-    else if (isa<Any>(re)) {
+    } else if (isa<Any>(re)) {
         return true;
-    }
-    else if (const Name * n = dyn_cast<Name>(re)) {
+    } else if (const Name * n = dyn_cast<Name>(re)) {
         // Eventually names might be set up for not unit length items.
         return (n->getType() == Name::Type::Unicode || n->getType() == Name::Type::UnicodeProperty || n->getType() == Name::Type::Byte);
+    } else if (const GraphemeBoundary * gb = dyn_cast<GraphemeBoundary>(re)) {
+        return isUnicodeUnitLength(gb->getExpression());
     }
     return false; // otherwise
@@ -142 +127 @@
                 return std::make_pair(0, std::numeric_limits<int>::max());
         }
+    } else if (const GraphemeBoundary * gb = dyn_cast<GraphemeBoundary>(re)) {
+        return std::make_pair(getUnicodeUnitLengthRange(gb->getExpression()).first, std::numeric_limits<int>::max());
     }
     return std::make_pair(1, 1);

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

@@ -478 +478 @@
     RE * asserted = a->getAsserted();
     if (a->getKind() == Assertion::Kind::Lookbehind) {
-        MarkerType m = marker;
         MarkerType lookback = compile(asserted, pb);
-        AlignMarkers(m, lookback, pb);
+        AlignMarkers(marker, lookback, pb);
         PabloAST * lb = markerVar(lookback);
         if (a->getSense() == Assertion::Sense::Negative) {
             lb = pb.createNot(lb);
         }
-        return makeMarker(markerPos(m), pb.createAnd(markerVar(marker), lb, "lookback"));
+        return makeMarker(markerPos(marker), pb.createAnd(markerVar(marker), lb, "lookback"));
     } else if (isUnicodeUnitLength(asserted)) {
         MarkerType lookahead = compile(asserted, pb);