X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=recctrl%2Fregxread.c;h=a90f02e47cb16208ba279d13937939cb0ec7736e;hb=5b886a7358c16434d5c9f5f0d4af2f6e2e5d5c73;hp=4ad161c1e1a057f6bd8e20a348eab262ae9f7112;hpb=e769baa9d142649c877f59f40af17b27b401ef2a;p=idzebra-moved-to-github.git

diff --git a/recctrl/regxread.c b/recctrl/regxread.c
index 4ad161c..a90f02e 100644
--- a/recctrl/regxread.c
+++ b/recctrl/regxread.c
@@ -1,10 +1,42 @@
 /*
- * Copyright (C) 1994-1996, Index Data I/S 
+ * Copyright (C) 1994-1997, Index Data I/S 
  * All rights reserved.
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: regxread.c,v $
- * Revision 1.3  1996-11-08 14:05:33  adam
+ * Revision 1.13  1997-12-12 06:33:58  adam
+ * Fixed bug that showed up when multiple filter where used.
+ * Made one routine thread-safe.
+ *
+ * Revision 1.12  1997/11/18 10:03:24  adam
+ * Member num_children removed from data1_node.
+ *
+ * Revision 1.11  1997/11/06 11:41:01  adam
+ * Implemented "begin variant" for the sgml.regx filter.
+ *
+ * Revision 1.10  1997/10/31 12:36:12  adam
+ * Minor change that avoids compiler warning.
+ *
+ * Revision 1.9  1997/09/29 09:02:49  adam
+ * Fixed small bug (introduced by previous commit).
+ *
+ * Revision 1.8  1997/09/17 12:19:22  adam
+ * Zebra version corresponds to YAZ version 1.4.
+ * Changed Zebra server so that it doesn't depend on global common_resource.
+ *
+ * Revision 1.7  1997/07/15 16:33:07  adam
+ * Check for zero length in execData.
+ *
+ * Revision 1.6  1997/02/24 10:41:51  adam
+ * Cleanup of code and commented out the "end element-end-record" code.
+ *
+ * Revision 1.5  1997/02/19 16:22:33  adam
+ * Fixed "end element" to terminate record in outer-most level.
+ *
+ * Revision 1.4  1997/02/12 20:42:58  adam
+ * Changed some log messages.
+ *
+ * Revision 1.3  1996/11/08 14:05:33  adam
  * Bug fix: data1 node member u.tag.get_bytes weren't initialized.
  *
  * Revision 1.2  1996/10/29  14:02:09  adam
@@ -123,7 +155,7 @@ struct lexRuleAction {
     int which; 
     union {
         struct {
-            struct DFA *dfa;        /* REGX_PATTERN */
+            struct DFA *dfa;    /* REGX_PATTERN */
             int body;
         } pattern;
         struct regxCode *code;  /* REGX_CODE */
@@ -153,24 +185,22 @@ struct lexSpec {
     struct lexTrans trans;
     int lineNo;
     NMEM m;
+    data1_handle dh;
     void *f_win_fh;
     void (*f_win_ef)(void *, off_t);
-#if F_WIN_READ
+
     int f_win_start;
     int f_win_end;
     int f_win_size;
     char *f_win_buf;
     int (*f_win_rf)(void *, char *, size_t);
     off_t (*f_win_sf)(void *, off_t);
-#else
-    char *scan_buf;
-    int scan_size;
-#endif
+
     struct lexRuleAction *beginActionList;
     struct lexRuleAction *endActionList;
 };
 
-#if F_WIN_READ
+
 static char *f_win_get (struct lexSpec *spec, off_t start_pos, off_t end_pos,
                         int *size)
 {
@@ -228,7 +258,6 @@ static int f_win_advance (struct lexSpec *spec, int *pos)
     *pos = F_WIN_EOF;
     return 0;
 }
-#endif
 
 static void regxCodeDel (struct regxCode **pp)
 {
@@ -275,9 +304,7 @@ static struct lexSpec *lexSpecMk (const char *name)
     p->trans.fastRule = NULL;
     p->beginActionList = NULL;
     p->endActionList = NULL;
-#if F_WIN_READ
     p->f_win_buf = NULL;
-#endif
     return p;
 }
 
@@ -316,14 +343,13 @@ static void lexSpecDel (struct lexSpec **pp)
     xfree (p->trans.fastRule);
     for (rp = p->trans.rules; rp; rp = rp1)
     {
+	rp1 = rp->next;
         actionListDel (&rp->info.actionList);
         xfree (rp);
     }
     actionListDel (&p->beginActionList);
     actionListDel (&p->endActionList);
-#if F_WIN_READ
     xfree (p->f_win_buf);
-#endif
     xfree (p);
     *pp = NULL;
 }
@@ -377,7 +403,7 @@ static int readParseToken (const char **cpp, int *len)
         cmd[i] = '\0';
         if (i == 0)
         {
-            logf (LOG_WARN, "Bad character %d %c", *cp, *cp);
+            logf (LOG_WARN, "bad character %d %c", *cp, *cp);
             cp++;
             while (*cp && *cp != ' ' && *cp != '\t' && *cp != '\n')
                 cp++;
@@ -393,7 +419,7 @@ static int readParseToken (const char **cpp, int *len)
             return REGX_BODY;
         else
         {
-            logf (LOG_WARN, "Bad command %s", cmd);
+            logf (LOG_WARN, "bad command %s", cmd);
             return 0;
         }
     }
@@ -429,14 +455,14 @@ static int actionListMk (struct lexSpec *spec, const char *s,
             {
                 xfree (*ap);
                 *ap = NULL;
-                logf (LOG_WARN, "Regular expression error. r=%d", r);
+                logf (LOG_WARN, "regular expression error. r=%d", r);
                 return -1;
             }
             dfa_mkstate ((*ap)->u.pattern.dfa);
             s++;
             break;
         case REGX_BEGIN:
-            logf (LOG_WARN, "Cannot use begin here");
+            logf (LOG_WARN, "cannot use begin here");
             continue;
         case REGX_END:
             *ap = xmalloc (sizeof(**ap));
@@ -471,12 +497,12 @@ int readOneSpec (struct lexSpec *spec, const char *s)
         r = dfa_parse (spec->trans.dfa, &s);
         if (r)
         {
-            logf (LOG_WARN, "Regular expression error. r=%d", r);
+            logf (LOG_WARN, "regular expression error. r=%d", r);
             return -1;
         }
         if (*s != '/')
         {
-            logf (LOG_WARN, "Expects / at end of pattern. got %c", *s);
+            logf (LOG_WARN, "expects / at end of pattern. got %c", *s);
             return -1;
         }
         s++;
@@ -498,11 +524,12 @@ int readFileSpec (struct lexSpec *spec)
     FILE *spec_inf;
 
     lineBuf = xmalloc (1+lineSize);
-    logf (LOG_LOG, "Reading spec %s", spec->name);
+    logf (LOG_LOG, "reading regx filter %s.flt", spec->name);
     sprintf (lineBuf, "%s.flt", spec->name);
-    if (!(spec_inf = yaz_path_fopen (data1_get_tabpath(), lineBuf, "r")))
+    if (!(spec_inf = yaz_path_fopen (data1_get_tabpath(spec->dh),
+				     lineBuf, "r")))
     {
-        logf (LOG_ERRNO|LOG_WARN, "Cannot read spec file %s", spec->name);
+        logf (LOG_ERRNO|LOG_WARN, "cannot read spec file %s", spec->name);
         xfree (lineBuf);
         return -1;
     }
@@ -580,6 +607,8 @@ static void execData (struct lexSpec *spec,
 {
     struct data1_node *res, *parent;
 
+    if (elen == 0) /* shouldn't happen, but it does! */
+	return ;
 #if REGX_DEBUG
     if (elen > 40)
         logf (LOG_DEBUG, "execData %.15s ... %.*s", ebuf, 15, ebuf + elen-15);
@@ -589,7 +618,7 @@ static void execData (struct lexSpec *spec,
         logf (LOG_DEBUG, "execData len=%d", elen);
 #endif
         
-        if (*d1_level <= 1)
+    if (*d1_level <= 1)
         return;
 
     parent = d1_stack[*d1_level -1];
@@ -612,7 +641,7 @@ static void execData (struct lexSpec *spec,
     }
     else
     {
-        res = data1_mk_node (spec->m);
+        res = data1_mk_node (spec->dh, spec->m);
         res->parent = parent;
         res->which = DATA1N_data;
         res->u.data.what = DATA1I_text;
@@ -628,7 +657,6 @@ static void execData (struct lexSpec *spec,
         memcpy (res->u.data.data, ebuf, elen);
         res->root = parent->root;
         
-        parent->num_children++;
         parent->last_child = res;
         if (d1_stack[*d1_level])
             d1_stack[*d1_level]->next = res;
@@ -645,6 +673,91 @@ static void execDataP (struct lexSpec *spec,
     execData (spec, d1_stack, d1_level, ebuf, elen, formatted_text);
 }
 
+static void variantBegin (struct lexSpec *spec, 
+			  data1_node **d1_stack, int *d1_level,
+			  const char *class_str, int class_len,
+			  const char *type_str, int type_len,
+			  const char *value_str, int value_len)
+{
+    struct data1_node *parent = d1_stack[*d1_level -1];
+    char tclass[DATA1_MAX_SYMBOL], ttype[DATA1_MAX_SYMBOL];
+    data1_vartype *tp;
+    int i;
+    data1_node *res;
+
+    if (*d1_level == 0)
+    {
+        logf (LOG_WARN, "in variant begin. No record type defined");
+        return ;
+    }
+    if (class_len >= DATA1_MAX_SYMBOL)
+	class_len = DATA1_MAX_SYMBOL-1;
+    memcpy (tclass, class_str, class_len);
+    tclass[class_len] = '\0';
+
+    if (type_len >= DATA1_MAX_SYMBOL)
+	type_len = DATA1_MAX_SYMBOL-1;
+    memcpy (ttype, type_str, type_len);
+    ttype[type_len] = '\0';
+
+#if REGX_DEBUG 
+    logf (LOG_DEBUG, "variant begin %s %s (%d)", tclass, ttype, *d1_level);
+#endif
+
+    if (!(tp =
+	  data1_getvartypebyct(spec->dh, parent->root->u.root.absyn->varset,
+			       tclass, ttype)))
+	return;
+    
+    if (parent->which != DATA1N_variant)
+    {
+	res = data1_mk_node (spec->dh, spec->m);
+	res->parent = parent;
+	res->which = DATA1N_variant;
+	res->u.variant.type = 0;
+	res->u.variant.value = 0;
+	res->root = parent->root;
+
+	parent->last_child = res;
+	if (d1_stack[*d1_level])
+	    d1_stack[*d1_level]->next = res;
+	else
+	    parent->child = res;
+	d1_stack[*d1_level] = res;
+	d1_stack[++(*d1_level)] = NULL;
+    }
+    for (i = *d1_level-1; d1_stack[i]->which == DATA1N_variant; i--)
+	if (d1_stack[i]->u.variant.type == tp)
+	{
+	    *d1_level = i;
+	    break;
+	}
+
+#if REGX_DEBUG 
+    logf (LOG_DEBUG, "variant node (%d)", *d1_level);
+#endif
+    parent = d1_stack[*d1_level-1];
+    res = data1_mk_node (spec->dh, spec->m);
+    res->parent = parent;
+    res->which = DATA1N_variant;
+    res->root = parent->root;
+    res->u.variant.type = tp;
+
+    if (value_len >= DATA1_LOCALDATA)
+	value_len =DATA1_LOCALDATA-1;
+    memcpy (res->lbuf, value_str, value_len);
+    res->lbuf[value_len] = '\0';
+
+    res->u.variant.value = res->lbuf;
+    
+    parent->last_child = res;
+    if (d1_stack[*d1_level])
+        d1_stack[*d1_level]->next = res;
+    else
+        parent->child = res;
+    d1_stack[*d1_level] = res;
+    d1_stack[++(*d1_level)] = NULL;
+}
 
 static void tagBegin (struct lexSpec *spec, 
                       data1_node **d1_stack, int *d1_level,
@@ -652,31 +765,30 @@ static void tagBegin (struct lexSpec *spec,
 {
     struct data1_node *parent = d1_stack[*d1_level -1];
     data1_element *elem = NULL;
-    data1_node *partag = get_parent_tag(parent);
+    data1_node *partag = get_parent_tag(spec->dh, parent);
     data1_node *res;
     data1_element *e = NULL;
     int localtag = 0;
 
     if (*d1_level == 0)
     {
-        logf (LOG_WARN, "In element begin. No record type defined");
+        logf (LOG_WARN, "in element begin. No record type defined");
         return ;
     }
     
-    res = data1_mk_node (spec->m);
+    res = data1_mk_node (spec->dh, spec->m);
     res->parent = parent;
     res->which = DATA1N_tag;
-    res->u.tag.tag = res->lbuf;
     res->u.tag.get_bytes = -1;
 
     if (len >= DATA1_LOCALDATA)
         len = DATA1_LOCALDATA-1;
-
-    memcpy (res->u.tag.tag, tag, len);
-    res->u.tag.tag[len] = '\0';
+    memcpy (res->lbuf, tag, len);
+    res->lbuf[len] = '\0';
+    res->u.tag.tag = res->lbuf;
    
 #if REGX_DEBUG 
-    logf (LOG_DEBUG, "Tag begin %s (%d)", res->u.tag.tag, *d1_level);
+    logf (LOG_DEBUG, "tag begin %s (%d)", res->u.tag.tag, *d1_level);
 #endif
     if (parent->which == DATA1N_variant)
         return ;
@@ -684,15 +796,14 @@ static void tagBegin (struct lexSpec *spec,
         if (!(e = partag->u.tag.element))
             localtag = 1;
     
-    elem = data1_getelementbytagname (d1_stack[0]->u.root.absyn, e,
-                                      res->u.tag.tag);
-    
+    elem = data1_getelementbytagname (spec->dh, d1_stack[0]->u.root.absyn,
+				      e, res->u.tag.tag);
     res->u.tag.element = elem;
     res->u.tag.node_selected = 0;
     res->u.tag.make_variantlist = 0;
     res->u.tag.no_data_requested = 0;
     res->root = parent->root;
-    parent->num_children++;
+
     parent->last_child = res;
     if (d1_stack[*d1_level])
         d1_stack[*d1_level]->next = res;
@@ -709,13 +820,14 @@ static void tagEnd (struct lexSpec *spec,
     while (*d1_level > 1)
     {
         (*d1_level)--;
-        if (!tag ||
-            (strlen(d1_stack[*d1_level]->u.tag.tag) == len &&
-             !memcmp (d1_stack[*d1_level]->u.tag.tag, tag, len)))
+        if ((d1_stack[*d1_level]->which == DATA1N_tag) &&
+	    (!tag ||
+	     (strlen(d1_stack[*d1_level]->u.tag.tag) == (size_t) len &&
+	      !memcmp (d1_stack[*d1_level]->u.tag.tag, tag, len))))
             break;
     }
 #if REGX_DEBUG
-    logf (LOG_DEBUG, "Tag end (%d)", *d1_level);
+    logf (LOG_DEBUG, "tag end (%d)", *d1_level);
 #endif
 }
 
@@ -726,9 +838,7 @@ static int tryMatch (struct lexSpec *spec, int *pptr, int *mptr,
     struct DFA_state *state = dfa->states[0];
     struct DFA_tran *t;
     unsigned char c;
-#if F_WIN_READ
     unsigned char c_prev = 0;
-#endif
     int ptr = *pptr;
     int start_ptr = *pptr;
     int last_rule = 0;
@@ -737,7 +847,6 @@ static int tryMatch (struct lexSpec *spec, int *pptr, int *mptr,
 
     while (1)
     {
-#if F_WIN_READ
         c = f_win_advance (spec, &ptr);
         if (ptr == F_WIN_EOF)
         {
@@ -749,19 +858,6 @@ static int tryMatch (struct lexSpec *spec, int *pptr, int *mptr,
             }
             break;
         }
-#else
-        if (ptr == spec->scan_size)
-        {
-            if (last_rule)
-            {
-                *mptr = start_ptr;
-                *pptr = last_ptr;
-                return 1;
-            }
-            break;
-        }
-        c = spec->scan_buf[ptr++];
-#endif
         t = state->trans;
         i = state->tran_no;
         while (1)
@@ -775,9 +871,7 @@ static int tryMatch (struct lexSpec *spec, int *pptr, int *mptr,
                 }
                 state = dfa->states[0];
                 start_ptr = ptr;
-#if F_WIN_READ
                 c_prev = c;
-#endif
                 break;
             }
             else if (c >= t->ch[0] && c <= t->ch[1])
@@ -785,7 +879,6 @@ static int tryMatch (struct lexSpec *spec, int *pptr, int *mptr,
                 state = dfa->states[t->to];
                 if (state->rule_no)
                 {
-#if F_WIN_READ
                     if (c_prev == '\n')
                     {
                         last_rule = state->rule_no;
@@ -796,10 +889,6 @@ static int tryMatch (struct lexSpec *spec, int *pptr, int *mptr,
                         last_rule = state->rule_nno;
                         last_ptr = ptr;
                     }
-#else
-                    last_rule = state->rule_no;
-                    last_ptr = ptr;
-#endif
                 }
                 break;
             }
@@ -834,12 +923,7 @@ static int execTok (struct lexSpec *spec, const char **src,
         {
             if (n >= arg_no)
                 n = arg_no-1;
-#if F_WIN_READ
             *tokBuf = f_win_get (spec, arg_start[n], arg_end[n], tokLen);
-#else
-            *tokBuf = spec->scan_buf + arg_start[n];
-            *tokLen = arg_end[n] - arg_start[n];
-#endif
         }
     }
     else if (*s == '\"')
@@ -877,10 +961,8 @@ static int execTok (struct lexSpec *spec, const char **src,
     return 2;
 }
 
-static char *regxStrz (const char *src, int len)
+static char *regxStrz (const char *src, int len, char *str)
 {
-    static char str[64];
-    
     if (len > 63)
         len = 63;
     memcpy (str, src, len);
@@ -901,7 +983,7 @@ static int execCode (struct lexSpec *spec,
     r = execTok (spec, &s, arg_no, arg_start, arg_end, &cmd_str, &cmd_len);
     while (r)
     {
-        char *p;
+        char *p, ptmp[64];
         
         if (r == 1)
         {
@@ -909,14 +991,14 @@ static int execCode (struct lexSpec *spec,
                          &cmd_str, &cmd_len);
             continue;
         }
-        p = regxStrz (cmd_str, cmd_len);
+        p = regxStrz (cmd_str, cmd_len, ptmp);
         if (!strcmp (p, "begin"))
         {
             r = execTok (spec, &s, arg_no, arg_start, arg_end,
                          &cmd_str, &cmd_len);
             if (r < 2)
                 continue;
-            p = regxStrz (cmd_str, cmd_len);
+            p = regxStrz (cmd_str, cmd_len, ptmp);
             if (!strcmp (p, "record"))
             {
                 r = execTok (spec, &s, arg_no, arg_start, arg_end,
@@ -936,13 +1018,13 @@ static int execCode (struct lexSpec *spec,
 #if REGX_DEBUG
                     logf (LOG_DEBUG, "begin record %s", absynName);
 #endif
-                    if (!(absyn = data1_get_absyn (absynName)))
+                    if (!(absyn = data1_get_absyn (spec->dh, absynName)))
                         logf (LOG_WARN, "Unknown tagset: %s", absynName);
                     else
                     {
                         data1_node *res;
 
-                        res = data1_mk_node (spec->m);
+                        res = data1_mk_node (spec->dh, spec->m);
                         res->which = DATA1N_root;
                         res->u.root.type = absynName;
                         res->u.root.absyn = absyn;
@@ -964,7 +1046,42 @@ static int execCode (struct lexSpec *spec,
                 tagBegin (spec, d1_stack, d1_level, cmd_str, cmd_len);
                 r = execTok (spec, &s, arg_no, arg_start, arg_end,
                              &cmd_str, &cmd_len);
-            }
+            } 
+	    else if (!strcmp (p, "variant"))
+	    {
+		int class_len;
+		const char *class_str = NULL;
+		int type_len;
+		const char *type_str = NULL;
+		int value_len;
+		const char *value_str = NULL;
+		r = execTok (spec, &s, arg_no, arg_start, arg_end,
+			     &cmd_str, &cmd_len);
+		if (r < 2)
+		    continue;
+		class_str = cmd_str;
+		class_len = cmd_len;
+		r = execTok (spec, &s, arg_no, arg_start, arg_end,
+			     &cmd_str, &cmd_len);
+		if (r < 2)
+		    continue;
+		type_str = cmd_str;
+		type_len = cmd_len;
+
+		r = execTok (spec, &s, arg_no, arg_start, arg_end,
+			     &cmd_str, &cmd_len);
+		if (r < 2)
+		    continue;
+		value_str = cmd_str;
+		value_len = cmd_len;
+
+                variantBegin (spec, d1_stack, d1_level, class_str, class_len,
+			      type_str, type_len, value_str, value_len);
+		
+		
+		r = execTok (spec, &s, arg_no, arg_start, arg_end,
+			     &cmd_str, &cmd_len);
+	    }
         }
         else if (!strcmp (p, "end"))
         {
@@ -972,7 +1089,7 @@ static int execCode (struct lexSpec *spec,
                          &cmd_str, &cmd_len);
             if (r > 1)
             {
-                p = regxStrz (cmd_str, cmd_len);
+                p = regxStrz (cmd_str, cmd_len, ptmp);
                 if (!strcmp (p, "record"))
                 {
                     *d1_level = 0;
@@ -987,6 +1104,13 @@ static int execCode (struct lexSpec *spec,
                 {
                     r = execTok (spec, &s, arg_no, arg_start, arg_end,
                                  &cmd_str, &cmd_len);
+#if 0
+                    if (*d1_level == 1)
+                    {
+                        *d1_level = 0;
+                        returnCode = 0;
+                    }
+#endif
                     if (r > 2)
                     {
                         tagEnd (spec, d1_stack, d1_level, cmd_str, cmd_len);
@@ -997,10 +1121,10 @@ static int execCode (struct lexSpec *spec,
                         tagEnd (spec, d1_stack, d1_level, NULL, 0);
                 }
                 else
-                    logf (LOG_WARN, "Missing record/element/variant");
+                    logf (LOG_WARN, "missing record/element/variant");
             }
             else
-                logf (LOG_WARN, "Missing record/element/variant");
+                logf (LOG_WARN, "missing record/element/variant");
         }
         else if (!strcmp (p, "data"))
         {
@@ -1021,12 +1145,12 @@ static int execCode (struct lexSpec *spec,
                         break;
                 }
                 else 
-                    logf (LOG_WARN, "Bad data option: %.*s",
+                    logf (LOG_WARN, "bad data option: %.*s",
                           cmd_len, cmd_str);
             }
             if (r != 2)
             {
-                logf (LOG_WARN, "Missing data item after data");
+                logf (LOG_WARN, "missing data item after data");
                 continue;
             }
             if (element_str)
@@ -1052,10 +1176,10 @@ static int execCode (struct lexSpec *spec,
                              &cmd_str, &cmd_len);
                 if (r < 2)
                 {
-                    logf (LOG_WARN, "Missing number after -offset");
+                    logf (LOG_WARN, "missing number after -offset");
                     continue;
                 }
-                p = regxStrz (cmd_str, cmd_len);
+                p = regxStrz (cmd_str, cmd_len, ptmp);
                 offset = atoi (p);
                 r = execTok (spec, &s, arg_no, arg_start, arg_end,
                              &cmd_str, &cmd_len);
@@ -1064,12 +1188,12 @@ static int execCode (struct lexSpec *spec,
                 offset = 0;
             if (r < 2)
             {
-                logf (LOG_WARN, "Missing index after unread command");
+                logf (LOG_WARN, "missing index after unread command");
                 continue;
             }
             if (cmd_len != 1 || *cmd_str < '0' || *cmd_str > '9')
             {
-                logf (LOG_WARN, "Bad index after unread command");
+                logf (LOG_WARN, "bad index after unread command");
                 continue;
             }
             else
@@ -1084,14 +1208,14 @@ static int execCode (struct lexSpec *spec,
         }
         else
         {
-            logf (LOG_WARN, "Unknown code command: %.*s", cmd_len, cmd_str);
+            logf (LOG_WARN, "unknown code command: %.*s", cmd_len, cmd_str);
             r = execTok (spec, &s, arg_no, arg_start, arg_end,
                          &cmd_str, &cmd_len);
             continue;
         }
         if (r > 1)
         {
-            logf (LOG_WARN, "Ignoring token %.*s", cmd_len, cmd_str);
+            logf (LOG_WARN, "ignoring token %.*s", cmd_len, cmd_str);
             do {
                 r = execTok (spec, &s, arg_no, arg_start, arg_end, &cmd_str,
                              &cmd_len);
@@ -1156,17 +1280,9 @@ static int execAction (struct lexSpec *spec, struct lexRuleAction *ap,
             break;
         case REGX_END:
             arg_start[arg_no] = *pptr;
-#if F_WIN_READ
             arg_end[arg_no] = F_WIN_EOF;
-#else
-            arg_end[arg_no] = spec->scan_size;
-#endif
             arg_no++;
-#if F_WIN_READ
             *pptr = F_WIN_EOF;
-#else
-            *pptr = spec->scan_size;
-#endif
         }
         ap = ap->next;
     }
@@ -1191,9 +1307,7 @@ data1_node *lexNode (struct lexSpec *spec, struct lexTrans *trans,
     struct DFA_state *state = trans->dfa->states[0];
     struct DFA_tran *t;
     unsigned char c;
-#if F_WIN_READ
     unsigned char c_prev = '\n';
-#endif
     int i;
     int last_rule = 0;
     int last_ptr = *ptr;
@@ -1202,7 +1316,6 @@ data1_node *lexNode (struct lexSpec *spec, struct lexTrans *trans,
 
     while (1)
     {
-#if F_WIN_READ
         c = f_win_advance (spec, ptr);
         if (*ptr == F_WIN_EOF)
         {
@@ -1232,33 +1345,6 @@ data1_node *lexNode (struct lexSpec *spec, struct lexTrans *trans,
             if (*ptr == F_WIN_EOF)
                 break;
         }
-#else
-        if (*ptr == spec->scan_size)
-        {
-            if (last_rule)
-            {
-                if (skip_ptr < start_ptr)
-                {
-                    execDataP (spec, d1_stack, d1_level,
-                              spec->scan_buf + skip_ptr, start_ptr - skip_ptr,
-                              0);
-                }
-                *ptr = last_ptr;
-                execRule (spec, trans, d1_stack, d1_level, last_rule,
-                          start_ptr, ptr);
-                skip_ptr = *ptr;
-                last_rule = 0;
-            }
-            else if (skip_ptr < *ptr)
-            {
-                execDataP (spec, d1_stack, d1_level,
-                          spec->scan_buf + skip_ptr, *ptr - skip_ptr, 0);
-            }
-            if (*ptr == spec->scan_size)
-                break;
-        }
-        c = spec->scan_buf[(*ptr)++];
-#endif
         t = state->trans;
         i = state->tran_no;
         while (1)
@@ -1268,44 +1354,37 @@ data1_node *lexNode (struct lexSpec *spec, struct lexTrans *trans,
                 {
                     if (skip_ptr < start_ptr)
                     {
-#if F_WIN_READ
                         int size;
                         char *buf;
                         buf = f_win_get (spec, skip_ptr, start_ptr, &size);
                         execDataP (spec, d1_stack, d1_level, buf, size, 0);
-#else                        
-                        execDataP (spec, d1_stack, d1_level,
-                                  spec->scan_buf + skip_ptr,
-                                  start_ptr - skip_ptr, 0);
-#endif
                     }
                     *ptr = last_ptr;
                     if (!execRule (spec, trans, d1_stack, d1_level, last_rule,
                                    start_ptr, ptr))
                     {
                         if (spec->f_win_ef && *ptr != F_WIN_EOF)
+			{
+#if REGX_DEBUG
+			    logf (LOG_DEBUG, "regx: endf ptr=%d", *ptr);
+#endif
                             (*spec->f_win_ef)(spec->f_win_fh, *ptr);
+			}
                         return NULL;
                     }
                     skip_ptr = *ptr;
                     last_rule = 0;
                     start_ptr = *ptr;
-#if F_WIN_READ
                     if (start_ptr > 0)
                     {
                         --start_ptr;
                         c_prev = f_win_advance (spec, &start_ptr);
                     }
-#endif
                 }
                 else
                 {
-#if F_WIN_READ
                     c_prev = f_win_advance (spec, &start_ptr);
                     *ptr = start_ptr;
-#else
-                    *ptr = ++start_ptr;
-#endif
                 }
                 state = trans->dfa->states[0];
                 break;
@@ -1315,7 +1394,6 @@ data1_node *lexNode (struct lexSpec *spec, struct lexTrans *trans,
                 state = trans->dfa->states[t->to];
                 if (state->rule_no)
                 {
-#if F_WIN_READ
                     if (c_prev == '\n')
                     {
                         last_rule = state->rule_no;
@@ -1326,18 +1404,6 @@ data1_node *lexNode (struct lexSpec *spec, struct lexTrans *trans,
                         last_rule = state->rule_nno;
                         last_ptr = *ptr;
                     }
-#else
-                    if (!start_ptr || spec->scan_buf[start_ptr-1] == '\n')
-                    {
-                        last_rule = state->rule_no;
-                        last_ptr = *ptr;
-                    } 
-                    else if (state->rule_nno)
-                    {
-                        last_rule = state->rule_nno;
-                        last_ptr = *ptr;
-                    }
-#endif
                 }
                 break;
             }
@@ -1365,31 +1431,18 @@ static data1_node *lexRoot (struct lexSpec *spec, off_t offset)
 }
 
 data1_node *grs_read_regx (struct grs_read_info *p)
-/*
-                             int (*rf)(void *, char *, size_t),
-                             off_t (*sf)(void *, off_t),
-                             void (*ef)(void *, off_t),
-                             void *fh,
-                             off_t offset,
-                             const char *name, NMEM m
-*/
 {
     int res;
-#if !F_WIN_READ
-    static int size;
-    int rd = 0;
-#endif
-    data1_node *n;
 
 #if REGX_DEBUG
-    logf (LOG_DEBUG, "data1_read_regx, offset=%ld type=%s",(long) offset,
-          name);
+    logf (LOG_DEBUG, "grs_read_regx");
 #endif
     if (!curLexSpec || strcmp (curLexSpec->name, p->type))
     {
         if (curLexSpec)
             lexSpecDel (&curLexSpec);
         curLexSpec = lexSpecMk (p->type);
+	curLexSpec->dh = p->dh;
         res = readFileSpec (curLexSpec);
         if (res)
         {
@@ -1397,7 +1450,6 @@ data1_node *grs_read_regx (struct grs_read_info *p)
             return NULL;
         }
     }
-#if F_WIN_READ
     if (!p->offset)
     {
         curLexSpec->f_win_start = 0;
@@ -1408,24 +1460,6 @@ data1_node *grs_read_regx (struct grs_read_info *p)
         curLexSpec->f_win_ef = p->endf;
         curLexSpec->f_win_size = 500000;
     }
-#else
-    if (!(curLexSpec->scan_buf = xmalloc (size = 4096)))
-	abort();
-    do
-    {
-	if (rd+4096 > size && !(curLexSpec->scan_buf
-                                = xrealloc (curLexSpec->scan_buf, size *= 2)))
-	    abort();
-	if ((res = (*rf)(fh, curLexSpec->scan_buf + rd, 4096)) < 0)
-            return NULL;
-	rd += res;
-    } while (res); 
-    curLexSpec->scan_size = rd;
-#endif
     curLexSpec->m = p->mem;
-    n = lexRoot (curLexSpec, p->offset);
-#if !F_WIN_READ
-    xfree (curLexSpec->scan_buf);
-#endif
-    return n;
+    return lexRoot (curLexSpec, p->offset);
 }