Implemented "begin variant" for the sgml.regx filter.

diff --git a/CHANGELOG b/CHANGELOG
index 79b706e..d471554 100644 (file)
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,3 +1,5 @@
+Implemented "begin variant" for the sgml.regx - filter.
+
 Fixed a few memory leaks.
 
 Moved towards generic character mapping. Type w, p uses

diff --git a/recctrl/recgrs.c b/recctrl/recgrs.c
index 46821bc..636fe27 100644 (file)
--- a/recctrl/recgrs.c
+++ b/recctrl/recgrs.c
@@ -4,7 +4,10 @@
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: recgrs.c,v $
- * Revision 1.13  1997-10-31 12:35:44  adam
+ * Revision 1.14  1997-11-06 11:41:01  adam
+ * Implemented "begin variant" for the sgml.regx filter.
+ *
+ * Revision 1.13  1997/10/31 12:35:44  adam
  * Added a few log statements.
  *
  * Revision 1.12  1997/10/29 12:02:22  adam
@@ -492,9 +495,15 @@ static int process_comp(data1_handle dh, data1_node *n, Z_RecordComposition *c)
                return 26; /* fix */
     }
     if (espec)
+    {
+        logf (LOG_LOG, "Element: Espec-1 match");
        return data1_doespec1(dh, n, espec);
+    }
     else
+    {
+       logf (LOG_DEBUG, "Element: all match");
        return -1;
+    }
 }
 
 static int grs_retrieve(struct recRetrieveCtrl *p)

diff --git a/recctrl/regxread.c b/recctrl/regxread.c
index 17ce5d9..77e7523 100644 (file)
--- a/recctrl/regxread.c
+++ b/recctrl/regxread.c
@@ -4,7 +4,10 @@
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: regxread.c,v $
- * Revision 1.10  1997-10-31 12:36:12  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
@@ -663,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,
@@ -704,12 +794,12 @@ static void tagBegin (struct lexSpec *spec,
     
     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])
@@ -727,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) == (size_t) 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
@@ -954,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"))
         {

diff --git a/tab/sgml.flt b/tab/sgml.flt
index 3225f56..83ad5dd 100644 (file)
--- a/tab/sgml.flt
+++ b/tab/sgml.flt
@@ -1,5 +1,8 @@
-# $Id: sgml.flt,v 1.3 1996-01-08 19:15:54 adam Exp $
+# $Id: sgml.flt,v 1.4 1997-11-06 11:41:01 adam Exp $
 BEGIN  /\n*</  BODY    />\n*/  { begin record $2 }
+/\n*<[Vv][Aa][Rr][ ]+/  /[^ >]+/   /[ ]+/  /[^ >]+/  /[ ]+/ /[^ >]+/ /[ ]*>/ {
+                                  begin variant $1 $3 $5
+                                }
 /\n*</         BODY    />\n*/  { begin element $1 }
 /\n*<\//       BODY    />\n*/  { end element }
 /[ \n\t]+/                     { data " " }