X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=dict%2Fdicttest.c;h=36cebc1995136bba59002b3f1b3ddcfc3273276b;hb=7d5a1ac22a7be94fd8d6a65426bd087df4285ccd;hp=86a733d36fdc0af0050dffd17030df16487c374d;hpb=3c5ad6ec79e41c91b818e9953b08c6217795693d;p=idzebra-moved-to-github.git

diff --git a/dict/dicttest.c b/dict/dicttest.c
index 86a733d..36cebc1 100644
--- a/dict/dicttest.c
+++ b/dict/dicttest.c
@@ -4,7 +4,27 @@
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: dicttest.c,v $
- * Revision 1.1  1994-08-16 16:26:47  adam
+ * Revision 1.7  1994-09-19 16:34:26  adam
+ * Depend rule change. Minor changes in dicttest.c
+ *
+ * Revision 1.6  1994/09/16  15:39:12  adam
+ * Initial code of lookup - not tested yet.
+ *
+ * Revision 1.5  1994/09/06  13:05:14  adam
+ * Further development of insertion. Some special cases are
+ * not properly handled yet! assert(0) are put here. The
+ * binary search in each page definitely reduce usr CPU.
+ *
+ * Revision 1.4  1994/09/01  17:49:37  adam
+ * Removed stupid line. Work on insertion in dictionary. Not finished yet.
+ *
+ * Revision 1.3  1994/09/01  17:44:06  adam
+ * depend include change.
+ *
+ * Revision 1.2  1994/08/18  12:40:54  adam
+ * Some development of dictionary. Not finished at all!
+ *
+ * Revision 1.1  1994/08/16  16:26:47  adam
  * Added dict.
  *
  */
@@ -12,9 +32,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
+#include <ctype.h>
 
 #include <dict.h>
-#include <options.h>
 
 char *prog;
 Dict dict;
@@ -23,29 +43,42 @@ int main (int argc, char **argv)
 {
     const char *name = NULL;
     const char *inputfile = NULL;
+    const char *base = NULL;
     int rw = 0;
+    int infosize = 4;
     int cache = 10;
     int ret;
-    int verbose = 0;
+    int no_of_iterations = 0;
+    int no_of_new = 0, no_of_same = 0, no_of_change = 0;
+    int no_of_hits = 0, no_of_misses = 0;
+    int unique = 0;
     char *arg;
     
     prog = argv[0];
     if (argc < 2)
     {
         fprintf (stderr, "usage:\n"
-                         "  %s [-v n] [-i f] [-w] [-c n] file\n", prog);
+                 "  %s [-u] [-s n] [-v n] [-i f] [-w] [-c n] base file\n",
+                 prog);
         exit (1);
     }
-    while ((ret = options ("v:i:wc:", argv, argc, &arg)) != -2)
+    while ((ret = options ("us:v:i:wc:", argv, argc, &arg)) != -2)
     {
         if (ret == 0)
         {
-            if (name)
+            if (!base)
+                base = arg;
+            else if (!name)
+                name = arg;
+            else
             {
-                fprintf (stderr, "%s: too many files specified\n", prog);
+                log (LOG_FATAL, "too many files specified\n");
                 exit (1);
             }
-            name = arg;
+        }
+        else if (ret == 'u')
+        {
+            unique = 1;
         }
         else if (ret == 'c')
         {
@@ -56,56 +89,118 @@ int main (int argc, char **argv)
         else if (ret == 'w')
             rw = 1;
         else if (ret == 'i')
-        {
             inputfile = arg;
-            rw = 1;
+        else if (ret == 's')
+        {
+            infosize = atoi(arg);
         }
         else if (ret == 'v')
-            verbose = atoi(arg);
+        {
+            log_init (atoi(arg), prog, NULL);
+        }
         else
         {
-            fprintf (stderr, "%s: unknown option\n", prog);
+            log (LOG_FATAL, "unknown option");
             exit (1);
         }
     }
-    if (!name)
+    if (!base || !name)
+    {
+        log (LOG_FATAL, "no base and/or dictionary specified");
+        exit (1);
+    }
+    common_resource = res_open (base);
+    if (!common_resource)
     {
-        fprintf (stderr, "%s: no dictionary file given\n", prog);
+        log (LOG_FATAL, "cannot open resource `%s'", base);
         exit (1);
     }
     dict = dict_open (name, cache, rw);
     if (!dict)
     {
-        fprintf (stderr, "%s: dict_open fail\n", prog);
+        log (LOG_FATAL, "dict_open fail of `%s'", name);
         exit (1);
     }
     if (inputfile)
     {
         FILE *ipf;
-        char ipf_buf[256];
-        char word[256];
-        int i, line = 1;
+        char ipf_buf[1024];
+        int line = 1;
+        char infobytes[120];
+        memset (infobytes, 0, 120);
 
         if (!(ipf = fopen(inputfile, "r")))
         {
-            fprintf (stderr, "%s: cannot open %s\n", prog, inputfile);
+            log (LOG_FATAL|LOG_ERRNO, "cannot open %s", inputfile);
             exit (1);
         }
         
-        while (fgets (ipf_buf, 255, ipf))
+        while (fgets (ipf_buf, 1023, ipf))
         {
-            for (i=0; i<255; i++)
-                if (ipf_buf[i] > ' ')
-                    word[i] = ipf_buf[i];
-                else
-                    break;
-            word[i] = 0;
-            if (i)
-                dict_insert (dict, word, &line);
+            char *ipf_ptr = ipf_buf;
+            sprintf (infobytes, "%d", line);
+            for (;*ipf_ptr && *ipf_ptr != '\n';ipf_ptr++)
+            {
+                if (isalpha(*ipf_ptr) || *ipf_ptr == '_')
+                {
+                    int i = 1;
+                    while (ipf_ptr[i] && (isalnum(ipf_ptr[i]) ||
+                                          ipf_ptr[i] == '_'))
+                        i++;
+                    if (ipf_ptr[i])
+                        ipf_ptr[i++] = '\0';
+                    if (rw)
+                    {
+                        switch(dict_insert (dict, ipf_ptr,
+                                            infosize, infobytes))
+                        {
+                        case 0:
+                            no_of_new++;
+                            break;
+                        case 1:
+                            no_of_change++;
+                        if (unique)
+                            log (LOG_LOG, "%s change\n", ipf_ptr);
+                            break;
+                        case 2:
+                            if (unique)
+                                log (LOG_LOG, "%s duplicate\n", ipf_ptr);
+                            no_of_same++;
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        char *cp;
+
+                        cp = dict_lookup (dict, ipf_ptr);
+                        if (cp)
+                            no_of_hits++;
+                        else
+                            no_of_misses++;
+                    }
+                    ++no_of_iterations;
+                    ipf_ptr += (i-1);
+                }
+            }
             ++line;
         }
         fclose (ipf);
     }
+    if (rw)
+    {
+        log (LOG_LOG, "Insertions.... %d", no_of_iterations);
+        log (LOG_LOG, "No of new..... %d", no_of_new);
+        log (LOG_LOG, "No of change.. %d", no_of_change);
+        log (LOG_LOG, "No of same.... %d", no_of_same);
+    }
+    else
+    {
+        log (LOG_LOG, "Lookups....... %d", no_of_iterations);
+        log (LOG_LOG, "No of hits.... %d", no_of_hits);
+        log (LOG_LOG, "No of misses.. %d", no_of_misses);
+    }
     dict_close (dict);
+    res_close (common_resource);
     return 0;
 }