Directive systag.
[idzebra-moved-to-github.git] / recctrl / regxread.c
1 /* $Id: regxread.c,v 1.46 2002-09-24 19:41:00 adam Exp $
2    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
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             dfa_mkstate ((*ap)->u.pattern.dfa);
477             s++;
478             break;
479         case REGX_BEGIN:
480             logf (LOG_WARN, "cannot use BEGIN here");
481             continue;
482         case REGX_INIT:
483             logf (LOG_WARN, "cannot use INIT here");
484             continue;
485         case REGX_END:
486             *ap = (struct lexRuleAction *) xmalloc (sizeof(**ap));
487             (*ap)->which = tok;
488             break;
489         }
490         ap = &(*ap)->next;
491     }
492     *ap = NULL;
493     return 0;
494 }
495
496 int readOneSpec (struct lexSpec *spec, const char *s)
497 {
498     int len, r, tok;
499     struct lexRule *rp;
500     struct lexContext *lc;
501
502     tok = readParseToken (&s, &len);
503     if (tok == REGX_CONTEXT)
504     {
505         char context_name[32];
506         tok = readParseToken (&s, &len);
507         if (tok != REGX_CODE)
508         {
509             logf (LOG_WARN, "missing name after CONTEXT keyword");
510             return 0;
511         }
512         if (len > 31)
513             len = 31;
514         memcpy (context_name, s, len);
515         context_name[len] = '\0';
516         lc = lexContextCreate (context_name);
517         lc->next = spec->context;
518         spec->context = lc;
519         return 0;
520     }
521     if (!spec->context)
522         spec->context = lexContextCreate ("main");
523        
524     switch (tok)
525     {
526     case REGX_BEGIN:
527         actionListDel (&spec->context->beginActionList);
528         actionListMk (spec, s, &spec->context->beginActionList);
529         break;
530     case REGX_END:
531         actionListDel (&spec->context->endActionList);
532         actionListMk (spec, s, &spec->context->endActionList);
533         break;
534     case REGX_INIT:
535         actionListDel (&spec->context->initActionList);
536         actionListMk (spec, s, &spec->context->initActionList);
537         break;
538     case REGX_PATTERN:
539 #if REGX_DEBUG
540         logf (LOG_LOG, "rule %d %s", spec->context->ruleNo, s);
541 #endif
542         r = dfa_parse (spec->context->dfa, &s);
543         if (r)
544         {
545             logf (LOG_WARN, "regular expression error. r=%d", r);
546             return -1;
547         }
548         if (*s != '/')
549         {
550             logf (LOG_WARN, "expects / at end of pattern. got %c", *s);
551             return -1;
552         }
553         s++;
554         rp = (struct lexRule *) xmalloc (sizeof(*rp));
555         rp->info.no = spec->context->ruleNo++;
556         rp->next = spec->context->rules;
557         spec->context->rules = rp;
558         actionListMk (spec, s, &rp->info.actionList);
559     }
560     return 0;
561 }
562
563 int readFileSpec (struct lexSpec *spec)
564 {
565     struct lexContext *lc;
566     int c, i, errors = 0;
567     FILE *spec_inf = 0;
568     WRBUF lineBuf;
569     char fname[256];
570
571 #if HAVE_TCL_H
572     if (spec->tcl_interp)
573     {
574         sprintf (fname, "%s.tflt", spec->name);
575         spec_inf = data1_path_fopen (spec->dh, fname, "r");
576     }
577 #endif
578     if (!spec_inf)
579     {
580         sprintf (fname, "%s.flt", spec->name);
581         spec_inf = data1_path_fopen (spec->dh, fname, "r");
582     }
583     if (!spec_inf)
584     {
585         logf (LOG_ERRNO|LOG_WARN, "cannot read spec file %s", spec->name);
586         return -1;
587     }
588     logf (LOG_LOG, "reading regx filter %s", fname);
589 #if HAVE_TCL_H
590     if (spec->tcl_interp)
591         logf (LOG_LOG, "Tcl enabled");
592 #endif
593     lineBuf = wrbuf_alloc();
594     spec->lineNo = 0;
595     c = getc (spec_inf);
596     while (c != EOF)
597     {
598         wrbuf_rewind (lineBuf);
599         if (c == '#' || c == '\n' || c == ' ' || c == '\t' || c == '\r')
600         {
601             while (c != '\n' && c != EOF)
602                 c = getc (spec_inf);
603             spec->lineNo++;
604             if (c == '\n')
605                 c = getc (spec_inf);
606         }
607         else
608         {
609             int addLine = 0;
610             
611             while (1)
612             {
613                 int c1 = c;
614                 wrbuf_putc(lineBuf, c);
615                 c = getc (spec_inf);
616                 while (c == '\r')
617                     c = getc (spec_inf);
618                 if (c == EOF)
619                     break;
620                 if (c1 == '\n')
621                 {
622                     if (c != ' ' && c != '\t')
623                         break;
624                     addLine++;
625                 }
626             }
627             wrbuf_putc(lineBuf, '\0');
628             readOneSpec (spec, wrbuf_buf(lineBuf));
629             spec->lineNo += addLine;
630         }
631     }
632     fclose (spec_inf);
633     wrbuf_free(lineBuf, 1);
634
635 #if 0
636     debug_dfa_trav = 1;
637     debug_dfa_tran = 1;
638     debug_dfa_followpos = 1;
639     dfa_verbose = 1;
640 #endif
641     for (lc = spec->context; lc; lc = lc->next)
642     {
643         struct lexRule *rp;
644         lc->fastRule = (struct lexRuleInfo **)
645             xmalloc (sizeof(*lc->fastRule) * lc->ruleNo);
646         for (i = 0; i < lc->ruleNo; i++)
647             lc->fastRule[i] = NULL;
648         for (rp = lc->rules; rp; rp = rp->next)
649             lc->fastRule[rp->info.no] = &rp->info;
650         dfa_mkstate (lc->dfa);
651     }
652     if (errors)
653         return -1;
654     
655     return 0;
656 }
657
658 #if 0
659 static struct lexSpec *curLexSpec = NULL;
660 #endif
661
662 static void execData (struct lexSpec *spec,
663                       const char *ebuf, int elen, int formatted_text)
664 {
665     struct data1_node *res, *parent;
666     int org_len;
667
668     if (elen == 0) /* shouldn't happen, but it does! */
669         return ;
670 #if REGX_DEBUG
671     if (elen > 40)
672         logf (LOG_LOG, "data (%d bytes) %.15s ... %.*s", elen,
673               ebuf, 15, ebuf + elen-15);
674     else if (elen > 0)
675         logf (LOG_LOG, "data (%d bytes) %.*s", elen, elen, ebuf);
676     else 
677         logf (LOG_LOG, "data (%d bytes)", elen);
678 #endif
679         
680     if (spec->d1_level <= 1)
681         return;
682
683     parent = spec->d1_stack[spec->d1_level -1];
684     assert (parent);
685
686     if ((res = spec->d1_stack[spec->d1_level]) && res->which == DATA1N_data)
687         org_len = res->u.data.len;
688     else
689     {
690         org_len = 0;
691
692         res = data1_mk_node2 (spec->dh, spec->m, DATA1N_data, parent);
693         res->u.data.what = DATA1I_text;
694         res->u.data.len = 0;
695         res->u.data.formatted_text = formatted_text;
696         res->u.data.data = 0;
697         
698         if (spec->d1_stack[spec->d1_level])
699             spec->d1_stack[spec->d1_level]->next = res;
700         spec->d1_stack[spec->d1_level] = res;
701     }
702     if (org_len + elen >= spec->concatBuf[spec->d1_level].max)
703     {
704         char *old_buf, *new_buf;
705
706         spec->concatBuf[spec->d1_level].max = org_len + elen + 256;
707         new_buf = (char *) xmalloc (spec->concatBuf[spec->d1_level].max);
708         if ((old_buf = spec->concatBuf[spec->d1_level].buf))
709         {
710             memcpy (new_buf, old_buf, org_len);
711             xfree (old_buf);
712         }
713         spec->concatBuf[spec->d1_level].buf = new_buf;
714     }
715     memcpy (spec->concatBuf[spec->d1_level].buf + org_len, ebuf, elen);
716     res->u.data.len += elen;
717 }
718
719 static void execDataP (struct lexSpec *spec,
720                        const char *ebuf, int elen, int formatted_text)
721 {
722     execData (spec, ebuf, elen, formatted_text);
723 }
724
725 static void tagDataRelease (struct lexSpec *spec)
726 {
727     data1_node *res;
728     
729     if ((res = spec->d1_stack[spec->d1_level]) &&
730         res->which == DATA1N_data && 
731         res->u.data.what == DATA1I_text)
732     {
733         assert (!res->u.data.data);
734         assert (res->u.data.len > 0);
735         if (res->u.data.len > DATA1_LOCALDATA)
736             res->u.data.data = (char *) nmem_malloc (spec->m, res->u.data.len);
737         else
738             res->u.data.data = res->lbuf;
739         memcpy (res->u.data.data, spec->concatBuf[spec->d1_level].buf,
740                 res->u.data.len);
741     }
742 }
743
744 static void variantBegin (struct lexSpec *spec, 
745                           const char *class_str, int class_len,
746                           const char *type_str, int type_len,
747                           const char *value_str, int value_len)
748 {
749     struct data1_node *parent = spec->d1_stack[spec->d1_level -1];
750     char tclass[DATA1_MAX_SYMBOL], ttype[DATA1_MAX_SYMBOL];
751     data1_vartype *tp;
752     int i;
753     data1_node *res;
754
755     if (spec->d1_level == 0)
756     {
757         logf (LOG_WARN, "in variant begin. No record type defined");
758         return ;
759     }
760     if (class_len >= DATA1_MAX_SYMBOL)
761         class_len = DATA1_MAX_SYMBOL-1;
762     memcpy (tclass, class_str, class_len);
763     tclass[class_len] = '\0';
764
765     if (type_len >= DATA1_MAX_SYMBOL)
766         type_len = DATA1_MAX_SYMBOL-1;
767     memcpy (ttype, type_str, type_len);
768     ttype[type_len] = '\0';
769
770 #if REGX_DEBUG 
771     logf (LOG_LOG, "variant begin %s %s (%d)", tclass, ttype,
772           spec->d1_level);
773 #endif
774
775     if (!(tp =
776           data1_getvartypebyct(spec->dh, parent->root->u.root.absyn->varset,
777                                tclass, ttype)))
778         return;
779     
780     if (parent->which != DATA1N_variant)
781     {
782         res = data1_mk_node2 (spec->dh, spec->m, DATA1N_variant, parent);
783         if (spec->d1_stack[spec->d1_level])
784             tagDataRelease (spec);
785         spec->d1_stack[spec->d1_level] = res;
786         spec->d1_stack[++(spec->d1_level)] = NULL;
787     }
788     for (i = spec->d1_level-1; spec->d1_stack[i]->which == DATA1N_variant; i--)
789         if (spec->d1_stack[i]->u.variant.type == tp)
790         {
791             spec->d1_level = i;
792             break;
793         }
794
795 #if REGX_DEBUG 
796     logf (LOG_LOG, "variant node (%d)", spec->d1_level);
797 #endif
798     parent = spec->d1_stack[spec->d1_level-1];
799     res = data1_mk_node2 (spec->dh, spec->m, DATA1N_variant, parent);
800     res->u.variant.type = tp;
801
802     if (value_len >= DATA1_LOCALDATA)
803         value_len =DATA1_LOCALDATA-1;
804     memcpy (res->lbuf, value_str, value_len);
805     res->lbuf[value_len] = '\0';
806
807     res->u.variant.value = res->lbuf;
808     
809     if (spec->d1_stack[spec->d1_level])
810         tagDataRelease (spec);
811     spec->d1_stack[spec->d1_level] = res;
812     spec->d1_stack[++(spec->d1_level)] = NULL;
813 }
814
815 static void tagStrip (const char **tag, int *len)
816 {
817     int i;
818
819     for (i = *len; i > 0 && isspace((*tag)[i-1]); --i)
820         ;
821     *len = i;
822     for (i = 0; i < *len && isspace((*tag)[i]); i++)
823         ;
824     *tag += i;
825     *len -= i;
826 }
827
828 static void tagBegin (struct lexSpec *spec, 
829                       const char *tag, int len)
830 {
831     if (spec->d1_level == 0)
832     {
833         logf (LOG_WARN, "in element begin. No record type defined");
834         return ;
835     }
836     tagStrip (&tag, &len);
837     if (spec->d1_stack[spec->d1_level])
838         tagDataRelease (spec);
839
840 #if REGX_DEBUG 
841     logf (LOG_LOG, "begin tag %s (%d)", tag, spec->d1_level);
842 #endif
843
844     spec->d1_stack[spec->d1_level] = data1_mk_tag_n (
845         spec->dh, spec->m, tag, len, 0, spec->d1_stack[spec->d1_level -1]);
846     spec->d1_stack[++(spec->d1_level)] = NULL;
847 }
848
849 static void tagEnd (struct lexSpec *spec, int min_level,
850                     const char *tag, int len)
851 {
852     tagStrip (&tag, &len);
853     while (spec->d1_level > min_level)
854     {
855         tagDataRelease (spec);
856         (spec->d1_level)--;
857         if (spec->d1_level == 0)
858             break;
859         if ((spec->d1_stack[spec->d1_level]->which == DATA1N_tag) &&
860             (!tag ||
861              (strlen(spec->d1_stack[spec->d1_level]->u.tag.tag) ==
862               (size_t) len &&
863               !memcmp (spec->d1_stack[spec->d1_level]->u.tag.tag, tag, len))))
864             break;
865     }
866 #if REGX_DEBUG
867     logf (LOG_LOG, "end tag (%d)", spec->d1_level);
868 #endif
869 }
870
871
872 static int tryMatch (struct lexSpec *spec, int *pptr, int *mptr,
873                      struct DFA *dfa)
874 {
875     struct DFA_state *state = dfa->states[0];
876     struct DFA_tran *t;
877     unsigned char c;
878     unsigned char c_prev = 0;
879     int ptr = *pptr;          /* current pointer */
880     int start_ptr = *pptr;    /* first char of match */
881     int last_ptr = 0;         /* last char of match */
882     int last_rule = 0;        /* rule number of current match */
883     int i;
884
885     while (1)
886     {
887         c = f_win_advance (spec, &ptr);
888         if (ptr == F_WIN_EOF)
889         {
890             if (last_rule)
891             {
892                 *mptr = start_ptr;
893                 *pptr = last_ptr;
894                 return 1;
895             }
896             break;
897         }
898         t = state->trans;
899         i = state->tran_no;
900         while (1)
901             if (--i < 0)
902             {
903                 if (last_rule)
904                 {
905                     *mptr = start_ptr;     /* match starts here */
906                     *pptr = last_ptr;      /* match end here (+1) */
907                     return 1;
908                 }
909                 state = dfa->states[0];
910                 start_ptr = ptr;
911                 c_prev = c;
912                 break;
913             }
914             else if (c >= t->ch[0] && c <= t->ch[1])
915             {
916                 state = dfa->states[t->to];
917                 if (state->rule_no)
918                 {
919                     if (c_prev == '\n')
920                     {
921                         last_rule = state->rule_no;
922                         last_ptr = ptr;
923                     }
924                     else
925                     {
926                         last_rule = state->rule_nno;
927                         last_ptr = ptr;
928                     }
929                 }
930                 break;
931             }
932             else
933                 t++;
934     }
935     return 0;
936 }
937
938 static int execTok (struct lexSpec *spec, const char **src,
939                     const char **tokBuf, int *tokLen)
940 {
941     const char *s = *src;
942
943     while (*s == ' ' || *s == '\t')
944         s++;
945     if (!*s)
946         return 0;
947     if (*s == '$' && s[1] >= '0' && s[1] <= '9')
948     {
949         int n = 0;
950         s++;
951         while (*s >= '0' && *s <= '9')
952             n = n*10 + (*s++ -'0');
953         if (spec->arg_no == 0)
954         {
955             *tokBuf = "";
956             *tokLen = 0;
957         }
958         else
959         {
960             if (n >= spec->arg_no)
961                 n = spec->arg_no-1;
962             *tokBuf = f_win_get (spec, spec->arg_start[n], spec->arg_end[n],
963                                  tokLen);
964         }
965     }
966     else if (*s == '\"')
967     {
968         *tokBuf = ++s;
969         while (*s && *s != '\"')
970             s++;
971         *tokLen = s - *tokBuf;
972         if (*s)
973             s++;
974         *src = s;
975     }
976     else if (*s == '\n' || *s == ';')
977     {
978         *src = s+1;
979         return 1;
980     }
981     else if (*s == '-')
982     {
983         *tokBuf = s++;
984         while (*s && *s != ' ' && *s != '\t' && *s != '\n' && *s != '\r' &&
985                *s != ';')
986             s++;
987         *tokLen = s - *tokBuf;
988         *src = s;
989         return 3;
990     }
991     else
992     {
993         *tokBuf = s++;
994         while (*s && *s != ' ' && *s != '\t' && *s != '\n' && *s != '\r' &&
995                *s != ';')
996             s++;
997         *tokLen = s - *tokBuf;
998     }
999     *src = s;
1000     return 2;
1001 }
1002
1003 static char *regxStrz (const char *src, int len, char *str)
1004 {
1005     if (len > 63)
1006         len = 63;
1007     memcpy (str, src, len);
1008     str[len] = '\0';
1009     return str;
1010 }
1011
1012 #if HAVE_TCL_H
1013 static int cmd_tcl_begin (ClientData clientData, Tcl_Interp *interp,
1014                           int argc, char **argv)
1015 {
1016     struct lexSpec *spec = (struct lexSpec *) clientData;
1017     if (argc < 2)
1018         return TCL_ERROR;
1019     if (!strcmp(argv[1], "record") && argc == 3)
1020     {
1021         char *absynName = argv[2];
1022         data1_node *res;
1023
1024 #if REGX_DEBUG
1025         logf (LOG_LOG, "begin record %s", absynName);
1026 #endif
1027         res = data1_mk_root (spec->dh, spec->m, absynName);
1028         
1029         spec->d1_stack[spec->d1_level++] = res;
1030
1031         res = data1_mk_tag (spec->dh, spec->m, absynName, 0, res);
1032
1033         spec->d1_stack[spec->d1_level++] = res;
1034
1035         spec->d1_stack[spec->d1_level] = NULL;
1036     }
1037     else if (!strcmp(argv[1], "element") && argc == 3)
1038     {
1039         tagBegin (spec, argv[2], strlen(argv[2]));
1040     }
1041     else if (!strcmp (argv[1], "variant") && argc == 5)
1042     {
1043         variantBegin (spec, argv[2], strlen(argv[2]),
1044                       argv[3], strlen(argv[3]),
1045                       argv[4], strlen(argv[4]));
1046     }
1047     else if (!strcmp (argv[1], "context") && argc == 3)
1048     {
1049         struct lexContext *lc = spec->context;
1050 #if REGX_DEBUG
1051         logf (LOG_LOG, "begin context %s",argv[2]);
1052 #endif
1053         while (lc && strcmp (argv[2], lc->name))
1054             lc = lc->next;
1055         if (lc)
1056         {
1057             spec->context_stack[++(spec->context_stack_top)] = lc;
1058         }
1059         else
1060             logf (LOG_WARN, "unknown context %s", argv[2]);
1061     }
1062     else
1063         return TCL_ERROR;
1064     return TCL_OK;
1065 }
1066
1067 static int cmd_tcl_end (ClientData clientData, Tcl_Interp *interp,
1068                         int argc, char **argv)
1069 {
1070     struct lexSpec *spec = (struct lexSpec *) clientData;
1071     if (argc < 2)
1072         return TCL_ERROR;
1073     
1074     if (!strcmp (argv[1], "record"))
1075     {
1076         while (spec->d1_level)
1077         {
1078             tagDataRelease (spec);
1079             (spec->d1_level)--;
1080         }
1081 #if REGX_DEBUG
1082         logf (LOG_LOG, "end record");
1083 #endif
1084         spec->stop_flag = 1;
1085     }
1086     else if (!strcmp (argv[1], "element"))
1087     {
1088         int min_level = 1;
1089         char *element = 0;
1090         if (argc >= 3 && !strcmp(argv[2], "-record"))
1091         {
1092             min_level = 0;
1093             if (argc == 4)
1094                 element = argv[3];
1095         }
1096         else
1097             if (argc == 3)
1098                 element = argv[2];
1099         tagEnd (spec, min_level, element, (element ? strlen(element) : 0));
1100         if (spec->d1_level == 0)
1101         {
1102 #if REGX_DEBUG
1103             logf (LOG_LOG, "end element end records");
1104 #endif
1105             spec->stop_flag = 1;
1106         }
1107     }
1108     else if (!strcmp (argv[1], "context"))
1109     {
1110 #if REGX_DEBUG
1111         logf (LOG_LOG, "end context");
1112 #endif
1113         if (spec->context_stack_top)
1114             (spec->context_stack_top)--;
1115     }
1116     else
1117         return TCL_ERROR;
1118     return TCL_OK;
1119 }
1120
1121 static int cmd_tcl_data (ClientData clientData, Tcl_Interp *interp,
1122                          int argc, char **argv)
1123 {
1124     int argi = 1;
1125     int textFlag = 0;
1126     const char *element = 0;
1127     struct lexSpec *spec = (struct lexSpec *) clientData;
1128     
1129     while (argi < argc)
1130     {
1131         if (!strcmp("-text", argv[argi]))
1132         {
1133             textFlag = 1;
1134             argi++;
1135         }
1136         else if (!strcmp("-element", argv[argi]))
1137         {
1138             argi++;
1139             if (argi < argc)
1140                 element = argv[argi++];
1141         }
1142         else
1143             break;
1144     }
1145     if (element)
1146         tagBegin (spec, element, strlen(element));
1147
1148     while (argi < argc)
1149     {
1150 #if TCL_MAJOR_VERSION > 8 || (TCL_MAJOR_VERSION == 8 && TCL_MINOR_VERSION > 0)
1151         Tcl_DString ds;
1152         char *native = Tcl_UtfToExternalDString(0, argv[argi], -1, &ds);
1153         execData (spec, native, strlen(native), textFlag);
1154         Tcl_DStringFree (&ds);
1155 #else
1156         execData (spec, argv[argi], strlen(argv[argi]), textFlag);
1157 #endif
1158         argi++;
1159     }
1160     if (element)
1161         tagEnd (spec, 1, NULL, 0);
1162     return TCL_OK;
1163 }
1164
1165 static int cmd_tcl_unread (ClientData clientData, Tcl_Interp *interp,
1166                            int argc, char **argv)
1167 {
1168     struct lexSpec *spec = (struct lexSpec *) clientData;
1169     int argi = 1;
1170     int offset = 0;
1171     int no;
1172     
1173     while (argi < argc)
1174     {
1175         if (!strcmp("-offset", argv[argi]))
1176         {
1177             argi++;
1178             if (argi < argc)
1179             {
1180                 offset = atoi(argv[argi]);
1181                 argi++;
1182             }
1183         }
1184         else
1185             break;
1186     }
1187     if (argi != argc-1)
1188         return TCL_ERROR;
1189     no = atoi(argv[argi]);
1190     if (no >= spec->arg_no)
1191         no = spec->arg_no - 1;
1192     spec->ptr = spec->arg_start[no] + offset;
1193     return TCL_OK;
1194 }
1195
1196 static void execTcl (struct lexSpec *spec, struct regxCode *code)
1197 {   
1198     int i;
1199     int ret;
1200     for (i = 0; i < spec->arg_no; i++)
1201     {
1202         char var_name[10], *var_buf;
1203         int var_len, ch;
1204         
1205         sprintf (var_name, "%d", i);
1206         var_buf = f_win_get (spec, spec->arg_start[i], spec->arg_end[i],
1207                              &var_len); 
1208         if (var_buf)
1209         {
1210             ch = var_buf[var_len];
1211             var_buf[var_len] = '\0';
1212             Tcl_SetVar (spec->tcl_interp, var_name, var_buf, 0);
1213             var_buf[var_len] = ch;
1214         }
1215     }
1216 #if HAVE_TCL_OBJECTS
1217     ret = Tcl_GlobalEvalObj(spec->tcl_interp, code->tcl_obj);
1218 #else
1219     ret = Tcl_GlobalEval (spec->tcl_interp, code->str);
1220 #endif
1221     if (ret != TCL_OK)
1222     {
1223         const char *err = Tcl_GetVar(spec->tcl_interp, "errorInfo", 0);
1224         logf(LOG_FATAL, "Tcl error, line=%d, \"%s\"\n%s", 
1225             spec->tcl_interp->errorLine,
1226             spec->tcl_interp->result,
1227             err ? err : "[NO ERRORINFO]");
1228     }
1229 }
1230 /* HAVE_TCL_H */
1231 #endif
1232
1233 static void execCode (struct lexSpec *spec, struct regxCode *code)
1234 {
1235     const char *s = code->str;
1236     int cmd_len, r;
1237     const char *cmd_str;
1238     
1239     r = execTok (spec, &s, &cmd_str, &cmd_len);
1240     while (r)
1241     {
1242         char *p, ptmp[64];
1243         
1244         if (r == 1)
1245         {
1246             r = execTok (spec, &s, &cmd_str, &cmd_len);
1247             continue;
1248         }
1249         p = regxStrz (cmd_str, cmd_len, ptmp);
1250         if (!strcmp (p, "begin"))
1251         {
1252             r = execTok (spec, &s, &cmd_str, &cmd_len);
1253             if (r < 2)
1254             {
1255                 logf (LOG_WARN, "missing keyword after 'begin'");
1256                 continue;
1257             }
1258             p = regxStrz (cmd_str, cmd_len, ptmp);
1259             if (!strcmp (p, "record"))
1260             {
1261                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1262                 if (r < 2)
1263                     continue;
1264                 if (spec->d1_level == 0)
1265                 {
1266                     static char absynName[64];
1267                     data1_node *res;
1268
1269                     if (cmd_len > 63)
1270                         cmd_len = 63;
1271                     memcpy (absynName, cmd_str, cmd_len);
1272                     absynName[cmd_len] = '\0';
1273 #if REGX_DEBUG
1274                     logf (LOG_LOG, "begin record %s", absynName);
1275 #endif
1276                     res = data1_mk_root (spec->dh, spec->m, absynName);
1277                     
1278                     spec->d1_stack[spec->d1_level++] = res;
1279
1280                     res = data1_mk_tag (spec->dh, spec->m, absynName, 0, res);
1281
1282                     spec->d1_stack[spec->d1_level++] = res;
1283
1284                     spec->d1_stack[spec->d1_level] = NULL;
1285                 }
1286                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1287             }
1288             else if (!strcmp (p, "element"))
1289             {
1290                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1291                 if (r < 2)
1292                     continue;
1293                 tagBegin (spec, cmd_str, cmd_len);
1294                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1295             } 
1296             else if (!strcmp (p, "variant"))
1297             {
1298                 int class_len;
1299                 const char *class_str = NULL;
1300                 int type_len;
1301                 const char *type_str = NULL;
1302                 int value_len;
1303                 const char *value_str = NULL;
1304                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1305                 if (r < 2)
1306                     continue;
1307                 class_str = cmd_str;
1308                 class_len = cmd_len;
1309                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1310                 if (r < 2)
1311                     continue;
1312                 type_str = cmd_str;
1313                 type_len = cmd_len;
1314
1315                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1316                 if (r < 2)
1317                     continue;
1318                 value_str = cmd_str;
1319                 value_len = cmd_len;
1320
1321                 variantBegin (spec, class_str, class_len,
1322                               type_str, type_len, value_str, value_len);
1323                 
1324                 
1325                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1326             }
1327             else if (!strcmp (p, "context"))
1328             {
1329                 if (r > 1)
1330                 {
1331                     struct lexContext *lc = spec->context;
1332                     r = execTok (spec, &s, &cmd_str, &cmd_len);
1333                     p = regxStrz (cmd_str, cmd_len, ptmp);
1334 #if REGX_DEBUG
1335                     logf (LOG_LOG, "begin context %s", p);
1336 #endif
1337                     while (lc && strcmp (p, lc->name))
1338                         lc = lc->next;
1339                     if (lc)
1340                         spec->context_stack[++(spec->context_stack_top)] = lc;
1341                     else
1342                         logf (LOG_WARN, "unknown context %s", p);
1343                     
1344                 }
1345                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1346             }
1347             else
1348             {
1349                 logf (LOG_WARN, "bad keyword '%s' after begin", p);
1350             }
1351         }
1352         else if (!strcmp (p, "end"))
1353         {
1354             r = execTok (spec, &s, &cmd_str, &cmd_len);
1355             if (r < 2)
1356             {
1357                 logf (LOG_WARN, "missing keyword after 'end'");
1358                 continue;
1359             }
1360             p = regxStrz (cmd_str, cmd_len, ptmp);
1361             if (!strcmp (p, "record"))
1362             {
1363                 while (spec->d1_level)
1364                 {
1365                     tagDataRelease (spec);
1366                     (spec->d1_level)--;
1367                 }
1368                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1369 #if REGX_DEBUG
1370                 logf (LOG_LOG, "end record");
1371 #endif
1372                 spec->stop_flag = 1;
1373             }
1374             else if (!strcmp (p, "element"))
1375             {
1376                 int min_level = 1;
1377                 while ((r = execTok (spec, &s, &cmd_str, &cmd_len)) == 3)
1378                 {
1379                     if (cmd_len==7 && !memcmp ("-record", cmd_str, cmd_len))
1380                         min_level = 0;
1381                 }
1382                 if (r > 2)
1383                 {
1384                     tagEnd (spec, min_level, cmd_str, cmd_len);
1385                     r = execTok (spec, &s, &cmd_str, &cmd_len);
1386                 }
1387                 else
1388                     tagEnd (spec, min_level, NULL, 0);
1389                 if (spec->d1_level == 0)
1390                 {
1391 #if REGX_DEBUG
1392                     logf (LOG_LOG, "end element end records");
1393 #endif
1394                     spec->stop_flag = 1;
1395                 }
1396
1397             }
1398             else if (!strcmp (p, "context"))
1399             {
1400 #if REGX_DEBUG
1401                 logf (LOG_LOG, "end context");
1402 #endif
1403                 if (spec->context_stack_top)
1404                     (spec->context_stack_top)--;
1405                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1406             }       
1407             else
1408                 logf (LOG_WARN, "bad keyword '%s' after end", p);
1409         }
1410         else if (!strcmp (p, "data"))
1411         {
1412             int textFlag = 0;
1413             int element_len;
1414             const char *element_str = NULL;
1415             
1416             while ((r = execTok (spec, &s, &cmd_str, &cmd_len)) == 3)
1417             {
1418                 if (cmd_len==5 && !memcmp ("-text", cmd_str, cmd_len))
1419                     textFlag = 1;
1420                 else if (cmd_len==8 && !memcmp ("-element", cmd_str, cmd_len))
1421                 {
1422                     r = execTok (spec, &s, &element_str, &element_len);
1423                     if (r < 2)
1424                         break;
1425                 }
1426                 else 
1427                     logf (LOG_WARN, "bad data option: %.*s",
1428                           cmd_len, cmd_str);
1429             }
1430             if (r != 2)
1431             {
1432                 logf (LOG_WARN, "missing data item after data");
1433                 continue;
1434             }
1435             if (element_str)
1436                 tagBegin (spec, element_str, element_len);
1437             do
1438             {
1439                 execData (spec, cmd_str, cmd_len,textFlag);
1440                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1441             } while (r > 1);
1442             if (element_str)
1443                 tagEnd (spec, 1, NULL, 0);
1444         }
1445         else if (!strcmp (p, "unread"))
1446         {
1447             int no, offset;
1448             r = execTok (spec, &s, &cmd_str, &cmd_len);
1449             if (r==3 && cmd_len == 7 && !memcmp ("-offset", cmd_str, cmd_len))
1450             {
1451                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1452                 if (r < 2)
1453                 {
1454                     logf (LOG_WARN, "missing number after -offset");
1455                     continue;
1456                 }
1457                 p = regxStrz (cmd_str, cmd_len, ptmp);
1458                 offset = atoi (p);
1459                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1460             }
1461             else
1462                 offset = 0;
1463             if (r < 2)
1464             {
1465                 logf (LOG_WARN, "missing index after unread command");
1466                 continue;
1467             }
1468             if (cmd_len != 1 || *cmd_str < '0' || *cmd_str > '9')
1469             {
1470                 logf (LOG_WARN, "bad index after unread command");
1471                 continue;
1472             }
1473             else
1474             {
1475                 no = *cmd_str - '0';
1476                 if (no >= spec->arg_no)
1477                     no = spec->arg_no - 1;
1478                 spec->ptr = spec->arg_start[no] + offset;
1479             }
1480             r = execTok (spec, &s, &cmd_str, &cmd_len);
1481         }
1482         else if (!strcmp (p, "context"))
1483         {
1484             if (r > 1)
1485             {
1486                 struct lexContext *lc = spec->context;
1487                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1488                 p = regxStrz (cmd_str, cmd_len, ptmp);
1489                 
1490                 while (lc && strcmp (p, lc->name))
1491                     lc = lc->next;
1492                 if (lc)
1493                     spec->context_stack[spec->context_stack_top] = lc;
1494                 else
1495                     logf (LOG_WARN, "unknown context %s", p);
1496
1497             }
1498             r = execTok (spec, &s, &cmd_str, &cmd_len);
1499         }
1500         else
1501         {
1502             logf (LOG_WARN, "unknown code command '%.*s'", cmd_len, cmd_str);
1503             r = execTok (spec, &s, &cmd_str, &cmd_len);
1504             continue;
1505         }
1506         if (r > 1)
1507         {
1508             logf (LOG_WARN, "ignoring token %.*s", cmd_len, cmd_str);
1509             do {
1510                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1511             } while (r > 1);
1512         }
1513     }
1514 }
1515
1516
1517 static int execAction (struct lexSpec *spec, struct lexRuleAction *ap,
1518                        int start_ptr, int *pptr)
1519 {
1520     int sptr;
1521     int arg_start[20];
1522     int arg_end[20];
1523     int arg_no = 1;
1524
1525     if (!ap)
1526         return 1;
1527     arg_start[0] = start_ptr;
1528     arg_end[0] = *pptr;
1529     spec->arg_start = arg_start;
1530     spec->arg_end = arg_end;
1531
1532     while (ap)
1533     {
1534         switch (ap->which)
1535         {
1536         case REGX_PATTERN:
1537             if (ap->u.pattern.body)
1538             {
1539                 arg_start[arg_no] = *pptr;
1540                 if (!tryMatch (spec, pptr, &sptr, ap->u.pattern.dfa))
1541                 {
1542                     arg_end[arg_no] = F_WIN_EOF;
1543                     arg_no++;
1544                     arg_start[arg_no] = F_WIN_EOF;
1545                     arg_end[arg_no] = F_WIN_EOF;
1546 /* return 1*/
1547                 }
1548                 else
1549                 {
1550                     arg_end[arg_no] = sptr;
1551                     arg_no++;
1552                     arg_start[arg_no] = sptr;
1553                     arg_end[arg_no] = *pptr;
1554                 }
1555             }
1556             else
1557             {
1558                 arg_start[arg_no] = *pptr;
1559                 if (!tryMatch (spec, pptr, &sptr, ap->u.pattern.dfa))
1560                     return 1;
1561                 if (sptr != arg_start[arg_no])
1562                     return 1;
1563                 arg_end[arg_no] = *pptr;
1564             }
1565             arg_no++;
1566             break;
1567         case REGX_CODE:
1568             spec->arg_no = arg_no;
1569             spec->ptr = *pptr;
1570 #if HAVE_TCL_H
1571             if (spec->tcl_interp)
1572                 execTcl(spec, ap->u.code);
1573             else
1574                 execCode (spec, ap->u.code);
1575 #else
1576             execCode (spec, ap->u.code);
1577 #endif
1578             *pptr = spec->ptr;
1579             if (spec->stop_flag)
1580                 return 0;
1581             break;
1582         case REGX_END:
1583             arg_start[arg_no] = *pptr;
1584             arg_end[arg_no] = F_WIN_EOF;
1585             arg_no++;
1586             *pptr = F_WIN_EOF;
1587         }
1588         ap = ap->next;
1589     }
1590     return 1;
1591 }
1592
1593 static int execRule (struct lexSpec *spec, struct lexContext *context,
1594                      int ruleNo, int start_ptr, int *pptr)
1595 {
1596 #if REGX_DEBUG
1597     logf (LOG_LOG, "exec rule %d", ruleNo);
1598 #endif
1599     return execAction (spec, context->fastRule[ruleNo]->actionList,
1600                        start_ptr, pptr);
1601 }
1602
1603 data1_node *lexNode (struct lexSpec *spec, int *ptr)
1604 {
1605     struct lexContext *context = spec->context_stack[spec->context_stack_top];
1606     struct DFA_state *state = context->dfa->states[0];
1607     struct DFA_tran *t;
1608     unsigned char c;
1609     unsigned char c_prev = '\n';
1610     int i;
1611     int last_rule = 0;        /* rule number of current match */
1612     int last_ptr = *ptr;      /* last char of match */
1613     int start_ptr = *ptr;     /* first char of match */
1614     int skip_ptr = *ptr;      /* first char of run */
1615
1616     while (1)
1617     {
1618         c = f_win_advance (spec, ptr);
1619         if (*ptr == F_WIN_EOF)
1620         {
1621             /* end of file met */
1622             if (last_rule)
1623             {
1624                 /* there was a match */
1625                 if (skip_ptr < start_ptr)
1626                 {
1627                     /* deal with chars that didn't match */
1628                     int size;
1629                     char *buf;
1630                     buf = f_win_get (spec, skip_ptr, start_ptr, &size);
1631                     execDataP (spec, buf, size, 0);
1632                 }
1633                 /* restore pointer */
1634                 *ptr = last_ptr;
1635                 /* execute rule */
1636                 if (!execRule (spec, context, last_rule, start_ptr, ptr))
1637                     break;
1638                 /* restore skip pointer */
1639                 skip_ptr = *ptr;
1640                 last_rule = 0;
1641             }
1642             else if (skip_ptr < *ptr)
1643             {
1644                 /* deal with chars that didn't match */
1645                 int size;
1646                 char *buf;
1647                 buf = f_win_get (spec, skip_ptr, *ptr, &size);
1648                 execDataP (spec, buf, size, 0);
1649             }
1650             if (*ptr == F_WIN_EOF)
1651                 break;
1652         }
1653         t = state->trans;
1654         i = state->tran_no;
1655         while (1)
1656             if (--i < 0)
1657             {   /* no transition for character c ... */
1658                 if (last_rule)
1659                 {
1660                     if (skip_ptr < start_ptr)
1661                     {
1662                         /* deal with chars that didn't match */
1663                         int size;
1664                         char *buf;
1665                         buf = f_win_get (spec, skip_ptr, start_ptr, &size);
1666                         execDataP (spec, buf, size, 0);
1667                     }
1668                     /* restore pointer */
1669                     *ptr = last_ptr;
1670                     if (!execRule (spec, context, last_rule, start_ptr, ptr))
1671                     {
1672                         if (spec->f_win_ef && *ptr != F_WIN_EOF)
1673                         {
1674 #if REGX_DEBUG
1675                             logf (LOG_LOG, "regx: endf ptr=%d", *ptr);
1676 #endif
1677                             (*spec->f_win_ef)(spec->f_win_fh, *ptr);
1678                         }
1679                         return NULL;
1680                     }
1681                     context = spec->context_stack[spec->context_stack_top];
1682                     skip_ptr = *ptr;
1683                     last_rule = 0;
1684                     last_ptr = start_ptr = *ptr;
1685                     if (start_ptr > 0)
1686                     {
1687                         --start_ptr;
1688                         c_prev = f_win_advance (spec, &start_ptr);
1689                     }
1690                 }
1691                 else
1692                 {
1693                     c_prev = f_win_advance (spec, &start_ptr);
1694                     *ptr = start_ptr;
1695                 }
1696                 state = context->dfa->states[0];
1697                 break;
1698             }
1699             else if (c >= t->ch[0] && c <= t->ch[1])
1700             {   /* transition ... */
1701                 state = context->dfa->states[t->to];
1702                 if (state->rule_no)
1703                 {
1704                     if (c_prev == '\n')
1705                     {
1706                         last_rule = state->rule_no;
1707                         last_ptr = *ptr;
1708                     } 
1709                     else if (state->rule_nno)
1710                     {
1711                         last_rule = state->rule_nno;
1712                         last_ptr = *ptr;
1713                     }
1714                 }
1715                 break;
1716             }
1717             else
1718                 t++;
1719     }
1720     return NULL;
1721 }
1722
1723 static data1_node *lexRoot (struct lexSpec *spec, off_t offset,
1724                             const char *context_name)
1725 {
1726     struct lexContext *lt = spec->context;
1727     int ptr = offset;
1728
1729     spec->stop_flag = 0;
1730     spec->d1_level = 0;
1731     spec->context_stack_top = 0;    
1732     while (lt)
1733     {
1734         if (!strcmp (lt->name, context_name))
1735             break;
1736         lt = lt->next;
1737     }
1738     if (!lt)
1739     {
1740         logf (LOG_WARN, "cannot find context %s", context_name);
1741         return NULL;
1742     }
1743     spec->context_stack[spec->context_stack_top] = lt;
1744     spec->d1_stack[spec->d1_level] = NULL;
1745 #if 1
1746     if (!lt->initFlag)
1747     {
1748         lt->initFlag = 1;
1749         execAction (spec, lt->initActionList, ptr, &ptr);
1750     }
1751 #endif
1752     execAction (spec, lt->beginActionList, ptr, &ptr);
1753     lexNode (spec, &ptr);
1754     while (spec->d1_level)
1755     {
1756         tagDataRelease (spec);
1757         (spec->d1_level)--;
1758     }
1759     execAction (spec, lt->endActionList, ptr, &ptr);
1760     return spec->d1_stack[0];
1761 }
1762
1763 void grs_destroy(void *clientData)
1764 {
1765     struct lexSpecs *specs = (struct lexSpecs *) clientData;
1766     if (specs->spec)
1767     {
1768         lexSpecDestroy(&specs->spec);
1769     }
1770     xfree (specs);
1771 }
1772
1773 void *grs_init(void)
1774 {
1775     struct lexSpecs *specs = (struct lexSpecs *) xmalloc (sizeof(*specs));
1776     specs->spec = 0;
1777     return specs;
1778 }
1779
1780 data1_node *grs_read_regx (struct grs_read_info *p)
1781 {
1782     int res;
1783     struct lexSpecs *specs = (struct lexSpecs *) p->clientData;
1784     struct lexSpec **curLexSpec = &specs->spec;
1785
1786 #if REGX_DEBUG
1787     logf (LOG_LOG, "grs_read_regx");
1788 #endif
1789     if (!*curLexSpec || strcmp ((*curLexSpec)->name, p->type))
1790     {
1791         if (*curLexSpec)
1792             lexSpecDestroy (curLexSpec);
1793         *curLexSpec = lexSpecCreate (p->type, p->dh);
1794         res = readFileSpec (*curLexSpec);
1795         if (res)
1796         {
1797             lexSpecDestroy (curLexSpec);
1798             return NULL;
1799         }
1800     }
1801     (*curLexSpec)->dh = p->dh;
1802     if (!p->offset)
1803     {
1804         (*curLexSpec)->f_win_start = 0;
1805         (*curLexSpec)->f_win_end = 0;
1806         (*curLexSpec)->f_win_rf = p->readf;
1807         (*curLexSpec)->f_win_sf = p->seekf;
1808         (*curLexSpec)->f_win_fh = p->fh;
1809         (*curLexSpec)->f_win_ef = p->endf;
1810         (*curLexSpec)->f_win_size = 500000;
1811     }
1812     (*curLexSpec)->m = p->mem;
1813     return lexRoot (*curLexSpec, p->offset, "main");
1814 }
1815
1816 static struct recTypeGrs regx_type = {
1817     "regx",
1818     grs_init,
1819     grs_destroy,
1820     grs_read_regx
1821 };
1822
1823 RecTypeGrs recTypeGrs_regx = &regx_type;
1824
1825 #if HAVE_TCL_H
1826 data1_node *grs_read_tcl (struct grs_read_info *p)
1827 {
1828     int res;
1829     struct lexSpecs *specs = (struct lexSpecs *) p->clientData;
1830     struct lexSpec **curLexSpec = &specs->spec;
1831
1832 #if REGX_DEBUG
1833     logf (LOG_LOG, "grs_read_tcl");
1834 #endif
1835     if (!*curLexSpec || strcmp ((*curLexSpec)->name, p->type))
1836     {
1837         Tcl_Interp *tcl_interp;
1838         if (*curLexSpec)
1839             lexSpecDestroy (curLexSpec);
1840         *curLexSpec = lexSpecCreate (p->type, p->dh);
1841         Tcl_FindExecutable("");
1842         tcl_interp = (*curLexSpec)->tcl_interp = Tcl_CreateInterp();
1843         Tcl_Init(tcl_interp);
1844         Tcl_CreateCommand (tcl_interp, "begin", cmd_tcl_begin, *curLexSpec, 0);
1845         Tcl_CreateCommand (tcl_interp, "end", cmd_tcl_end, *curLexSpec, 0);
1846         Tcl_CreateCommand (tcl_interp, "data", cmd_tcl_data, *curLexSpec, 0);
1847         Tcl_CreateCommand (tcl_interp, "unread", cmd_tcl_unread,
1848                            *curLexSpec, 0);
1849         res = readFileSpec (*curLexSpec);
1850         if (res)
1851         {
1852             lexSpecDestroy (curLexSpec);
1853             return NULL;
1854         }
1855     }
1856     (*curLexSpec)->dh = p->dh;
1857     if (!p->offset)
1858     {
1859         (*curLexSpec)->f_win_start = 0;
1860         (*curLexSpec)->f_win_end = 0;
1861         (*curLexSpec)->f_win_rf = p->readf;
1862         (*curLexSpec)->f_win_sf = p->seekf;
1863         (*curLexSpec)->f_win_fh = p->fh;
1864         (*curLexSpec)->f_win_ef = p->endf;
1865         (*curLexSpec)->f_win_size = 500000;
1866     }
1867     (*curLexSpec)->m = p->mem;
1868     return lexRoot (*curLexSpec, p->offset, "main");
1869 }
1870
1871 static struct recTypeGrs tcl_type = {
1872     "tcl",
1873     grs_init,
1874     grs_destroy,
1875     grs_read_tcl
1876 };
1877
1878 RecTypeGrs recTypeGrs_tcl = &tcl_type;
1879 #endif