/** \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;
};
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);
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") &&
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"
#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;
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)
/* 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;
}
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,
{
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);
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);
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
/*
projects / yaz-moved-to-github.git / commitdiff