1 files changed, 21 insertions, 21 deletions

diff --git a/contrib/aho-corasick/acism.c b/contrib/aho-corasick/acism.c
index a0b478ad8..e2b48a590 100644
--- a/contrib/aho-corasick/acism.c
+++ b/contrib/aho-corasick/acism.c
@@ -24,20 +24,20 @@
 
 #define BACK ((SYMBOL)0)
 #define ROOT ((STATE) 0)
+extern const guchar lc_map[256];
 
 int
 acism_lookup(ac_trie_t const *psp, const char *text, size_t len,
            ACISM_ACTION *cb, void *context, int *statep, bool caseless)
 {
-    ac_trie_t const ps = *psp;
     char const *cp = text, *endp = cp + len;
     uint8_t s;
     STATE state = *statep;
     int ret = 0;
 
     while (cp < endp) {
-    	s = caseless ? g_ascii_tolower (*cp++) : *cp++;
-        _SYMBOL sym = ps.symv[s];
+        s = caseless ? lc_map[(guint8)*cp++] : *cp++;
+        _SYMBOL sym = psp->symv[s];
         if (!sym) {
             // Input byte is not in any pattern string.
             state = ROOT;
@@ -48,17 +48,17 @@ acism_lookup(ac_trie_t const *psp, const char *text, size_t len,
         //  following the backref chain.
 
         TRAN next;
-        while (!t_valid(&ps, next = p_tran(&ps, state, sym)) && state != ROOT) {
-            TRAN back = p_tran(&ps, state, BACK);
-            state = t_valid(&ps, back) ? t_next(&ps, back) : ROOT;
+        while (!t_valid(psp, next = p_tran(psp, state, sym)) && state != ROOT) {
+            TRAN back = p_tran(psp, state, BACK);
+            state = t_valid(psp, back) ? t_next(psp, back) : ROOT;
         }
 
-        if (!t_valid(&ps, next))
+        if (!t_valid(psp, next))
             continue;
 
         if (!(next & (IS_MATCH | IS_SUFFIX))) {
             // No complete match yet; keep going.
-            state = t_next(&ps, next);
+            state = t_next(psp, next);
             continue;
         }
 
@@ -73,27 +73,27 @@ acism_lookup(ac_trie_t const *psp, const char *text, size_t len,
 
         // Initially state is ROOT. The chain search saves the
         //  first state from which the next char has a transition.
-        state = t_isleaf(&ps, next) ? 0 : t_next(&ps, next);
+        state = t_isleaf(psp, next) ? 0 : t_next(psp, next);
 
         while (1) {
 
-            if (t_valid(&ps, next)) {
+            if (t_valid(psp, next)) {
 
                 if (next & IS_MATCH) {
                     unsigned strno, ss = s + sym, i;
-                    if (t_isleaf(&ps, ps.tranv[ss])) {
-                        strno = t_strno(&ps, ps.tranv[ss]);
+                    if (t_isleaf(psp, psp->tranv[ss])) {
+                        strno = t_strno(psp, psp->tranv[ss]);
                     } else {
-                        for (i = p_hash(&ps, ss); ps.hashv[i].state != ss; ++i);
-                        strno = ps.hashv[i].strno;
+                        for (i = p_hash(psp, ss); psp->hashv[i].state != ss; ++i);
+                        strno = psp->hashv[i].strno;
                     }
 
                     if ((ret = cb(strno, cp - text, context)))
                         goto EXIT;
                 }
 
-                if (!state && !t_isleaf(&ps, next))
-                    state = t_next(&ps, next);
+                if (!state && !t_isleaf(psp, next))
+                    state = t_next(psp, next);
                 if ( state && !(next & IS_SUFFIX))
                     break;
             }
@@ -101,9 +101,9 @@ acism_lookup(ac_trie_t const *psp, const char *text, size_t len,
             if (s == ROOT)
                 break;
 
-            TRAN b = p_tran(&ps, s, BACK);
-            s = t_valid(&ps, b) ? t_next(&ps, b) : ROOT;
-            next = p_tran(&ps, s, sym);
+            TRAN b = p_tran(psp, s, BACK);
+            s = t_valid(psp, b) ? t_next(psp, b) : ROOT;
+            next = p_tran(psp, s, sym);
         }
     }
 EXIT:
@@ -118,7 +118,7 @@ acism_destroy(ac_trie_t *psp)
 	if (psp->flags & IS_MMAP)
 		munmap((char*)psp->tranv - sizeof(ac_trie_t),
 				sizeof(ac_trie_t) + p_size(psp));
-	else free(psp->tranv);
-	free(psp);
+	else g_free(psp->tranv);
+	g_free(psp);
 }
 //EOF