/*
- * Copyright (C) 1994-1999, Index Data
+ * Copyright (C) 1994-2001, Index Data
* All rights reserved.
- * Sebastian Hammer, Adam Dickmeiss
*
* $Log: regxread.c,v $
- * Revision 1.29 1999-07-12 07:27:54 adam
+ * Revision 1.38 2002-04-04 20:50:37 adam
+ * Multi register works with record paths and data1 profile path
+ *
+ * Revision 1.37 2001/05/29 08:51:59 adam
+ * More fixes for character encodings.
+ *
+ * Revision 1.36 2001/05/22 21:02:26 adam
+ * Fixes for Tcl UTF8 character handling.
+ *
+ * Revision 1.35 2001/03/29 21:31:31 adam
+ * Fixed "record begin" for Tcl filter.
+ *
+ * Revision 1.34 2000/11/29 14:24:01 adam
+ * Script configure uses yaz pthreads options. Added locking for
+ * zebra_register_{lock,unlock}.
+ *
+ * Revision 1.33 1999/11/30 13:48:04 adam
+ * Improved installation. Updated for inclusion of YAZ header files.
+ *
+ * Revision 1.32 1999/09/07 07:19:21 adam
+ * Work on character mapping. Implemented replace rules.
+ *
+ * Revision 1.31 1999/07/14 13:05:29 adam
+ * Tcl filter works with objects when TCL is version 8 or later; filter
+ * works with strings otherwise (slow).
+ *
+ * Revision 1.30 1999/07/14 10:55:28 adam
+ * Fixed memory leak.
+ *
+ * Revision 1.29 1999/07/12 07:27:54 adam
* Improved speed of Tcl processing. Fixed one memory leak.
*
* Revision 1.28 1999/07/06 12:26:04 adam
#include <string.h>
#include <ctype.h>
-#include <tpath.h>
+#include <yaz/tpath.h>
#include <zebrautl.h>
#include <dfa.h>
#include "grsread.h"
#if HAVE_TCL_H
#include <tcl.h>
+
+#if MAJOR_VERSION >= 8
+#define HAVE_TCL_OBJECTS
+#endif
#endif
#define REGX_DEBUG 0
struct regxCode {
char *str;
-#if HAVE_TCL_H
+#if HAVE_TCL_OBJECTS
Tcl_Obj *tcl_obj;
#endif
};
};
struct lexConcatBuf {
- int len;
int max;
char *buf;
};
int (*f_win_rf)(void *, char *, size_t);
off_t (*f_win_sf)(void *, off_t);
- struct lexConcatBuf **concatBuf;
+ struct lexConcatBuf *concatBuf;
int maxLevel;
data1_node **d1_stack;
int d1_level;
struct regxCode *p = *pp;
if (p)
{
-#if HAVE_TCL_H
+#if HAVE_TCL_OBJECTS
if (p->tcl_obj)
Tcl_DecrRefCount (p->tcl_obj);
#endif
p->str = (char *) xmalloc (len+1);
memcpy (p->str, buf, len);
p->str[len] = '\0';
-#if HAVE_TCL_H
+#if HAVE_TCL_OBJECTS
p->tcl_obj = Tcl_NewStringObj ((char *) buf, len);
if (p->tcl_obj)
Tcl_IncrRefCount (p->tcl_obj);
p->f_win_buf = NULL;
p->maxLevel = 128;
- p->concatBuf = (struct lexConcatBuf **)
+ p->concatBuf = (struct lexConcatBuf *)
xmalloc (sizeof(*p->concatBuf) * p->maxLevel);
for (i = 0; i < p->maxLevel; i++)
{
- p->concatBuf[i] = (struct lexConcatBuf *)
- xmalloc (sizeof(**p->concatBuf));
- p->concatBuf[i]->len = p->concatBuf[i]->max = 0;
- p->concatBuf[i]->buf = 0;
+ p->concatBuf[i].max = 0;
+ p->concatBuf[i].buf = 0;
}
p->d1_stack = (data1_node **) xmalloc (sizeof(*p->d1_stack) * p->maxLevel);
p->d1_level = 0;
return ;
for (i = 0; i < p->maxLevel; i++)
- xfree (p->concatBuf[i]);
+ xfree (p->concatBuf[i].buf);
xfree (p->concatBuf);
lt = p->context;
lexContextDestroy (lt);
lt = lt_next;
}
-#if HAVE_TCL_H
+#if HAVE_TCL_OBJECTS
if (p->tcl_interp)
Tcl_DeleteInterp (p->tcl_interp);
#endif
break;
case REGX_PATTERN:
#if REGX_DEBUG
- logf (LOG_DEBUG, "rule %d %s", spec->context->ruleNo, s);
+ logf (LOG_LOG, "rule %d %s", spec->context->ruleNo, s);
#endif
r = dfa_parse (spec->context->dfa, &s);
if (r)
if (spec->tcl_interp)
{
sprintf (fname, "%s.tflt", spec->name);
- spec_inf = yaz_path_fopen (data1_get_tabpath(spec->dh), fname, "r");
+ spec_inf = data1_path_fopen (spec->dh, fname, "r");
}
#endif
if (!spec_inf)
{
sprintf (fname, "%s.flt", spec->name);
- spec_inf = yaz_path_fopen (data1_get_tabpath(spec->dh), fname, "r");
+ spec_inf = data1_path_fopen (spec->dh, fname, "r");
}
if (!spec_inf)
{
return ;
#if REGX_DEBUG
if (elen > 40)
- logf (LOG_DEBUG, "data (%d bytes) %.15s ... %.*s", elen,
+ logf (LOG_LOG, "data (%d bytes) %.15s ... %.*s", elen,
ebuf, 15, ebuf + elen-15);
else if (elen > 0)
- logf (LOG_DEBUG, "data (%d bytes) %.*s", elen, elen, ebuf);
+ logf (LOG_LOG, "data (%d bytes) %.*s", elen, elen, ebuf);
else
- logf (LOG_DEBUG, "data (%d bytes)", elen);
+ logf (LOG_LOG, "data (%d bytes)", elen);
#endif
if (spec->d1_level <= 1)
parent->child = res;
spec->d1_stack[spec->d1_level] = res;
}
- if (org_len + elen >= spec->concatBuf[spec->d1_level]->max)
+ 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))
+ 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;
+ spec->concatBuf[spec->d1_level].buf = new_buf;
}
- assert (spec->concatBuf[spec->d1_level]);
- memcpy (spec->concatBuf[spec->d1_level]->buf + org_len, ebuf, elen);
+ memcpy (spec->concatBuf[spec->d1_level].buf + org_len, ebuf, elen);
res->u.data.len += elen;
}
res->u.data.data = (char *) nmem_malloc (spec->m, res->u.data.len);
else
res->u.data.data = res->lbuf;
- memcpy (res->u.data.data, spec->concatBuf[spec->d1_level]->buf,
+ memcpy (res->u.data.data, spec->concatBuf[spec->d1_level].buf,
res->u.data.len);
}
}
ttype[type_len] = '\0';
#if REGX_DEBUG
- logf (LOG_DEBUG, "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_DEBUG, "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_node (spec->dh, spec->m);
static void tagBegin (struct lexSpec *spec,
const char *tag, int len)
{
- struct data1_node *parent = spec->d1_stack[spec->d1_level -1];
+ struct data1_node *parent;
data1_element *elem = NULL;
- data1_node *partag = get_parent_tag(spec->dh, parent);
+ data1_node *partag;
data1_node *res;
data1_element *e = NULL;
int localtag = 0;
return ;
}
tagStrip (&tag, &len);
+
+ parent = spec->d1_stack[spec->d1_level -1];
+ partag = get_parent_tag(spec->dh, parent);
- res = data1_mk_node (spec->dh, spec->m);
+ res = data1_mk_node_type (spec->dh, spec->m, DATA1N_tag);
res->parent = parent;
- res->which = DATA1N_tag;
- res->u.tag.get_bytes = -1;
if (len >= DATA1_LOCALDATA)
res->u.tag.tag = (char *) nmem_malloc (spec->m, len+1);
res->u.tag.tag[len] = '\0';
#if REGX_DEBUG
- logf (LOG_DEBUG, "begin tag %s (%d)", res->u.tag.tag, spec->d1_level);
+ logf (LOG_LOG, "begin tag %s (%d)", res->u.tag.tag, spec->d1_level);
#endif
if (parent->which == DATA1N_variant)
return ;
spec->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->last_child = res;
break;
}
#if REGX_DEBUG
- logf (LOG_DEBUG, "end tag (%d)", spec->d1_level);
+ logf (LOG_LOG, "end tag (%d)", spec->d1_level);
#endif
}
data1_absyn *absyn;
#if REGX_DEBUG
- logf (LOG_DEBUG, "begin record %s", absynName);
+ logf (LOG_LOG, "begin record %s", absynName);
#endif
if (!(absyn = data1_get_absyn (spec->dh, absynName)))
logf (LOG_WARN, "Unknown tagset: %s", absynName);
res = data1_mk_node (spec->dh, spec->m);
res->which = DATA1N_root;
- res->u.root.type = absynName;
+ res->u.root.type =
+ data1_insert_string(spec->dh, res, spec->m, absynName);
res->u.root.absyn = absyn;
res->root = res;
{
struct lexContext *lc = spec->context;
#if REGX_DEBUG
- logf (LOG_DEBUG, "begin context %s",argv[2]);
+ logf (LOG_LOG, "begin context %s",argv[2]);
#endif
while (lc && strcmp (argv[2], lc->name))
lc = lc->next;
(spec->d1_level)--;
}
#if REGX_DEBUG
- logf (LOG_DEBUG, "end record");
+ logf (LOG_LOG, "end record");
#endif
spec->stop_flag = 1;
}
if (spec->d1_level == 0)
{
#if REGX_DEBUG
- logf (LOG_DEBUG, "end element end records");
+ logf (LOG_LOG, "end element end records");
#endif
spec->stop_flag = 1;
}
else if (!strcmp (argv[1], "context"))
{
#if REGX_DEBUG
- logf (LOG_DEBUG, "end context");
+ logf (LOG_LOG, "end context");
#endif
if (spec->context_stack_top)
(spec->context_stack_top)--;
while (argi < argc)
{
+#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);
+ Tcl_DStringFree (&ds);
+#else
execData (spec, argv[argi], strlen(argv[argi]), textFlag);
+#endif
argi++;
}
if (element)
var_buf[var_len] = ch;
}
}
- if (code->tcl_obj)
- ret = Tcl_GlobalEvalObj(spec->tcl_interp, code->tcl_obj);
- else
- ret = Tcl_GlobalEval (spec->tcl_interp, code->str);
+#if HAVE_TCL_OBJECTS
+ ret = Tcl_GlobalEvalObj(spec->tcl_interp, code->tcl_obj);
+#else
+ ret = Tcl_GlobalEval (spec->tcl_interp, code->str);
+#endif
if (ret != TCL_OK)
{
const char *err = Tcl_GetVar(spec->tcl_interp, "errorInfo", 0);
absynName[cmd_len] = '\0';
#if REGX_DEBUG
- logf (LOG_DEBUG, "begin record %s", absynName);
+ logf (LOG_LOG, "begin record %s", absynName);
#endif
if (!(absyn = data1_get_absyn (spec->dh, absynName)))
logf (LOG_WARN, "Unknown tagset: %s", absynName);
r = execTok (spec, &s, &cmd_str, &cmd_len);
p = regxStrz (cmd_str, cmd_len, ptmp);
#if REGX_DEBUG
- logf (LOG_DEBUG, "begin context %s", p);
+ logf (LOG_LOG, "begin context %s", p);
#endif
while (lc && strcmp (p, lc->name))
lc = lc->next;
}
r = execTok (spec, &s, &cmd_str, &cmd_len);
#if REGX_DEBUG
- logf (LOG_DEBUG, "end record");
+ logf (LOG_LOG, "end record");
#endif
spec->stop_flag = 1;
}
if (spec->d1_level == 0)
{
#if REGX_DEBUG
- logf (LOG_DEBUG, "end element end records");
+ logf (LOG_LOG, "end element end records");
#endif
spec->stop_flag = 1;
}
else if (!strcmp (p, "context"))
{
#if REGX_DEBUG
- logf (LOG_DEBUG, "end context");
+ logf (LOG_LOG, "end context");
#endif
if (spec->context_stack_top)
(spec->context_stack_top)--;
int ruleNo, int start_ptr, int *pptr)
{
#if REGX_DEBUG
- logf (LOG_DEBUG, "exec rule %d", ruleNo);
+ logf (LOG_LOG, "exec rule %d", ruleNo);
#endif
return execAction (spec, context->fastRule[ruleNo]->actionList,
start_ptr, pptr);
if (spec->f_win_ef && *ptr != F_WIN_EOF)
{
#if REGX_DEBUG
- logf (LOG_DEBUG, "regx: endf ptr=%d", *ptr);
+ logf (LOG_LOG, "regx: endf ptr=%d", *ptr);
#endif
(*spec->f_win_ef)(spec->f_win_fh, *ptr);
}
struct lexSpec **curLexSpec = &specs->spec;
#if REGX_DEBUG
- logf (LOG_DEBUG, "grs_read_regx");
+ logf (LOG_LOG, "grs_read_regx");
#endif
if (!*curLexSpec || strcmp ((*curLexSpec)->name, p->type))
{
struct lexSpec **curLexSpec = &specs->spec;
#if REGX_DEBUG
- logf (LOG_DEBUG, "grs_read_tcl");
+ logf (LOG_LOG, "grs_read_tcl");
#endif
if (!*curLexSpec || strcmp ((*curLexSpec)->name, p->type))
{
if (*curLexSpec)
lexSpecDestroy (curLexSpec);
*curLexSpec = lexSpecCreate (p->type, p->dh);
+ Tcl_FindExecutable("");
tcl_interp = (*curLexSpec)->tcl_interp = Tcl_CreateInterp();
+ Tcl_Init(tcl_interp);
Tcl_CreateCommand (tcl_interp, "begin", cmd_tcl_begin, *curLexSpec, 0);
Tcl_CreateCommand (tcl_interp, "end", cmd_tcl_end, *curLexSpec, 0);
Tcl_CreateCommand (tcl_interp, "data", cmd_tcl_data, *curLexSpec, 0);