Fix bug in tryMatch (introduced by previous commit)
[idzebra-moved-to-github.git] / recctrl / regxread.c
1 /* $Id: regxread.c,v 1.49 2003-09-16 13:56:52 adam Exp $
2    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003
3    Index Data Aps
4
5 This file is part of the Zebra server.
6
7 Zebra is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with Zebra; see the file LICENSE.zebra.  If not, write to the
19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.
21 */
22
23
24 #include <stdio.h>
25 #include <assert.h>
26 #include <string.h>
27 #include <ctype.h>
28
29 #include <yaz/tpath.h>
30 #include <zebrautl.h>
31 #include <dfa.h>
32 #include "grsread.h"
33
34 #if HAVE_TCL_H
35 #include <tcl.h>
36
37 #if MAJOR_VERSION >= 8
38 #define HAVE_TCL_OBJECTS
39 #endif
40 #endif
41
42 #define REGX_DEBUG 0
43
44 #define F_WIN_EOF 2000000000
45 #define F_WIN_READ 1
46
47 #define REGX_EOF     0
48 #define REGX_PATTERN 1
49 #define REGX_BODY    2
50 #define REGX_BEGIN   3
51 #define REGX_END     4
52 #define REGX_CODE    5
53 #define REGX_CONTEXT 6
54 #define REGX_INIT    7
55
56 struct regxCode {
57     char *str;
58 #if HAVE_TCL_OBJECTS
59     Tcl_Obj *tcl_obj;
60 #endif
61 };
62
63 struct lexRuleAction {
64     int which; 
65     union {
66         struct {
67             struct DFA *dfa;    /* REGX_PATTERN */
68             int body;
69         } pattern;
70         struct regxCode *code;  /* REGX_CODE */
71     } u;
72     struct lexRuleAction *next;
73 };
74
75 struct lexRuleInfo {
76     int no;
77     struct lexRuleAction *actionList;
78 };
79
80 struct lexRule {
81     struct lexRuleInfo info;
82     struct lexRule *next;
83 };
84
85 struct lexContext {
86     char *name;
87     struct DFA *dfa;
88     struct lexRule *rules;
89     struct lexRuleInfo **fastRule;
90     int ruleNo;
91     int initFlag;
92
93     struct lexRuleAction *beginActionList;
94     struct lexRuleAction *endActionList;
95     struct lexRuleAction *initActionList;
96     struct lexContext *next;
97 };
98
99 struct lexConcatBuf {
100     int max;
101     char *buf;
102 };
103
104 struct lexSpec {
105     char *name;
106     struct lexContext *context;
107
108     struct lexContext **context_stack;
109     int context_stack_size;
110     int context_stack_top;
111
112     int lineNo;
113     NMEM m;
114     data1_handle dh;
115 #if HAVE_TCL_H
116     Tcl_Interp *tcl_interp;
117 #endif
118     void *f_win_fh;
119     void (*f_win_ef)(void *, off_t);
120
121     int f_win_start;      /* first byte of buffer is this file offset */
122     int f_win_end;        /* last byte of buffer is this offset - 1 */
123     int f_win_size;       /* size of buffer */
124     char *f_win_buf;      /* buffer itself */
125     int (*f_win_rf)(void *, char *, size_t);
126     off_t (*f_win_sf)(void *, off_t);
127
128     struct lexConcatBuf *concatBuf;
129     int maxLevel;
130     data1_node **d1_stack;
131     int d1_level;
132     int stop_flag;
133     
134     int *arg_start;
135     int *arg_end;
136     int arg_no;
137     int ptr;
138 };
139
140 struct lexSpecs {
141     struct lexSpec *spec;
142 };
143
144 static char *f_win_get (struct lexSpec *spec, off_t start_pos, off_t end_pos,
145                         int *size)
146 {
147     int i, r, off = start_pos - spec->f_win_start;
148
149     if (off >= 0 && end_pos <= spec->f_win_end)
150     {
151         *size = end_pos - start_pos;
152         return spec->f_win_buf + off;
153     }
154     if (off < 0 || start_pos >= spec->f_win_end)
155     {
156         (*spec->f_win_sf)(spec->f_win_fh, start_pos);
157         spec->f_win_start = start_pos;
158
159         if (!spec->f_win_buf)
160             spec->f_win_buf = (char *) xmalloc (spec->f_win_size);
161         *size = (*spec->f_win_rf)(spec->f_win_fh, spec->f_win_buf,
162                                   spec->f_win_size);
163         spec->f_win_end = spec->f_win_start + *size;
164
165         if (*size > end_pos - start_pos)
166             *size = end_pos - start_pos;
167         return spec->f_win_buf;
168     }
169     for (i = 0; i<spec->f_win_end - start_pos; i++)
170         spec->f_win_buf[i] = spec->f_win_buf[i + off];
171     r = (*spec->f_win_rf)(spec->f_win_fh,
172                           spec->f_win_buf + i,
173                           spec->f_win_size - i);
174     spec->f_win_start = start_pos;
175     spec->f_win_end += r;
176     *size = i + r;
177     if (*size > end_pos - start_pos)
178         *size = end_pos - start_pos;
179     return spec->f_win_buf;
180 }
181
182 static int f_win_advance (struct lexSpec *spec, int *pos)
183 {
184     int size;
185     char *buf;
186     
187     if (*pos >= spec->f_win_start && *pos < spec->f_win_end)
188         return spec->f_win_buf[(*pos)++ - spec->f_win_start];
189     if (*pos == F_WIN_EOF)
190         return 0;
191     buf = f_win_get (spec, *pos, *pos+1, &size);
192     if (size == 1)
193     {
194         (*pos)++;
195         return *buf;
196     }
197     *pos = F_WIN_EOF;
198     return 0;
199 }
200
201 static void regxCodeDel (struct regxCode **pp)
202 {
203     struct regxCode *p = *pp;
204     if (p)
205     {
206 #if HAVE_TCL_OBJECTS
207         if (p->tcl_obj)
208             Tcl_DecrRefCount (p->tcl_obj);
209 #endif
210         xfree (p->str); 
211         xfree (p);
212         *pp = NULL;
213     }
214 }
215
216 static void regxCodeMk (struct regxCode **pp, const char *buf, int len)
217 {
218     struct regxCode *p;
219
220     p = (struct regxCode *) xmalloc (sizeof(*p));
221     p->str = (char *) xmalloc (len+1);
222     memcpy (p->str, buf, len);
223     p->str[len] = '\0';
224 #if HAVE_TCL_OBJECTS
225     p->tcl_obj = Tcl_NewStringObj ((char *) buf, len);
226     if (p->tcl_obj)
227         Tcl_IncrRefCount (p->tcl_obj);
228 #endif
229     *pp = p;
230 }
231
232 static struct DFA *lexSpecDFA (void)
233 {
234     struct DFA *dfa;
235
236     dfa = dfa_init ();
237     dfa_parse_cmap_del (dfa, ' ');
238     dfa_parse_cmap_del (dfa, '\t');
239     dfa_parse_cmap_add (dfa, '/', 0);
240     return dfa;
241 }
242
243 static void actionListDel (struct lexRuleAction **rap)
244 {
245     struct lexRuleAction *ra1, *ra;
246
247     for (ra = *rap; ra; ra = ra1)
248     {
249         ra1 = ra->next;
250         switch (ra->which)
251         {
252         case REGX_PATTERN:
253             dfa_delete (&ra->u.pattern.dfa);
254             break;
255         case REGX_CODE:
256             regxCodeDel (&ra->u.code);
257             break;
258         }
259         xfree (ra);
260     }
261     *rap = NULL;
262 }
263
264 static struct lexContext *lexContextCreate (const char *name)
265 {
266     struct lexContext *p = (struct lexContext *) xmalloc (sizeof(*p));
267
268     p->name = xstrdup (name);
269     p->ruleNo = 1;
270     p->initFlag = 0;
271     p->dfa = lexSpecDFA ();
272     p->rules = NULL;
273     p->fastRule = NULL;
274     p->beginActionList = NULL;
275     p->endActionList = NULL;
276     p->initActionList = NULL;
277     p->next = NULL;
278     return p;
279 }
280
281 static void lexContextDestroy (struct lexContext *p)
282 {
283     struct lexRule *rp, *rp1;
284
285     dfa_delete (&p->dfa);
286     xfree (p->fastRule);
287     for (rp = p->rules; rp; rp = rp1)
288     {
289         rp1 = rp->next;
290         actionListDel (&rp->info.actionList);
291         xfree (rp);
292     }
293     actionListDel (&p->beginActionList);
294     actionListDel (&p->endActionList);
295     actionListDel (&p->initActionList);
296     xfree (p->name);
297     xfree (p);
298 }
299
300 static struct lexSpec *lexSpecCreate (const char *name, data1_handle dh)
301 {
302     struct lexSpec *p;
303     int i;
304     
305     p = (struct lexSpec *) xmalloc (sizeof(*p));
306     p->name = (char *) xmalloc (strlen(name)+1);
307     strcpy (p->name, name);
308
309 #if HAVE_TCL_H
310     p->tcl_interp = 0;
311 #endif
312     p->dh = dh;
313     p->context = NULL;
314     p->context_stack_size = 100;
315     p->context_stack = (struct lexContext **)
316         xmalloc (sizeof(*p->context_stack) * p->context_stack_size);
317     p->f_win_buf = NULL;
318
319     p->maxLevel = 128;
320     p->concatBuf = (struct lexConcatBuf *)
321         xmalloc (sizeof(*p->concatBuf) * p->maxLevel);
322     for (i = 0; i < p->maxLevel; i++)
323     {
324         p->concatBuf[i].max = 0;
325         p->concatBuf[i].buf = 0;
326     }
327     p->d1_stack = (data1_node **) xmalloc (sizeof(*p->d1_stack) * p->maxLevel);
328     p->d1_level = 0;
329     return p;
330 }
331
332 static void lexSpecDestroy (struct lexSpec **pp)
333 {
334     struct lexSpec *p;
335     struct lexContext *lt;
336     int i;
337
338     assert (pp);
339     p = *pp;
340     if (!p)
341         return ;
342
343     for (i = 0; i < p->maxLevel; i++)
344         xfree (p->concatBuf[i].buf);
345     xfree (p->concatBuf);
346
347     lt = p->context;
348     while (lt)
349     {
350         struct lexContext *lt_next = lt->next;
351         lexContextDestroy (lt);
352         lt = lt_next;
353     }
354 #if HAVE_TCL_OBJECTS
355     if (p->tcl_interp)
356         Tcl_DeleteInterp (p->tcl_interp);
357 #endif
358     xfree (p->name);
359     xfree (p->f_win_buf);
360     xfree (p->context_stack);
361     xfree (p->d1_stack);
362     xfree (p);
363     *pp = NULL;
364 }
365
366 static int readParseToken (const char **cpp, int *len)
367 {
368     const char *cp = *cpp;
369     char cmd[32];
370     int i, level;
371
372     while (*cp == ' ' || *cp == '\t' || *cp == '\n' || *cp == '\r')
373         cp++;
374     switch (*cp)
375     {
376     case '\0':
377         return 0;
378     case '/':
379         *cpp = cp+1;
380         return REGX_PATTERN;
381     case '{':
382         *cpp = cp+1;
383         level = 1;
384         while (*++cp)
385         {
386             if (*cp == '{')
387                 level++;
388             else if (*cp == '}')
389             {
390                 level--;
391                 if (level == 0)
392                     break;
393             }
394         }
395         *len = cp - *cpp;
396         return REGX_CODE;
397     default:
398         i = 0;
399         while (1)
400         {
401             if (*cp >= 'a' && *cp <= 'z')
402                 cmd[i] = *cp;
403             else if (*cp >= 'A' && *cp <= 'Z')
404                 cmd[i] = *cp + 'a' - 'A';
405             else
406                 break;
407             if (i < (int) sizeof(cmd)-2)
408                 i++;
409             cp++;
410         }
411         cmd[i] = '\0';
412         if (i == 0)
413         {
414             logf (LOG_WARN, "bad character %d %c", *cp, *cp);
415             cp++;
416             while (*cp && *cp != ' ' && *cp != '\t' &&
417                    *cp != '\n' && *cp != '\r')
418                 cp++;
419             *cpp = cp;
420             return 0;
421         }
422         *cpp = cp;
423         if (!strcmp (cmd, "begin"))
424             return REGX_BEGIN;
425         else if (!strcmp (cmd, "end"))
426             return REGX_END;
427         else if (!strcmp (cmd, "body"))
428             return REGX_BODY;
429         else if (!strcmp (cmd, "context"))
430             return REGX_CONTEXT;
431         else if (!strcmp (cmd, "init"))
432             return REGX_INIT;
433         else
434         {
435             logf (LOG_WARN, "bad command %s", cmd);
436             return 0;
437         }
438     }
439 }
440
441 static int actionListMk (struct lexSpec *spec, const char *s,
442                          struct lexRuleAction **ap)
443 {
444     int r, tok, len;
445     int bodyMark = 0;
446     const char *s0;
447
448     while ((tok = readParseToken (&s, &len)))
449     {
450         switch (tok)
451         {
452         case REGX_BODY:
453             bodyMark = 1;
454             continue;
455         case REGX_CODE:
456             *ap = (struct lexRuleAction *) xmalloc (sizeof(**ap));
457             (*ap)->which = tok;
458             regxCodeMk (&(*ap)->u.code, s, len);
459             s += len+1;
460             break;
461         case REGX_PATTERN:
462             *ap = (struct lexRuleAction *) xmalloc (sizeof(**ap));
463             (*ap)->which = tok;
464             (*ap)->u.pattern.body = bodyMark;
465             bodyMark = 0;
466             (*ap)->u.pattern.dfa = lexSpecDFA ();
467             s0 = s;
468             r = dfa_parse ((*ap)->u.pattern.dfa, &s);
469             if (r || *s != '/')
470             {
471                 xfree (*ap);
472                 *ap = NULL;
473                 logf (LOG_WARN, "regular expression error '%.*s'", s-s0, s0);
474                 return -1;
475             }
476             if (debug_dfa_tran)
477                 printf ("pattern: %.*s\n", s-s0, s0);
478             dfa_mkstate ((*ap)->u.pattern.dfa);
479             s++;
480             break;
481         case REGX_BEGIN:
482             logf (LOG_WARN, "cannot use BEGIN here");
483             continue;
484         case REGX_INIT:
485             logf (LOG_WARN, "cannot use INIT here");
486             continue;
487         case REGX_END:
488             *ap = (struct lexRuleAction *) xmalloc (sizeof(**ap));
489             (*ap)->which = tok;
490             break;
491         }
492         ap = &(*ap)->next;
493     }
494     *ap = NULL;
495     return 0;
496 }
497
498 int readOneSpec (struct lexSpec *spec, const char *s)
499 {
500     int len, r, tok;
501     struct lexRule *rp;
502     struct lexContext *lc;
503
504     tok = readParseToken (&s, &len);
505     if (tok == REGX_CONTEXT)
506     {
507         char context_name[32];
508         tok = readParseToken (&s, &len);
509         if (tok != REGX_CODE)
510         {
511             logf (LOG_WARN, "missing name after CONTEXT keyword");
512             return 0;
513         }
514         if (len > 31)
515             len = 31;
516         memcpy (context_name, s, len);
517         context_name[len] = '\0';
518         lc = lexContextCreate (context_name);
519         lc->next = spec->context;
520         spec->context = lc;
521         return 0;
522     }
523     if (!spec->context)
524         spec->context = lexContextCreate ("main");
525        
526     switch (tok)
527     {
528     case REGX_BEGIN:
529         actionListDel (&spec->context->beginActionList);
530         actionListMk (spec, s, &spec->context->beginActionList);
531         break;
532     case REGX_END:
533         actionListDel (&spec->context->endActionList);
534         actionListMk (spec, s, &spec->context->endActionList);
535         break;
536     case REGX_INIT:
537         actionListDel (&spec->context->initActionList);
538         actionListMk (spec, s, &spec->context->initActionList);
539         break;
540     case REGX_PATTERN:
541 #if REGX_DEBUG
542         logf (LOG_LOG, "rule %d %s", spec->context->ruleNo, s);
543 #endif
544         r = dfa_parse (spec->context->dfa, &s);
545         if (r)
546         {
547             logf (LOG_WARN, "regular expression error. r=%d", r);
548             return -1;
549         }
550         if (*s != '/')
551         {
552             logf (LOG_WARN, "expects / at end of pattern. got %c", *s);
553             return -1;
554         }
555         s++;
556         rp = (struct lexRule *) xmalloc (sizeof(*rp));
557         rp->info.no = spec->context->ruleNo++;
558         rp->next = spec->context->rules;
559         spec->context->rules = rp;
560         actionListMk (spec, s, &rp->info.actionList);
561     }
562     return 0;
563 }
564
565 int readFileSpec (struct lexSpec *spec)
566 {
567     struct lexContext *lc;
568     int c, i, errors = 0;
569     FILE *spec_inf = 0;
570     WRBUF lineBuf;
571     char fname[256];
572
573 #if HAVE_TCL_H
574     if (spec->tcl_interp)
575     {
576         sprintf (fname, "%s.tflt", spec->name);
577         spec_inf = data1_path_fopen (spec->dh, fname, "r");
578     }
579 #endif
580     if (!spec_inf)
581     {
582         sprintf (fname, "%s.flt", spec->name);
583         spec_inf = data1_path_fopen (spec->dh, fname, "r");
584     }
585     if (!spec_inf)
586     {
587         logf (LOG_ERRNO|LOG_WARN, "cannot read spec file %s", spec->name);
588         return -1;
589     }
590     logf (LOG_LOG, "reading regx filter %s", fname);
591 #if HAVE_TCL_H
592     if (spec->tcl_interp)
593         logf (LOG_LOG, "Tcl enabled");
594 #endif
595
596 #if 0
597     debug_dfa_trav = 0;
598     debug_dfa_tran = 1;
599     debug_dfa_followpos = 0;
600     dfa_verbose = 1;
601 #endif
602
603     lineBuf = wrbuf_alloc();
604     spec->lineNo = 0;
605     c = getc (spec_inf);
606     while (c != EOF)
607     {
608         wrbuf_rewind (lineBuf);
609         if (c == '#' || c == '\n' || c == ' ' || c == '\t' || c == '\r')
610         {
611             while (c != '\n' && c != EOF)
612                 c = getc (spec_inf);
613             spec->lineNo++;
614             if (c == '\n')
615                 c = getc (spec_inf);
616         }
617         else
618         {
619             int addLine = 0;
620             
621             while (1)
622             {
623                 int c1 = c;
624                 wrbuf_putc(lineBuf, c);
625                 c = getc (spec_inf);
626                 while (c == '\r')
627                     c = getc (spec_inf);
628                 if (c == EOF)
629                     break;
630                 if (c1 == '\n')
631                 {
632                     if (c != ' ' && c != '\t')
633                         break;
634                     addLine++;
635                 }
636             }
637             wrbuf_putc(lineBuf, '\0');
638             readOneSpec (spec, wrbuf_buf(lineBuf));
639             spec->lineNo += addLine;
640         }
641     }
642     fclose (spec_inf);
643     wrbuf_free(lineBuf, 1);
644
645     for (lc = spec->context; lc; lc = lc->next)
646     {
647         struct lexRule *rp;
648         lc->fastRule = (struct lexRuleInfo **)
649             xmalloc (sizeof(*lc->fastRule) * lc->ruleNo);
650         for (i = 0; i < lc->ruleNo; i++)
651             lc->fastRule[i] = NULL;
652         for (rp = lc->rules; rp; rp = rp->next)
653             lc->fastRule[rp->info.no] = &rp->info;
654         dfa_mkstate (lc->dfa);
655     }
656     if (errors)
657         return -1;
658     
659     return 0;
660 }
661
662 #if 0
663 static struct lexSpec *curLexSpec = NULL;
664 #endif
665
666 static void execData (struct lexSpec *spec,
667                       const char *ebuf, int elen, int formatted_text)
668 {
669     struct data1_node *res, *parent;
670     int org_len;
671
672     if (elen == 0) /* shouldn't happen, but it does! */
673         return ;
674 #if REGX_DEBUG
675     if (elen > 80)
676         logf (LOG_LOG, "data(%d bytes) %.40s ... %.*s", elen,
677               ebuf, 40, ebuf + elen-40);
678     else if (elen == 1 && ebuf[0] == '\n')
679     {
680         logf (LOG_LOG, "data(new line)");
681     }
682     else if (elen > 0)
683         logf (LOG_LOG, "data(%d bytes) %.*s", elen, elen, ebuf);
684     else 
685         logf (LOG_LOG, "data(%d bytes)", elen);
686 #endif
687         
688     if (spec->d1_level <= 1)
689         return;
690
691     parent = spec->d1_stack[spec->d1_level -1];
692     assert (parent);
693
694     if ((res = spec->d1_stack[spec->d1_level]) && res->which == DATA1N_data)
695         org_len = res->u.data.len;
696     else
697     {
698         org_len = 0;
699
700         res = data1_mk_node2 (spec->dh, spec->m, DATA1N_data, parent);
701         res->u.data.what = DATA1I_text;
702         res->u.data.len = 0;
703         res->u.data.formatted_text = formatted_text;
704         res->u.data.data = 0;
705         
706         if (spec->d1_stack[spec->d1_level])
707             spec->d1_stack[spec->d1_level]->next = res;
708         spec->d1_stack[spec->d1_level] = res;
709     }
710     if (org_len + elen >= spec->concatBuf[spec->d1_level].max)
711     {
712         char *old_buf, *new_buf;
713
714         spec->concatBuf[spec->d1_level].max = org_len + elen + 256;
715         new_buf = (char *) xmalloc (spec->concatBuf[spec->d1_level].max);
716         if ((old_buf = spec->concatBuf[spec->d1_level].buf))
717         {
718             memcpy (new_buf, old_buf, org_len);
719             xfree (old_buf);
720         }
721         spec->concatBuf[spec->d1_level].buf = new_buf;
722     }
723     memcpy (spec->concatBuf[spec->d1_level].buf + org_len, ebuf, elen);
724     res->u.data.len += elen;
725 }
726
727 static void execDataP (struct lexSpec *spec,
728                        const char *ebuf, int elen, int formatted_text)
729 {
730     execData (spec, ebuf, elen, formatted_text);
731 }
732
733 static void tagDataRelease (struct lexSpec *spec)
734 {
735     data1_node *res;
736     
737     if ((res = spec->d1_stack[spec->d1_level]) &&
738         res->which == DATA1N_data && 
739         res->u.data.what == DATA1I_text)
740     {
741         assert (!res->u.data.data);
742         assert (res->u.data.len > 0);
743         if (res->u.data.len > DATA1_LOCALDATA)
744             res->u.data.data = (char *) nmem_malloc (spec->m, res->u.data.len);
745         else
746             res->u.data.data = res->lbuf;
747         memcpy (res->u.data.data, spec->concatBuf[spec->d1_level].buf,
748                 res->u.data.len);
749     }
750 }
751
752 static void variantBegin (struct lexSpec *spec, 
753                           const char *class_str, int class_len,
754                           const char *type_str, int type_len,
755                           const char *value_str, int value_len)
756 {
757     struct data1_node *parent = spec->d1_stack[spec->d1_level -1];
758     char tclass[DATA1_MAX_SYMBOL], ttype[DATA1_MAX_SYMBOL];
759     data1_vartype *tp;
760     int i;
761     data1_node *res;
762
763     if (spec->d1_level == 0)
764     {
765         logf (LOG_WARN, "in variant begin. No record type defined");
766         return ;
767     }
768     if (class_len >= DATA1_MAX_SYMBOL)
769         class_len = DATA1_MAX_SYMBOL-1;
770     memcpy (tclass, class_str, class_len);
771     tclass[class_len] = '\0';
772
773     if (type_len >= DATA1_MAX_SYMBOL)
774         type_len = DATA1_MAX_SYMBOL-1;
775     memcpy (ttype, type_str, type_len);
776     ttype[type_len] = '\0';
777
778 #if REGX_DEBUG 
779     logf (LOG_LOG, "variant begin(%s,%s,%d)", tclass, ttype,
780           spec->d1_level);
781 #endif
782
783     if (!(tp =
784           data1_getvartypebyct(spec->dh, parent->root->u.root.absyn->varset,
785                                tclass, ttype)))
786         return;
787     
788     if (parent->which != DATA1N_variant)
789     {
790         res = data1_mk_node2 (spec->dh, spec->m, DATA1N_variant, parent);
791         if (spec->d1_stack[spec->d1_level])
792             tagDataRelease (spec);
793         spec->d1_stack[spec->d1_level] = res;
794         spec->d1_stack[++(spec->d1_level)] = NULL;
795     }
796     for (i = spec->d1_level-1; spec->d1_stack[i]->which == DATA1N_variant; i--)
797         if (spec->d1_stack[i]->u.variant.type == tp)
798         {
799             spec->d1_level = i;
800             break;
801         }
802
803 #if REGX_DEBUG 
804     logf (LOG_LOG, "variant node(%d)", spec->d1_level);
805 #endif
806     parent = spec->d1_stack[spec->d1_level-1];
807     res = data1_mk_node2 (spec->dh, spec->m, DATA1N_variant, parent);
808     res->u.variant.type = tp;
809
810     if (value_len >= DATA1_LOCALDATA)
811         value_len =DATA1_LOCALDATA-1;
812     memcpy (res->lbuf, value_str, value_len);
813     res->lbuf[value_len] = '\0';
814
815     res->u.variant.value = res->lbuf;
816     
817     if (spec->d1_stack[spec->d1_level])
818         tagDataRelease (spec);
819     spec->d1_stack[spec->d1_level] = res;
820     spec->d1_stack[++(spec->d1_level)] = NULL;
821 }
822
823 static void tagStrip (const char **tag, int *len)
824 {
825     int i;
826
827     for (i = *len; i > 0 && isspace((*tag)[i-1]); --i)
828         ;
829     *len = i;
830     for (i = 0; i < *len && isspace((*tag)[i]); i++)
831         ;
832     *tag += i;
833     *len -= i;
834 }
835
836 static void tagBegin (struct lexSpec *spec, 
837                       const char *tag, int len)
838 {
839     if (spec->d1_level == 0)
840     {
841         logf (LOG_WARN, "in element begin. No record type defined");
842         return ;
843     }
844     tagStrip (&tag, &len);
845     if (spec->d1_stack[spec->d1_level])
846         tagDataRelease (spec);
847
848 #if REGX_DEBUG 
849     logf (LOG_LOG, "begin tag(%.*s, %d)", len, tag, spec->d1_level);
850 #endif
851
852     spec->d1_stack[spec->d1_level] = data1_mk_tag_n (
853         spec->dh, spec->m, tag, len, 0, spec->d1_stack[spec->d1_level -1]);
854     spec->d1_stack[++(spec->d1_level)] = NULL;
855 }
856
857 static void tagEnd (struct lexSpec *spec, int min_level,
858                     const char *tag, int len)
859 {
860     tagStrip (&tag, &len);
861     while (spec->d1_level > min_level)
862     {
863         tagDataRelease (spec);
864         (spec->d1_level)--;
865         if (spec->d1_level == 0)
866             break;
867         if ((spec->d1_stack[spec->d1_level]->which == DATA1N_tag) &&
868             (!tag ||
869              (strlen(spec->d1_stack[spec->d1_level]->u.tag.tag) ==
870               (size_t) len &&
871               !memcmp (spec->d1_stack[spec->d1_level]->u.tag.tag, tag, len))))
872             break;
873     }
874 #if REGX_DEBUG
875     logf (LOG_LOG, "end tag(%d)", spec->d1_level);
876 #endif
877 }
878
879
880 static int tryMatch (struct lexSpec *spec, int *pptr, int *mptr,
881                      struct DFA *dfa, int greedy)
882 {
883     struct DFA_state *state = dfa->states[0];
884     struct DFA_tran *t;
885     unsigned char c;
886     unsigned char c_prev = 0;
887     int ptr = *pptr;          /* current pointer */
888     int start_ptr = *pptr;    /* first char of match */
889     int last_ptr = 0;         /* last char of match */
890     int last_rule = 0;        /* rule number of current match */
891     int restore_ptr = 0;
892     int i;
893
894     if (ptr)
895     {
896         --ptr;
897         c = f_win_advance (spec, &ptr);
898     }
899     while (1)
900     {
901         if (dfa->states[0] == state)
902         {
903             c_prev = c;
904             restore_ptr = ptr;
905         }
906         c = f_win_advance (spec, &ptr);
907
908         if (ptr == F_WIN_EOF)
909         {
910             if (last_rule)
911             {
912                 *mptr = start_ptr;
913                 *pptr = last_ptr;
914                 return 1;
915             }
916             break;
917         }
918
919         t = state->trans;
920         i = state->tran_no;
921         while (1)
922             if (--i < 0)    /* no transition for character c */
923             {
924                 if (last_rule)
925                 {
926                     *mptr = start_ptr;     /* match starts here */
927                     *pptr = last_ptr;      /* match end here (+1) */
928                     return 1;
929                 }
930                 state = dfa->states[0];
931
932                 ptr = restore_ptr;
933                 c = f_win_advance (spec, &ptr);
934
935                 start_ptr = ptr;
936
937                 break;
938             }
939             else if (c >= t->ch[0] && c <= t->ch[1])
940             {
941                 state = dfa->states[t->to];
942                 if (state->rule_no && c_prev == '\n')
943                 {
944                     last_rule = state->rule_no;
945                     last_ptr = ptr;
946                 }
947                 else if (state->rule_nno)
948                 {
949                     last_rule = state->rule_nno;
950                     last_ptr = ptr;
951                 }
952                 break;
953             }
954             else
955                 t++;
956     }
957     return 0;
958 }
959
960 static int execTok (struct lexSpec *spec, const char **src,
961                     const char **tokBuf, int *tokLen)
962 {
963     const char *s = *src;
964
965     while (*s == ' ' || *s == '\t')
966         s++;
967     if (!*s)
968         return 0;
969     if (*s == '$' && s[1] >= '0' && s[1] <= '9')
970     {
971         int n = 0;
972         s++;
973         while (*s >= '0' && *s <= '9')
974             n = n*10 + (*s++ -'0');
975         if (spec->arg_no == 0)
976         {
977             *tokBuf = "";
978             *tokLen = 0;
979         }
980         else
981         {
982             if (n >= spec->arg_no)
983                 n = spec->arg_no-1;
984             *tokBuf = f_win_get (spec, spec->arg_start[n], spec->arg_end[n],
985                                  tokLen);
986         }
987     }
988     else if (*s == '\"')
989     {
990         *tokBuf = ++s;
991         while (*s && *s != '\"')
992             s++;
993         *tokLen = s - *tokBuf;
994         if (*s)
995             s++;
996         *src = s;
997     }
998     else if (*s == '\n' || *s == ';')
999     {
1000         *src = s+1;
1001         return 1;
1002     }
1003     else if (*s == '-')
1004     {
1005         *tokBuf = s++;
1006         while (*s && *s != ' ' && *s != '\t' && *s != '\n' && *s != '\r' &&
1007                *s != ';')
1008             s++;
1009         *tokLen = s - *tokBuf;
1010         *src = s;
1011         return 3;
1012     }
1013     else
1014     {
1015         *tokBuf = s++;
1016         while (*s && *s != ' ' && *s != '\t' && *s != '\n' && *s != '\r' &&
1017                *s != ';')
1018             s++;
1019         *tokLen = s - *tokBuf;
1020     }
1021     *src = s;
1022     return 2;
1023 }
1024
1025 static char *regxStrz (const char *src, int len, char *str)
1026 {
1027     if (len > 63)
1028         len = 63;
1029     memcpy (str, src, len);
1030     str[len] = '\0';
1031     return str;
1032 }
1033
1034 #if HAVE_TCL_H
1035 static int cmd_tcl_begin (ClientData clientData, Tcl_Interp *interp,
1036                           int argc, char **argv)
1037 {
1038     struct lexSpec *spec = (struct lexSpec *) clientData;
1039     if (argc < 2)
1040         return TCL_ERROR;
1041     if (!strcmp(argv[1], "record") && argc == 3)
1042     {
1043         char *absynName = argv[2];
1044         data1_node *res;
1045
1046 #if REGX_DEBUG
1047         logf (LOG_LOG, "begin record %s", absynName);
1048 #endif
1049         res = data1_mk_root (spec->dh, spec->m, absynName);
1050         
1051         spec->d1_stack[spec->d1_level++] = res;
1052
1053         res = data1_mk_tag (spec->dh, spec->m, absynName, 0, res);
1054
1055         spec->d1_stack[spec->d1_level++] = res;
1056
1057         spec->d1_stack[spec->d1_level] = NULL;
1058     }
1059     else if (!strcmp(argv[1], "element") && argc == 3)
1060     {
1061         tagBegin (spec, argv[2], strlen(argv[2]));
1062     }
1063     else if (!strcmp (argv[1], "variant") && argc == 5)
1064     {
1065         variantBegin (spec, argv[2], strlen(argv[2]),
1066                       argv[3], strlen(argv[3]),
1067                       argv[4], strlen(argv[4]));
1068     }
1069     else if (!strcmp (argv[1], "context") && argc == 3)
1070     {
1071         struct lexContext *lc = spec->context;
1072 #if REGX_DEBUG
1073         logf (LOG_LOG, "begin context %s",argv[2]);
1074 #endif
1075         while (lc && strcmp (argv[2], lc->name))
1076             lc = lc->next;
1077         if (lc)
1078         {
1079             spec->context_stack[++(spec->context_stack_top)] = lc;
1080         }
1081         else
1082             logf (LOG_WARN, "unknown context %s", argv[2]);
1083     }
1084     else
1085         return TCL_ERROR;
1086     return TCL_OK;
1087 }
1088
1089 static int cmd_tcl_end (ClientData clientData, Tcl_Interp *interp,
1090                         int argc, char **argv)
1091 {
1092     struct lexSpec *spec = (struct lexSpec *) clientData;
1093     if (argc < 2)
1094         return TCL_ERROR;
1095     
1096     if (!strcmp (argv[1], "record"))
1097     {
1098         while (spec->d1_level)
1099         {
1100             tagDataRelease (spec);
1101             (spec->d1_level)--;
1102         }
1103 #if REGX_DEBUG
1104         logf (LOG_LOG, "end record");
1105 #endif
1106         spec->stop_flag = 1;
1107     }
1108     else if (!strcmp (argv[1], "element"))
1109     {
1110         int min_level = 1;
1111         char *element = 0;
1112         if (argc >= 3 && !strcmp(argv[2], "-record"))
1113         {
1114             min_level = 0;
1115             if (argc == 4)
1116                 element = argv[3];
1117         }
1118         else
1119             if (argc == 3)
1120                 element = argv[2];
1121         tagEnd (spec, min_level, element, (element ? strlen(element) : 0));
1122         if (spec->d1_level == 0)
1123         {
1124 #if REGX_DEBUG
1125             logf (LOG_LOG, "end element end records");
1126 #endif
1127             spec->stop_flag = 1;
1128         }
1129     }
1130     else if (!strcmp (argv[1], "context"))
1131     {
1132 #if REGX_DEBUG
1133         logf (LOG_LOG, "end context");
1134 #endif
1135         if (spec->context_stack_top)
1136             (spec->context_stack_top)--;
1137     }
1138     else
1139         return TCL_ERROR;
1140     return TCL_OK;
1141 }
1142
1143 static int cmd_tcl_data (ClientData clientData, Tcl_Interp *interp,
1144                          int argc, char **argv)
1145 {
1146     int argi = 1;
1147     int textFlag = 0;
1148     const char *element = 0;
1149     struct lexSpec *spec = (struct lexSpec *) clientData;
1150     
1151     while (argi < argc)
1152     {
1153         if (!strcmp("-text", argv[argi]))
1154         {
1155             textFlag = 1;
1156             argi++;
1157         }
1158         else if (!strcmp("-element", argv[argi]))
1159         {
1160             argi++;
1161             if (argi < argc)
1162                 element = argv[argi++];
1163         }
1164         else
1165             break;
1166     }
1167     if (element)
1168         tagBegin (spec, element, strlen(element));
1169
1170     while (argi < argc)
1171     {
1172 #if TCL_MAJOR_VERSION > 8 || (TCL_MAJOR_VERSION == 8 && TCL_MINOR_VERSION > 0)
1173         Tcl_DString ds;
1174         char *native = Tcl_UtfToExternalDString(0, argv[argi], -1, &ds);
1175         execData (spec, native, strlen(native), textFlag);
1176         Tcl_DStringFree (&ds);
1177 #else
1178         execData (spec, argv[argi], strlen(argv[argi]), textFlag);
1179 #endif
1180         argi++;
1181     }
1182     if (element)
1183         tagEnd (spec, 1, NULL, 0);
1184     return TCL_OK;
1185 }
1186
1187 static int cmd_tcl_unread (ClientData clientData, Tcl_Interp *interp,
1188                            int argc, char **argv)
1189 {
1190     struct lexSpec *spec = (struct lexSpec *) clientData;
1191     int argi = 1;
1192     int offset = 0;
1193     int no;
1194     
1195     while (argi < argc)
1196     {
1197         if (!strcmp("-offset", argv[argi]))
1198         {
1199             argi++;
1200             if (argi < argc)
1201             {
1202                 offset = atoi(argv[argi]);
1203                 argi++;
1204             }
1205         }
1206         else
1207             break;
1208     }
1209     if (argi != argc-1)
1210         return TCL_ERROR;
1211     no = atoi(argv[argi]);
1212     if (no >= spec->arg_no)
1213         no = spec->arg_no - 1;
1214     spec->ptr = spec->arg_start[no] + offset;
1215     return TCL_OK;
1216 }
1217
1218 static void execTcl (struct lexSpec *spec, struct regxCode *code)
1219 {   
1220     int i;
1221     int ret;
1222     for (i = 0; i < spec->arg_no; i++)
1223     {
1224         char var_name[10], *var_buf;
1225         int var_len, ch;
1226         
1227         sprintf (var_name, "%d", i);
1228         var_buf = f_win_get (spec, spec->arg_start[i], spec->arg_end[i],
1229                              &var_len); 
1230         if (var_buf)
1231         {
1232             ch = var_buf[var_len];
1233             var_buf[var_len] = '\0';
1234             Tcl_SetVar (spec->tcl_interp, var_name, var_buf, 0);
1235             var_buf[var_len] = ch;
1236         }
1237     }
1238 #if HAVE_TCL_OBJECTS
1239     ret = Tcl_GlobalEvalObj(spec->tcl_interp, code->tcl_obj);
1240 #else
1241     ret = Tcl_GlobalEval (spec->tcl_interp, code->str);
1242 #endif
1243     if (ret != TCL_OK)
1244     {
1245         const char *err = Tcl_GetVar(spec->tcl_interp, "errorInfo", 0);
1246         logf(LOG_FATAL, "Tcl error, line=%d, \"%s\"\n%s", 
1247             spec->tcl_interp->errorLine,
1248             spec->tcl_interp->result,
1249             err ? err : "[NO ERRORINFO]");
1250     }
1251 }
1252 /* HAVE_TCL_H */
1253 #endif
1254
1255 static void execCode (struct lexSpec *spec, struct regxCode *code)
1256 {
1257     const char *s = code->str;
1258     int cmd_len, r;
1259     const char *cmd_str;
1260     
1261     r = execTok (spec, &s, &cmd_str, &cmd_len);
1262     while (r)
1263     {
1264         char *p, ptmp[64];
1265         
1266         if (r == 1)
1267         {
1268             r = execTok (spec, &s, &cmd_str, &cmd_len);
1269             continue;
1270         }
1271         p = regxStrz (cmd_str, cmd_len, ptmp);
1272         if (!strcmp (p, "begin"))
1273         {
1274             r = execTok (spec, &s, &cmd_str, &cmd_len);
1275             if (r < 2)
1276             {
1277                 logf (LOG_WARN, "missing keyword after 'begin'");
1278                 continue;
1279             }
1280             p = regxStrz (cmd_str, cmd_len, ptmp);
1281             if (!strcmp (p, "record"))
1282             {
1283                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1284                 if (r < 2)
1285                     continue;
1286                 if (spec->d1_level == 0)
1287                 {
1288                     static char absynName[64];
1289                     data1_node *res;
1290
1291                     if (cmd_len > 63)
1292                         cmd_len = 63;
1293                     memcpy (absynName, cmd_str, cmd_len);
1294                     absynName[cmd_len] = '\0';
1295 #if REGX_DEBUG
1296                     logf (LOG_LOG, "begin record %s", absynName);
1297 #endif
1298                     res = data1_mk_root (spec->dh, spec->m, absynName);
1299                     
1300                     spec->d1_stack[spec->d1_level++] = res;
1301
1302                     res = data1_mk_tag (spec->dh, spec->m, absynName, 0, res);
1303
1304                     spec->d1_stack[spec->d1_level++] = res;
1305
1306                     spec->d1_stack[spec->d1_level] = NULL;
1307                 }
1308                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1309             }
1310             else if (!strcmp (p, "element"))
1311             {
1312                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1313                 if (r < 2)
1314                     continue;
1315                 tagBegin (spec, cmd_str, cmd_len);
1316                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1317             } 
1318             else if (!strcmp (p, "variant"))
1319             {
1320                 int class_len;
1321                 const char *class_str = NULL;
1322                 int type_len;
1323                 const char *type_str = NULL;
1324                 int value_len;
1325                 const char *value_str = NULL;
1326                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1327                 if (r < 2)
1328                     continue;
1329                 class_str = cmd_str;
1330                 class_len = cmd_len;
1331                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1332                 if (r < 2)
1333                     continue;
1334                 type_str = cmd_str;
1335                 type_len = cmd_len;
1336
1337                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1338                 if (r < 2)
1339                     continue;
1340                 value_str = cmd_str;
1341                 value_len = cmd_len;
1342
1343                 variantBegin (spec, class_str, class_len,
1344                               type_str, type_len, value_str, value_len);
1345                 
1346                 
1347                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1348             }
1349             else if (!strcmp (p, "context"))
1350             {
1351                 if (r > 1)
1352                 {
1353                     struct lexContext *lc = spec->context;
1354                     r = execTok (spec, &s, &cmd_str, &cmd_len);
1355                     p = regxStrz (cmd_str, cmd_len, ptmp);
1356 #if REGX_DEBUG
1357                     logf (LOG_LOG, "begin context %s", p);
1358 #endif
1359                     while (lc && strcmp (p, lc->name))
1360                         lc = lc->next;
1361                     if (lc)
1362                         spec->context_stack[++(spec->context_stack_top)] = lc;
1363                     else
1364                         logf (LOG_WARN, "unknown context %s", p);
1365                     
1366                 }
1367                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1368             }
1369             else
1370             {
1371                 logf (LOG_WARN, "bad keyword '%s' after begin", p);
1372             }
1373         }
1374         else if (!strcmp (p, "end"))
1375         {
1376             r = execTok (spec, &s, &cmd_str, &cmd_len);
1377             if (r < 2)
1378             {
1379                 logf (LOG_WARN, "missing keyword after 'end'");
1380                 continue;
1381             }
1382             p = regxStrz (cmd_str, cmd_len, ptmp);
1383             if (!strcmp (p, "record"))
1384             {
1385                 while (spec->d1_level)
1386                 {
1387                     tagDataRelease (spec);
1388                     (spec->d1_level)--;
1389                 }
1390                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1391 #if REGX_DEBUG
1392                 logf (LOG_LOG, "end record");
1393 #endif
1394                 spec->stop_flag = 1;
1395             }
1396             else if (!strcmp (p, "element"))
1397             {
1398                 int min_level = 1;
1399                 while ((r = execTok (spec, &s, &cmd_str, &cmd_len)) == 3)
1400                 {
1401                     if (cmd_len==7 && !memcmp ("-record", cmd_str, cmd_len))
1402                         min_level = 0;
1403                 }
1404                 if (r > 2)
1405                 {
1406                     tagEnd (spec, min_level, cmd_str, cmd_len);
1407                     r = execTok (spec, &s, &cmd_str, &cmd_len);
1408                 }
1409                 else
1410                     tagEnd (spec, min_level, NULL, 0);
1411                 if (spec->d1_level == 0)
1412                 {
1413 #if REGX_DEBUG
1414                     logf (LOG_LOG, "end element end records");
1415 #endif
1416                     spec->stop_flag = 1;
1417                 }
1418
1419             }
1420             else if (!strcmp (p, "context"))
1421             {
1422 #if REGX_DEBUG
1423                 logf (LOG_LOG, "end context");
1424 #endif
1425                 if (spec->context_stack_top)
1426                     (spec->context_stack_top)--;
1427                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1428             }       
1429             else
1430                 logf (LOG_WARN, "bad keyword '%s' after end", p);
1431         }
1432         else if (!strcmp (p, "data"))
1433         {
1434             int textFlag = 0;
1435             int element_len;
1436             const char *element_str = NULL;
1437             
1438             while ((r = execTok (spec, &s, &cmd_str, &cmd_len)) == 3)
1439             {
1440                 if (cmd_len==5 && !memcmp ("-text", cmd_str, cmd_len))
1441                     textFlag = 1;
1442                 else if (cmd_len==8 && !memcmp ("-element", cmd_str, cmd_len))
1443                 {
1444                     r = execTok (spec, &s, &element_str, &element_len);
1445                     if (r < 2)
1446                         break;
1447                 }
1448                 else 
1449                     logf (LOG_WARN, "bad data option: %.*s",
1450                           cmd_len, cmd_str);
1451             }
1452             if (r != 2)
1453             {
1454                 logf (LOG_WARN, "missing data item after data");
1455                 continue;
1456             }
1457             if (element_str)
1458                 tagBegin (spec, element_str, element_len);
1459             do
1460             {
1461                 execData (spec, cmd_str, cmd_len,textFlag);
1462                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1463             } while (r > 1);
1464             if (element_str)
1465                 tagEnd (spec, 1, NULL, 0);
1466         }
1467         else if (!strcmp (p, "unread"))
1468         {
1469             int no, offset;
1470             r = execTok (spec, &s, &cmd_str, &cmd_len);
1471             if (r==3 && cmd_len == 7 && !memcmp ("-offset", cmd_str, cmd_len))
1472             {
1473                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1474                 if (r < 2)
1475                 {
1476                     logf (LOG_WARN, "missing number after -offset");
1477                     continue;
1478                 }
1479                 p = regxStrz (cmd_str, cmd_len, ptmp);
1480                 offset = atoi (p);
1481                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1482             }
1483             else
1484                 offset = 0;
1485             if (r < 2)
1486             {
1487                 logf (LOG_WARN, "missing index after unread command");
1488                 continue;
1489             }
1490             if (cmd_len != 1 || *cmd_str < '0' || *cmd_str > '9')
1491             {
1492                 logf (LOG_WARN, "bad index after unread command");
1493                 continue;
1494             }
1495             else
1496             {
1497                 no = *cmd_str - '0';
1498                 if (no >= spec->arg_no)
1499                     no = spec->arg_no - 1;
1500                 spec->ptr = spec->arg_start[no] + offset;
1501             }
1502             r = execTok (spec, &s, &cmd_str, &cmd_len);
1503         }
1504         else if (!strcmp (p, "context"))
1505         {
1506             if (r > 1)
1507             {
1508                 struct lexContext *lc = spec->context;
1509                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1510                 p = regxStrz (cmd_str, cmd_len, ptmp);
1511                 
1512                 while (lc && strcmp (p, lc->name))
1513                     lc = lc->next;
1514                 if (lc)
1515                     spec->context_stack[spec->context_stack_top] = lc;
1516                 else
1517                     logf (LOG_WARN, "unknown context %s", p);
1518
1519             }
1520             r = execTok (spec, &s, &cmd_str, &cmd_len);
1521         }
1522         else
1523         {
1524             logf (LOG_WARN, "unknown code command '%.*s'", cmd_len, cmd_str);
1525             r = execTok (spec, &s, &cmd_str, &cmd_len);
1526             continue;
1527         }
1528         if (r > 1)
1529         {
1530             logf (LOG_WARN, "ignoring token %.*s", cmd_len, cmd_str);
1531             do {
1532                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1533             } while (r > 1);
1534         }
1535     }
1536 }
1537
1538
1539 static int execAction (struct lexSpec *spec, struct lexRuleAction *ap,
1540                        int start_ptr, int *pptr)
1541 {
1542     int sptr;
1543     int arg_start[20];
1544     int arg_end[20];
1545     int arg_no = 1;
1546
1547     if (!ap)
1548         return 1;
1549     arg_start[0] = start_ptr;
1550     arg_end[0] = *pptr;
1551     spec->arg_start = arg_start;
1552     spec->arg_end = arg_end;
1553
1554     while (ap)
1555     {
1556         switch (ap->which)
1557         {
1558         case REGX_PATTERN:
1559             if (ap->u.pattern.body)
1560             {
1561                 arg_start[arg_no] = *pptr;
1562                 if (!tryMatch (spec, pptr, &sptr, ap->u.pattern.dfa, 0))
1563                 {
1564                     arg_end[arg_no] = F_WIN_EOF;
1565                     arg_no++;
1566                     arg_start[arg_no] = F_WIN_EOF;
1567                     arg_end[arg_no] = F_WIN_EOF;
1568                     yaz_log(LOG_DEBUG, "Pattern match rest of record");
1569                     *pptr = F_WIN_EOF;
1570                 }
1571                 else
1572                 {
1573                     arg_end[arg_no] = sptr;
1574                     arg_no++;
1575                     arg_start[arg_no] = sptr;
1576                     arg_end[arg_no] = *pptr;
1577                 }
1578             }
1579             else
1580             {
1581                 arg_start[arg_no] = *pptr;
1582                 if (!tryMatch (spec, pptr, &sptr, ap->u.pattern.dfa, 1))
1583                     return 1;
1584                 if (sptr != arg_start[arg_no])
1585                     return 1;
1586                 arg_end[arg_no] = *pptr;
1587             }
1588             arg_no++;
1589             break;
1590         case REGX_CODE:
1591             spec->arg_no = arg_no;
1592             spec->ptr = *pptr;
1593 #if HAVE_TCL_H
1594             if (spec->tcl_interp)
1595                 execTcl(spec, ap->u.code);
1596             else
1597                 execCode (spec, ap->u.code);
1598 #else
1599             execCode (spec, ap->u.code);
1600 #endif
1601             *pptr = spec->ptr;
1602             if (spec->stop_flag)
1603                 return 0;
1604             break;
1605         case REGX_END:
1606             arg_start[arg_no] = *pptr;
1607             arg_end[arg_no] = F_WIN_EOF;
1608             arg_no++;
1609             *pptr = F_WIN_EOF;
1610         }
1611         ap = ap->next;
1612     }
1613     return 1;
1614 }
1615
1616 static int execRule (struct lexSpec *spec, struct lexContext *context,
1617                      int ruleNo, int start_ptr, int *pptr)
1618 {
1619 #if REGX_DEBUG
1620     logf (LOG_LOG, "exec rule %d", ruleNo);
1621 #endif
1622     return execAction (spec, context->fastRule[ruleNo]->actionList,
1623                        start_ptr, pptr);
1624 }
1625
1626 data1_node *lexNode (struct lexSpec *spec, int *ptr)
1627 {
1628     struct lexContext *context = spec->context_stack[spec->context_stack_top];
1629     struct DFA_state *state = context->dfa->states[0];
1630     struct DFA_tran *t;
1631     unsigned char c;
1632     unsigned char c_prev = '\n';
1633     int i;
1634     int last_rule = 0;        /* rule number of current match */
1635     int last_ptr = *ptr;      /* last char of match */
1636     int start_ptr = *ptr;     /* first char of match */
1637     int skip_ptr = *ptr;      /* first char of run */
1638
1639     while (1)
1640     {
1641         c = f_win_advance (spec, ptr);
1642         if (*ptr == F_WIN_EOF)
1643         {
1644             /* end of file met */
1645             if (last_rule)
1646             {
1647                 /* there was a match */
1648                 if (skip_ptr < start_ptr)
1649                 {
1650                     /* deal with chars that didn't match */
1651                     int size;
1652                     char *buf;
1653                     buf = f_win_get (spec, skip_ptr, start_ptr, &size);
1654                     execDataP (spec, buf, size, 0);
1655                 }
1656                 /* restore pointer */
1657                 *ptr = last_ptr;
1658                 /* execute rule */
1659                 if (!execRule (spec, context, last_rule, start_ptr, ptr))
1660                     break;
1661                 /* restore skip pointer */
1662                 skip_ptr = *ptr;
1663                 last_rule = 0;
1664             }
1665             else if (skip_ptr < *ptr)
1666             {
1667                 /* deal with chars that didn't match */
1668                 int size;
1669                 char *buf;
1670                 buf = f_win_get (spec, skip_ptr, *ptr, &size);
1671                 execDataP (spec, buf, size, 0);
1672             }
1673             if (*ptr == F_WIN_EOF)
1674                 break;
1675         }
1676         t = state->trans;
1677         i = state->tran_no;
1678         while (1)
1679             if (--i < 0)
1680             {   /* no transition for character c ... */
1681                 if (last_rule)
1682                 {
1683                     if (skip_ptr < start_ptr)
1684                     {
1685                         /* deal with chars that didn't match */
1686                         int size;
1687                         char *buf;
1688                         buf = f_win_get (spec, skip_ptr, start_ptr, &size);
1689                         execDataP (spec, buf, size, 0);
1690                     }
1691                     /* restore pointer */
1692                     *ptr = last_ptr;
1693                     if (!execRule (spec, context, last_rule, start_ptr, ptr))
1694                     {
1695                         if (spec->f_win_ef && *ptr != F_WIN_EOF)
1696                         {
1697 #if REGX_DEBUG
1698                             logf (LOG_LOG, "regx: endf ptr=%d", *ptr);
1699 #endif
1700                             (*spec->f_win_ef)(spec->f_win_fh, *ptr);
1701                         }
1702                         return NULL;
1703                     }
1704                     context = spec->context_stack[spec->context_stack_top];
1705                     skip_ptr = *ptr;
1706                     last_rule = 0;
1707                     last_ptr = start_ptr = *ptr;
1708                     if (start_ptr > 0)
1709                     {
1710                         --start_ptr;
1711                         c_prev = f_win_advance (spec, &start_ptr);
1712                     }
1713                 }
1714                 else
1715                 {
1716                     c_prev = f_win_advance (spec, &start_ptr);
1717                     *ptr = start_ptr;
1718                 }
1719                 state = context->dfa->states[0];
1720                 break;
1721             }
1722             else if (c >= t->ch[0] && c <= t->ch[1])
1723             {   /* transition ... */
1724                 state = context->dfa->states[t->to];
1725                 if (state->rule_no)
1726                 {
1727                     if (c_prev == '\n')
1728                     {
1729                         last_rule = state->rule_no;
1730                         last_ptr = *ptr;
1731                     } 
1732                     else if (state->rule_nno)
1733                     {
1734                         last_rule = state->rule_nno;
1735                         last_ptr = *ptr;
1736                     }
1737                 }
1738                 break;
1739             }
1740             else
1741                 t++;
1742     }
1743     return NULL;
1744 }
1745
1746 static data1_node *lexRoot (struct lexSpec *spec, off_t offset,
1747                             const char *context_name)
1748 {
1749     struct lexContext *lt = spec->context;
1750     int ptr = offset;
1751
1752     spec->stop_flag = 0;
1753     spec->d1_level = 0;
1754     spec->context_stack_top = 0;    
1755     while (lt)
1756     {
1757         if (!strcmp (lt->name, context_name))
1758             break;
1759         lt = lt->next;
1760     }
1761     if (!lt)
1762     {
1763         logf (LOG_WARN, "cannot find context %s", context_name);
1764         return NULL;
1765     }
1766     spec->context_stack[spec->context_stack_top] = lt;
1767     spec->d1_stack[spec->d1_level] = NULL;
1768 #if 1
1769     if (!lt->initFlag)
1770     {
1771         lt->initFlag = 1;
1772         execAction (spec, lt->initActionList, ptr, &ptr);
1773     }
1774 #endif
1775     execAction (spec, lt->beginActionList, ptr, &ptr);
1776     lexNode (spec, &ptr);
1777     while (spec->d1_level)
1778     {
1779         tagDataRelease (spec);
1780         (spec->d1_level)--;
1781     }
1782     execAction (spec, lt->endActionList, ptr, &ptr);
1783     return spec->d1_stack[0];
1784 }
1785
1786 void grs_destroy(void *clientData)
1787 {
1788     struct lexSpecs *specs = (struct lexSpecs *) clientData;
1789     if (specs->spec)
1790     {
1791         lexSpecDestroy(&specs->spec);
1792     }
1793     xfree (specs);
1794 }
1795
1796 void *grs_init(void)
1797 {
1798     struct lexSpecs *specs = (struct lexSpecs *) xmalloc (sizeof(*specs));
1799     specs->spec = 0;
1800     return specs;
1801 }
1802
1803 data1_node *grs_read_regx (struct grs_read_info *p)
1804 {
1805     int res;
1806     struct lexSpecs *specs = (struct lexSpecs *) p->clientData;
1807     struct lexSpec **curLexSpec = &specs->spec;
1808
1809 #if REGX_DEBUG
1810     logf (LOG_LOG, "grs_read_regx");
1811 #endif
1812     if (!*curLexSpec || strcmp ((*curLexSpec)->name, p->type))
1813     {
1814         if (*curLexSpec)
1815             lexSpecDestroy (curLexSpec);
1816         *curLexSpec = lexSpecCreate (p->type, p->dh);
1817         res = readFileSpec (*curLexSpec);
1818         if (res)
1819         {
1820             lexSpecDestroy (curLexSpec);
1821             return NULL;
1822         }
1823     }
1824     (*curLexSpec)->dh = p->dh;
1825     if (!p->offset)
1826     {
1827         (*curLexSpec)->f_win_start = 0;
1828         (*curLexSpec)->f_win_end = 0;
1829         (*curLexSpec)->f_win_rf = p->readf;
1830         (*curLexSpec)->f_win_sf = p->seekf;
1831         (*curLexSpec)->f_win_fh = p->fh;
1832         (*curLexSpec)->f_win_ef = p->endf;
1833         (*curLexSpec)->f_win_size = 500000;
1834     }
1835     (*curLexSpec)->m = p->mem;
1836     return lexRoot (*curLexSpec, p->offset, "main");
1837 }
1838
1839 static struct recTypeGrs regx_type = {
1840     "regx",
1841     grs_init,
1842     grs_destroy,
1843     grs_read_regx
1844 };
1845
1846 RecTypeGrs recTypeGrs_regx = &regx_type;
1847
1848 #if HAVE_TCL_H
1849 data1_node *grs_read_tcl (struct grs_read_info *p)
1850 {
1851     int res;
1852     struct lexSpecs *specs = (struct lexSpecs *) p->clientData;
1853     struct lexSpec **curLexSpec = &specs->spec;
1854
1855 #if REGX_DEBUG
1856     logf (LOG_LOG, "grs_read_tcl");
1857 #endif
1858     if (!*curLexSpec || strcmp ((*curLexSpec)->name, p->type))
1859     {
1860         Tcl_Interp *tcl_interp;
1861         if (*curLexSpec)
1862             lexSpecDestroy (curLexSpec);
1863         *curLexSpec = lexSpecCreate (p->type, p->dh);
1864         Tcl_FindExecutable("");
1865         tcl_interp = (*curLexSpec)->tcl_interp = Tcl_CreateInterp();
1866         Tcl_Init(tcl_interp);
1867         Tcl_CreateCommand (tcl_interp, "begin", cmd_tcl_begin, *curLexSpec, 0);
1868         Tcl_CreateCommand (tcl_interp, "end", cmd_tcl_end, *curLexSpec, 0);
1869         Tcl_CreateCommand (tcl_interp, "data", cmd_tcl_data, *curLexSpec, 0);
1870         Tcl_CreateCommand (tcl_interp, "unread", cmd_tcl_unread,
1871                            *curLexSpec, 0);
1872         res = readFileSpec (*curLexSpec);
1873         if (res)
1874         {
1875             lexSpecDestroy (curLexSpec);
1876             return NULL;
1877         }
1878     }
1879     (*curLexSpec)->dh = p->dh;
1880     if (!p->offset)
1881     {
1882         (*curLexSpec)->f_win_start = 0;
1883         (*curLexSpec)->f_win_end = 0;
1884         (*curLexSpec)->f_win_rf = p->readf;
1885         (*curLexSpec)->f_win_sf = p->seekf;
1886         (*curLexSpec)->f_win_fh = p->fh;
1887         (*curLexSpec)->f_win_ef = p->endf;
1888         (*curLexSpec)->f_win_size = 500000;
1889     }
1890     (*curLexSpec)->m = p->mem;
1891     return lexRoot (*curLexSpec, p->offset, "main");
1892 }
1893
1894 static struct recTypeGrs tcl_type = {
1895     "tcl",
1896     grs_init,
1897     grs_destroy,
1898     grs_read_tcl
1899 };
1900
1901 RecTypeGrs recTypeGrs_tcl = &tcl_type;
1902 #endif