recctrl/regxread.c

   1 /* $Id: regxread.c,v 1.50 2004-05-25 12:13:15 adam Exp $
   2    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
   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 = 0;
 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_level = 0;
1052
1053         spec->d1_stack[spec->d1_level++] = res;
1054
1055         res = data1_mk_tag (spec->dh, spec->m, absynName, 0, res);
1056
1057         spec->d1_stack[spec->d1_level++] = res;
1058
1059         spec->d1_stack[spec->d1_level] = NULL;
1060     }
1061     else if (!strcmp(argv[1], "element") && argc == 3)
1062     {
1063         tagBegin (spec, argv[2], strlen(argv[2]));
1064     }
1065     else if (!strcmp (argv[1], "variant") && argc == 5)
1066     {
1067         variantBegin (spec, argv[2], strlen(argv[2]),
1068                       argv[3], strlen(argv[3]),
1069                       argv[4], strlen(argv[4]));
1070     }
1071     else if (!strcmp (argv[1], "context") && argc == 3)
1072     {
1073         struct lexContext *lc = spec->context;
1074 #if REGX_DEBUG
1075         logf (LOG_LOG, "begin context %s",argv[2]);
1076 #endif
1077         while (lc && strcmp (argv[2], lc->name))
1078             lc = lc->next;
1079         if (lc)
1080         {
1081             spec->context_stack[++(spec->context_stack_top)] = lc;
1082         }
1083         else
1084             logf (LOG_WARN, "unknown context %s", argv[2]);
1085     }
1086     else
1087         return TCL_ERROR;
1088     return TCL_OK;
1089 }
1090
1091 static int cmd_tcl_end (ClientData clientData, Tcl_Interp *interp,
1092                         int argc, char **argv)
1093 {
1094     struct lexSpec *spec = (struct lexSpec *) clientData;
1095     if (argc < 2)
1096         return TCL_ERROR;
1097
1098     if (!strcmp (argv[1], "record"))
1099     {
1100         while (spec->d1_level)
1101         {
1102             tagDataRelease (spec);
1103             (spec->d1_level)--;
1104         }
1105 #if REGX_DEBUG
1106         logf (LOG_LOG, "end record");
1107 #endif
1108         spec->stop_flag = 1;
1109     }
1110     else if (!strcmp (argv[1], "element"))
1111     {
1112         int min_level = 2;
1113         char *element = 0;
1114         if (argc >= 3 && !strcmp(argv[2], "-record"))
1115         {
1116             min_level = 0;
1117             if (argc == 4)
1118                 element = argv[3];
1119         }
1120         else
1121             if (argc == 3)
1122                 element = argv[2];
1123         tagEnd (spec, min_level, element, (element ? strlen(element) : 0));
1124         if (spec->d1_level <= 1)
1125         {
1126 #if REGX_DEBUG
1127             logf (LOG_LOG, "end element end records");
1128 #endif
1129             spec->stop_flag = 1;
1130         }
1131     }
1132     else if (!strcmp (argv[1], "context"))
1133     {
1134 #if REGX_DEBUG
1135         logf (LOG_LOG, "end context");
1136 #endif
1137         if (spec->context_stack_top)
1138             (spec->context_stack_top)--;
1139     }
1140     else
1141         return TCL_ERROR;
1142     return TCL_OK;
1143 }
1144
1145 static int cmd_tcl_data (ClientData clientData, Tcl_Interp *interp,
1146                          int argc, char **argv)
1147 {
1148     int argi = 1;
1149     int textFlag = 0;
1150     const char *element = 0;
1151     struct lexSpec *spec = (struct lexSpec *) clientData;
1152
1153     while (argi < argc)
1154     {
1155         if (!strcmp("-text", argv[argi]))
1156         {
1157             textFlag = 1;
1158             argi++;
1159         }
1160         else if (!strcmp("-element", argv[argi]))
1161         {
1162             argi++;
1163             if (argi < argc)
1164                 element = argv[argi++];
1165         }
1166         else
1167             break;
1168     }
1169     if (element)
1170         tagBegin (spec, element, strlen(element));
1171
1172     while (argi < argc)
1173     {
1174 #if TCL_MAJOR_VERSION > 8 || (TCL_MAJOR_VERSION == 8 && TCL_MINOR_VERSION > 0)
1175         Tcl_DString ds;
1176         char *native = Tcl_UtfToExternalDString(0, argv[argi], -1, &ds);
1177         execData (spec, native, strlen(native), textFlag);
1178         Tcl_DStringFree (&ds);
1179 #else
1180         execData (spec, argv[argi], strlen(argv[argi]), textFlag);
1181 #endif
1182         argi++;
1183     }
1184     if (element)
1185         tagEnd (spec, 2, NULL, 0);
1186     return TCL_OK;
1187 }
1188
1189 static int cmd_tcl_unread (ClientData clientData, Tcl_Interp *interp,
1190                            int argc, char **argv)
1191 {
1192     struct lexSpec *spec = (struct lexSpec *) clientData;
1193     int argi = 1;
1194     int offset = 0;
1195     int no;
1196
1197     while (argi < argc)
1198     {
1199         if (!strcmp("-offset", argv[argi]))
1200         {
1201             argi++;
1202             if (argi < argc)
1203             {
1204                 offset = atoi(argv[argi]);
1205                 argi++;
1206             }
1207         }
1208         else
1209             break;
1210     }
1211     if (argi != argc-1)
1212         return TCL_ERROR;
1213     no = atoi(argv[argi]);
1214     if (no >= spec->arg_no)
1215         no = spec->arg_no - 1;
1216     spec->ptr = spec->arg_start[no] + offset;
1217     return TCL_OK;
1218 }
1219
1220 static void execTcl (struct lexSpec *spec, struct regxCode *code)
1221 {
1222     int i;
1223     int ret;
1224     for (i = 0; i < spec->arg_no; i++)
1225     {
1226         char var_name[10], *var_buf;
1227         int var_len, ch;
1228
1229         sprintf (var_name, "%d", i);
1230         var_buf = f_win_get (spec, spec->arg_start[i], spec->arg_end[i],
1231                              &var_len);
1232         if (var_buf)
1233         {
1234             ch = var_buf[var_len];
1235             var_buf[var_len] = '\0';
1236             Tcl_SetVar (spec->tcl_interp, var_name, var_buf, 0);
1237             var_buf[var_len] = ch;
1238         }
1239     }
1240 #if HAVE_TCL_OBJECTS
1241     ret = Tcl_GlobalEvalObj(spec->tcl_interp, code->tcl_obj);
1242 #else
1243     ret = Tcl_GlobalEval (spec->tcl_interp, code->str);
1244 #endif
1245     if (ret != TCL_OK)
1246     {
1247         const char *err = Tcl_GetVar(spec->tcl_interp, "errorInfo", 0);
1248         logf(LOG_FATAL, "Tcl error, line=%d, \"%s\"\n%s",
1249             spec->tcl_interp->errorLine,
1250             spec->tcl_interp->result,
1251             err ? err : "[NO ERRORINFO]");
1252     }
1253 }
1254 /* HAVE_TCL_H */
1255 #endif
1256
1257 static void execCode (struct lexSpec *spec, struct regxCode *code)
1258 {
1259     const char *s = code->str;
1260     int cmd_len, r;
1261     const char *cmd_str;
1262
1263     r = execTok (spec, &s, &cmd_str, &cmd_len);
1264     while (r)
1265     {
1266         char *p, ptmp[64];
1267
1268         if (r == 1)
1269         {
1270             r = execTok (spec, &s, &cmd_str, &cmd_len);
1271             continue;
1272         }
1273         p = regxStrz (cmd_str, cmd_len, ptmp);
1274         if (!strcmp (p, "begin"))
1275         {
1276             r = execTok (spec, &s, &cmd_str, &cmd_len);
1277             if (r < 2)
1278             {
1279                 logf (LOG_WARN, "missing keyword after 'begin'");
1280                 continue;
1281             }
1282             p = regxStrz (cmd_str, cmd_len, ptmp);
1283             if (!strcmp (p, "record"))
1284             {
1285                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1286                 if (r < 2)
1287                     continue;
1288                 if (spec->d1_level <= 1)
1289                 {
1290                     static char absynName[64];
1291                     data1_node *res;
1292
1293                     if (cmd_len > 63)
1294                         cmd_len = 63;
1295                     memcpy (absynName, cmd_str, cmd_len);
1296                     absynName[cmd_len] = '\0';
1297 #if REGX_DEBUG
1298                     logf (LOG_LOG, "begin record %s", absynName);
1299 #endif
1300                     res = data1_mk_root (spec->dh, spec->m, absynName);
1301
1302                     spec->d1_level = 0;
1303
1304                     spec->d1_stack[spec->d1_level++] = res;
1305
1306                     res = data1_mk_tag (spec->dh, spec->m, absynName, 0, res);
1307
1308                     spec->d1_stack[spec->d1_level++] = res;
1309
1310                     spec->d1_stack[spec->d1_level] = NULL;
1311                 }
1312                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1313             }
1314             else if (!strcmp (p, "element"))
1315             {
1316                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1317                 if (r < 2)
1318                     continue;
1319                 tagBegin (spec, cmd_str, cmd_len);
1320                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1321             }
1322             else if (!strcmp (p, "variant"))
1323             {
1324                 int class_len;
1325                 const char *class_str = NULL;
1326                 int type_len;
1327                 const char *type_str = NULL;
1328                 int value_len;
1329                 const char *value_str = NULL;
1330                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1331                 if (r < 2)
1332                     continue;
1333                 class_str = cmd_str;
1334                 class_len = cmd_len;
1335                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1336                 if (r < 2)
1337                     continue;
1338                 type_str = cmd_str;
1339                 type_len = cmd_len;
1340
1341                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1342                 if (r < 2)
1343                     continue;
1344                 value_str = cmd_str;
1345                 value_len = cmd_len;
1346
1347                 variantBegin (spec, class_str, class_len,
1348                               type_str, type_len, value_str, value_len);
1349
1350
1351                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1352             }
1353             else if (!strcmp (p, "context"))
1354             {
1355                 if (r > 1)
1356                 {
1357                     struct lexContext *lc = spec->context;
1358                     r = execTok (spec, &s, &cmd_str, &cmd_len);
1359                     p = regxStrz (cmd_str, cmd_len, ptmp);
1360 #if REGX_DEBUG
1361                     logf (LOG_LOG, "begin context %s", p);
1362 #endif
1363                     while (lc && strcmp (p, lc->name))
1364                         lc = lc->next;
1365                     if (lc)
1366                         spec->context_stack[++(spec->context_stack_top)] = lc;
1367                     else
1368                         logf (LOG_WARN, "unknown context %s", p);
1369
1370                 }
1371                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1372             }
1373             else
1374             {
1375                 logf (LOG_WARN, "bad keyword '%s' after begin", p);
1376             }
1377         }
1378         else if (!strcmp (p, "end"))
1379         {
1380             r = execTok (spec, &s, &cmd_str, &cmd_len);
1381             if (r < 2)
1382             {
1383                 logf (LOG_WARN, "missing keyword after 'end'");
1384                 continue;
1385             }
1386             p = regxStrz (cmd_str, cmd_len, ptmp);
1387             if (!strcmp (p, "record"))
1388             {
1389                 while (spec->d1_level)
1390                 {
1391                     tagDataRelease (spec);
1392                     (spec->d1_level)--;
1393                 }
1394                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1395 #if REGX_DEBUG
1396                 logf (LOG_LOG, "end record");
1397 #endif
1398                 spec->stop_flag = 1;
1399             }
1400             else if (!strcmp (p, "element"))
1401             {
1402                 int min_level = 2;
1403                 while ((r = execTok (spec, &s, &cmd_str, &cmd_len)) == 3)
1404                 {
1405                     if (cmd_len==7 && !memcmp ("-record", cmd_str, cmd_len))
1406                         min_level = 0;
1407                 }
1408                 if (r > 2)
1409                 {
1410                     tagEnd (spec, min_level, cmd_str, cmd_len);
1411                     r = execTok (spec, &s, &cmd_str, &cmd_len);
1412                 }
1413                 else
1414                     tagEnd (spec, min_level, NULL, 0);
1415                 if (spec->d1_level <= 1)
1416                 {
1417 #if REGX_DEBUG
1418                     logf (LOG_LOG, "end element end records");
1419 #endif
1420                     spec->stop_flag = 1;
1421                 }
1422
1423             }
1424             else if (!strcmp (p, "context"))
1425             {
1426 #if REGX_DEBUG
1427                 logf (LOG_LOG, "end context");
1428 #endif
1429                 if (spec->context_stack_top)
1430                     (spec->context_stack_top)--;
1431                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1432             }
1433             else
1434                 logf (LOG_WARN, "bad keyword '%s' after end", p);
1435         }
1436         else if (!strcmp (p, "data"))
1437         {
1438             int textFlag = 0;
1439             int element_len;
1440             const char *element_str = NULL;
1441
1442             while ((r = execTok (spec, &s, &cmd_str, &cmd_len)) == 3)
1443             {
1444                 if (cmd_len==5 && !memcmp ("-text", cmd_str, cmd_len))
1445                     textFlag = 1;
1446                 else if (cmd_len==8 && !memcmp ("-element", cmd_str, cmd_len))
1447                 {
1448                     r = execTok (spec, &s, &element_str, &element_len);
1449                     if (r < 2)
1450                         break;
1451                 }
1452                 else
1453                     logf (LOG_WARN, "bad data option: %.*s",
1454                           cmd_len, cmd_str);
1455             }
1456             if (r != 2)
1457             {
1458                 logf (LOG_WARN, "missing data item after data");
1459                 continue;
1460             }
1461             if (element_str)
1462                 tagBegin (spec, element_str, element_len);
1463             do
1464             {
1465                 execData (spec, cmd_str, cmd_len,textFlag);
1466                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1467             } while (r > 1);
1468             if (element_str)
1469                 tagEnd (spec, 2, NULL, 0);
1470         }
1471         else if (!strcmp (p, "unread"))
1472         {
1473             int no, offset;
1474             r = execTok (spec, &s, &cmd_str, &cmd_len);
1475             if (r==3 && cmd_len == 7 && !memcmp ("-offset", cmd_str, cmd_len))
1476             {
1477                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1478                 if (r < 2)
1479                 {
1480                     logf (LOG_WARN, "missing number after -offset");
1481                     continue;
1482                 }
1483                 p = regxStrz (cmd_str, cmd_len, ptmp);
1484                 offset = atoi (p);
1485                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1486             }
1487             else
1488                 offset = 0;
1489             if (r < 2)
1490             {
1491                 logf (LOG_WARN, "missing index after unread command");
1492                 continue;
1493             }
1494             if (cmd_len != 1 || *cmd_str < '0' || *cmd_str > '9')
1495             {
1496                 logf (LOG_WARN, "bad index after unread command");
1497                 continue;
1498             }
1499             else
1500             {
1501                 no = *cmd_str - '0';
1502                 if (no >= spec->arg_no)
1503                     no = spec->arg_no - 1;
1504                 spec->ptr = spec->arg_start[no] + offset;
1505             }
1506             r = execTok (spec, &s, &cmd_str, &cmd_len);
1507         }
1508         else if (!strcmp (p, "context"))
1509         {
1510             if (r > 1)
1511             {
1512                 struct lexContext *lc = spec->context;
1513                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1514                 p = regxStrz (cmd_str, cmd_len, ptmp);
1515
1516                 while (lc && strcmp (p, lc->name))
1517                     lc = lc->next;
1518                 if (lc)
1519                     spec->context_stack[spec->context_stack_top] = lc;
1520                 else
1521                     logf (LOG_WARN, "unknown context %s", p);
1522
1523             }
1524             r = execTok (spec, &s, &cmd_str, &cmd_len);
1525         }
1526         else
1527         {
1528             logf (LOG_WARN, "unknown code command '%.*s'", cmd_len, cmd_str);
1529             r = execTok (spec, &s, &cmd_str, &cmd_len);
1530             continue;
1531         }
1532         if (r > 1)
1533         {
1534             logf (LOG_WARN, "ignoring token %.*s", cmd_len, cmd_str);
1535             do {
1536                 r = execTok (spec, &s, &cmd_str, &cmd_len);
1537             } while (r > 1);
1538         }
1539     }
1540 }
1541
1542
1543 static int execAction (struct lexSpec *spec, struct lexRuleAction *ap,
1544                        int start_ptr, int *pptr)
1545 {
1546     int sptr;
1547     int arg_start[20];
1548     int arg_end[20];
1549     int arg_no = 1;
1550
1551     if (!ap)
1552         return 1;
1553     arg_start[0] = start_ptr;
1554     arg_end[0] = *pptr;
1555     spec->arg_start = arg_start;
1556     spec->arg_end = arg_end;
1557
1558     while (ap)
1559     {
1560         switch (ap->which)
1561         {
1562         case REGX_PATTERN:
1563             if (ap->u.pattern.body)
1564             {
1565                 arg_start[arg_no] = *pptr;
1566                 if (!tryMatch (spec, pptr, &sptr, ap->u.pattern.dfa, 0))
1567                 {
1568                     arg_end[arg_no] = F_WIN_EOF;
1569                     arg_no++;
1570                     arg_start[arg_no] = F_WIN_EOF;
1571                     arg_end[arg_no] = F_WIN_EOF;
1572                     yaz_log(LOG_DEBUG, "Pattern match rest of record");
1573                     *pptr = F_WIN_EOF;
1574                 }
1575                 else
1576                 {
1577                     arg_end[arg_no] = sptr;
1578                     arg_no++;
1579                     arg_start[arg_no] = sptr;
1580                     arg_end[arg_no] = *pptr;
1581                 }
1582             }
1583             else
1584             {
1585                 arg_start[arg_no] = *pptr;
1586                 if (!tryMatch (spec, pptr, &sptr, ap->u.pattern.dfa, 1))
1587                     return 1;
1588                 if (sptr != arg_start[arg_no])
1589                     return 1;
1590                 arg_end[arg_no] = *pptr;
1591             }
1592             arg_no++;
1593             break;
1594         case REGX_CODE:
1595             spec->arg_no = arg_no;
1596             spec->ptr = *pptr;
1597 #if HAVE_TCL_H
1598             if (spec->tcl_interp)
1599                 execTcl(spec, ap->u.code);
1600             else
1601                 execCode (spec, ap->u.code);
1602 #else
1603             execCode (spec, ap->u.code);
1604 #endif
1605             *pptr = spec->ptr;
1606             if (spec->stop_flag)
1607                 return 0;
1608             break;
1609         case REGX_END:
1610             arg_start[arg_no] = *pptr;
1611             arg_end[arg_no] = F_WIN_EOF;
1612             arg_no++;
1613             *pptr = F_WIN_EOF;
1614         }
1615         ap = ap->next;
1616     }
1617     return 1;
1618 }
1619
1620 static int execRule (struct lexSpec *spec, struct lexContext *context,
1621                      int ruleNo, int start_ptr, int *pptr)
1622 {
1623 #if REGX_DEBUG
1624     logf (LOG_LOG, "exec rule %d", ruleNo);
1625 #endif
1626     return execAction (spec, context->fastRule[ruleNo]->actionList,
1627                        start_ptr, pptr);
1628 }
1629
1630 data1_node *lexNode (struct lexSpec *spec, int *ptr)
1631 {
1632     struct lexContext *context = spec->context_stack[spec->context_stack_top];
1633     struct DFA_state *state = context->dfa->states[0];
1634     struct DFA_tran *t;
1635     unsigned char c;
1636     unsigned char c_prev = '\n';
1637     int i;
1638     int last_rule = 0;        /* rule number of current match */
1639     int last_ptr = *ptr;      /* last char of match */
1640     int start_ptr = *ptr;     /* first char of match */
1641     int skip_ptr = *ptr;      /* first char of run */
1642
1643     while (1)
1644     {
1645         c = f_win_advance (spec, ptr);
1646         if (*ptr == F_WIN_EOF)
1647         {
1648             /* end of file met */
1649             if (last_rule)
1650             {
1651                 /* there was a match */
1652                 if (skip_ptr < start_ptr)
1653                 {
1654                     /* deal with chars that didn't match */
1655                     int size;
1656                     char *buf;
1657                     buf = f_win_get (spec, skip_ptr, start_ptr, &size);
1658                     execDataP (spec, buf, size, 0);
1659                 }
1660                 /* restore pointer */
1661                 *ptr = last_ptr;
1662                 /* execute rule */
1663                 if (!execRule (spec, context, last_rule, start_ptr, ptr))
1664                     break;
1665                 /* restore skip pointer */
1666                 skip_ptr = *ptr;
1667                 last_rule = 0;
1668             }
1669             else if (skip_ptr < *ptr)
1670             {
1671                 /* deal with chars that didn't match */
1672                 int size;
1673                 char *buf;
1674                 buf = f_win_get (spec, skip_ptr, *ptr, &size);
1675                 execDataP (spec, buf, size, 0);
1676             }
1677             if (*ptr == F_WIN_EOF)
1678                 break;
1679         }
1680         t = state->trans;
1681         i = state->tran_no;
1682         while (1)
1683             if (--i < 0)
1684             {   /* no transition for character c ... */
1685                 if (last_rule)
1686                 {
1687                     if (skip_ptr < start_ptr)
1688                     {
1689                         /* deal with chars that didn't match */
1690                         int size;
1691                         char *buf;
1692                         buf = f_win_get (spec, skip_ptr, start_ptr, &size);
1693                         execDataP (spec, buf, size, 0);
1694                     }
1695                     /* restore pointer */
1696                     *ptr = last_ptr;
1697                     if (!execRule (spec, context, last_rule, start_ptr, ptr))
1698                     {
1699                         if (spec->f_win_ef && *ptr != F_WIN_EOF)
1700                         {
1701 #if REGX_DEBUG
1702                             logf (LOG_LOG, "regx: endf ptr=%d", *ptr);
1703 #endif
1704                             (*spec->f_win_ef)(spec->f_win_fh, *ptr);
1705                         }
1706                         return NULL;
1707                     }
1708                     context = spec->context_stack[spec->context_stack_top];
1709                     skip_ptr = *ptr;
1710                     last_rule = 0;
1711                     last_ptr = start_ptr = *ptr;
1712                     if (start_ptr > 0)
1713                     {
1714                         --start_ptr;
1715                         c_prev = f_win_advance (spec, &start_ptr);
1716                     }
1717                 }
1718                 else
1719                 {
1720                     c_prev = f_win_advance (spec, &start_ptr);
1721                     *ptr = start_ptr;
1722                 }
1723                 state = context->dfa->states[0];
1724                 break;
1725             }
1726             else if (c >= t->ch[0] && c <= t->ch[1])
1727             {   /* transition ... */
1728                 state = context->dfa->states[t->to];
1729                 if (state->rule_no)
1730                 {
1731                     if (c_prev == '\n')
1732                     {
1733                         last_rule = state->rule_no;
1734                         last_ptr = *ptr;
1735                     }
1736                     else if (state->rule_nno)
1737                     {
1738                         last_rule = state->rule_nno;
1739                         last_ptr = *ptr;
1740                     }
1741                 }
1742                 break;
1743             }
1744             else
1745                 t++;
1746     }
1747     return NULL;
1748 }
1749
1750 static data1_node *lexRoot (struct lexSpec *spec, off_t offset,
1751                             const char *context_name)
1752 {
1753     struct lexContext *lt = spec->context;
1754     int ptr = offset;
1755
1756     spec->stop_flag = 0;
1757     spec->d1_level = 0;
1758     spec->context_stack_top = 0;
1759     while (lt)
1760     {
1761         if (!strcmp (lt->name, context_name))
1762             break;
1763         lt = lt->next;
1764     }
1765     if (!lt)
1766     {
1767         logf (LOG_WARN, "cannot find context %s", context_name);
1768         return NULL;
1769     }
1770     spec->context_stack[spec->context_stack_top] = lt;
1771     spec->d1_stack[spec->d1_level] = NULL;
1772 #if 1
1773     if (!lt->initFlag)
1774     {
1775         lt->initFlag = 1;
1776         execAction (spec, lt->initActionList, ptr, &ptr);
1777     }
1778 #endif
1779     execAction (spec, lt->beginActionList, ptr, &ptr);
1780     lexNode (spec, &ptr);
1781     while (spec->d1_level)
1782     {
1783         tagDataRelease (spec);
1784         (spec->d1_level)--;
1785     }
1786     execAction (spec, lt->endActionList, ptr, &ptr);
1787     return spec->d1_stack[0];
1788 }
1789
1790 void grs_destroy(void *clientData)
1791 {
1792     struct lexSpecs *specs = (struct lexSpecs *) clientData;
1793     if (specs->spec)
1794     {
1795         lexSpecDestroy(&specs->spec);
1796     }
1797     xfree (specs);
1798 }
1799
1800 void *grs_init(void)
1801 {
1802     struct lexSpecs *specs = (struct lexSpecs *) xmalloc (sizeof(*specs));
1803     specs->spec = 0;
1804     return specs;
1805 }
1806
1807 data1_node *grs_read_regx (struct grs_read_info *p)
1808 {
1809     int res;
1810     struct lexSpecs *specs = (struct lexSpecs *) p->clientData;
1811     struct lexSpec **curLexSpec = &specs->spec;
1812
1813 #if REGX_DEBUG
1814     logf (LOG_LOG, "grs_read_regx");
1815 #endif
1816     if (!*curLexSpec || strcmp ((*curLexSpec)->name, p->type))
1817     {
1818         if (*curLexSpec)
1819             lexSpecDestroy (curLexSpec);
1820         *curLexSpec = lexSpecCreate (p->type, p->dh);
1821         res = readFileSpec (*curLexSpec);
1822         if (res)
1823         {
1824             lexSpecDestroy (curLexSpec);
1825             return NULL;
1826         }
1827     }
1828     (*curLexSpec)->dh = p->dh;
1829     if (!p->offset)
1830     {
1831         (*curLexSpec)->f_win_start = 0;
1832         (*curLexSpec)->f_win_end = 0;
1833         (*curLexSpec)->f_win_rf = p->readf;
1834         (*curLexSpec)->f_win_sf = p->seekf;
1835         (*curLexSpec)->f_win_fh = p->fh;
1836         (*curLexSpec)->f_win_ef = p->endf;
1837         (*curLexSpec)->f_win_size = 500000;
1838     }
1839     (*curLexSpec)->m = p->mem;
1840     return lexRoot (*curLexSpec, p->offset, "main");
1841 }
1842
1843 static struct recTypeGrs regx_type = {
1844     "regx",
1845     grs_init,
1846     grs_destroy,
1847     grs_read_regx
1848 };
1849
1850 RecTypeGrs recTypeGrs_regx = &regx_type;
1851
1852 #if HAVE_TCL_H
1853 data1_node *grs_read_tcl (struct grs_read_info *p)
1854 {
1855     int res;
1856     struct lexSpecs *specs = (struct lexSpecs *) p->clientData;
1857     struct lexSpec **curLexSpec = &specs->spec;
1858
1859 #if REGX_DEBUG
1860     logf (LOG_LOG, "grs_read_tcl");
1861 #endif
1862     if (!*curLexSpec || strcmp ((*curLexSpec)->name, p->type))
1863     {
1864         Tcl_Interp *tcl_interp;
1865         if (*curLexSpec)
1866             lexSpecDestroy (curLexSpec);
1867         *curLexSpec = lexSpecCreate (p->type, p->dh);
1868         Tcl_FindExecutable("");
1869         tcl_interp = (*curLexSpec)->tcl_interp = Tcl_CreateInterp();
1870         Tcl_Init(tcl_interp);
1871         Tcl_CreateCommand (tcl_interp, "begin", cmd_tcl_begin, *curLexSpec, 0);
1872         Tcl_CreateCommand (tcl_interp, "end", cmd_tcl_end, *curLexSpec, 0);
1873         Tcl_CreateCommand (tcl_interp, "data", cmd_tcl_data, *curLexSpec, 0);
1874         Tcl_CreateCommand (tcl_interp, "unread", cmd_tcl_unread,
1875                            *curLexSpec, 0);
1876         res = readFileSpec (*curLexSpec);
1877         if (res)
1878         {
1879             lexSpecDestroy (curLexSpec);
1880             return NULL;
1881         }
1882     }
1883     (*curLexSpec)->dh = p->dh;
1884     if (!p->offset)
1885     {
1886         (*curLexSpec)->f_win_start = 0;
1887         (*curLexSpec)->f_win_end = 0;
1888         (*curLexSpec)->f_win_rf = p->readf;
1889         (*curLexSpec)->f_win_sf = p->seekf;
1890         (*curLexSpec)->f_win_fh = p->fh;
1891         (*curLexSpec)->f_win_ef = p->endf;
1892         (*curLexSpec)->f_win_size = 500000;
1893     }
1894     (*curLexSpec)->m = p->mem;
1895     return lexRoot (*curLexSpec, p->offset, "main");
1896 }
1897
1898 static struct recTypeGrs tcl_type = {
1899     "tcl",
1900     grs_init,
1901     grs_destroy,
1902     grs_read_tcl
1903 };
1904
1905 RecTypeGrs recTypeGrs_tcl = &tcl_type;
1906 #endif