record_conv: extensible conversion
authorAdam Dickmeiss <adam@indexdata.dk>
Thu, 1 Mar 2012 13:52:58 +0000 (14:52 +0100)
committerAdam Dickmeiss <adam@indexdata.dk>
Thu, 1 Mar 2012 13:52:58 +0000 (14:52 +0100)
A new conversion type may be defined for the record_conv system,
with the new function yaz_record_conv_add_type.

include/yaz/record_conv.h
src/record_conv.c

index 501e1e9..acf1c82 100644 (file)
@@ -44,6 +44,22 @@ YAZ_BEGIN_CDECL
 /** record conversion handle  */
 typedef struct yaz_record_conv_struct *yaz_record_conv_t;
 
+/** record conversion type */
+struct yaz_record_conv_type {
+    /** \brief internal; no need to set */
+    struct yaz_record_conv_type *next;
+
+    /** \brief construct and configure a type of ours */
+    void * (*construct)(yaz_record_conv_t , const xmlNode *, const char *path,
+                        WRBUF error_msg);
+
+    /** \brief converts a record */
+    int  (*convert)(void *info, WRBUF record, WRBUF error_msg);
+
+    /** \brief destroys our conversion handler */
+    void (*destroy)(void *info);
+};
+
 /** creates record handle
     \return record handle
 */
@@ -127,6 +143,14 @@ const char *yaz_record_conv_get_error(yaz_record_conv_t p);
 YAZ_EXPORT
 void yaz_record_conv_set_path(yaz_record_conv_t p, const char *path);
 
+/** adds a type to our conversion handler
+    \param p record conversion handle
+    \param type info
+*/    
+YAZ_EXPORT
+void yaz_record_conv_add_type(yaz_record_conv_t p,
+                              struct yaz_record_conv_type *type);
+
 YAZ_END_CDECL
 
 #endif
index d039c51..c6ce964 100644 (file)
@@ -49,31 +49,23 @@ struct yaz_record_conv_struct {
 
     /** \brief path for opening files  */
     char *path;
+
+    /** \brief handlers */
+    struct yaz_record_conv_type *types;
 };
 
-/** \brief tranformation types (rule types) */
-enum YAZ_RECORD_CONV_RULE 
-{
-    YAZ_RECORD_CONV_RULE_XSLT,
-    YAZ_RECORD_CONV_RULE_MARC
+struct marc_info {
+    NMEM nmem;
+    const char *input_charset;
+    const char *output_charset;
+    int input_format_mode;
+    int output_format_mode;
 };
 
 /** \brief tranformation info (rule info) */
 struct yaz_record_conv_rule {
-    enum YAZ_RECORD_CONV_RULE which;
-    union {
-#if YAZ_HAVE_XSLT
-        struct {
-            xmlDocPtr xsp_doc;
-        } xslt;
-#endif
-        struct {
-            const char *input_charset;
-            const char *output_charset;
-            int input_format;
-            int output_format;
-        } marc;
-    } u;
+    struct yaz_record_conv_type *type;
+    void *info;
     struct yaz_record_conv_rule *next;
 };
 
@@ -84,16 +76,7 @@ static void yaz_record_conv_reset(yaz_record_conv_t p)
     struct yaz_record_conv_rule *r;
     for (r = p->rules; r; r = r->next)
     {
-        if (r->which == YAZ_RECORD_CONV_RULE_MARC)
-        {
-            ;
-        }
-#if YAZ_HAVE_XSLT
-        else if (r->which == YAZ_RECORD_CONV_RULE_XSLT)
-        {
-            xmlFreeDoc(r->u.xslt.xsp_doc);
-        }
-#endif
+        r->type->destroy(r->info);
     }
     wrbuf_rewind(p->wr_error);
     nmem_reset(p->nmem);
@@ -103,53 +86,48 @@ static void yaz_record_conv_reset(yaz_record_conv_t p)
     p->rules_p = &p->rules;
 }
 
-yaz_record_conv_t yaz_record_conv_create()
+void yaz_record_conv_add_type(yaz_record_conv_t p,
+                              struct yaz_record_conv_type *type)
 {
-    yaz_record_conv_t p = (yaz_record_conv_t) xmalloc(sizeof(*p));
-    p->nmem = nmem_create();
-    p->wr_error = wrbuf_alloc();
-    p->rules = 0;
-    p->path = 0;
-
-#if YAZ_HAVE_EXSLT
-    exsltRegisterAll(); 
-#endif
-    yaz_record_conv_reset(p);
-    return p;
+    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);
     }
 }
 
-/** \brief adds a rule */
-static struct yaz_record_conv_rule *add_rule(yaz_record_conv_t p,
-                                             enum YAZ_RECORD_CONV_RULE type)
-{
-    struct yaz_record_conv_rule *r = (struct yaz_record_conv_rule *)
-        nmem_malloc(p->nmem, sizeof(*r));
-    r->which = type;
-    r->next = 0;
-    *p->rules_p = r;
-    p->rules_p = &r->next;
-    return r;
-}
-
-/** \brief parse 'xslt' conversion node */
-static int conv_xslt(yaz_record_conv_t p, const xmlNode *ptr)
-{
 #if YAZ_HAVE_XSLT
+static void *construct_xslt(yaz_record_conv_t p, const xmlNode *ptr,
+                            const char *path, WRBUF wr_error)
+{
     struct _xmlAttr *attr;
     const char *stylesheet = 0;
 
+    if (strcmp((const char *) ptr->name, "xslt"))
+        return 0;
+
     for (attr = ptr->properties; attr; attr = attr->next)
     {
         if (!xmlStrcmp(attr->name, BAD_CAST "stylesheet") &&
@@ -157,51 +135,51 @@ static int conv_xslt(yaz_record_conv_t p, const xmlNode *ptr)
             stylesheet = (const char *) attr->children->content;
         else
         {
-            wrbuf_printf(p->wr_error, "Bad attribute '%s'"
+            wrbuf_printf(wr_error, "Bad attribute '%s'"
                          "Expected stylesheet.", attr->name);
-            return -1;
+            return 0;
         }
     }
     if (!stylesheet)
     {
-        wrbuf_printf(p->wr_error, "Element <xslt>: "
+        wrbuf_printf(wr_error, "Element <xslt>: "
                      "attribute 'stylesheet' expected");
-        return -1;
+        return 0;
     }
     else
     {
         char fullpath[1024];
         xsltStylesheetPtr xsp;
         xmlDocPtr xsp_doc;
-        if (!yaz_filepath_resolve(stylesheet, p->path, 0, fullpath))
+        if (!yaz_filepath_resolve(stylesheet, path, 0, fullpath))
         {
-            wrbuf_printf(p->wr_error, "Element <xslt stylesheet=\"%s\"/>:"
+            wrbuf_printf(wr_error, "Element <xslt stylesheet=\"%s\"/>:"
                          " could not locate stylesheet '%s'",
                          stylesheet, stylesheet);
-            if (p->path)
-                wrbuf_printf(p->wr_error, " with path '%s'", p->path);
+            if (path)
+                wrbuf_printf(wr_error, " with path '%s'", path);
                 
-            return -1;
+            return 0;
         }
         xsp_doc = xmlParseFile(fullpath);
         if (!xsp_doc)
         {
-            wrbuf_printf(p->wr_error, "Element: <xslt stylesheet=\"%s\"/>:"
+            wrbuf_printf(wr_error, "Element: <xslt stylesheet=\"%s\"/>:"
                          " xml parse failed: %s", stylesheet, fullpath);
-            if (p->path)
-                wrbuf_printf(p->wr_error, " with path '%s'", p->path);
-            return -1;
+            if (path)
+                wrbuf_printf(wr_error, " with path '%s'", path);
+            return 0;
         }
         /* need to copy this before passing it to the processor. It will
            be encapsulated in the xsp and destroyed by xsltFreeStylesheet */
         xsp = xsltParseStylesheetDoc(xmlCopyDoc(xsp_doc, 1));
         if (!xsp)
         {
-            wrbuf_printf(p->wr_error, "Element: <xslt stylesheet=\"%s\"/>:"
+            wrbuf_printf(wr_error, "Element: <xslt stylesheet=\"%s\"/>:"
                          " xslt parse failed: %s", stylesheet, fullpath);
-            if (p->path)
-                wrbuf_printf(p->wr_error, " with path '%s'", p->path);
-            wrbuf_printf(p->wr_error, " ("
+            if (path)
+                wrbuf_printf(wr_error, " with path '%s'", path);
+            wrbuf_printf(wr_error, " ("
 #if YAZ_HAVE_EXSLT
                          
                          "EXSLT enabled"
@@ -210,44 +188,110 @@ static int conv_xslt(yaz_record_conv_t p, const xmlNode *ptr)
 #endif
                          ")");
             xmlFreeDoc(xsp_doc);
-            return -1;
+            return 0;
         }
         else
         {
-            struct yaz_record_conv_rule *r = 
-                add_rule(p, YAZ_RECORD_CONV_RULE_XSLT);
-            r->u.xslt.xsp_doc = xsp_doc;
             xsltFreeStylesheet(xsp);
+            return xsp_doc;
         }
     }
     return 0;
+}
+
+static int convert_xslt(void *info, WRBUF record, WRBUF wr_error)
+{
+    int ret = 0;
+    xmlDocPtr doc = xmlParseMemory(wrbuf_buf(record),
+                                   wrbuf_len(record));
+    if (!doc)
+    {
+        wrbuf_printf(wr_error, "xmlParseMemory failed");
+        ret = -1;
+    }
+    else
+    {
+        xmlDocPtr xsp_doc = xmlCopyDoc((xmlDocPtr) info, 1);
+        xsltStylesheetPtr xsp = xsltParseStylesheetDoc(xsp_doc);
+        xmlDocPtr res = xsltApplyStylesheet(xsp, doc, 0);
+        if (res)
+        {
+            xmlChar *out_buf = 0;
+            int out_len;
+            
+#if HAVE_XSLTSAVERESULTTOSTRING
+            xsltSaveResultToString(&out_buf, &out_len, res, xsp);
 #else
-    wrbuf_printf(p->wr_error, "xslt unsupported."
-                 " YAZ compiled without XSLT support");
-    return -1;
+            xmlDocDumpFormatMemory (res, &out_buf, &out_len, 1);
 #endif
+            if (!out_buf)
+            {
+                wrbuf_printf(wr_error,
+                             "xsltSaveResultToString failed");
+                ret = -1;
+            }
+            else
+            {
+                wrbuf_rewind(record);
+                wrbuf_write(record, (const char *) out_buf, out_len);
+                
+                xmlFree(out_buf);
+            }
+            xmlFreeDoc(res);
+        }
+        else
+        {
+            wrbuf_printf(wr_error, "xsltApplyStylesheet failed");
+            ret = -1;
+        }
+        xmlFreeDoc(doc);
+        xsltFreeStylesheet(xsp); /* frees xsp_doc too */
+    }
+    return ret;
 }
 
-/** \brief parse 'marc' conversion node */
-static int conv_marc(yaz_record_conv_t p, const xmlNode *ptr)
+static void destroy_xslt(void *info)
 {
+    if (info)
+    {
+        xmlDocPtr xsp_doc = info;
+        xmlFreeDoc(xsp_doc);
+    }
+}
+
+/* YAZ_HAVE_XSLT */
+#endif
+
+
+static void *construct_marc(yaz_record_conv_t p, const xmlNode *ptr,
+                            const char *path, WRBUF wr_error)
+{
+    NMEM nmem = nmem_create();
+    struct marc_info *info = nmem_malloc(nmem, sizeof(*info));
     struct _xmlAttr *attr;
-    const char *input_charset = 0;
-    const char *output_charset = 0;
     const char *input_format = 0;
     const char *output_format = 0;
-    int input_format_mode = 0;
-    int output_format_mode = 0;
-    struct yaz_record_conv_rule *r;
+
+    if (strcmp((const char *) ptr->name, "marc"))
+    {
+        nmem_destroy(nmem);
+        return 0;
+    }
+
+    info->nmem = nmem;
+    info->input_charset = 0;
+    info->output_charset = 0;
+    info->input_format_mode = 0;
+    info->output_format_mode = 0;
 
     for (attr = ptr->properties; attr; attr = attr->next)
     {
         if (!xmlStrcmp(attr->name, BAD_CAST "inputcharset") &&
             attr->children && attr->children->type == XML_TEXT_NODE)
-            input_charset = (const char *) attr->children->content;
+            info->input_charset = (const char *) attr->children->content;
         else if (!xmlStrcmp(attr->name, BAD_CAST "outputcharset") &&
             attr->children && attr->children->type == XML_TEXT_NODE)
-            output_charset = (const char *) attr->children->content;
+            info->output_charset = (const char *) attr->children->content;
         else if (!xmlStrcmp(attr->name, BAD_CAST "inputformat") &&
             attr->children && attr->children->type == XML_TEXT_NODE)
             input_format = (const char *) attr->children->content;
@@ -256,114 +300,183 @@ static int conv_marc(yaz_record_conv_t p, const xmlNode *ptr)
             output_format = (const char *) attr->children->content;
         else
         {
-            wrbuf_printf(p->wr_error, "Element <marc>: expected attributes"
+            wrbuf_printf(wr_error, "Element <marc>: expected attributes"
                          "'inputformat', 'inputcharset', 'outputformat' or"
                          " 'outputcharset', got attribute '%s'", 
                          attr->name);
-            return -1;
+            nmem_destroy(info->nmem);
+            return 0;
         }
     }
     if (!input_format)
     {
         wrbuf_printf(p->wr_error, "Element <marc>: "
                      "attribute 'inputformat' required");
-        return -1;
+        nmem_destroy(info->nmem);
+        return 0;
     }
     else if (!strcmp(input_format, "marc"))
     {
-        input_format_mode = YAZ_MARC_ISO2709;
+        info->input_format_mode = YAZ_MARC_ISO2709;
     }
     else if (!strcmp(input_format, "xml"))
     {
-        input_format_mode = YAZ_MARC_MARCXML;
+        info->input_format_mode = YAZ_MARC_MARCXML;
         /** Libxml2 generates UTF-8 encoding by default .
             So we convert from UTF-8 to outputcharset (if defined) 
         */
-        if (!input_charset && output_charset)
-            input_charset = "utf-8";
+        if (!info->input_charset && info->output_charset)
+            info->input_charset = "utf-8";
     }
     else
     {
-        wrbuf_printf(p->wr_error, "Element <marc inputformat='%s'>: "
+        wrbuf_printf(wr_error, "Element <marc inputformat='%s'>: "
                      " Unsupported input format"
                      " defined by attribute value", 
                      input_format);
-        return -1;
+        nmem_destroy(info->nmem);
+        return 0;
     }
     
     if (!output_format)
     {
-        wrbuf_printf(p->wr_error, 
+        wrbuf_printf(wr_error, 
                      "Element <marc>: attribute 'outputformat' required");
-        return -1;
+        nmem_destroy(info->nmem);
+        return 0;
     }
     else if (!strcmp(output_format, "line"))
     {
-        output_format_mode = YAZ_MARC_LINE;
+        info->output_format_mode = YAZ_MARC_LINE;
     }
     else if (!strcmp(output_format, "marcxml"))
     {
-        output_format_mode = YAZ_MARC_MARCXML;
-        if (input_charset && !output_charset)
-            output_charset = "utf-8";
+        info->output_format_mode = YAZ_MARC_MARCXML;
+        if (info->input_charset && !info->output_charset)
+            info->output_charset = "utf-8";
     }
     else if (!strcmp(output_format, "turbomarc"))
     {
-        output_format_mode = YAZ_MARC_TURBOMARC;
-        if (input_charset && !output_charset)
-            output_charset = "utf-8";
+        info->output_format_mode = YAZ_MARC_TURBOMARC;
+        if (info->input_charset && !info->output_charset)
+            info->output_charset = "utf-8";
     }
     else if (!strcmp(output_format, "marc"))
     {
-        output_format_mode = YAZ_MARC_ISO2709;
+        info->output_format_mode = YAZ_MARC_ISO2709;
     }
     else if (!strcmp(output_format, "marcxchange"))
     {
-        output_format_mode = YAZ_MARC_XCHANGE;
-        if (input_charset && !output_charset)
-            output_charset = "utf-8";
+        info->output_format_mode = YAZ_MARC_XCHANGE;
+        if (info->input_charset && !info->output_charset)
+            info->output_charset = "utf-8";
     }
     else
     {
-        wrbuf_printf(p->wr_error, "Element <marc outputformat='%s'>: "
+        wrbuf_printf(wr_error, "Element <marc outputformat='%s'>: "
                      " Unsupported output format"
                      " defined by attribute value", 
                      output_format);
-        return -1;
+        nmem_destroy(info->nmem);
+        return 0;
     }
-    if (input_charset && output_charset)
+    if (info->input_charset && info->output_charset)
     {
-        yaz_iconv_t cd = yaz_iconv_open(output_charset, input_charset);
+        yaz_iconv_t cd = yaz_iconv_open(info->output_charset,
+                                        info->input_charset);
         if (!cd)
         {
             wrbuf_printf(p->wr_error, 
                          "Element <marc inputcharset='%s' outputcharset='%s'>:"
                          " Unsupported character set mapping"
                          " defined by attribute values",
-                         input_charset, output_charset);
-            return -1;
+                         info->input_charset, info->output_charset);
+            nmem_destroy(info->nmem);
+            return 0;
         }
         yaz_iconv_close(cd);
     }
-    else if (input_charset)
+    else if (info->input_charset)
     {
-        wrbuf_printf(p->wr_error, "Element <marc>: "
+        wrbuf_printf(wr_error, "Element <marc>: "
                      "attribute 'outputcharset' missing");
-        return -1;
+        nmem_destroy(info->nmem);
+        return 0;
     }
-    else if (output_charset)
+    else if (info->output_charset)
     {
-        wrbuf_printf(p->wr_error, "Element <marc>: "
+        wrbuf_printf(wr_error, "Element <marc>: "
                      "attribute 'inputcharset' missing");
-        return -1;
+        nmem_destroy(info->nmem);
+        return 0;
     }
-    r = add_rule(p, YAZ_RECORD_CONV_RULE_MARC);
+    info->input_charset = nmem_strdup(p->nmem, info->input_charset);
+    info->output_charset = nmem_strdup(p->nmem, info->output_charset);
+    return info;
+}
 
-    r->u.marc.input_charset = nmem_strdup(p->nmem, input_charset);
-    r->u.marc.output_charset = nmem_strdup(p->nmem, output_charset);
-    r->u.marc.input_format = input_format_mode;
-    r->u.marc.output_format = output_format_mode;
-    return 0;
+static int convert_marc(void *info, WRBUF record, WRBUF wr_error)
+{
+    struct marc_info *mi = info;
+    int ret = 0;
+    
+    yaz_iconv_t cd = yaz_iconv_open(mi->output_charset, mi->input_charset);
+    yaz_marc_t mt = yaz_marc_create();
+    
+    yaz_marc_xml(mt, mi->output_format_mode);
+    
+    if (cd)
+        yaz_marc_iconv(mt, cd);
+    if (mi->input_format_mode == YAZ_MARC_ISO2709)
+    {
+        int sz = yaz_marc_read_iso2709(mt, wrbuf_buf(record),
+                                       wrbuf_len(record));
+        if (sz > 0)
+            ret = 0;
+        else
+            ret = -1;
+    }
+    else if (mi->input_format_mode == YAZ_MARC_MARCXML ||
+             mi->input_format_mode == YAZ_MARC_TURBOMARC)
+    {
+        xmlDocPtr doc = xmlParseMemory(wrbuf_buf(record),
+                                       wrbuf_len(record));
+        if (!doc)
+        {
+            wrbuf_printf(wr_error, "xmlParseMemory failed");
+            ret = -1;
+        }
+        else
+        {
+            ret = yaz_marc_read_xml(mt, xmlDocGetRootElement(doc));
+            if (ret)
+                wrbuf_printf(wr_error, "yaz_marc_read_xml failed");
+        }
+        xmlFreeDoc(doc);
+    }
+    else
+    {
+        wrbuf_printf(wr_error, "unsupported input format");
+        ret = -1;
+    }
+    if (ret == 0)
+    {
+        wrbuf_rewind(record);
+        ret = yaz_marc_write_mode(mt, record);
+        if (ret)
+            wrbuf_printf(wr_error, "yaz_marc_write_mode failed");
+    }
+    if (cd)
+        yaz_iconv_close(cd);
+    yaz_marc_destroy(mt);
+    return ret;
+}
+
+static void destroy_marc(void *info)
+{
+    struct marc_info *mi = info;
+    
+    nmem_destroy(mi->nmem);
 }
 
 int yaz_record_conv_configure(yaz_record_conv_t p, const xmlNode *ptr)
@@ -372,27 +485,33 @@ int yaz_record_conv_configure(yaz_record_conv_t p, const xmlNode *ptr)
 
     /* parsing element children */
     for (ptr = ptr->children; ptr; ptr = ptr->next)
+    {
+        struct yaz_record_conv_type *t;
+        struct yaz_record_conv_rule *r;
+        void *info = 0;
+        if (ptr->type != XML_ELEMENT_NODE)
+            continue;
+        for (t = p->types; t; t = t->next)
         {
-            if (ptr->type != XML_ELEMENT_NODE)
-                continue;
-            if (!strcmp((const char *) ptr->name, "xslt"))
-                {
-                    if (conv_xslt(p, ptr))
-                        return -1;
-                }
-            else if (!strcmp((const char *) ptr->name, "marc"))
-                {
-                    if (conv_marc(p, ptr))
-                        return -1;
-                }
-            else
-                {
-                    wrbuf_printf(p->wr_error, "Element <backend>: expected "
-                                 "<marc> or <xslt> element, got <%s>"
-                                 , ptr->name);
-                    return -1;
-                }
+            wrbuf_rewind(p->wr_error);
+            info = t->construct(p, ptr, p->path, p->wr_error);
+            if (info)
+                break;
         }
+        if (!info)
+        {
+            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;
+        *p->rules_p = r;
+        p->rules_p = &r->next;
+    }
     return 0;
 }
 
@@ -400,7 +519,17 @@ static int yaz_record_conv_record_rule(yaz_record_conv_t p,
                                        struct yaz_record_conv_rule *r,
                                        const char *input_record_buf,
                                        size_t input_record_len,
-                                       WRBUF output_record);
+                                       WRBUF output_record)
+{
+    int ret = 0;
+    WRBUF record = output_record; /* pointer transfer */
+    wrbuf_rewind(p->wr_error);
+    
+    wrbuf_write(record, input_record_buf, input_record_len);
+    for (; ret == 0 && r; r = r->next)
+        ret = r->type->convert(r->info, record, p->wr_error);
+    return ret;
+}
 
 int yaz_record_conv_opac_record(yaz_record_conv_t p,
                                 Z_OPACRecord *input_record,
@@ -408,17 +537,19 @@ int yaz_record_conv_opac_record(yaz_record_conv_t p,
 {
     int ret = 0;
     struct yaz_record_conv_rule *r = p->rules;
-    if (!r || r->which != YAZ_RECORD_CONV_RULE_MARC)
+    if (!r || r->type->construct != construct_marc)
         ret = -1; /* no marc rule so we can't do OPAC */
     else
     {
+        struct marc_info *mi = r->info;
+
         WRBUF res = wrbuf_alloc();
         yaz_marc_t mt = yaz_marc_create();
-        yaz_iconv_t cd = yaz_iconv_open(r->u.marc.output_charset,
-                                        r->u.marc.input_charset);
+        yaz_iconv_t cd = yaz_iconv_open(mi->output_charset,
+                                        mi->input_charset);
         
         wrbuf_rewind(p->wr_error);
-        yaz_marc_xml(mt, r->u.marc.output_format);
+        yaz_marc_xml(mt, mi->output_format_mode);
         
         yaz_marc_iconv(mt, cd);
         
@@ -448,127 +579,6 @@ int yaz_record_conv_record(yaz_record_conv_t p,
                                        input_record_len, output_record);
 }
 
-static int yaz_record_conv_record_rule(yaz_record_conv_t p,
-                                       struct yaz_record_conv_rule *r,
-                                       const char *input_record_buf,
-                                       size_t input_record_len,
-                                       WRBUF output_record)
-{
-    int ret = 0;
-    WRBUF record = output_record; /* pointer transfer */
-    wrbuf_rewind(p->wr_error);
-    
-    wrbuf_write(record, input_record_buf, input_record_len);
-    for (; ret == 0 && r; r = r->next)
-    {
-        if (r->which == YAZ_RECORD_CONV_RULE_MARC)
-        {
-            yaz_iconv_t cd = 
-                yaz_iconv_open(r->u.marc.output_charset,
-                               r->u.marc.input_charset);
-            yaz_marc_t mt = yaz_marc_create();
-
-            yaz_marc_xml(mt, r->u.marc.output_format);
-
-            if (cd)
-                yaz_marc_iconv(mt, cd);
-            if (r->u.marc.input_format == YAZ_MARC_ISO2709)
-            {
-                int sz = yaz_marc_read_iso2709(mt, wrbuf_buf(record),
-                                               wrbuf_len(record));
-                if (sz > 0)
-                    ret = 0;
-                else
-                    ret = -1;
-            }
-            else if (r->u.marc.input_format == YAZ_MARC_MARCXML ||
-                     r->u.marc.input_format == YAZ_MARC_TURBOMARC)
-            {
-                xmlDocPtr doc = xmlParseMemory(wrbuf_buf(record),
-                                               wrbuf_len(record));
-                if (!doc)
-                {
-                    wrbuf_printf(p->wr_error, "xmlParseMemory failed");
-                    ret = -1;
-                }
-                else
-                {
-                    ret = yaz_marc_read_xml(mt, xmlDocGetRootElement(doc));
-                    if (ret)
-                        wrbuf_printf(p->wr_error, "yaz_marc_read_xml failed");
-                }
-                xmlFreeDoc(doc);
-            }
-            else
-            {
-                wrbuf_printf(p->wr_error, "unsupported input format");
-                ret = -1;
-            }
-            if (ret == 0)
-            {
-                wrbuf_rewind(record);
-                ret = yaz_marc_write_mode(mt, record);
-                if (ret)
-                    wrbuf_printf(p->wr_error, "yaz_marc_write_mode failed");
-            }
-            if (cd)
-                yaz_iconv_close(cd);
-            yaz_marc_destroy(mt);
-        }
-#if YAZ_HAVE_XSLT
-        else if (r->which == YAZ_RECORD_CONV_RULE_XSLT)
-        {
-            xmlDocPtr doc = xmlParseMemory(wrbuf_buf(record),
-                                           wrbuf_len(record));
-            if (!doc)
-            {
-                wrbuf_printf(p->wr_error, "xmlParseMemory failed");
-                ret = -1;
-            }
-            else
-            {
-                xmlDocPtr xsp_doc = xmlCopyDoc(r->u.xslt.xsp_doc, 1);
-                xsltStylesheetPtr xsp = xsltParseStylesheetDoc(xsp_doc);
-                xmlDocPtr res = xsltApplyStylesheet(xsp, doc, 0);
-                if (res)
-                {
-                    xmlChar *out_buf = 0;
-                    int out_len;
-
-#if HAVE_XSLTSAVERESULTTOSTRING
-                    xsltSaveResultToString(&out_buf, &out_len, res, xsp);
-#else
-                    xmlDocDumpFormatMemory (res, &out_buf, &out_len, 1);
-#endif
-                    if (!out_buf)
-                    {
-                        wrbuf_printf(p->wr_error,
-                                     "xsltSaveResultToString failed");
-                        ret = -1;
-                    }
-                    else
-                    {
-                        wrbuf_rewind(record);
-                        wrbuf_write(record, (const char *) out_buf, out_len);
-                        
-                        xmlFree(out_buf);
-                    }
-                    xmlFreeDoc(res);
-                }
-                else
-                {
-                    wrbuf_printf(p->wr_error, "xsltApplyStylesheet failed");
-                    ret = -1;
-                }
-                xmlFreeDoc(doc);
-                xsltFreeStylesheet(xsp); /* frees xsp_doc too */
-            }
-        }
-#endif
-    }
-    return ret;
-}
-
 const char *yaz_record_conv_get_error(yaz_record_conv_t p)
 {
     return wrbuf_cstr(p->wr_error);
@@ -581,6 +591,43 @@ void yaz_record_conv_set_path(yaz_record_conv_t p, const char *path)
     if (path)
         p->path = xstrdup(path);
 }
+
+yaz_record_conv_t yaz_record_conv_create()
+{
+    yaz_record_conv_t p = (yaz_record_conv_t) xmalloc(sizeof(*p));
+    p->nmem = nmem_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;
+}
+
+/* YAZ_HAVE_XML2 */
 #endif
 
 /*