/* This file is part of the YAZ toolkit.
- * Copyright (C) 1995-2012 Index Data
+ * Copyright (C) 1995-2013 Index Data
* See the file LICENSE for details.
*/
/**
const char *output_charset;
int input_format_mode;
int output_format_mode;
+ const char *leader_spec;
};
/** \brief tranformation info (rule info) */
}
#if YAZ_HAVE_XSLT
+struct xslt_info {
+ NMEM nmem;
+ xmlDocPtr xsp_doc;
+ const char **xsl_parms;
+};
+
static void *construct_xslt(const xmlNode *ptr,
const char *path, WRBUF wr_error)
{
struct _xmlAttr *attr;
const char *stylesheet = 0;
+ struct xslt_info *info = 0;
+ NMEM nmem = 0;
+ int max_parms = 10;
+ int no_parms = 0;
if (strcmp((const char *) ptr->name, "xslt"))
return 0;
return 0;
}
}
+ nmem = nmem_create();
+ info = nmem_malloc(nmem, sizeof(*info));
+ info->nmem = nmem;
+ info->xsl_parms = nmem_malloc(
+ nmem, (2 * max_parms + 1) * sizeof(*info->xsl_parms));
+
+ for (ptr = ptr->children; ptr; ptr = ptr->next)
+ {
+ const char *name = 0;
+ const char *value = 0;
+ char *qvalue = 0;
+ if (ptr->type != XML_ELEMENT_NODE)
+ continue;
+ if (strcmp((const char *) ptr->name, "param"))
+ {
+ wrbuf_printf(wr_error, "Bad element '%s'"
+ "Expected param.", ptr->name);
+ nmem_destroy(nmem);
+ return 0;
+ }
+ for (attr = ptr->properties; attr; attr = attr->next)
+ {
+ if (!xmlStrcmp(attr->name, BAD_CAST "name") &&
+ attr->children && attr->children->type == XML_TEXT_NODE)
+ name = (const char *) attr->children->content;
+ else if (!xmlStrcmp(attr->name, BAD_CAST "value") &&
+ attr->children && attr->children->type == XML_TEXT_NODE)
+ value = (const char *) attr->children->content;
+ else
+ {
+ wrbuf_printf(wr_error, "Bad attribute '%s'"
+ "Expected name or value.", attr->name);
+ nmem_destroy(nmem);
+ return 0;
+ }
+ }
+ if (!name || !value)
+ {
+ wrbuf_printf(wr_error, "Missing attributes name or value");
+ nmem_destroy(nmem);
+ return 0;
+ }
+ if (no_parms >= max_parms)
+ {
+ wrbuf_printf(wr_error, "Too many parameters given");
+ nmem_destroy(nmem);
+ return 0;
+ }
+
+ qvalue = nmem_malloc(nmem, strlen(value) + 3);
+ strcpy(qvalue, "\'");
+ strcat(qvalue, value);
+ strcat(qvalue, "\'");
+
+ info->xsl_parms[2 * no_parms] = nmem_strdup(nmem, name);
+ info->xsl_parms[2 * no_parms + 1] = qvalue;
+ no_parms++;
+ }
+
+ info->xsl_parms[2 * no_parms] = '\0';
+
if (!stylesheet)
{
wrbuf_printf(wr_error, "Element <xslt>: "
"attribute 'stylesheet' expected");
- return 0;
+ nmem_destroy(nmem);
}
else
{
char fullpath[1024];
xsltStylesheetPtr xsp;
- xmlDocPtr xsp_doc;
if (!yaz_filepath_resolve(stylesheet, path, 0, fullpath))
{
wrbuf_printf(wr_error, "Element <xslt stylesheet=\"%s\"/>:"
stylesheet, stylesheet);
if (path)
wrbuf_printf(wr_error, " with path '%s'", path);
-
+
+ nmem_destroy(nmem);
return 0;
}
- xsp_doc = xmlParseFile(fullpath);
- if (!xsp_doc)
+ info->xsp_doc = xmlParseFile(fullpath);
+ if (!info->xsp_doc)
{
wrbuf_printf(wr_error, "Element: <xslt stylesheet=\"%s\"/>:"
" xml parse failed: %s", stylesheet, fullpath);
if (path)
wrbuf_printf(wr_error, " with path '%s'", path);
+ nmem_destroy(nmem);
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));
+ xsp = xsltParseStylesheetDoc(xmlCopyDoc(info->xsp_doc, 1));
if (!xsp)
{
wrbuf_printf(wr_error, "Element: <xslt stylesheet=\"%s\"/>:"
wrbuf_printf(wr_error, " with path '%s'", path);
wrbuf_printf(wr_error, " ("
#if YAZ_HAVE_EXSLT
-
+
"EXSLT enabled"
#else
"EXSLT not supported"
#endif
")");
- xmlFreeDoc(xsp_doc);
- return 0;
+ xmlFreeDoc(info->xsp_doc);
+ nmem_destroy(info->nmem);
}
else
{
xsltFreeStylesheet(xsp);
- return xsp_doc;
+ return info;
}
}
return 0;
}
-static int convert_xslt(void *info, WRBUF record, WRBUF wr_error)
+static int convert_xslt(void *vinfo, WRBUF record, WRBUF wr_error)
{
int ret = 0;
+ struct xslt_info *info = vinfo;
+
xmlDocPtr doc = xmlParseMemory(wrbuf_buf(record),
wrbuf_len(record));
if (!doc)
}
else
{
- xmlDocPtr xsp_doc = xmlCopyDoc((xmlDocPtr) info, 1);
+ xmlDocPtr xsp_doc = xmlCopyDoc(info->xsp_doc, 1);
xsltStylesheetPtr xsp = xsltParseStylesheetDoc(xsp_doc);
- xmlDocPtr res = xsltApplyStylesheet(xsp, doc, 0);
+ xmlDocPtr res = xsltApplyStylesheet(xsp, doc, info->xsl_parms);
if (res)
{
xmlChar *out_buf = 0;
int out_len;
-
+
#if HAVE_XSLTSAVERESULTTOSTRING
xsltSaveResultToString(&out_buf, &out_len, res, xsp);
#else
{
wrbuf_rewind(record);
wrbuf_write(record, (const char *) out_buf, out_len);
-
+
xmlFree(out_buf);
}
xmlFreeDoc(res);
return ret;
}
-static void destroy_xslt(void *info)
+static void destroy_xslt(void *vinfo)
{
+ struct xslt_info *info = vinfo;
+
if (info)
{
- xmlDocPtr xsp_doc = info;
- xmlFreeDoc(xsp_doc);
+ xmlFreeDoc(info->xsp_doc);
+ nmem_destroy(info->nmem);
}
}
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)
{
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"
"'inputformat', 'inputcharset', 'outputformat' or"
- " 'outputcharset', got attribute '%s'",
+ " 'outputcharset', got attribute '%s'",
attr->name);
nmem_destroy(info->nmem);
return 0;
{
info->input_format_mode = YAZ_MARC_MARCXML;
/** Libxml2 generates UTF-8 encoding by default .
- So we convert from UTF-8 to outputcharset (if defined)
+ So we convert from UTF-8 to outputcharset (if defined)
*/
if (!info->input_charset && info->output_charset)
info->input_charset = "utf-8";
}
+ else if (!strcmp(input_format, "json"))
+ {
+ info->input_format_mode = YAZ_MARC_JSON;
+ }
else
{
wrbuf_printf(wr_error, "Element <marc inputformat='%s'>: "
" Unsupported input format"
- " defined by attribute value",
+ " defined by attribute value",
input_format);
nmem_destroy(info->nmem);
return 0;
}
-
+
if (!output_format)
{
- wrbuf_printf(wr_error,
+ wrbuf_printf(wr_error,
"Element <marc>: attribute 'outputformat' required");
nmem_destroy(info->nmem);
return 0;
if (info->input_charset && !info->output_charset)
info->output_charset = "utf-8";
}
+ else if (!strcmp(output_format, "json"))
+ {
+ info->output_format_mode = YAZ_MARC_JSON;
+ if (info->input_charset && !info->output_charset)
+ info->output_charset = "utf-8";
+ }
else
{
wrbuf_printf(wr_error, "Element <marc outputformat='%s'>: "
" Unsupported output format"
- " defined by attribute value",
+ " defined by attribute value",
output_format);
nmem_destroy(info->nmem);
return 0;
info->input_charset);
if (!cd)
{
- wrbuf_printf(wr_error,
+ wrbuf_printf(wr_error,
"Element <marc inputcharset='%s' outputcharset='%s'>:"
" Unsupported character set mapping"
" defined by attribute values",
{
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 (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)
static void destroy_marc(void *info)
{
struct marc_info *mi = info;
-
+
nmem_destroy(mi->nmem);
}
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;
#else
bt[0].next = types;
#endif
-
+
yaz_record_conv_reset(p);
/* parsing element children */
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);
int ret = 0;
struct yaz_record_conv_rule *r = p->rules;
if (!r || r->type->construct != construct_marc)
+ {
+ wrbuf_puts(p->wr_error, "Expecting MARC rule as first rule for OPAC");
ret = -1; /* no marc rule so we can't do OPAC */
+ }
else
{
struct marc_info *mi = r->info;
yaz_marc_t mt = yaz_marc_create();
yaz_iconv_t cd = yaz_iconv_open(mi->output_charset,
mi->input_charset);
-
+
wrbuf_rewind(p->wr_error);
yaz_marc_xml(mt, mi->output_format_mode);
-
+
yaz_marc_iconv(mt, cd);
-
+
yaz_opac_decode_wrbuf(mt, input_record, res);
if (ret != -1)
{
- ret = yaz_record_conv_record_rule(p,
+ ret = yaz_record_conv_record_rule(p,
r->next,
wrbuf_buf(res), wrbuf_len(res),
output_record);
p->rules = 0;
p->path = 0;
#if YAZ_HAVE_EXSLT
- exsltRegisterAll();
-#endif
+ exsltRegisterAll();
+#endif
return p;
}
projects / yaz-moved-to-github.git / blobdiff