commit f591ddde8913633972409b9ebb3967738007730e
Author: David Lutterkort <lutter@redhat.com>
Date:   Sun Nov 13 19:38:39 2011 -0800

    * src/fa.c (totalize): handle case-insensitive FA's properly
    
    The convention for case-insensitive FA's is that they do not contain any
    transitions on [A-Z], effectively removing upper case letters from the
    alphabet.
    
    totalize used to create transitions into the crash state that did
    transition on upper case letters, violating the convention.

diff --git a/src/fa.c b/src/fa.c
index ecfe8f4..40194e3 100644
--- a/src/fa.c
+++ b/src/fa.c
@@ -60,6 +60,10 @@ int fa_minimization_algorithm = FA_MIN_HOPCROFT;
  * fa_as_regexp, we store regexps on transitions in the re field of each
  * transition. TRANS_RE indicates that we do that, and is used by fa_dot to
  * produce proper graphs of an automaton transitioning on regexps.
+ *
+ * For case-insensitive regexps (nocase == 1), the FA never has transitions
+ * on uppercase letters [A-Z], effectively removing these letters from the
+ * alphabet.
  */
 struct fa {
     struct state *initial;
@@ -2344,6 +2348,34 @@ int fa_contains(struct fa *fa1, struct fa *fa2) {
     goto done;
 }
 
+static int add_crash_trans(struct fa *fa, struct state *s, struct state *crash,
+                           int min, int max) {
+    int result;
+
+    if (fa->nocase) {
+        /* Never transition on anything in [A-Z] */
+        if (min > 'Z' || max < 'A') {
+            result = add_new_trans(s, crash, min, max);
+        } else if (min >= 'A' && max <= 'Z') {
+            result = 0;
+        } else if (max <= 'Z') {
+            /* min < 'A' */
+            result = add_new_trans(s, crash, min, 'A' - 1);
+        } else if (min >= 'A') {
+            /* max > 'Z' */
+            result = add_new_trans(s, crash, 'Z' + 1, max);
+        } else {
+            /* min < 'A' && max > 'Z' */
+            result = add_new_trans(s, crash, min, 'A' - 1);
+            if (result == 0)
+                result = add_new_trans(s, crash, 'Z' + 1, max);
+        }
+    } else {
+        result = add_new_trans(s, crash, min, max);
+    }
+    return result;
+}
+
 static int totalize(struct fa *fa) {
     int r;
     struct state *crash = add_state(fa, 0);
@@ -2352,42 +2384,25 @@ static int totalize(struct fa *fa) {
     F(mark_reachable(fa));
     sort_transition_intervals(fa);
 
-    if (fa->nocase) {
-        r = add_new_trans(crash, crash, UCHAR_MIN, 'A' - 1);
-        if (r < 0)
-            return -1;
-        r = add_new_trans(crash, crash, 'Z' + 1, UCHAR_MAX);
-        if (r < 0)
-            return -1;
-    } else {
-        r = add_new_trans(crash, crash, UCHAR_MIN, UCHAR_MAX);
-        if (r < 0)
-            return -1;
-    }
+    r = add_crash_trans(fa, crash, crash, UCHAR_MIN, UCHAR_MAX);
+    if (r < 0)
+        return -1;
 
     list_for_each(s, fa->initial) {
         int next = UCHAR_MIN;
         int tused = s->tused;
         for (int i=0; i < tused; i++) {
             uchar min = s->trans[i].min, max = s->trans[i].max;
-            if (fa->nocase) {
-                /* Don't add transitions on [A-Z] into crash */
-                if (isupper(min)) min = 'A';
-                if (isupper(max)) max = 'Z';
-            }
             if (min > next) {
-                r = add_new_trans(s, crash, next, min - 1);
+                r = add_crash_trans(fa, s, crash, next, min - 1);
                 if (r < 0)
                     return -1;
             }
-            if (max + 1 > next) {
+            if (max + 1 > next)
                 next = max + 1;
-                if (fa->nocase && isupper(next))
-                    next = 'Z' + 1;
-            }
         }
         if (next <= UCHAR_MAX) {
-            r = add_new_trans(s, crash, next, UCHAR_MAX);
+            r = add_crash_trans(fa, s, crash, next, UCHAR_MAX);
             if (r < 0)
                 return -1;
         }
@@ -3019,6 +3034,10 @@ int fa_nocase(struct fa *fa) {
                 /* t->min < 'A' */
                 t->max = 'A' - 1;
                 F(add_new_trans(s, t->to, lc_min, lc_max));
+            } else if (t->min >= 'A') {
+                /* t->max > 'Z' */
+                t->min = 'Z' + 1;
+                F(add_new_trans(s, t->to, lc_min, lc_max));
             } else {
                 /* t->min < 'A' && t->max > 'Z' */
                 F(add_new_trans(s, t->to, 'Z' + 1, t->max));
diff --git a/tests/fatest.c b/tests/fatest.c
index be4460b..e3658ab 100644
--- a/tests/fatest.c
+++ b/tests/fatest.c
@@ -581,6 +581,24 @@ static void testExpandNoCase(CuTest *tc) {
     free(s);
 }
 
+static void testNoCaseComplement(CuTest *tc) {
+    const char *key_s = "keY";
+    struct fa *key = make_good_fa(tc, key_s);
+    struct fa *isect = NULL;
+
+    fa_nocase(key);
+
+    struct fa *comp = mark(fa_complement(key));
+
+    key = make_good_fa(tc, key_s);
+
+    /* We used to have a bug in totalize that caused the intersection
+     * to contain "keY" */
+    isect = fa_intersect(key, comp);
+
+    CuAssertIntEquals(tc, 1, fa_is_basic(isect, FA_EMPTY));
+}
+
 int main(int argc, char **argv) {
     if (argc == 1) {
         char *output = NULL;
@@ -605,6 +623,7 @@ int main(int argc, char **argv) {
         SUITE_ADD_TEST(suite, testExpandCharRanges);
         SUITE_ADD_TEST(suite, testNoCase);
         SUITE_ADD_TEST(suite, testExpandNoCase);
+        SUITE_ADD_TEST(suite, testNoCaseComplement);
 
         CuSuiteRun(suite);
         CuSuiteSummary(suite, &output);
diff --git a/tests/modules/pass_nocase.aug b/tests/modules/pass_nocase.aug
index 6d254a3..ef248f4 100644
--- a/tests/modules/pass_nocase.aug
+++ b/tests/modules/pass_nocase.aug
@@ -10,7 +10,7 @@ test lns1 get "KEY" = { "1" = "KEY" }
 test lns1 get "KeY" = { "1" = "KeY" }
 
 let lns2 =
-  let re = /[a-z]/i - /Key/i in
+  let re = /[A-Za-z]+/ - /Key/i in
   [ label "1" . store re ] | [ label "2" . store /Key/i ]
 
 test lns2 get "Key" = { "2" = "Key" }