X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=recctrl%2Fregxread.c;h=77e752324db5cba9519053d844bdd8465da2496a;hb=8b458130570103484319d3c2d6b8004cf5cf708e;hp=9b689f13a5b7013e5f2a390936eac347a44ea8f7;hpb=0178f4d569300f64162b53e0cd10d413c7b7cd99;p=idzebra-moved-to-github.git diff --git a/recctrl/regxread.c b/recctrl/regxread.c index 9b689f1..77e7523 100644 --- a/recctrl/regxread.c +++ b/recctrl/regxread.c @@ -4,7 +4,26 @@ * Sebastian Hammer, Adam Dickmeiss * * $Log: regxread.c,v $ - * Revision 1.5 1997-02-19 16:22:33 adam + * Revision 1.11 1997-11-06 11:41:01 adam + * Implemented "begin variant" for the sgml.regx filter. + * + * Revision 1.10 1997/10/31 12:36:12 adam + * Minor change that avoids compiler warning. + * + * Revision 1.9 1997/09/29 09:02:49 adam + * Fixed small bug (introduced by previous commit). + * + * Revision 1.8 1997/09/17 12:19:22 adam + * Zebra version corresponds to YAZ version 1.4. + * Changed Zebra server so that it doesn't depend on global common_resource. + * + * Revision 1.7 1997/07/15 16:33:07 adam + * Check for zero length in execData. + * + * Revision 1.6 1997/02/24 10:41:51 adam + * Cleanup of code and commented out the "end element-end-record" code. + * + * Revision 1.5 1997/02/19 16:22:33 adam * Fixed "end element" to terminate record in outer-most level. * * Revision 1.4 1997/02/12 20:42:58 adam @@ -129,7 +148,7 @@ struct lexRuleAction { int which; union { struct { - struct DFA *dfa; /* REGX_PATTERN */ + struct DFA *dfa; /* REGX_PATTERN */ int body; } pattern; struct regxCode *code; /* REGX_CODE */ @@ -159,24 +178,22 @@ struct lexSpec { struct lexTrans trans; int lineNo; NMEM m; + data1_handle dh; void *f_win_fh; void (*f_win_ef)(void *, off_t); -#if F_WIN_READ + int f_win_start; int f_win_end; int f_win_size; char *f_win_buf; int (*f_win_rf)(void *, char *, size_t); off_t (*f_win_sf)(void *, off_t); -#else - char *scan_buf; - int scan_size; -#endif + struct lexRuleAction *beginActionList; struct lexRuleAction *endActionList; }; -#if F_WIN_READ + static char *f_win_get (struct lexSpec *spec, off_t start_pos, off_t end_pos, int *size) { @@ -234,7 +251,6 @@ static int f_win_advance (struct lexSpec *spec, int *pos) *pos = F_WIN_EOF; return 0; } -#endif static void regxCodeDel (struct regxCode **pp) { @@ -281,9 +297,7 @@ static struct lexSpec *lexSpecMk (const char *name) p->trans.fastRule = NULL; p->beginActionList = NULL; p->endActionList = NULL; -#if F_WIN_READ p->f_win_buf = NULL; -#endif return p; } @@ -327,9 +341,7 @@ static void lexSpecDel (struct lexSpec **pp) } actionListDel (&p->beginActionList); actionListDel (&p->endActionList); -#if F_WIN_READ xfree (p->f_win_buf); -#endif xfree (p); *pp = NULL; } @@ -506,7 +518,8 @@ int readFileSpec (struct lexSpec *spec) lineBuf = xmalloc (1+lineSize); logf (LOG_LOG, "reading regx filter %s.flt", spec->name); sprintf (lineBuf, "%s.flt", spec->name); - if (!(spec_inf = yaz_path_fopen (data1_get_tabpath(), lineBuf, "r"))) + if (!(spec_inf = yaz_path_fopen (data1_get_tabpath(spec->dh), + lineBuf, "r"))) { logf (LOG_ERRNO|LOG_WARN, "cannot read spec file %s", spec->name); xfree (lineBuf); @@ -586,6 +599,8 @@ static void execData (struct lexSpec *spec, { struct data1_node *res, *parent; + if (elen == 0) /* shouldn't happen, but it does! */ + return ; #if REGX_DEBUG if (elen > 40) logf (LOG_DEBUG, "execData %.15s ... %.*s", ebuf, 15, ebuf + elen-15); @@ -595,7 +610,7 @@ static void execData (struct lexSpec *spec, logf (LOG_DEBUG, "execData len=%d", elen); #endif - if (*d1_level <= 1) + if (*d1_level <= 1) return; parent = d1_stack[*d1_level -1]; @@ -618,7 +633,7 @@ static void execData (struct lexSpec *spec, } else { - res = data1_mk_node (spec->m); + res = data1_mk_node (spec->dh, spec->m); res->parent = parent; res->which = DATA1N_data; res->u.data.what = DATA1I_text; @@ -651,6 +666,93 @@ static void execDataP (struct lexSpec *spec, execData (spec, d1_stack, d1_level, ebuf, elen, formatted_text); } +static void variantBegin (struct lexSpec *spec, + data1_node **d1_stack, int *d1_level, + const char *class_str, int class_len, + const char *type_str, int type_len, + const char *value_str, int value_len) +{ + struct data1_node *parent = d1_stack[*d1_level -1]; + char tclass[DATA1_MAX_SYMBOL], ttype[DATA1_MAX_SYMBOL]; + data1_vartype *tp; + int i; + data1_node *res; + + if (*d1_level == 0) + { + logf (LOG_WARN, "in variant begin. No record type defined"); + return ; + } + if (class_len >= DATA1_MAX_SYMBOL) + class_len = DATA1_MAX_SYMBOL-1; + memcpy (tclass, class_str, class_len); + tclass[class_len] = '\0'; + + if (type_len >= DATA1_MAX_SYMBOL) + type_len = DATA1_MAX_SYMBOL-1; + memcpy (ttype, type_str, type_len); + ttype[type_len] = '\0'; + +#if REGX_DEBUG + logf (LOG_DEBUG, "variant begin %s %s (%d)", tclass, ttype, *d1_level); +#endif + + if (!(tp = + data1_getvartypebyct(spec->dh, parent->root->u.root.absyn->varset, + tclass, ttype))) + return; + + if (parent->which != DATA1N_variant) + { + res = data1_mk_node (spec->dh, spec->m); + res->parent = parent; + res->which = DATA1N_variant; + res->u.variant.type = 0; + res->u.variant.value = 0; + res->root = parent->root; + + parent->num_children++; + parent->last_child = res; + if (d1_stack[*d1_level]) + d1_stack[*d1_level]->next = res; + else + parent->child = res; + d1_stack[*d1_level] = res; + d1_stack[++(*d1_level)] = NULL; + } + for (i = *d1_level-1; d1_stack[i]->which == DATA1N_variant; i--) + if (d1_stack[i]->u.variant.type == tp) + { + *d1_level = i; + break; + } + +#if REGX_DEBUG + logf (LOG_DEBUG, "variant node (%d)", *d1_level); +#endif + parent = d1_stack[*d1_level-1]; + res = data1_mk_node (spec->dh, spec->m); + res->parent = parent; + res->which = DATA1N_variant; + res->root = parent->root; + res->u.variant.type = tp; + + if (value_len >= DATA1_LOCALDATA) + value_len =DATA1_LOCALDATA-1; + memcpy (res->lbuf, value_str, value_len); + res->lbuf[value_len] = '\0'; + + res->u.variant.value = res->lbuf; + + parent->num_children++; + parent->last_child = res; + if (d1_stack[*d1_level]) + d1_stack[*d1_level]->next = res; + else + parent->child = res; + d1_stack[*d1_level] = res; + d1_stack[++(*d1_level)] = NULL; +} static void tagBegin (struct lexSpec *spec, data1_node **d1_stack, int *d1_level, @@ -658,7 +760,7 @@ static void tagBegin (struct lexSpec *spec, { struct data1_node *parent = d1_stack[*d1_level -1]; data1_element *elem = NULL; - data1_node *partag = get_parent_tag(parent); + data1_node *partag = get_parent_tag(spec->dh, parent); data1_node *res; data1_element *e = NULL; int localtag = 0; @@ -669,7 +771,7 @@ static void tagBegin (struct lexSpec *spec, return ; } - res = data1_mk_node (spec->m); + res = data1_mk_node (spec->dh, spec->m); res->parent = parent; res->which = DATA1N_tag; res->u.tag.tag = res->lbuf; @@ -690,14 +792,14 @@ static void tagBegin (struct lexSpec *spec, if (!(e = partag->u.tag.element)) localtag = 1; - elem = data1_getelementbytagname (d1_stack[0]->u.root.absyn, e, - res->u.tag.tag); - + elem = data1_getelementbytagname (spec->dh, d1_stack[0]->u.root.absyn, + e, res->u.tag.tag); res->u.tag.element = elem; res->u.tag.node_selected = 0; res->u.tag.make_variantlist = 0; res->u.tag.no_data_requested = 0; res->root = parent->root; + parent->num_children++; parent->last_child = res; if (d1_stack[*d1_level]) @@ -715,9 +817,10 @@ static void tagEnd (struct lexSpec *spec, while (*d1_level > 1) { (*d1_level)--; - if (!tag || - (strlen(d1_stack[*d1_level]->u.tag.tag) == len && - !memcmp (d1_stack[*d1_level]->u.tag.tag, tag, len))) + if ((d1_stack[*d1_level]->which == DATA1N_tag) && + (!tag || + (strlen(d1_stack[*d1_level]->u.tag.tag) == (size_t) len && + !memcmp (d1_stack[*d1_level]->u.tag.tag, tag, len)))) break; } #if REGX_DEBUG @@ -732,9 +835,7 @@ static int tryMatch (struct lexSpec *spec, int *pptr, int *mptr, struct DFA_state *state = dfa->states[0]; struct DFA_tran *t; unsigned char c; -#if F_WIN_READ unsigned char c_prev = 0; -#endif int ptr = *pptr; int start_ptr = *pptr; int last_rule = 0; @@ -743,7 +844,6 @@ static int tryMatch (struct lexSpec *spec, int *pptr, int *mptr, while (1) { -#if F_WIN_READ c = f_win_advance (spec, &ptr); if (ptr == F_WIN_EOF) { @@ -755,19 +855,6 @@ static int tryMatch (struct lexSpec *spec, int *pptr, int *mptr, } break; } -#else - if (ptr == spec->scan_size) - { - if (last_rule) - { - *mptr = start_ptr; - *pptr = last_ptr; - return 1; - } - break; - } - c = spec->scan_buf[ptr++]; -#endif t = state->trans; i = state->tran_no; while (1) @@ -781,9 +868,7 @@ static int tryMatch (struct lexSpec *spec, int *pptr, int *mptr, } state = dfa->states[0]; start_ptr = ptr; -#if F_WIN_READ c_prev = c; -#endif break; } else if (c >= t->ch[0] && c <= t->ch[1]) @@ -791,7 +876,6 @@ static int tryMatch (struct lexSpec *spec, int *pptr, int *mptr, state = dfa->states[t->to]; if (state->rule_no) { -#if F_WIN_READ if (c_prev == '\n') { last_rule = state->rule_no; @@ -802,10 +886,6 @@ static int tryMatch (struct lexSpec *spec, int *pptr, int *mptr, last_rule = state->rule_nno; last_ptr = ptr; } -#else - last_rule = state->rule_no; - last_ptr = ptr; -#endif } break; } @@ -840,12 +920,7 @@ static int execTok (struct lexSpec *spec, const char **src, { if (n >= arg_no) n = arg_no-1; -#if F_WIN_READ *tokBuf = f_win_get (spec, arg_start[n], arg_end[n], tokLen); -#else - *tokBuf = spec->scan_buf + arg_start[n]; - *tokLen = arg_end[n] - arg_start[n]; -#endif } } else if (*s == '\"') @@ -942,13 +1017,13 @@ static int execCode (struct lexSpec *spec, #if REGX_DEBUG logf (LOG_DEBUG, "begin record %s", absynName); #endif - if (!(absyn = data1_get_absyn (absynName))) + if (!(absyn = data1_get_absyn (spec->dh, absynName))) logf (LOG_WARN, "Unknown tagset: %s", absynName); else { data1_node *res; - res = data1_mk_node (spec->m); + res = data1_mk_node (spec->dh, spec->m); res->which = DATA1N_root; res->u.root.type = absynName; res->u.root.absyn = absyn; @@ -970,7 +1045,42 @@ static int execCode (struct lexSpec *spec, tagBegin (spec, d1_stack, d1_level, cmd_str, cmd_len); r = execTok (spec, &s, arg_no, arg_start, arg_end, &cmd_str, &cmd_len); - } + } + else if (!strcmp (p, "variant")) + { + int class_len; + const char *class_str = NULL; + int type_len; + const char *type_str = NULL; + int value_len; + const char *value_str = NULL; + r = execTok (spec, &s, arg_no, arg_start, arg_end, + &cmd_str, &cmd_len); + if (r < 2) + continue; + class_str = cmd_str; + class_len = cmd_len; + r = execTok (spec, &s, arg_no, arg_start, arg_end, + &cmd_str, &cmd_len); + if (r < 2) + continue; + type_str = cmd_str; + type_len = cmd_len; + + r = execTok (spec, &s, arg_no, arg_start, arg_end, + &cmd_str, &cmd_len); + if (r < 2) + continue; + value_str = cmd_str; + value_len = cmd_len; + + variantBegin (spec, d1_stack, d1_level, class_str, class_len, + type_str, type_len, value_str, value_len); + + + r = execTok (spec, &s, arg_no, arg_start, arg_end, + &cmd_str, &cmd_len); + } } else if (!strcmp (p, "end")) { @@ -993,11 +1103,13 @@ static int execCode (struct lexSpec *spec, { r = execTok (spec, &s, arg_no, arg_start, arg_end, &cmd_str, &cmd_len); +#if 0 if (*d1_level == 1) { *d1_level = 0; returnCode = 0; } +#endif if (r > 2) { tagEnd (spec, d1_stack, d1_level, cmd_str, cmd_len); @@ -1167,17 +1279,9 @@ static int execAction (struct lexSpec *spec, struct lexRuleAction *ap, break; case REGX_END: arg_start[arg_no] = *pptr; -#if F_WIN_READ arg_end[arg_no] = F_WIN_EOF; -#else - arg_end[arg_no] = spec->scan_size; -#endif arg_no++; -#if F_WIN_READ *pptr = F_WIN_EOF; -#else - *pptr = spec->scan_size; -#endif } ap = ap->next; } @@ -1202,9 +1306,7 @@ data1_node *lexNode (struct lexSpec *spec, struct lexTrans *trans, struct DFA_state *state = trans->dfa->states[0]; struct DFA_tran *t; unsigned char c; -#if F_WIN_READ unsigned char c_prev = '\n'; -#endif int i; int last_rule = 0; int last_ptr = *ptr; @@ -1213,7 +1315,6 @@ data1_node *lexNode (struct lexSpec *spec, struct lexTrans *trans, while (1) { -#if F_WIN_READ c = f_win_advance (spec, ptr); if (*ptr == F_WIN_EOF) { @@ -1243,33 +1344,6 @@ data1_node *lexNode (struct lexSpec *spec, struct lexTrans *trans, if (*ptr == F_WIN_EOF) break; } -#else - if (*ptr == spec->scan_size) - { - if (last_rule) - { - if (skip_ptr < start_ptr) - { - execDataP (spec, d1_stack, d1_level, - spec->scan_buf + skip_ptr, start_ptr - skip_ptr, - 0); - } - *ptr = last_ptr; - execRule (spec, trans, d1_stack, d1_level, last_rule, - start_ptr, ptr); - skip_ptr = *ptr; - last_rule = 0; - } - else if (skip_ptr < *ptr) - { - execDataP (spec, d1_stack, d1_level, - spec->scan_buf + skip_ptr, *ptr - skip_ptr, 0); - } - if (*ptr == spec->scan_size) - break; - } - c = spec->scan_buf[(*ptr)++]; -#endif t = state->trans; i = state->tran_no; while (1) @@ -1279,44 +1353,37 @@ data1_node *lexNode (struct lexSpec *spec, struct lexTrans *trans, { if (skip_ptr < start_ptr) { -#if F_WIN_READ int size; char *buf; buf = f_win_get (spec, skip_ptr, start_ptr, &size); execDataP (spec, d1_stack, d1_level, buf, size, 0); -#else - execDataP (spec, d1_stack, d1_level, - spec->scan_buf + skip_ptr, - start_ptr - skip_ptr, 0); -#endif } *ptr = last_ptr; if (!execRule (spec, trans, d1_stack, d1_level, last_rule, start_ptr, ptr)) { if (spec->f_win_ef && *ptr != F_WIN_EOF) + { +#if REGX_DEBUG + logf (LOG_DEBUG, "regx: endf ptr=%d", *ptr); +#endif (*spec->f_win_ef)(spec->f_win_fh, *ptr); + } return NULL; } skip_ptr = *ptr; last_rule = 0; start_ptr = *ptr; -#if F_WIN_READ if (start_ptr > 0) { --start_ptr; c_prev = f_win_advance (spec, &start_ptr); } -#endif } else { -#if F_WIN_READ c_prev = f_win_advance (spec, &start_ptr); *ptr = start_ptr; -#else - *ptr = ++start_ptr; -#endif } state = trans->dfa->states[0]; break; @@ -1326,7 +1393,6 @@ data1_node *lexNode (struct lexSpec *spec, struct lexTrans *trans, state = trans->dfa->states[t->to]; if (state->rule_no) { -#if F_WIN_READ if (c_prev == '\n') { last_rule = state->rule_no; @@ -1337,18 +1403,6 @@ data1_node *lexNode (struct lexSpec *spec, struct lexTrans *trans, last_rule = state->rule_nno; last_ptr = *ptr; } -#else - if (!start_ptr || spec->scan_buf[start_ptr-1] == '\n') - { - last_rule = state->rule_no; - last_ptr = *ptr; - } - else if (state->rule_nno) - { - last_rule = state->rule_nno; - last_ptr = *ptr; - } -#endif } break; } @@ -1376,31 +1430,19 @@ static data1_node *lexRoot (struct lexSpec *spec, off_t offset) } data1_node *grs_read_regx (struct grs_read_info *p) -/* - int (*rf)(void *, char *, size_t), - off_t (*sf)(void *, off_t), - void (*ef)(void *, off_t), - void *fh, - off_t offset, - const char *name, NMEM m -*/ { int res; -#if !F_WIN_READ - static int size; - int rd = 0; -#endif data1_node *n; #if REGX_DEBUG - logf (LOG_DEBUG, "data1_read_regx, offset=%ld type=%s",(long) offset, - name); + logf (LOG_DEBUG, "grs_read_regx"); #endif if (!curLexSpec || strcmp (curLexSpec->name, p->type)) { if (curLexSpec) lexSpecDel (&curLexSpec); curLexSpec = lexSpecMk (p->type); + curLexSpec->dh = p->dh; res = readFileSpec (curLexSpec); if (res) { @@ -1408,7 +1450,6 @@ data1_node *grs_read_regx (struct grs_read_info *p) return NULL; } } -#if F_WIN_READ if (!p->offset) { curLexSpec->f_win_start = 0; @@ -1419,24 +1460,7 @@ data1_node *grs_read_regx (struct grs_read_info *p) curLexSpec->f_win_ef = p->endf; curLexSpec->f_win_size = 500000; } -#else - if (!(curLexSpec->scan_buf = xmalloc (size = 4096))) - abort(); - do - { - if (rd+4096 > size && !(curLexSpec->scan_buf - = xrealloc (curLexSpec->scan_buf, size *= 2))) - abort(); - if ((res = (*rf)(fh, curLexSpec->scan_buf + rd, 4096)) < 0) - return NULL; - rd += res; - } while (res); - curLexSpec->scan_size = rd; -#endif curLexSpec->m = p->mem; n = lexRoot (curLexSpec, p->offset); -#if !F_WIN_READ - xfree (curLexSpec->scan_buf); -#endif return n; }