Function dfa_parse got 'const' string argument.

[idzebra-moved-to-github.git] / dict / lookgrep.c

diff --git a/dict/lookgrep.c b/dict/lookgrep.c
index 05b8e72..2336970 100644 (file)
--- a/dict/lookgrep.c
+++ b/dict/lookgrep.c
@@ -4,7 +4,35 @@
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: lookgrep.c,v $
- * Revision 1.4  1995-01-24 16:01:02  adam
+ * Revision 1.13  1996-01-08 09:09:30  adam
+ * Function dfa_parse got 'const' string argument.
+ *
+ * Revision 1.12  1995/12/11  09:04:48  adam
+ * Bug fix: the lookup/scan/lookgrep didn't handle empty dictionary.
+ *
+ * Revision 1.11  1995/12/06  14:43:02  adam
+ * New function: dict_delete.
+ *
+ * Revision 1.10  1995/11/16  17:00:44  adam
+ * Changed stupid log.
+ *
+ * Revision 1.9  1995/10/27  13:58:09  adam
+ * Makes 'Database unavailable' diagnostic.
+ *
+ * Revision 1.8  1995/10/19  14:57:21  adam
+ * New feature: grep lookup saves length of longest prefix match.
+ *
+ * Revision 1.7  1995/10/17  18:01:22  adam
+ * Userfunc may return non-zero in which case the the grepping stops
+ * immediately.
+ *
+ * Revision 1.6  1995/10/09  16:18:32  adam
+ * Function dict_lookup_grep got extra client data parameter.
+ *
+ * Revision 1.5  1995/09/14  11:52:59  adam
+ * Grep handle function parameter info is const now.
+ *
+ * Revision 1.4  1995/01/24  16:01:02  adam
  * Added -ansi to CFLAGS.
  * Use new API of dfa module.
  *
@@ -228,9 +256,10 @@ static INLINE int move (MatchContext *mc, MatchWord *Rj1, MatchWord *Rj,
 
 
 static int dict_grep (Dict dict, Dict_ptr ptr, MatchContext *mc,
-                      MatchWord *Rj, int pos,
-                      int (*userfunc)(Dict_char *name, char *info),
-                      Dict_char *prefix, struct DFA *dfa)
+                      MatchWord *Rj, int pos, void *client,
+                      int (*userfunc)(Dict_char *, const char *, void *),
+                      Dict_char *prefix, struct DFA *dfa,
+                      int *max_pos)
 {
     int lo, hi, d;
     void *p;
@@ -261,10 +290,14 @@ static int dict_grep (Dict dict, Dict_ptr ptr, MatchContext *mc,
 
                 memcpy (&ch, info+j*sizeof(Dict_char), sizeof(Dict_char));
                 prefix[pos+j] = ch;
+                if (pos+j > *max_pos)
+                    *max_pos = pos+j;
                 if (ch == DICT_EOS)
                 {
                     if (was_match)
-                        (*userfunc)(prefix, info+(j+1)*sizeof(Dict_char));
+                        if ((*userfunc)(prefix, info+(j+1)*sizeof(Dict_char),
+                                        client))
+                            return 1;
                     break;
                 }
                 move (mc, Rj1, Rj0, ch, dfa, Rj_tmp);
@@ -296,6 +329,8 @@ static int dict_grep (Dict dict, Dict_ptr ptr, MatchContext *mc,
             memcpy (&ch, info+sizeof(Dict_ptr), sizeof(Dict_char));
             prefix[pos] = ch;
             
+            if (pos > *max_pos)
+                *max_pos = pos;
             move (mc, Rj1, Rj, ch, dfa, Rj_tmp);
             for (d = mc->n; --d >= 0; )
                 if (Rj1[mc->range*mc->n + d])
@@ -309,16 +344,18 @@ static int dict_grep (Dict dict, Dict_ptr ptr, MatchContext *mc,
                         if (Rj1[mc->range*mc->n + d] & mc->match_mask[d])
                         {
                             prefix[pos+1] = DICT_EOS;
-                            (*userfunc)(prefix, info+sizeof(Dict_ptr)+
-                                        sizeof(Dict_char));
+                            if ((*userfunc)(prefix, info+sizeof(Dict_ptr)+
+                                            sizeof(Dict_char), client))
+                                return 1;
                             break;
                         }
                 }
                 memcpy (&subptr, info, sizeof(Dict_ptr));
                 if (subptr)
                 {
-                    dict_grep (dict, subptr, mc, Rj1, pos+1,
-                                  userfunc, prefix, dfa);
+                    if (dict_grep (dict, subptr, mc, Rj1, pos+1,
+                                   client, userfunc, prefix, dfa, max_pos))
+                        return 1;
                     dict_bf_readp (dict->dbf, ptr, &p);
                     indxp = (short*) ((char*) p+DICT_pagesize(dict)
                                       -sizeof(short));
@@ -330,16 +367,19 @@ static int dict_grep (Dict dict, Dict_ptr ptr, MatchContext *mc,
     return 0;
 }
 
-int dict_lookup_grep (Dict dict, Dict_char *pattern, int range,
-                    int (*userfunc)(Dict_char *name, char *info))
+int dict_lookup_grep (Dict dict, Dict_char *pattern, int range, void *client,
+                      int *max_pos,
+                      int (*userfunc)(Dict_char *name, const char *info,
+                                      void *client))
 {
     MatchWord *Rj;
     Dict_char prefix[MAX_LENGTH+1];
-    char *this_pattern = pattern;
+    const char *this_pattern = pattern;
     MatchContext *mc;
     struct DFA *dfa = dfa_init();
     int i, d;
 
+    logf (LOG_DEBUG, "dict_lookup_grep '%s' range=%d", pattern, range);
     i = dfa_parse (dfa, &this_pattern);
     if (i || *this_pattern)
     {
@@ -368,8 +408,13 @@ int dict_lookup_grep (Dict dict, Dict_char *pattern, int range,
             }
         }
     }
-    i = dict_grep (dict, 1, mc, Rj, 0, userfunc, prefix, dfa);
-
+    *max_pos = 0;
+    if (dict->head.last > 1)
+        i = dict_grep (dict, 1, mc, Rj, 0, client, userfunc, prefix,
+                       dfa, max_pos);
+    else
+        i = 0;
+    logf (LOG_DEBUG, "max_pos = %d", *max_pos);
     dfa_delete (&dfa);
     xfree (Rj);
     rm_MatchContext (&mc);