X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=recctrl%2Fregxread.c;h=d809993f04676233e44caae4f015cc627a21a108;hb=13bf0c380e98816595127291b64368dd9b8ca639;hp=9b8473b060b977fe92f653d6ebb49927827e83ac;hpb=b385fad64ec1afb51fd0ec9ad76567282ab20bfe;p=idzebra-moved-to-github.git

diff --git a/recctrl/regxread.c b/recctrl/regxread.c
index 9b8473b..d809993 100644
--- a/recctrl/regxread.c
+++ b/recctrl/regxread.c
@@ -1,5 +1,5 @@
-/* $Id: regxread.c,v 1.47 2003-04-24 19:34:20 adam Exp $
-   Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003
+/* $Id: regxread.c,v 1.52 2004-08-15 17:22:45 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.
@@ -473,6 +473,8 @@ static int actionListMk (struct lexSpec *spec, const char *s,
                 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;
@@ -590,6 +592,14 @@ int readFileSpec (struct lexSpec *spec)
     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);
@@ -632,12 +642,6 @@ int readFileSpec (struct lexSpec *spec)
     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;
@@ -660,7 +664,8 @@ static struct lexSpec *curLexSpec = NULL;
 #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;
@@ -668,13 +673,12 @@ static void execData (struct lexSpec *spec,
     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)");
-        assert(0);
     }
     else if (elen > 0)
         logf (LOG_LOG, "data(%d bytes) %.*s", elen, elen, ebuf);
@@ -688,43 +692,82 @@ static void execData (struct lexSpec *spec,
     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;
+	}
+    } 
+    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;
 	}
-	spec->concatBuf[spec->d1_level].buf = new_buf;
+	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)
@@ -875,21 +918,33 @@ static void tagEnd (struct lexSpec *spec, int min_level,
 
 
 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)
@@ -900,10 +955,11 @@ static int tryMatch (struct lexSpec *spec, int *pptr, int *mptr,
             }
             break;
         }
+
         t = state->trans;
         i = state->tran_no;
         while (1)
-            if (--i < 0)
+            if (--i < 0)    /* no transition for character c */
             {
                 if (last_rule)
                 {
@@ -912,27 +968,28 @@ static int tryMatch (struct lexSpec *spec, int *pptr, int *mptr,
                     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++;
@@ -1016,14 +1073,14 @@ static char *regxStrz (const char *src, int len, char *str)
 
 #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
@@ -1031,6 +1088,8 @@ static int cmd_tcl_begin (ClientData clientData, Tcl_Interp *interp,
 #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);
@@ -1070,7 +1129,7 @@ static int cmd_tcl_begin (ClientData clientData, Tcl_Interp *interp,
 }
 
 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)
@@ -1090,8 +1149,8 @@ static int cmd_tcl_end (ClientData clientData, Tcl_Interp *interp,
     }
     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;
@@ -1102,7 +1161,7 @@ static int cmd_tcl_end (ClientData clientData, Tcl_Interp *interp,
 	    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");
@@ -1124,11 +1183,12 @@ static int cmd_tcl_end (ClientData clientData, Tcl_Interp *interp,
 }
 
 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)
@@ -1144,6 +1204,12 @@ static int cmd_tcl_data (ClientData clientData, Tcl_Interp *interp,
 	    if (argi < argc)
 		element = argv[argi++];
 	}
+	else if (!strcmp("-attribute", argv[argi]))
+	{
+	    argi++;
+	    if (argi < argc)
+		attribute = argv[argi++];
+	}
 	else
 	    break;
     }
@@ -1155,20 +1221,22 @@ static int cmd_tcl_data (ClientData clientData, Tcl_Interp *interp,
 #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;
@@ -1266,7 +1334,7 @@ static void execCode (struct lexSpec *spec, struct regxCode *code)
                 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;
@@ -1280,6 +1348,8 @@ static void execCode (struct lexSpec *spec, struct regxCode *code)
 #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);
@@ -1378,7 +1448,7 @@ static void execCode (struct lexSpec *spec, struct regxCode *code)
 	    }
 	    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))
@@ -1391,7 +1461,7 @@ static void execCode (struct lexSpec *spec, struct regxCode *code)
 		}
 		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");
@@ -1417,6 +1487,8 @@ static void execCode (struct lexSpec *spec, struct regxCode *code)
             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)
             {
@@ -1428,6 +1500,13 @@ static void execCode (struct lexSpec *spec, struct regxCode *code)
                     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);
@@ -1441,11 +1520,12 @@ static void execCode (struct lexSpec *spec, struct regxCode *code)
                 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"))
         {
@@ -1542,13 +1622,14 @@ static int execAction (struct lexSpec *spec, struct lexRuleAction *ap,
             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
                 {
@@ -1561,7 +1642,7 @@ static int execAction (struct lexSpec *spec, struct lexRuleAction *ap,
             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;