X-Git-Url: http://git.indexdata.com/?p=yaz-moved-to-github.git;a=blobdiff_plain;f=src%2Frecord_conv.c;h=212e96b7a901e40ed13bb1edb8e4cf1e3819a2d5;hp=c6ce964638364ac9f05468cc9d5b6755c2d07376;hb=b1c1ccaac399ee2eff5f993654accb5d17844c9e;hpb=95b69dabd857fa3342a71df2be123333b42c8da2

diff --git a/src/record_conv.c b/src/record_conv.c
index c6ce964..212e96b 100644
--- a/src/record_conv.c
+++ b/src/record_conv.c
@@ -49,9 +49,6 @@ struct yaz_record_conv_struct {
 
     /** \brief path for opening files  */
     char *path;
-
-    /** \brief handlers */
-    struct yaz_record_conv_type *types;
 };
 
 struct marc_info {
@@ -60,6 +57,7 @@ struct marc_info {
     const char *output_charset;
     int input_format_mode;
     int output_format_mode;
+    const char *leader_spec;
 };
 
 /** \brief tranformation info (rule info) */
@@ -86,40 +84,21 @@ static void yaz_record_conv_reset(yaz_record_conv_t p)
     p->rules_p = &p->rules;
 }
 
-void yaz_record_conv_add_type(yaz_record_conv_t p,
-                              struct yaz_record_conv_type *type)
-{
-    struct yaz_record_conv_type **tp = &p->types;
-    while (*tp)
-        tp = &(*tp)->next;
-    *tp = xmalloc(sizeof(*type));
-    memcpy(*tp, type, sizeof(*type));
-    (*tp)->next = 0;
-}
-
 void yaz_record_conv_destroy(yaz_record_conv_t p)
 {
     if (p)
     {
-        struct yaz_record_conv_type *t = p->types;
-
         yaz_record_conv_reset(p);
         nmem_destroy(p->nmem);
         wrbuf_destroy(p->wr_error);
 
-        while (t)
-        { 
-            struct yaz_record_conv_type *t_next = t->next;
-            xfree(t);
-            t = t_next;
-        }
         xfree(p->path);
         xfree(p);
     }
 }
 
 #if YAZ_HAVE_XSLT
-static void *construct_xslt(yaz_record_conv_t p, const xmlNode *ptr,
+static void *construct_xslt(const xmlNode *ptr,
                             const char *path, WRBUF wr_error)
 {
     struct _xmlAttr *attr;
@@ -263,7 +242,7 @@ static void destroy_xslt(void *info)
 #endif
 
 
-static void *construct_marc(yaz_record_conv_t p, const xmlNode *ptr,
+static void *construct_marc(const xmlNode *ptr,
                             const char *path, WRBUF wr_error)
 {
     NMEM nmem = nmem_create();
@@ -283,6 +262,7 @@ static void *construct_marc(yaz_record_conv_t p, const xmlNode *ptr,
     info->output_charset = 0;
     info->input_format_mode = 0;
     info->output_format_mode = 0;
+    info->leader_spec = 0;
 
     for (attr = ptr->properties; attr; attr = attr->next)
     {
@@ -298,6 +278,10 @@ static void *construct_marc(yaz_record_conv_t p, const xmlNode *ptr,
         else if (!xmlStrcmp(attr->name, BAD_CAST "outputformat") &&
             attr->children && attr->children->type == XML_TEXT_NODE)
             output_format = (const char *) attr->children->content;
+        else if (!xmlStrcmp(attr->name, BAD_CAST "leaderspec") &&
+                 attr->children && attr->children->type == XML_TEXT_NODE)
+            info->leader_spec =
+                nmem_strdup(info->nmem,(const char *) attr->children->content);
         else
         {
             wrbuf_printf(wr_error, "Element <marc>: expected attributes"
@@ -310,7 +294,7 @@ static void *construct_marc(yaz_record_conv_t p, const xmlNode *ptr,
     }
     if (!input_format)
     {
-        wrbuf_printf(p->wr_error, "Element <marc>: "
+        wrbuf_printf(wr_error, "Element <marc>: "
                      "attribute 'inputformat' required");
         nmem_destroy(info->nmem);
         return 0;
@@ -386,7 +370,7 @@ static void *construct_marc(yaz_record_conv_t p, const xmlNode *ptr,
                                         info->input_charset);
         if (!cd)
         {
-            wrbuf_printf(p->wr_error, 
+            wrbuf_printf(wr_error, 
                          "Element <marc inputcharset='%s' outputcharset='%s'>:"
                          " Unsupported character set mapping"
                          " defined by attribute values",
@@ -396,22 +380,22 @@ static void *construct_marc(yaz_record_conv_t p, const xmlNode *ptr,
         }
         yaz_iconv_close(cd);
     }
-    else if (info->input_charset)
+    else if (!info->output_charset)
     {
         wrbuf_printf(wr_error, "Element <marc>: "
                      "attribute 'outputcharset' missing");
         nmem_destroy(info->nmem);
         return 0;
     }
-    else if (info->output_charset)
+    else if (!info->input_charset)
     {
         wrbuf_printf(wr_error, "Element <marc>: "
                      "attribute 'inputcharset' missing");
         nmem_destroy(info->nmem);
         return 0;
     }
-    info->input_charset = nmem_strdup(p->nmem, info->input_charset);
-    info->output_charset = nmem_strdup(p->nmem, info->output_charset);
+    info->input_charset = nmem_strdup(info->nmem, info->input_charset);
+    info->output_charset = nmem_strdup(info->nmem, info->output_charset);
     return info;
 }
 
@@ -424,7 +408,9 @@ static int convert_marc(void *info, WRBUF record, WRBUF wr_error)
     yaz_marc_t mt = yaz_marc_create();
     
     yaz_marc_xml(mt, mi->output_format_mode);
-    
+    if (mi->leader_spec)
+        yaz_marc_leader_spec(mt, mi->leader_spec);
+        
     if (cd)
         yaz_marc_iconv(mt, cd);
     if (mi->input_format_mode == YAZ_MARC_ISO2709)
@@ -479,8 +465,27 @@ static void destroy_marc(void *info)
     nmem_destroy(mi->nmem);
 }
 
-int yaz_record_conv_configure(yaz_record_conv_t p, const xmlNode *ptr)
+int yaz_record_conv_configure_t(yaz_record_conv_t p, const xmlNode *ptr,
+                                struct yaz_record_conv_type *types)
 {
+    struct yaz_record_conv_type bt[2];
+    
+    /* register marc */
+    bt[0].construct = construct_marc;
+    bt[0].convert = convert_marc;
+    bt[0].destroy = destroy_marc;
+
+#if YAZ_HAVE_XSLT
+    /* register xslt */
+    bt[0].next = &bt[1];
+    bt[1].next = types;
+    bt[1].construct = construct_xslt;
+    bt[1].convert = convert_xslt;
+    bt[1].destroy = destroy_xslt;
+#else
+    bt[0].next = types;
+#endif
+    
     yaz_record_conv_reset(p);
 
     /* parsing element children */
@@ -491,30 +496,39 @@ int yaz_record_conv_configure(yaz_record_conv_t p, const xmlNode *ptr)
         void *info = 0;
         if (ptr->type != XML_ELEMENT_NODE)
             continue;
-        for (t = p->types; t; t = t->next)
+        for (t = &bt[0]; t; t = t->next)
         {
             wrbuf_rewind(p->wr_error);
-            info = t->construct(p, ptr, p->path, p->wr_error);
-            if (info)
+            info = t->construct(ptr, p->path, p->wr_error);
+
+            if (info || wrbuf_len(p->wr_error))
                 break;
+            /* info== 0 and no error reported , ie not handled by it */
         }
         if (!info)
         {
-            wrbuf_printf(p->wr_error, "Element <backend>: expected "
-                         "<marc> or <xslt> element, got <%s>"
-                         , ptr->name);
+            if (wrbuf_len(p->wr_error) == 0)
+                wrbuf_printf(p->wr_error, "Element <backend>: expected "
+                             "<marc> or <xslt> element, got <%s>"
+                             , ptr->name);
             return -1;
         }
         r = (struct yaz_record_conv_rule *) nmem_malloc(p->nmem, sizeof(*r));
         r->next = 0;
         r->info = info;
-        r->type = t;
+        r->type = nmem_malloc(p->nmem, sizeof(*t));
+        memcpy(r->type, t, sizeof(*t));
         *p->rules_p = r;
         p->rules_p = &r->next;
     }
     return 0;
 }
 
+int yaz_record_conv_configure(yaz_record_conv_t p, const xmlNode *ptr)
+{
+    return yaz_record_conv_configure_t(p, ptr, 0);
+}
+
 static int yaz_record_conv_record_rule(yaz_record_conv_t p,
                                        struct yaz_record_conv_rule *r,
                                        const char *input_record_buf,
@@ -599,31 +613,9 @@ yaz_record_conv_t yaz_record_conv_create()
     p->wr_error = wrbuf_alloc();
     p->rules = 0;
     p->path = 0;
-    p->types = 0;
-
 #if YAZ_HAVE_EXSLT
     exsltRegisterAll(); 
 #endif    
-    { /* register marc */
-        struct yaz_record_conv_type t;
-
-        t.construct = construct_marc;
-        t.convert = convert_marc;
-        t.destroy = destroy_marc;
-
-        yaz_record_conv_add_type(p, &t);
-    }
-#if YAZ_HAVE_XSLT
-    { /* register xslt */
-        struct yaz_record_conv_type t;
-        
-        t.construct = construct_xslt;
-        t.convert = convert_xslt;
-        t.destroy = destroy_xslt;
-
-        yaz_record_conv_add_type(p, &t);
-    }
-#endif
     return p;
 }