-/* $Id: regxread.c,v 1.45 2002-08-19 21:11:27 adam Exp $
- Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
+/* $Id: regxread.c,v 1.53 2004-09-27 10:44:50 adam Exp $
+ Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
This file is part of the Zebra server.
struct lexSpecs {
struct lexSpec *spec;
+ char type[256];
};
static char *f_win_get (struct lexSpec *spec, off_t start_pos, off_t end_pos,
logf (LOG_WARN, "regular expression error '%.*s'", s-s0, s0);
return -1;
}
+ if (debug_dfa_tran)
+ printf ("pattern: %.*s\n", s-s0, s0);
dfa_mkstate ((*ap)->u.pattern.dfa);
s++;
break;
if (spec->tcl_interp)
logf (LOG_LOG, "Tcl enabled");
#endif
+
+#if 0
+ debug_dfa_trav = 0;
+ debug_dfa_tran = 1;
+ debug_dfa_followpos = 0;
+ dfa_verbose = 1;
+#endif
+
lineBuf = wrbuf_alloc();
spec->lineNo = 0;
c = getc (spec_inf);
fclose (spec_inf);
wrbuf_free(lineBuf, 1);
-#if 0
- debug_dfa_trav = 1;
- debug_dfa_tran = 1;
- debug_dfa_followpos = 1;
- dfa_verbose = 1;
-#endif
for (lc = spec->context; lc; lc = lc->next)
{
struct lexRule *rp;
#endif
static void execData (struct lexSpec *spec,
- const char *ebuf, int elen, int formatted_text)
+ const char *ebuf, int elen, int formatted_text,
+ const char *attribute_str, int attribute_len)
{
struct data1_node *res, *parent;
int org_len;
if (elen == 0) /* shouldn't happen, but it does! */
return ;
#if REGX_DEBUG
- if (elen > 40)
- logf (LOG_LOG, "data (%d bytes) %.15s ... %.*s", elen,
- ebuf, 15, ebuf + elen-15);
+ if (elen > 80)
+ logf (LOG_LOG, "data(%d bytes) %.40s ... %.*s", elen,
+ ebuf, 40, ebuf + elen-40);
+ else if (elen == 1 && ebuf[0] == '\n')
+ {
+ logf (LOG_LOG, "data(new line)");
+ }
else if (elen > 0)
- logf (LOG_LOG, "data (%d bytes) %.*s", elen, elen, ebuf);
+ logf (LOG_LOG, "data(%d bytes) %.*s", elen, elen, ebuf);
else
- logf (LOG_LOG, "data (%d bytes)", elen);
+ logf (LOG_LOG, "data(%d bytes)", elen);
#endif
if (spec->d1_level <= 1)
parent = spec->d1_stack[spec->d1_level -1];
assert (parent);
- if ((res = spec->d1_stack[spec->d1_level]) && res->which == DATA1N_data)
- org_len = res->u.data.len;
- else
+ if (attribute_str)
{
- org_len = 0;
+ data1_xattr **ap;
+ res = parent;
+ if (res->which != DATA1N_tag)
+ return;
+ /* sweep through exising attributes.. */
+ for (ap = &res->u.tag.attributes; *ap; ap = &(*ap)->next)
+ if (strlen((*ap)->name) == attribute_len &&
+ !memcmp((*ap)->name, attribute_str, attribute_len))
+ break;
+ if (!*ap)
+ {
+ /* new attribute. Create it with name + value */
+ *ap = nmem_malloc(spec->m, sizeof(**ap));
- res = data1_mk_node2 (spec->dh, spec->m, DATA1N_data, parent);
- res->u.data.what = DATA1I_text;
- res->u.data.len = 0;
- res->u.data.formatted_text = formatted_text;
- res->u.data.data = 0;
-
- if (spec->d1_stack[spec->d1_level])
- spec->d1_stack[spec->d1_level]->next = res;
- spec->d1_stack[spec->d1_level] = res;
- }
- if (org_len + elen >= spec->concatBuf[spec->d1_level].max)
- {
- char *old_buf, *new_buf;
+ (*ap)->name = nmem_malloc(spec->m, attribute_len+1);
+ memcpy((*ap)->name, attribute_str, attribute_len);
+ (*ap)->name[attribute_len] = '\0';
- spec->concatBuf[spec->d1_level].max = org_len + elen + 256;
- new_buf = (char *) xmalloc (spec->concatBuf[spec->d1_level].max);
- if ((old_buf = spec->concatBuf[spec->d1_level].buf))
+ (*ap)->value = nmem_malloc(spec->m, elen+1);
+ memcpy((*ap)->value, ebuf, elen);
+ (*ap)->value[elen] = '\0';
+ (*ap)->next = 0;
+ }
+ else
{
- memcpy (new_buf, old_buf, org_len);
- xfree (old_buf);
+ /* append to value if attribute already exists */
+ char *nv = nmem_malloc(spec->m, elen + 1 + strlen((*ap)->value));
+ strcpy(nv, (*ap)->value);
+ memcpy (nv + strlen(nv), ebuf, elen);
+ nv[strlen(nv)+elen] = '\0';
+ (*ap)->value = nv;
}
- spec->concatBuf[spec->d1_level].buf = new_buf;
+ }
+ else
+ {
+ if ((res = spec->d1_stack[spec->d1_level]) &&
+ res->which == DATA1N_data)
+ org_len = res->u.data.len;
+ else
+ {
+ org_len = 0;
+
+ res = data1_mk_node2 (spec->dh, spec->m, DATA1N_data, parent);
+ res->u.data.what = DATA1I_text;
+ res->u.data.len = 0;
+ res->u.data.formatted_text = formatted_text;
+ res->u.data.data = 0;
+
+ if (spec->d1_stack[spec->d1_level])
+ spec->d1_stack[spec->d1_level]->next = res;
+ spec->d1_stack[spec->d1_level] = res;
+ }
+ if (org_len + elen >= spec->concatBuf[spec->d1_level].max)
+ {
+ char *old_buf, *new_buf;
+
+ spec->concatBuf[spec->d1_level].max = org_len + elen + 256;
+ new_buf = (char *) xmalloc (spec->concatBuf[spec->d1_level].max);
+ if ((old_buf = spec->concatBuf[spec->d1_level].buf))
+ {
+ memcpy (new_buf, old_buf, org_len);
+ xfree (old_buf);
+ }
+ spec->concatBuf[spec->d1_level].buf = new_buf;
+ }
+ memcpy (spec->concatBuf[spec->d1_level].buf + org_len, ebuf, elen);
+ res->u.data.len += elen;
}
- memcpy (spec->concatBuf[spec->d1_level].buf + org_len, ebuf, elen);
- res->u.data.len += elen;
}
static void execDataP (struct lexSpec *spec,
const char *ebuf, int elen, int formatted_text)
{
- execData (spec, ebuf, elen, formatted_text);
+ execData (spec, ebuf, elen, formatted_text, 0, 0);
}
static void tagDataRelease (struct lexSpec *spec)
ttype[type_len] = '\0';
#if REGX_DEBUG
- logf (LOG_LOG, "variant begin %s %s (%d)", tclass, ttype,
+ logf (LOG_LOG, "variant begin(%s,%s,%d)", tclass, ttype,
spec->d1_level);
#endif
}
#if REGX_DEBUG
- logf (LOG_LOG, "variant node (%d)", spec->d1_level);
+ logf (LOG_LOG, "variant node(%d)", spec->d1_level);
#endif
parent = spec->d1_stack[spec->d1_level-1];
res = data1_mk_node2 (spec->dh, spec->m, DATA1N_variant, parent);
tagDataRelease (spec);
#if REGX_DEBUG
- logf (LOG_LOG, "begin tag %s (%d)", res->u.tag.tag, spec->d1_level);
+ logf (LOG_LOG, "begin tag(%.*s, %d)", len, tag, spec->d1_level);
#endif
spec->d1_stack[spec->d1_level] = data1_mk_tag_n (
break;
}
#if REGX_DEBUG
- logf (LOG_LOG, "end tag (%d)", spec->d1_level);
+ logf (LOG_LOG, "end tag(%d)", spec->d1_level);
#endif
}
static int tryMatch (struct lexSpec *spec, int *pptr, int *mptr,
- struct DFA *dfa)
+ struct DFA *dfa, int greedy)
{
struct DFA_state *state = dfa->states[0];
struct DFA_tran *t;
- unsigned char c;
+ unsigned char c = 0;
unsigned char c_prev = 0;
int ptr = *pptr; /* current pointer */
int start_ptr = *pptr; /* first char of match */
int last_ptr = 0; /* last char of match */
int last_rule = 0; /* rule number of current match */
+ int restore_ptr = 0;
int i;
+ if (ptr)
+ {
+ --ptr;
+ c = f_win_advance (spec, &ptr);
+ }
while (1)
{
+ if (dfa->states[0] == state)
+ {
+ c_prev = c;
+ restore_ptr = ptr;
+ }
c = f_win_advance (spec, &ptr);
+
if (ptr == F_WIN_EOF)
{
if (last_rule)
}
break;
}
+
t = state->trans;
i = state->tran_no;
while (1)
- if (--i < 0)
+ if (--i < 0) /* no transition for character c */
{
if (last_rule)
{
return 1;
}
state = dfa->states[0];
+
+ ptr = restore_ptr;
+ c = f_win_advance (spec, &ptr);
+
start_ptr = ptr;
- c_prev = c;
+
break;
}
else if (c >= t->ch[0] && c <= t->ch[1])
{
state = dfa->states[t->to];
- if (state->rule_no)
- {
- if (c_prev == '\n')
- {
- last_rule = state->rule_no;
- last_ptr = ptr;
- }
- else
- {
- last_rule = state->rule_nno;
- last_ptr = ptr;
- }
- }
- break;
+ if (state->rule_no && c_prev == '\n')
+ {
+ last_rule = state->rule_no;
+ last_ptr = ptr;
+ }
+ else if (state->rule_nno)
+ {
+ last_rule = state->rule_nno;
+ last_ptr = ptr;
+ }
+ break;
}
else
t++;
#if HAVE_TCL_H
static int cmd_tcl_begin (ClientData clientData, Tcl_Interp *interp,
- int argc, char **argv)
+ int argc, const char **argv)
{
struct lexSpec *spec = (struct lexSpec *) clientData;
if (argc < 2)
return TCL_ERROR;
if (!strcmp(argv[1], "record") && argc == 3)
{
- char *absynName = argv[2];
+ const char *absynName = argv[2];
data1_node *res;
#if REGX_DEBUG
#endif
res = data1_mk_root (spec->dh, spec->m, absynName);
+ spec->d1_level = 0;
+
spec->d1_stack[spec->d1_level++] = res;
res = data1_mk_tag (spec->dh, spec->m, absynName, 0, res);
}
static int cmd_tcl_end (ClientData clientData, Tcl_Interp *interp,
- int argc, char **argv)
+ int argc, const char **argv)
{
struct lexSpec *spec = (struct lexSpec *) clientData;
if (argc < 2)
}
else if (!strcmp (argv[1], "element"))
{
- int min_level = 1;
- char *element = 0;
+ int min_level = 2;
+ const char *element = 0;
if (argc >= 3 && !strcmp(argv[2], "-record"))
{
min_level = 0;
if (argc == 3)
element = argv[2];
tagEnd (spec, min_level, element, (element ? strlen(element) : 0));
- if (spec->d1_level == 0)
+ if (spec->d1_level <= 1)
{
#if REGX_DEBUG
logf (LOG_LOG, "end element end records");
}
static int cmd_tcl_data (ClientData clientData, Tcl_Interp *interp,
- int argc, char **argv)
+ int argc, const char **argv)
{
int argi = 1;
int textFlag = 0;
const char *element = 0;
+ const char *attribute = 0;
struct lexSpec *spec = (struct lexSpec *) clientData;
while (argi < argc)
if (argi < argc)
element = argv[argi++];
}
+ else if (!strcmp("-attribute", argv[argi]))
+ {
+ argi++;
+ if (argi < argc)
+ attribute = argv[argi++];
+ }
else
break;
}
#if TCL_MAJOR_VERSION > 8 || (TCL_MAJOR_VERSION == 8 && TCL_MINOR_VERSION > 0)
Tcl_DString ds;
char *native = Tcl_UtfToExternalDString(0, argv[argi], -1, &ds);
- execData (spec, native, strlen(native), textFlag);
+ execData (spec, native, strlen(native), textFlag, attribute,
+ attribute ? strlen(attribute) : 0);
Tcl_DStringFree (&ds);
#else
- execData (spec, argv[argi], strlen(argv[argi]), textFlag);
+ execData (spec, argv[argi], strlen(argv[argi]), textFlag, attribute,
+ attribute ? strlen(attribute) : 0);
#endif
argi++;
}
if (element)
- tagEnd (spec, 1, NULL, 0);
+ tagEnd (spec, 2, NULL, 0);
return TCL_OK;
}
static int cmd_tcl_unread (ClientData clientData, Tcl_Interp *interp,
- int argc, char **argv)
+ int argc, const char **argv)
{
struct lexSpec *spec = (struct lexSpec *) clientData;
int argi = 1;
r = execTok (spec, &s, &cmd_str, &cmd_len);
if (r < 2)
continue;
- if (spec->d1_level == 0)
+ if (spec->d1_level <= 1)
{
static char absynName[64];
data1_node *res;
#endif
res = data1_mk_root (spec->dh, spec->m, absynName);
+ spec->d1_level = 0;
+
spec->d1_stack[spec->d1_level++] = res;
res = data1_mk_tag (spec->dh, spec->m, absynName, 0, res);
}
else if (!strcmp (p, "element"))
{
- int min_level = 1;
+ int min_level = 2;
while ((r = execTok (spec, &s, &cmd_str, &cmd_len)) == 3)
{
if (cmd_len==7 && !memcmp ("-record", cmd_str, cmd_len))
}
else
tagEnd (spec, min_level, NULL, 0);
- if (spec->d1_level == 0)
+ if (spec->d1_level <= 1)
{
#if REGX_DEBUG
logf (LOG_LOG, "end element end records");
int textFlag = 0;
int element_len;
const char *element_str = NULL;
+ int attribute_len;
+ const char *attribute_str = NULL;
while ((r = execTok (spec, &s, &cmd_str, &cmd_len)) == 3)
{
if (r < 2)
break;
}
+ else if (cmd_len==10 && !memcmp ("-attribute", cmd_str,
+ cmd_len))
+ {
+ r = execTok (spec, &s, &attribute_str, &attribute_len);
+ if (r < 2)
+ break;
+ }
else
logf (LOG_WARN, "bad data option: %.*s",
cmd_len, cmd_str);
tagBegin (spec, element_str, element_len);
do
{
- execData (spec, cmd_str, cmd_len,textFlag);
+ execData (spec, cmd_str, cmd_len, textFlag,
+ attribute_str, attribute_len);
r = execTok (spec, &s, &cmd_str, &cmd_len);
} while (r > 1);
if (element_str)
- tagEnd (spec, 1, NULL, 0);
+ tagEnd (spec, 2, NULL, 0);
}
else if (!strcmp (p, "unread"))
{
if (ap->u.pattern.body)
{
arg_start[arg_no] = *pptr;
- if (!tryMatch (spec, pptr, &sptr, ap->u.pattern.dfa))
+ if (!tryMatch (spec, pptr, &sptr, ap->u.pattern.dfa, 0))
{
arg_end[arg_no] = F_WIN_EOF;
arg_no++;
arg_start[arg_no] = F_WIN_EOF;
arg_end[arg_no] = F_WIN_EOF;
-/* return 1*/
+ yaz_log(LOG_DEBUG, "Pattern match rest of record");
+ *pptr = F_WIN_EOF;
}
else
{
else
{
arg_start[arg_no] = *pptr;
- if (!tryMatch (spec, pptr, &sptr, ap->u.pattern.dfa))
+ if (!tryMatch (spec, pptr, &sptr, ap->u.pattern.dfa, 1))
return 1;
if (sptr != arg_start[arg_no])
return 1;
xfree (specs);
}
-void *grs_init(void)
+void *grs_init(Res res, RecType recType)
{
struct lexSpecs *specs = (struct lexSpecs *) xmalloc (sizeof(*specs));
specs->spec = 0;
+ strcpy(specs->type, "");
return specs;
}
+
+void grs_config(void *clientData, Res res, const char *args)
+{
+ struct lexSpecs *specs = (struct lexSpecs *) clientData;
+ if (strlen(args) < sizeof(specs->type))
+ strcpy(specs->type, args);
+}
+
data1_node *grs_read_regx (struct grs_read_info *p)
{
int res;
#if REGX_DEBUG
logf (LOG_LOG, "grs_read_regx");
#endif
- if (!*curLexSpec || strcmp ((*curLexSpec)->name, p->type))
+ if (!*curLexSpec || strcmp ((*curLexSpec)->name, specs->type))
{
if (*curLexSpec)
lexSpecDestroy (curLexSpec);
- *curLexSpec = lexSpecCreate (p->type, p->dh);
+ *curLexSpec = lexSpecCreate (specs->type, p->dh);
res = readFileSpec (*curLexSpec);
if (res)
{
return lexRoot (*curLexSpec, p->offset, "main");
}
-static struct recTypeGrs regx_type = {
- "regx",
+static int extract_regx(void *clientData, struct recExtractCtrl *ctrl)
+{
+ return zebra_grs_extract(clientData, ctrl, grs_read_regx);
+}
+
+static int retrieve_regx(void *clientData, struct recRetrieveCtrl *ctrl)
+{
+ return zebra_grs_retrieve(clientData, ctrl, grs_read_regx);
+}
+
+static struct recType regx_type = {
+ "grs.regx",
grs_init,
+ grs_config,
grs_destroy,
- grs_read_regx
+ extract_regx,
+ retrieve_regx,
};
-RecTypeGrs recTypeGrs_regx = ®x_type;
#if HAVE_TCL_H
data1_node *grs_read_tcl (struct grs_read_info *p)
#if REGX_DEBUG
logf (LOG_LOG, "grs_read_tcl");
#endif
- if (!*curLexSpec || strcmp ((*curLexSpec)->name, p->type))
+ if (!*curLexSpec || strcmp ((*curLexSpec)->name, specs->type))
{
Tcl_Interp *tcl_interp;
if (*curLexSpec)
lexSpecDestroy (curLexSpec);
- *curLexSpec = lexSpecCreate (p->type, p->dh);
+ *curLexSpec = lexSpecCreate (specs->type, p->dh);
Tcl_FindExecutable("");
tcl_interp = (*curLexSpec)->tcl_interp = Tcl_CreateInterp();
Tcl_Init(tcl_interp);
return lexRoot (*curLexSpec, p->offset, "main");
}
-static struct recTypeGrs tcl_type = {
- "tcl",
+static int extract_tcl(void *clientData, struct recExtractCtrl *ctrl)
+{
+ return zebra_grs_extract(clientData, ctrl, grs_read_tcl);
+}
+
+static int retrieve_tcl(void *clientData, struct recRetrieveCtrl *ctrl)
+{
+ return zebra_grs_retrieve(clientData, ctrl, grs_read_tcl);
+}
+
+static struct recType tcl_type = {
+ "grs.tcl",
grs_init,
+ grs_config,
grs_destroy,
- grs_read_tcl
+ extract_tcl,
+ retrieve_tcl,
};
-RecTypeGrs recTypeGrs_tcl = &tcl_type;
#endif
+
+RecType
+#ifdef IDZEBRA_STATIC_GRS_REGX
+idzebra_filter_grs_regx
+#else
+idzebra_filter
+#endif
+
+[] = {
+ ®x_type,
+#if HAVE_TCL_H
+ &tcl_type,
+#endif
+ 0,
+};
projects / idzebra-moved-to-github.git / blobdiff