index/regxread.c

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