Function dict_lookup_grep got extra parameter, init_pos, which marks

from which position in pattern approximate pattern matching should occur.

diff --git a/dict/Makefile b/dict/Makefile
index a723105..22af8c9 100644 (file)
--- a/dict/Makefile
+++ b/dict/Makefile
@@ -1,13 +1,13 @@
 # Copyright (C) 1994, Index Data I/S 
 # All rights reserved.
 # Sebastian Hammer, Adam Dickmeiss
 # Copyright (C) 1994, Index Data I/S 
 # All rights reserved.
 # Sebastian Hammer, Adam Dickmeiss

-# $Id: Makefile,v 1.20 1995-12-06 17:48:30 adam Exp $
+# $Id: Makefile,v 1.21 1996-03-20 09:35:15 adam Exp $

 
 SHELL=/bin/sh
 RANLIB=ranlib
 
 
 SHELL=/bin/sh
 RANLIB=ranlib
 

-YAZLIB=-lyaz
-YAZINC=
+YAZLIB=../../yaz/lib/libyaz.a
+YAZINC=-I../../yaz/include

 
 INCLUDE=-I../include $(YAZINC)
 TPROG1=dicttest
 
 INCLUDE=-I../include $(YAZINC)
 TPROG1=dicttest

diff --git a/dict/dicttest.c b/dict/dicttest.c
index 181f14a..849111e 100644 (file)
--- a/dict/dicttest.c
+++ b/dict/dicttest.c
@@ -4,7 +4,11 @@
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: dicttest.c,v $
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: dicttest.c,v $

- * Revision 1.19  1996-02-02 13:43:50  adam
+ * Revision 1.20  1996-03-20 09:35:16  adam
+ * Function dict_lookup_grep got extra parameter, init_pos, which marks
+ * from which position in pattern approximate pattern matching should occur.
+ *
+ * Revision 1.19  1996/02/02  13:43:50  adam

  * The public functions simply use char instead of Dict_char to represent
  * search strings. Dict_char is used internally only.
  *
  * The public functions simply use char instead of Dict_char to represent
  * search strings. Dict_char is used internally only.
  *

@@ -97,6 +101,7 @@ int main (int argc, char **argv)
     const char *base = NULL;
     int do_delete = 0;
     int range = -1;
     const char *base = NULL;
     int do_delete = 0;
     int range = -1;

+    int srange = 0;

     int rw = 0;
     int infosize = 4;
     int cache = 10;
     int rw = 0;
     int infosize = 4;
     int cache = 10;

@@ -113,11 +118,12 @@ int main (int argc, char **argv)
     if (argc < 2)
     {
         fprintf (stderr, "usage:\n "
     if (argc < 2)
     {
         fprintf (stderr, "usage:\n "

-                 " %s [-d] [-r n] [-u] [-g pat] [-s n] [-v n] [-i f] [-w]"
-                 " [-c n] base file\n\n",
+                 " %s [-d] [-r n] [-p n] [-u] [-g pat] [-s n] [-v n] [-i f]"
+                 " [-w] [-c n] base file\n\n",

                  prog);
         fprintf (stderr, "  -d      delete instead of insert\n");
         fprintf (stderr, "  -r n    set regular match range\n");
                  prog);
         fprintf (stderr, "  -d      delete instead of insert\n");
         fprintf (stderr, "  -r n    set regular match range\n");

+        fprintf (stderr, "  -p n    set regular match start range\n");

         fprintf (stderr, "  -u      report if keys change during insert\n");
         fprintf (stderr, "  -g p    try pattern n (see -r)\n");
         fprintf (stderr, "  -s n    set info size to n (instead of 4)\n");
         fprintf (stderr, "  -u      report if keys change during insert\n");
         fprintf (stderr, "  -g p    try pattern n (see -r)\n");
         fprintf (stderr, "  -s n    set info size to n (instead of 4)\n");

@@ -127,7 +133,7 @@ int main (int argc, char **argv)
         fprintf (stderr, "  -c n    cache size (number of pages)\n");
         exit (1);
     }
         fprintf (stderr, "  -c n    cache size (number of pages)\n");
         exit (1);
     }

-    while ((ret = options ("dr:ug:s:v:i:wc:", argv, argc, &arg)) != -2)
+    while ((ret = options ("dr:p:ug:s:v:i:wc:", argv, argc, &arg)) != -2)

     {
         if (ret == 0)
         {
     {
         if (ret == 0)
         {

@@ -151,6 +157,10 @@ int main (int argc, char **argv)
         {
             range = atoi (arg);
         }
         {
             range = atoi (arg);
         }

+        else if (ret == 'p')
+        {
+            srange = atoi (arg);
+        }

         else if (ret == 'u')
         {
             unique = 1;
         else if (ret == 'u')
         {
             unique = 1;

@@ -268,7 +278,7 @@ int main (int argc, char **argv)
                     {
                         look_hits = 0;
                         dict_lookup_grep (dict, ipf_ptr, range, NULL,
                     {
                         look_hits = 0;
                         dict_lookup_grep (dict, ipf_ptr, range, NULL,

-                                          &max_pos, grep_handle);
+                                          &max_pos, srange, grep_handle);

                         if (look_hits)
                             no_of_hits++;
                         else
                         if (look_hits)
                             no_of_hits++;
                         else

@@ -288,7 +298,7 @@ int main (int argc, char **argv)
             range = 0;
         logf (LOG_LOG, "Grepping '%s'", grep_pattern);
         dict_lookup_grep (dict, grep_pattern, range, NULL, &max_pos,
             range = 0;
         logf (LOG_LOG, "Grepping '%s'", grep_pattern);
         dict_lookup_grep (dict, grep_pattern, range, NULL, &max_pos,

-                          grep_handle);
+                          srange, grep_handle);

     }
     if (rw)
     {
     }
     if (rw)
     {

diff --git a/dict/lookgrep.c b/dict/lookgrep.c
index 2fd3533..1cb452a 100644 (file)
--- a/dict/lookgrep.c
+++ b/dict/lookgrep.c
@@ -4,7 +4,11 @@
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: lookgrep.c,v $
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: lookgrep.c,v $

- * Revision 1.14  1996-02-02 13:43:51  adam
+ * Revision 1.15  1996-03-20 09:35:18  adam
+ * Function dict_lookup_grep got extra parameter, init_pos, which marks
+ * from which position in pattern approximate pattern matching should occur.
+ *
+ * Revision 1.14  1996/02/02  13:43:51  adam

  * The public functions simply use char instead of Dict_char to represent
  * search strings. Dict_char is used internally only.
  *
  * The public functions simply use char instead of Dict_char to represent
  * search strings. Dict_char is used internally only.
  *

@@ -232,7 +236,8 @@ static void or (MatchContext *mc, MatchWord *Rdst,
 }
 
 static INLINE int move (MatchContext *mc, MatchWord *Rj1, MatchWord *Rj,
 }
 
 static INLINE int move (MatchContext *mc, MatchWord *Rj1, MatchWord *Rj,

-                 Dict_char ch, struct DFA *dfa, MatchWord *Rtmp)
+                        Dict_char ch, struct DFA *dfa, MatchWord *Rtmp,
+                        int range)

 {
     int d;
     MatchWord *Rtmp_2 = Rtmp + mc->n;
 {
     int d;
     MatchWord *Rtmp_2 = Rtmp + mc->n;

@@ -263,7 +268,7 @@ static int dict_grep (Dict dict, Dict_ptr ptr, MatchContext *mc,
                       MatchWord *Rj, int pos, void *client,
                       int (*userfunc)(char *, const char *, void *),
                       Dict_char *prefix, struct DFA *dfa,
                       MatchWord *Rj, int pos, void *client,
                       int (*userfunc)(char *, const char *, void *),
                       Dict_char *prefix, struct DFA *dfa,

-                      int *max_pos)
+                      int *max_pos, int init_pos)

 {
     int lo, hi, d;
     void *p;
 {
     int lo, hi, d;
     void *p;

@@ -291,6 +296,7 @@ static int dict_grep (Dict dict, Dict_ptr ptr, MatchContext *mc,
                 MatchWord *Rj0 =    Rj + j    *mc->fact;
                 MatchWord *Rj1 =    Rj + (j+1)*mc->fact;
                 MatchWord *Rj_tmp = Rj + (j+2)*mc->fact;
                 MatchWord *Rj0 =    Rj + j    *mc->fact;
                 MatchWord *Rj1 =    Rj + (j+1)*mc->fact;
                 MatchWord *Rj_tmp = Rj + (j+2)*mc->fact;

+                int range;

 
                 memcpy (&ch, info+j*sizeof(Dict_char), sizeof(Dict_char));
                 prefix[pos+j] = ch;
 
                 memcpy (&ch, info+j*sizeof(Dict_char), sizeof(Dict_char));
                 prefix[pos+j] = ch;

@@ -304,15 +310,19 @@ static int dict_grep (Dict dict, Dict_ptr ptr, MatchContext *mc,
                             return 1;
                     break;
                 }
                             return 1;
                     break;
                 }

-                move (mc, Rj1, Rj0, ch, dfa, Rj_tmp);
+                if (pos+j >= init_pos)
+                    range = mc->range;
+                else
+                    range = 0;
+                move (mc, Rj1, Rj0, ch, dfa, Rj_tmp, range);

                 for (d = mc->n; --d >= 0; )
                 for (d = mc->n; --d >= 0; )

-                    if (Rj1[mc->range*mc->n + d])
+                    if (Rj1[range*mc->n + d])

                         break;
                 if (d < 0)
                     break;
                 was_match = 0;
                 for (d = mc->n; --d >= 0; )
                         break;
                 if (d < 0)
                     break;
                 was_match = 0;
                 for (d = mc->n; --d >= 0; )

-                    if (Rj1[mc->range*mc->n + d] & mc->match_mask[d])
+                    if (Rj1[range*mc->n + d] & mc->match_mask[d])

                     {
                         was_match = 1;
                         break;
                     {
                         was_match = 1;
                         break;

@@ -324,6 +334,7 @@ static int dict_grep (Dict dict, Dict_ptr ptr, MatchContext *mc,
             MatchWord *Rj1 =    Rj+  mc->fact;
             MatchWord *Rj_tmp = Rj+2*mc->fact;
             Dict_char ch;
             MatchWord *Rj1 =    Rj+  mc->fact;
             MatchWord *Rj_tmp = Rj+2*mc->fact;
             Dict_char ch;

+            int range;

 
             /* Dict_ptr             subptr */
             /* Dict_char            sub char */
 
             /* Dict_ptr             subptr */
             /* Dict_char            sub char */

@@ -335,9 +346,13 @@ static int dict_grep (Dict dict, Dict_ptr ptr, MatchContext *mc,
             
             if (pos > *max_pos)
                 *max_pos = pos;
             
             if (pos > *max_pos)
                 *max_pos = pos;

-            move (mc, Rj1, Rj, ch, dfa, Rj_tmp);
+            if (pos >= init_pos)
+                range = mc->range;
+            else
+                range = 0;
+            move (mc, Rj1, Rj, ch, dfa, Rj_tmp, range);

             for (d = mc->n; --d >= 0; )
             for (d = mc->n; --d >= 0; )

-                if (Rj1[mc->range*mc->n + d])
+                if (Rj1[range*mc->n + d])

                     break;
             if (d >= 0)
             {
                     break;
             if (d >= 0)
             {

@@ -345,7 +360,7 @@ static int dict_grep (Dict dict, Dict_ptr ptr, MatchContext *mc,
                 if (info[sizeof(Dict_ptr)+sizeof(Dict_char)])
                 {
                     for (d = mc->n; --d >= 0; )
                 if (info[sizeof(Dict_ptr)+sizeof(Dict_char)])
                 {
                     for (d = mc->n; --d >= 0; )

-                        if (Rj1[mc->range*mc->n + d] & mc->match_mask[d])
+                        if (Rj1[range*mc->n + d] & mc->match_mask[d])

                         {
                             prefix[pos+1] = DICT_EOS;
                             if ((*userfunc)((char*) prefix,
                         {
                             prefix[pos+1] = DICT_EOS;
                             if ((*userfunc)((char*) prefix,

@@ -359,7 +374,8 @@ static int dict_grep (Dict dict, Dict_ptr ptr, MatchContext *mc,
                 if (subptr)
                 {
                     if (dict_grep (dict, subptr, mc, Rj1, pos+1,
                 if (subptr)
                 {
                     if (dict_grep (dict, subptr, mc, Rj1, pos+1,

-                                   client, userfunc, prefix, dfa, max_pos))
+                                   client, userfunc, prefix, dfa, max_pos,
+                                   init_pos))

                         return 1;
                     dict_bf_readp (dict->dbf, ptr, &p);
                     indxp = (short*) ((char*) p+DICT_pagesize(dict)
                         return 1;
                     dict_bf_readp (dict->dbf, ptr, &p);
                     indxp = (short*) ((char*) p+DICT_pagesize(dict)

@@ -373,7 +389,7 @@ static int dict_grep (Dict dict, Dict_ptr ptr, MatchContext *mc,
 }
 
 int dict_lookup_grep (Dict dict, const char *pattern, int range, void *client,
 }
 
 int dict_lookup_grep (Dict dict, const char *pattern, int range, void *client,

-                      int *max_pos,
+                      int *max_pos, int init_pos,

                       int (*userfunc)(char *name, const char *info,
                                       void *client))
 {
                       int (*userfunc)(char *name, const char *info,
                                       void *client))
 {

@@ -416,7 +432,7 @@ int dict_lookup_grep (Dict dict, const char *pattern, int range, void *client,
     *max_pos = 0;
     if (dict->head.last > 1)
         i = dict_grep (dict, 1, mc, Rj, 0, client, userfunc, prefix,
     *max_pos = 0;
     if (dict->head.last > 1)
         i = dict_grep (dict, 1, mc, Rj, 0, client, userfunc, prefix,

-                       dfa, max_pos);
+                       dfa, max_pos, init_pos);

     else
         i = 0;
     logf (LOG_DEBUG, "max_pos = %d", *max_pos);
     else
         i = 0;
     logf (LOG_DEBUG, "max_pos = %d", *max_pos);

diff --git a/include/dict.h b/include/dict.h
index 2323ac7..e357411 100644 (file)
--- a/include/dict.h
+++ b/include/dict.h
@@ -4,7 +4,11 @@
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: dict.h,v $
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: dict.h,v $

- * Revision 1.19  1996-02-02 13:43:54  adam
+ * Revision 1.20  1996-03-20 09:35:23  adam
+ * Function dict_lookup_grep got extra parameter, init_pos, which marks
+ * from which position in pattern approximate pattern matching should occur.
+ *
+ * Revision 1.19  1996/02/02  13:43:54  adam

  * The public functions simply use char instead of Dict_char to represent
  * search strings. Dict_char is used internally only.
  *
  * The public functions simply use char instead of Dict_char to represent
  * search strings. Dict_char is used internally only.
  *

@@ -137,7 +141,7 @@ char      *dict_lookup (Dict dict, const char *p);
 int        dict_lookup_ec (Dict dict, char *p, int range,
                            int (*f)(char *name));
 int        dict_lookup_grep (Dict dict, const char *p, int range, void *client,
 int        dict_lookup_ec (Dict dict, char *p, int range,
                            int (*f)(char *name));
 int        dict_lookup_grep (Dict dict, const char *p, int range, void *client,

-                             int *max_pos,
+                             int *max_pos, int init_pos,

                              int (*f)(char *name, const char *info,
                                       void *client));
 int        dict_strcmp (const Dict_char *s1, const Dict_char *s2);
                              int (*f)(char *name, const char *info,
                                       void *client));
 int        dict_strcmp (const Dict_char *s1, const Dict_char *s2);