static void
xslt_yelp_document (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltStylePreCompPtr comp)
{
YelpTransform *transform;
xmlChar *page_id = NULL;
gchar *temp;
xmlChar *page_buf;
gint buf_size;
xsltStylesheetPtr style = NULL;
const char *old_outfile;
xmlDocPtr new_doc = NULL;
xmlDocPtr old_doc;
xmlNodePtr old_insert;
debug_print (DB_FUNCTION, "entering\n");
if (ctxt->state == XSLT_STATE_STOPPED)
return;
if (!ctxt || !node || !inst || !comp)
return;
transform = (YelpTransform *) ctxt->_private;
page_id = xsltEvalAttrValueTemplate (ctxt, inst,
(const xmlChar *) "href",
NULL);
if (page_id == NULL || *page_id == '\0') {
if (page_id)
xmlFree (page_id);
else
xsltTransformError (ctxt, NULL, inst,
_("No href attribute found on "
"yelp:document\n"));
/* FIXME: put a real error here */
goto done;
}
debug_print (DB_ARG, " page_id = \"%s\"\n", page_id);
old_outfile = ctxt->outputFile;
old_doc = ctxt->output;
old_insert = ctxt->insert;
ctxt->outputFile = (const char *) page_id;
style = xsltNewStylesheet ();
if (style == NULL) {
xsltTransformError (ctxt, NULL, inst,
_("Out of memory"));
goto done;
}
style->omitXmlDeclaration = TRUE;
new_doc = xmlNewDoc (BAD_CAST "1.0");
new_doc->charset = XML_CHAR_ENCODING_UTF8;
new_doc->dict = ctxt->dict;
xmlDictReference (new_doc->dict);
ctxt->output = new_doc;
ctxt->insert = (xmlNodePtr) new_doc;
xsltApplyOneTemplate (ctxt, node, inst->children, NULL, NULL);
xsltSaveResultToString (&page_buf, &buf_size, new_doc, style);
ctxt->outputFile = old_outfile;
ctxt->output = old_doc;
ctxt->insert = old_insert;
g_mutex_lock (transform->mutex);
temp = g_strdup ((gchar *) page_id);
xmlFree (page_id);
g_async_queue_push (transform->queue, g_strdup ((gchar *) temp));
g_hash_table_insert (transform->chunks, temp, page_buf);
transform->idle_funcs++;
g_idle_add ((GSourceFunc) transform_chunk, transform);
g_mutex_unlock (transform->mutex);
done:
if (new_doc)
xmlFreeDoc (new_doc);
if (style)
xsltFreeStylesheet (style);
}
// Based on default implementation from libxslt 1.1.22 and xsltICUSort.c example.
void xsltUnicodeSortFunction(xsltTransformContextPtr ctxt, xmlNodePtr *sorts, int nbsorts)
{
#ifdef XSLT_REFACTORED
xsltStyleItemSortPtr comp;
#else
xsltStylePreCompPtr comp;
#endif
xmlXPathObjectPtr *resultsTab[XSLT_MAX_SORT];
xmlXPathObjectPtr *results = NULL, *res;
xmlNodeSetPtr list = NULL;
int descending, number, desc, numb;
int len = 0;
int i, j, incr;
int tst;
int depth;
xmlNodePtr node;
xmlXPathObjectPtr tmp;
int tempstype[XSLT_MAX_SORT], temporder[XSLT_MAX_SORT];
if ((ctxt == NULL) || (sorts == NULL) || (nbsorts <= 0) ||
(nbsorts >= XSLT_MAX_SORT))
return;
if (sorts[0] == NULL)
return;
comp = static_cast<xsltStylePreComp*>(sorts[0]->psvi);
if (comp == NULL)
return;
list = ctxt->nodeList;
if ((list == NULL) || (list->nodeNr <= 1))
return; /* nothing to do */
for (j = 0; j < nbsorts; j++) {
comp = static_cast<xsltStylePreComp*>(sorts[j]->psvi);
tempstype[j] = 0;
if ((comp->stype == NULL) && (comp->has_stype != 0)) {
comp->stype =
xsltEvalAttrValueTemplate(ctxt, sorts[j],
(const xmlChar *) "data-type",
XSLT_NAMESPACE);
if (comp->stype != NULL) {
tempstype[j] = 1;
if (xmlStrEqual(comp->stype, (const xmlChar *) "text"))
comp->number = 0;
else if (xmlStrEqual(comp->stype, (const xmlChar *) "number"))
comp->number = 1;
else {
xsltTransformError(ctxt, NULL, sorts[j],
"xsltDoSortFunction: no support for data-type = %s\n",
comp->stype);
comp->number = 0; /* use default */
}
}
}
temporder[j] = 0;
if ((comp->order == NULL) && (comp->has_order != 0)) {
comp->order = xsltEvalAttrValueTemplate(ctxt, sorts[j],
(const xmlChar *) "order",
XSLT_NAMESPACE);
if (comp->order != NULL) {
temporder[j] = 1;
if (xmlStrEqual(comp->order, (const xmlChar *) "ascending"))
comp->descending = 0;
else if (xmlStrEqual(comp->order,
(const xmlChar *) "descending"))
comp->descending = 1;
else {
xsltTransformError(ctxt, NULL, sorts[j],
"xsltDoSortFunction: invalid value %s for order\n",
comp->order);
comp->descending = 0; /* use default */
}
}
}
}
len = list->nodeNr;
resultsTab[0] = xsltComputeSortResult(ctxt, sorts[0]);
for (i = 1;i < XSLT_MAX_SORT;i++)
resultsTab[i] = NULL;
results = resultsTab[0];
comp = static_cast<xsltStylePreComp*>(sorts[0]->psvi);
descending = comp->descending;
number = comp->number;
if (results == NULL)
return;
// We are passing a language identifier to a function that expects a locale identifier.
// The implementation of Collator should be lenient, and accept both "en-US" and "en_US", for example.
// This lets an author specify sorting rules, e.g. "de_DE@collation=phonebook", which isn't
// possible with language alone.
Collator collator(comp->has_lang ? reinterpret_cast<const char*>(comp->lang) : "en", comp->lower_first);
/* Shell's sort of node-set */
for (incr = len / 2; incr > 0; incr /= 2) {
for (i = incr; i < len; i++) {
j = i - incr;
if (results[i] == NULL)
continue;
while (j >= 0) {
if (results[j] == NULL)
tst = 1;
else {
if (number) {
/* We make NaN smaller than number in accordance
with XSLT spec */
if (xmlXPathIsNaN(results[j]->floatval)) {
if (xmlXPathIsNaN(results[j + incr]->floatval))
tst = 0;
else
tst = -1;
} else if (xmlXPathIsNaN(results[j + incr]->floatval))
tst = 1;
else if (results[j]->floatval ==
results[j + incr]->floatval)
tst = 0;
else if (results[j]->floatval >
results[j + incr]->floatval)
tst = 1;
else tst = -1;
} else
tst = collator.collateUTF8(reinterpret_cast<const char*>(results[j]->stringval), reinterpret_cast<const char*>(results[j + incr]->stringval));
if (descending)
tst = -tst;
}
if (tst == 0) {
/*
* Okay we need to use multi level sorts
*/
depth = 1;
while (depth < nbsorts) {
if (sorts[depth] == NULL)
break;
comp = static_cast<xsltStylePreComp*>(sorts[depth]->psvi);
if (comp == NULL)
break;
desc = comp->descending;
numb = comp->number;
/*
* Compute the result of the next level for the
* full set, this might be optimized ... or not
*/
if (resultsTab[depth] == NULL)
resultsTab[depth] = xsltComputeSortResult(ctxt,
sorts[depth]);
res = resultsTab[depth];
if (res == NULL)
break;
if (res[j] == NULL) {
if (res[j+incr] != NULL)
tst = 1;
} else {
if (numb) {
/* We make NaN smaller than number in
accordance with XSLT spec */
if (xmlXPathIsNaN(res[j]->floatval)) {
if (xmlXPathIsNaN(res[j +
incr]->floatval))
tst = 0;
else
tst = -1;
} else if (xmlXPathIsNaN(res[j + incr]->
floatval))
tst = 1;
else if (res[j]->floatval == res[j + incr]->
floatval)
tst = 0;
else if (res[j]->floatval >
res[j + incr]->floatval)
tst = 1;
else tst = -1;
} else
tst = collator.collateUTF8(reinterpret_cast<const char*>(res[j]->stringval), reinterpret_cast<const char*>(res[j + incr]->stringval));
if (desc)
tst = -tst;
}
/*
* if we still can't differenciate at this level
* try one level deeper.
*/
if (tst != 0)
break;
depth++;
}
}
if (tst == 0) {
tst = results[j]->index > results[j + incr]->index;
}
if (tst > 0) {
tmp = results[j];
results[j] = results[j + incr];
results[j + incr] = tmp;
node = list->nodeTab[j];
list->nodeTab[j] = list->nodeTab[j + incr];
list->nodeTab[j + incr] = node;
depth = 1;
while (depth < nbsorts) {
if (sorts[depth] == NULL)
break;
if (resultsTab[depth] == NULL)
break;
res = resultsTab[depth];
tmp = res[j];
res[j] = res[j + incr];
res[j + incr] = tmp;
depth++;
}
j -= incr;
} else
break;
}
}
}
for (j = 0; j < nbsorts; j++) {
comp = static_cast<xsltStylePreComp*>(sorts[j]->psvi);
if (tempstype[j] == 1) {
/* The data-type needs to be recomputed each time */
xmlFree((void *)(comp->stype));
comp->stype = NULL;
}
if (temporder[j] == 1) {
/* The order needs to be recomputed each time */
xmlFree((void *)(comp->order));
comp->order = NULL;
}
if (resultsTab[j] != NULL) {
for (i = 0;i < len;i++)
xmlXPathFreeObject(resultsTab[j][i]);
xmlFree(resultsTab[j]);
}
}
}
/**
* xsltAttribute:
* @ctxt: a XSLT process context
* @node: the current node in the source tree
* @inst: the xsl:attribute element
* @comp: precomputed information
*
* Process the xslt attribute node on the source node
*/
void
xsltAttribute(xsltTransformContextPtr ctxt,
xmlNodePtr contextNode,
xmlNodePtr inst,
xsltStylePreCompPtr castedComp)
{
#ifdef XSLT_REFACTORED
xsltStyleItemAttributePtr comp =
(xsltStyleItemAttributePtr) castedComp;
#else
xsltStylePreCompPtr comp = castedComp;
#endif
xmlNodePtr targetElem;
xmlChar *prop = NULL;
const xmlChar *name = NULL, *prefix = NULL, *nsName = NULL;
xmlChar *value = NULL;
xmlNsPtr ns = NULL;
xmlAttrPtr attr;
if ((ctxt == NULL) || (contextNode == NULL) || (inst == NULL) ||
(inst->type != XML_ELEMENT_NODE) )
return;
/*
* A comp->has_name == 0 indicates that we need to skip this instruction,
* since it was evaluated to be invalid already during compilation.
*/
if (!comp->has_name)
return;
/*
* BIG NOTE: This previously used xsltGetSpecialNamespace() and
* xsltGetNamespace(), but since both are not appropriate, we
* will process namespace lookup here to avoid adding yet another
* ns-lookup function to namespaces.c.
*/
/*
* SPEC XSLT 1.0: Error cases:
* - Creating nodes other than text nodes during the instantiation of
* the content of the xsl:attribute element; implementations may
* either signal the error or ignore the offending nodes."
*/
if (comp == NULL) {
xsltTransformError(ctxt, NULL, inst,
"Internal error in xsltAttribute(): "
"The XSLT 'attribute' instruction was not compiled.\n");
return;
}
/*
* TODO: Shouldn't ctxt->insert == NULL be treated as an internal error?
* So report an internal error?
*/
if (ctxt->insert == NULL)
return;
/*
* SPEC XSLT 1.0:
* "Adding an attribute to a node that is not an element;
* implementations may either signal the error or ignore the attribute."
*
* TODO: I think we should signal such errors in the future, and maybe
* provide an option to ignore such errors.
*/
targetElem = ctxt->insert;
if (targetElem->type != XML_ELEMENT_NODE)
return;
/*
* SPEC XSLT 1.0:
* "Adding an attribute to an element after children have been added
* to it; implementations may either signal the error or ignore the
* attribute."
*
* TODO: We should decide whether not to report such errors or
* to ignore them; note that we *ignore* if the parent is not an
* element, but here we report an error.
*/
if (targetElem->children != NULL) {
/*
* NOTE: Ah! This seems to be intended to support streamed
* result generation!.
*/
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: Cannot add attributes to an "
"element if children have been already added "
"to the element.\n");
return;
}
/*
* Process the name
* ----------------
*/
#ifdef WITH_DEBUGGER
if (ctxt->debugStatus != XSLT_DEBUG_NONE)
xslHandleDebugger(inst, contextNode, NULL, ctxt);
#endif
if (comp->name == NULL) {
/* TODO: fix attr acquisition wrt to the XSLT namespace */
prop = xsltEvalAttrValueTemplate(ctxt, inst,
(const xmlChar *) "name", XSLT_NAMESPACE);
if (prop == NULL) {
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: The attribute 'name' is missing.\n");
goto error;
}
if (xmlValidateQName(prop, 0)) {
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: The effective name '%s' is not a "
"valid QName.\n", prop);
/* we fall through to catch any further errors, if possible */
}
/*
* Reject a name of "xmlns".
*/
if (xmlStrEqual(prop, BAD_CAST "xmlns")) {
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: The effective name 'xmlns' is not allowed.\n");
xmlFree(prop);
goto error;
}
name = xsltSplitQName(ctxt->dict, prop, &prefix);
xmlFree(prop);
} else {
/*
* The "name" value was static.
*/
#ifdef XSLT_REFACTORED
prefix = comp->nsPrefix;
name = comp->name;
#else
name = xsltSplitQName(ctxt->dict, comp->name, &prefix);
#endif
}
/*
* Process namespace semantics
* ---------------------------
*
* Evaluate the namespace name.
*/
if (comp->has_ns) {
/*
* The "namespace" attribute was existent.
*/
if (comp->ns != NULL) {
/*
* No AVT; just plain text for the namespace name.
*/
if (comp->ns[0] != 0)
nsName = comp->ns;
} else {
xmlChar *tmpNsName;
/*
* Eval the AVT.
*/
/* TODO: check attr acquisition wrt to the XSLT namespace */
tmpNsName = xsltEvalAttrValueTemplate(ctxt, inst,
(const xmlChar *) "namespace", XSLT_NAMESPACE);
/*
* This fixes bug #302020: The AVT might also evaluate to the
* empty string; this means that the empty string also indicates
* "no namespace".
* SPEC XSLT 1.0:
* "If the string is empty, then the expanded-name of the
* attribute has a null namespace URI."
*/
if ((tmpNsName != NULL) && (tmpNsName[0] != 0))
nsName = xmlDictLookup(ctxt->dict, BAD_CAST tmpNsName, -1);
xmlFree(tmpNsName);
}
if (xmlStrEqual(nsName, BAD_CAST "http://www.w3.org/2000/xmlns/")) {
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: Namespace http://www.w3.org/2000/xmlns/ "
"forbidden.\n");
goto error;
}
if (xmlStrEqual(nsName, XML_XML_NAMESPACE)) {
prefix = BAD_CAST "xml";
} else if (xmlStrEqual(prefix, BAD_CAST "xml")) {
prefix = NULL;
}
} else if (prefix != NULL) {
/*
* SPEC XSLT 1.0:
* "If the namespace attribute is not present, then the QName is
* expanded into an expanded-name using the namespace declarations
* in effect for the xsl:attribute element, *not* including any
* default namespace declaration."
*/
ns = xmlSearchNs(inst->doc, inst, prefix);
if (ns == NULL) {
/*
* Note that this is treated as an error now (checked with
* Saxon, Xalan-J and MSXML).
*/
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: The QName '%s:%s' has no "
"namespace binding in scope in the stylesheet; "
"this is an error, since the namespace was not "
"specified by the instruction itself.\n", prefix, name);
} else
nsName = ns->href;
}
/*
* Find/create a matching ns-decl in the result tree.
*/
ns = NULL;
#if 0
if (0) {
/*
* OPTIMIZE TODO: How do we know if we are adding to a
* fragment or to the result tree?
*
* If we are adding to a result tree fragment (i.e., not to the
* actual result tree), we'll don't bother searching for the
* ns-decl, but just store it in the dummy-doc of the result
* tree fragment.
*/
if (nsName != NULL) {
/*
* TODO: Get the doc of @targetElem.
*/
ns = xsltTreeAcquireStoredNs(some doc, nsName, prefix);
}
}
#endif
if (nsName != NULL) {
/*
* Something about ns-prefixes:
* SPEC XSLT 1.0:
* "XSLT processors may make use of the prefix of the QName specified
* in the name attribute when selecting the prefix used for outputting
* the created attribute as XML; however, they are not required to do
* so and, if the prefix is xmlns, they must not do so"
*/
/*
* xsl:attribute can produce a scenario where the prefix is NULL,
* so generate a prefix.
*/
if ((prefix == NULL) || xmlStrEqual(prefix, BAD_CAST "xmlns")) {
xmlChar *pref = xmlStrdup(BAD_CAST "ns_1");
ns = xsltGetSpecialNamespace(ctxt, inst, nsName, pref, targetElem);
xmlFree(pref);
} else {
ns = xsltGetSpecialNamespace(ctxt, inst, nsName, prefix,
targetElem);
}
if (ns == NULL) {
xsltTransformError(ctxt, NULL, inst,
"Namespace fixup error: Failed to acquire an in-scope "
"namespace binding for the generated attribute '{%s}%s'.\n",
nsName, name);
goto error;
}
}
/*
* Construction of the value
* -------------------------
*/
if (inst->children == NULL) {
/*
* No content.
* TODO: Do we need to put the empty string in ?
*/
attr = xmlSetNsProp(ctxt->insert, ns, name, (const xmlChar *) "");
} else if ((inst->children->next == NULL) &&
((inst->children->type == XML_TEXT_NODE) ||
(inst->children->type == XML_CDATA_SECTION_NODE)))
{
xmlNodePtr copyTxt;
/*
* xmlSetNsProp() will take care of duplicates.
*/
attr = xmlSetNsProp(ctxt->insert, ns, name, NULL);
if (attr == NULL) /* TODO: report error ? */
goto error;
/*
* This was taken over from xsltCopyText() (transform.c).
*/
if (ctxt->internalized &&
(ctxt->insert->doc != NULL) &&
(ctxt->insert->doc->dict == ctxt->dict))
{
copyTxt = xmlNewText(NULL);
if (copyTxt == NULL) /* TODO: report error */
goto error;
/*
* This is a safe scenario where we don't need to lookup
* the dict.
*/
copyTxt->content = inst->children->content;
/*
* Copy "disable-output-escaping" information.
* TODO: Does this have any effect for attribute values
* anyway?
*/
if (inst->children->name == xmlStringTextNoenc)
copyTxt->name = xmlStringTextNoenc;
} else {
/*
* Copy the value.
*/
copyTxt = xmlNewText(inst->children->content);
if (copyTxt == NULL) /* TODO: report error */
goto error;
}
attr->children = attr->last = copyTxt;
copyTxt->parent = (xmlNodePtr) attr;
copyTxt->doc = attr->doc;
/*
* Copy "disable-output-escaping" information.
* TODO: Does this have any effect for attribute values
* anyway?
*/
if (inst->children->name == xmlStringTextNoenc)
copyTxt->name = xmlStringTextNoenc;
/*
* since we create the attribute without content IDness must be
* asserted as a second step
*/
if ((copyTxt->content != NULL) &&
(xmlIsID(attr->doc, attr->parent, attr)))
xmlAddID(NULL, attr->doc, copyTxt->content, attr);
} else {
/*
* The sequence constructor might be complex, so instantiate it.
*/
value = xsltEvalTemplateString(ctxt, contextNode, inst);
if (value != NULL) {
attr = xmlSetNsProp(ctxt->insert, ns, name, value);
xmlFree(value);
} else {
/*
* TODO: Do we have to add the empty string to the attr?
* TODO: Does a value of NULL indicate an
* error in xsltEvalTemplateString() ?
*/
attr = xmlSetNsProp(ctxt->insert, ns, name,
(const xmlChar *) "");
}
}
error:
return;
}
/**
* xsltNumberFormat:
* @ctxt: the XSLT transformation context
* @data: the formatting informations
* @node: the data to format
*
* Convert one number.
*/
void
xsltNumberFormat(xsltTransformContextPtr ctxt,
xsltNumberDataPtr data,
xmlNodePtr node)
{
xmlBufferPtr output = NULL;
xmlNodePtr copy = NULL;
int amount, i;
double number;
xsltFormat tokens;
int tempformat = 0;
if ((data->format == NULL) && (data->has_format != 0)) {
data->format = xsltEvalAttrValueTemplate(ctxt, data->node,
(const xmlChar *) "format",
XSLT_NAMESPACE);
tempformat = 1;
}
if (data->format == NULL) {
return;
}
output = xmlBufferCreate();
if (output == NULL)
goto XSLT_NUMBER_FORMAT_END;
xsltNumberFormatTokenize(data->format, &tokens);
/*
* Evaluate the XPath expression to find the value(s)
*/
if (data->value) {
amount = xsltNumberFormatGetValue(ctxt->xpathCtxt,
node,
data->value,
&number);
if (amount == 1) {
xsltNumberFormatInsertNumbers(data,
&number,
1,
&tokens,
output);
}
} else if (data->level) {
if (xmlStrEqual(data->level, (const xmlChar *) "single")) {
amount = xsltNumberFormatGetMultipleLevel(ctxt,
node,
data->count,
data->from,
&number,
1,
data->doc,
data->node);
if (amount == 1) {
xsltNumberFormatInsertNumbers(data,
&number,
1,
&tokens,
output);
}
} else if (xmlStrEqual(data->level, (const xmlChar *) "multiple")) {
double numarray[1024];
int max = sizeof(numarray)/sizeof(numarray[0]);
amount = xsltNumberFormatGetMultipleLevel(ctxt,
node,
data->count,
data->from,
numarray,
max,
data->doc,
data->node);
if (amount > 0) {
xsltNumberFormatInsertNumbers(data,
numarray,
amount,
&tokens,
output);
}
} else if (xmlStrEqual(data->level, (const xmlChar *) "any")) {
amount = xsltNumberFormatGetAnyLevel(ctxt,
node,
data->count,
data->from,
&number,
data->doc,
data->node);
if (amount > 0) {
xsltNumberFormatInsertNumbers(data,
&number,
1,
&tokens,
output);
}
}
}
/* Insert number as text node */
copy = xmlNewText(xmlBufferContent(output));
if (copy != NULL) {
xmlAddChild(ctxt->insert, copy);
}
if (tokens.start != NULL)
xmlFree(tokens.start);
if (tokens.end != NULL)
xmlFree(tokens.end);
for (i = 0;i < tokens.nTokens;i++) {
if (tokens.tokens[i].separator != NULL)
xmlFree(tokens.tokens[i].separator);
}
XSLT_NUMBER_FORMAT_END:
if (tempformat == 1) {
/* The format need to be recomputed each time */
xmlFree(data->format);
data->format = NULL;
}
if (output != NULL)
xmlBufferFree(output);
}
/**
* xsltICUSortFunction:
* @ctxt: a XSLT process context
* @sorts: array of sort nodes
* @nbsorts: the number of sorts in the array
*
* reorder the current node list accordingly to the set of sorting
* requirement provided by the arry of nodes.
* uses the ICU library
*/
void
xsltICUSortFunction(xsltTransformContextPtr ctxt, xmlNodePtr *sorts,
int nbsorts) {
xmlXPathObjectPtr *resultsTab[XSLT_MAX_SORT];
xmlXPathObjectPtr *results = NULL, *res;
xmlNodeSetPtr list = NULL;
int descending, number, desc, numb;
int len = 0;
int i, j, incr;
int tst;
int depth;
xmlNodePtr node;
xmlXPathObjectPtr tmp;
xsltStylePreCompPtr comp;
int tempstype[XSLT_MAX_SORT], temporder[XSLT_MAX_SORT];
/* Start ICU change */
UCollator *coll = 0;
UConverter *conv;
UErrorCode status;
UChar *target,*target2;
int targetlen, target2len;
/* End ICU change */
if ((ctxt == NULL) || (sorts == NULL) || (nbsorts <= 0) ||
(nbsorts >= XSLT_MAX_SORT))
return;
if (sorts[0] == NULL)
return;
comp = sorts[0]->_private;
if (comp == NULL)
return;
list = ctxt->nodeList;
if ((list == NULL) || (list->nodeNr <= 1))
return; /* nothing to do */
for (j = 0; j < nbsorts; j++) {
comp = sorts[j]->_private;
tempstype[j] = 0;
if ((comp->stype == NULL) && (comp->has_stype != 0)) {
comp->stype =
xsltEvalAttrValueTemplate(ctxt, sorts[j],
(const xmlChar *) "data-type",
XSLT_NAMESPACE);
if (comp->stype != NULL) {
tempstype[j] = 1;
if (xmlStrEqual(comp->stype, (const xmlChar *) "text"))
comp->number = 0;
else if (xmlStrEqual(comp->stype, (const xmlChar *) "number"))
comp->number = 1;
else {
xsltTransformError(ctxt, NULL, sorts[j],
"xsltDoSortFunction: no support for data-type = %s\n",
comp->stype);
comp->number = 0; /* use default */
}
}
}
temporder[j] = 0;
if ((comp->order == NULL) && (comp->has_order != 0)) {
comp->order = xsltEvalAttrValueTemplate(ctxt, sorts[j],
(const xmlChar *) "order",
XSLT_NAMESPACE);
if (comp->order != NULL) {
temporder[j] = 1;
if (xmlStrEqual(comp->order, (const xmlChar *) "ascending"))
comp->descending = 0;
else if (xmlStrEqual(comp->order,
(const xmlChar *) "descending"))
comp->descending = 1;
else {
xsltTransformError(ctxt, NULL, sorts[j],
"xsltDoSortFunction: invalid value %s for order\n",
comp->order);
comp->descending = 0; /* use default */
}
}
}
}
len = list->nodeNr;
resultsTab[0] = xsltComputeSortResult(ctxt, sorts[0]);
for (i = 1;i < XSLT_MAX_SORT;i++)
resultsTab[i] = NULL;
results = resultsTab[0];
comp = sorts[0]->_private;
descending = comp->descending;
number = comp->number;
if (results == NULL)
return;
/* Start ICU change */
status = U_ZERO_ERROR;
conv = ucnv_open("UTF8", &status);
if(U_FAILURE(status)) {
xsltTransformError(ctxt, NULL, NULL, "xsltICUSortFunction: Error opening converter\n");
}
if(comp->has_lang)
coll = ucol_open(comp->lang, &status);
if(U_FAILURE(status) || !comp->has_lang) {
status = U_ZERO_ERROR;
coll = ucol_open("en", &status);
}
if(U_FAILURE(status)) {
xsltTransformError(ctxt, NULL, NULL, "xsltICUSortFunction: Error opening collator\n");
}
if(comp->lower_first)
ucol_setAttribute(coll,UCOL_CASE_FIRST,UCOL_LOWER_FIRST,&status);
else
ucol_setAttribute(coll,UCOL_CASE_FIRST,UCOL_UPPER_FIRST,&status);
if(U_FAILURE(status)) {
xsltTransformError(ctxt, NULL, NULL, "xsltICUSortFunction: Error setting collator attribute\n");
}
/* End ICU change */
/* Shell's sort of node-set */
for (incr = len / 2; incr > 0; incr /= 2) {
for (i = incr; i < len; i++) {
j = i - incr;
if (results[i] == NULL)
continue;
while (j >= 0) {
if (results[j] == NULL)
tst = 1;
else {
if (number) {
if (results[j]->floatval == results[j + incr]->floatval)
tst = 0;
else if (results[j]->floatval >
results[j + incr]->floatval)
tst = 1;
else tst = -1;
} else {
/* tst = xmlStrcmp(results[j]->stringval,
results[j + incr]->stringval); */
/* Start ICU change */
targetlen = xmlStrlen(results[j]->stringval) * 2;
target2len = xmlStrlen(results[j + incr]->stringval) * 2;
target = xmlMalloc(targetlen * sizeof(UChar));
target2 = xmlMalloc(target2len * sizeof(UChar));
targetlen = ucnv_toUChars(conv, target, targetlen, results[j]->stringval, -1, &status);
target2len = ucnv_toUChars(conv, target2, target2len, results[j+incr]->stringval, -1, &status);
tst = ucol_strcoll(coll, target, u_strlen(target), target2, u_strlen(target2));
/* End ICU change */
}
if (descending)
tst = -tst;
}
if (tst == 0) {
/*
* Okay we need to use multi level sorts
*/
depth = 1;
while (depth < nbsorts) {
if (sorts[depth] == NULL)
break;
comp = sorts[depth]->_private;
if (comp == NULL)
break;
desc = comp->descending;
numb = comp->number;
/*
* Compute the result of the next level for the
* full set, this might be optimized ... or not
*/
if (resultsTab[depth] == NULL)
resultsTab[depth] = xsltComputeSortResult(ctxt,
sorts[depth]);
res = resultsTab[depth];
if (res == NULL)
break;
if (res[j] == NULL)
tst = 1;
else {
if (numb) {
if (res[j]->floatval == res[j + incr]->floatval)
tst = 0;
else if (res[j]->floatval >
res[j + incr]->floatval)
tst = 1;
else tst = -1;
} else {
/* tst = xmlStrcmp(res[j]->stringval,
res[j + incr]->stringval); */
/* Start ICU change */
targetlen = xmlStrlen(res[j]->stringval) * 2;
target2len = xmlStrlen(res[j + incr]->stringval) * 2;
target = xmlMalloc(targetlen * sizeof(UChar));
target2 = xmlMalloc(target2len * sizeof(UChar));
targetlen = ucnv_toUChars(conv, target, targetlen, res[j]->stringval, -1, &status);
target2len = ucnv_toUChars(conv, target2, target2len, res[j+incr]->stringval, -1, &status);
tst = ucol_strcoll(coll, target, u_strlen(target), target2, u_strlen(target2));
/* End ICU change */
}
if (desc)
tst = -tst;
}
/*
* if we still can't differenciate at this level
* try one level deeper.
*/
if (tst != 0)
break;
depth++;
}
}
if (tst == 0) {
tst = results[j]->index > results[j + incr]->index;
}
if (tst > 0) {
tmp = results[j];
results[j] = results[j + incr];
results[j + incr] = tmp;
node = list->nodeTab[j];
list->nodeTab[j] = list->nodeTab[j + incr];
list->nodeTab[j + incr] = node;
depth = 1;
while (depth < nbsorts) {
if (sorts[depth] == NULL)
break;
if (resultsTab[depth] == NULL)
break;
res = resultsTab[depth];
tmp = res[j];
res[j] = res[j + incr];
res[j + incr] = tmp;
depth++;
}
j -= incr;
} else
break;
}
}
}
/* Start ICU change */
ucol_close(coll);
ucnv_close(conv);
/* End ICU change */
for (j = 0; j < nbsorts; j++) {
comp = sorts[j]->_private;
if (tempstype[j] == 1) {
/* The data-type needs to be recomputed each time */
xmlFree(comp->stype);
comp->stype = NULL;
}
if (temporder[j] == 1) {
/* The order needs to be recomputed each time */
xmlFree(comp->order);
comp->order = NULL;
}
if (resultsTab[j] != NULL) {
for (i = 0;i < len;i++)
xmlXPathFreeObject(resultsTab[j][i]);
xmlFree(resultsTab[j]);
}
}
}
/**
* xsltAttributeInternal:
* @ctxt: a XSLT process context
* @node: the node in the source tree.
* @inst: the xsl:attribute element
* @comp: precomputed information
* @fromAttributeSet: the attribute comes from an attribute-set
*
* Process the xslt attribute node on the source node
*/
static void
xsltAttributeInternal(xsltTransformContextPtr ctxt, xmlNodePtr node,
xmlNodePtr inst,
xsltStylePreCompPtr castedComp,
int fromAttributeSet) {
#ifdef XSLT_REFACTORED
xsltStyleItemAttributePtr comp =
(xsltStyleItemAttributePtr) castedComp;
/*
* TODO: Change the fields of the compiled struct:
* 1) @name (char)
* 2) @nameType (String, AVT)
* 3) @nsName (char)
* 4) nsNameType (None, String, AVT)
*/
#else
xsltStylePreCompPtr comp = castedComp;
#endif
xmlNodePtr targetElem;
xmlChar *prop = NULL;
const xmlChar *name = NULL, *prefix = NULL, *nsName = NULL;
xmlChar *value = NULL;
xmlNsPtr ns = NULL;
xmlAttrPtr attr;
if ((ctxt == NULL) || (node == NULL) || (inst == NULL))
return;
/*
* BIG NOTE: This previously used xsltGetSpecialNamespace() and
* xsltGetNamespace(), but since both are not appropriate, we
* will process namespace lookup here to avoid adding yet another
* ns-lookup function to namespaces.c.
*/
/*
* SPEC XSLT 1.0: Error cases:
* - Creating nodes other than text nodes during the instantiation of
* the content of the xsl:attribute element; implementations may
* either signal the error or ignore the offending nodes."
*/
if (comp == NULL) {
xsltTransformError(ctxt, NULL, inst,
"Internal error in xsltAttributeInternal(): "
"The instruction was no compiled.\n");
return;
}
/*
* TODO: Shouldn't ctxt->insert == NULL be treated as an internal error?
* So report an internal error?
*/
if (ctxt->insert == NULL)
return;
/*
* SPEC XSLT 1.0:
* "Adding an attribute to a node that is not an element;
* implementations may either signal the error or ignore the attribute."
*
* TODO: I think we should signal such errors in the future, and maybe
* provide an option to ignore such errors.
*/
targetElem = ctxt->insert;
if (targetElem->type != XML_ELEMENT_NODE)
return;
/*
* SPEC XSLT 1.0:
* "Adding an attribute to an element after children have been added
* to it; implementations may either signal the error or ignore the
* attribute."
*
* TODO: We should decide whether not to report such errors or
* to ignore them; note that we *ignore* if the parent is not an
* element, but here we report an error.
*/
if (targetElem->children != NULL) {
/*
* NOTE: Ah! This seems to be intended to support streamed
* result generation!.
*/
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: Cannot add attributes to an "
"element if children have been already added "
"to the element.\n");
return;
}
/*
* Process the name
* ----------------
*/
if (!comp->has_name) /* TODO: raise error */
return;
#ifdef WITH_DEBUGGER
if (ctxt->debugStatus != XSLT_DEBUG_NONE)
xslHandleDebugger(inst, node, NULL, ctxt);
#endif
if (comp->name == NULL) {
/* TODO: fix attr acquisition wrt to the XSLT namespace */
prop = xsltEvalAttrValueTemplate(ctxt, inst,
(const xmlChar *) "name", XSLT_NAMESPACE);
if (prop == NULL) {
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: The attribute 'name' is missing.\n");
goto error;
}
if (xmlValidateQName(prop, 0)) {
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: The effective name '%s' is not a "
"valid QName.\n", prop);
/* we fall through to catch any further errors, if possible */
}
name = xsltSplitQName(ctxt->dict, prop, &prefix);
xmlFree(prop);
} else {
name = xsltSplitQName(ctxt->dict, comp->name, &prefix);
}
if (!xmlStrncasecmp(prefix, (xmlChar *) "xmlns", 5)) {
#ifdef WITH_XSLT_DEBUG_PARSING
xsltGenericDebug(xsltGenericDebugContext,
"xsltAttribute: xmlns prefix forbidden\n");
#endif
/*
* SPEC XSLT 1.0:
* "It is an error if the string that results from instantiating
* the attribute value template is not a QName or is the string
* xmlns. An XSLT processor may signal the error; if it does not
* signal the error, it must recover by not adding the attribute
* to the result tree."
* TODO: Decide which way to go here.
*/
goto error;
}
/*
* Process namespace semantics
* ---------------------------
*
* Evaluate the namespace name.
*/
if (comp->has_ns) {
if (comp->ns != NULL) {
if (comp->ns[0] != 0)
nsName = comp->ns;
} else {
xmlChar *tmpNsName;
/*
* Eval the AVT.
*/
/* TODO: check attr acquisition wrt to the XSLT namespace */
tmpNsName = xsltEvalAttrValueTemplate(ctxt, inst,
(const xmlChar *) "namespace", XSLT_NAMESPACE);
/*
* This fixes bug #302020: The AVT might also evaluate to the
* empty string; this means that the empty string also indicates
* "no namespace".
* SPEC XSLT 1.0:
* "If the string is empty, then the expanded-name of the
* attribute has a null namespace URI."
*/
if ((tmpNsName != NULL) && (tmpNsName[0] != 0))
nsName = xmlDictLookup(ctxt->dict, BAD_CAST tmpNsName, -1);
xmlFree(tmpNsName);
};
} else if (prefix != NULL) {
/*
* SPEC XSLT 1.0:
* "If the namespace attribute is not present, then the QName is
* expanded into an expanded-name using the namespace declarations
* in effect for the xsl:attribute element, *not* including any
* default namespace declaration."
*/
ns = xmlSearchNs(inst->doc, inst, prefix);
if (ns == NULL) {
/*
* Note that this is treated as an error now (checked with
* Saxon, Xalan-J and MSXML).
*/
xsltTransformError(ctxt, NULL, inst,
"xsl:attribute: The effective prefix '%s', has no "
"namespace binding in scope in the stylesheet; "
"this is an error, since the namespace was not "
"specified by the instruction itself.\n", prefix);
} else
nsName = ns->href;
}
if (fromAttributeSet) {
/*
* I think this tries to ensure that xsl:attribute(s) coming
* from an xsl:attribute-set won't override attribute of
* literal result elements or of explicit xsl:attribute(s).
*/
attr = xmlHasNsProp(targetElem, name, nsName);
if (attr != NULL)
return;
}
/*
* Something about ns-prefixes:
* SPEC XSLT 1.0:
* "XSLT processors may make use of the prefix of the QName specified
* in the name attribute when selecting the prefix used for outputting
* the created attribute as XML; however, they are not required to do
* so and, if the prefix is xmlns, they must not do so"
*/
/*
* Find/create a matching ns-decl in the result tree.
*/
ns = NULL;
#if 0
if (0) {
/*
* OPTIMIZE TODO: How do we know if we are adding to a
* fragment or not?
*
* If we are adding to a result tree fragment (i.e., not to the
* actual result tree), we'll don't bother searching for the
* ns-decl, but just store it in the dummy-doc of the result
* tree fragment.
*/
if (nsName != NULL) {
ns = xsltTreeAcquireStoredNs(ctxt->document->doc, nsName,
prefix);
}
}
#endif
if (nsName != NULL) {
/*
* The owner-element might be in the same namespace.
*/
if ((targetElem->ns != NULL) &&
(targetElem->ns->prefix != NULL) &&
xmlStrEqual(targetElem->ns->href, nsName))
{
ns = targetElem->ns;
goto namespace_finished;
}
if (prefix != NULL) {
/*
* Search by ns-prefix.
*/
ns = xmlSearchNs(targetElem->doc, targetElem, prefix);
if ((ns != NULL) && (xmlStrEqual(ns->href, nsName))) {
goto namespace_finished;
}
}
/*
* Fallback to a search by ns-name.
*/
ns = xmlSearchNsByHref(targetElem->doc, targetElem, nsName);
if ((ns != NULL) && (ns->prefix != NULL)) {
goto namespace_finished;
}
/*
* OK, we need to declare the namespace on the target element.
*/
if (prefix) {
if (targetElem->nsDef != NULL) {
ns = targetElem->nsDef;
do {
if ((ns->prefix) && xmlStrEqual(ns->prefix, prefix)) {
/*
* The prefix is aready occupied.
*/
break;
}
ns = ns->next;
} while (ns != NULL);
if (ns == NULL) {
ns = xmlNewNs(targetElem, nsName, prefix);
goto namespace_finished;
}
}
}
/*
* Generate a new prefix.
*/
{
const xmlChar *basepref = prefix;
xmlChar pref[30];
int counter = 1;
if (prefix != NULL)
basepref = prefix;
else
basepref = xmlStrdup(BAD_CAST "ns");
do {
snprintf((char *) pref, 30, "%s%d",
basepref, counter++);
ns = xmlSearchNs(targetElem->doc, targetElem, BAD_CAST pref);
if (counter > 1000) {
xsltTransformError(ctxt, NULL, inst,
"Namespace fixup error: Failed to compute a "
"new unique ns-prefix for the generated attribute "
"{%s}%s'.\n", nsName, name);
ns = NULL;
break;
}
} while (ns != NULL);
if (basepref != prefix)
xmlFree((xmlChar *)basepref);
ns = xmlNewNs(targetElem, nsName, BAD_CAST pref);
}
namespace_finished:
if (ns == NULL) {
xsltTransformError(ctxt, NULL, inst,
"Namespace fixup error: Failed to acquire an in-scope "
"namespace binding of the generated attribute '{%s}%s'.\n",
nsName, name);
/*
* TODO: Should we just stop here?
*/
}
}
/*
* Construction of the value
* -------------------------
*/
if (inst->children == NULL) {
/*
* No content.
* TODO: Do we need to put the empty string in ?
*/
attr = xmlSetNsProp(ctxt->insert, ns, name, (const xmlChar *) "");
} else if ((inst->children->next == NULL) &&
((inst->children->type == XML_TEXT_NODE) ||
(inst->children->type == XML_CDATA_SECTION_NODE)))
{
xmlNodePtr origTxt = inst->children, copyTxt;
/*
* Optimization: if the content is just 1 text node, then
* just need to copy it over, or just assign it to the result
* if the string is shared.
*/
attr = xmlSetNsProp(ctxt->insert, ns, name, NULL);
if (attr == NULL) /* TODO: report error ? */
goto error;
/*
* This was taken over from xsltCopyText() (transform.c).
*/
if (ctxt->internalized &&
(ctxt->insert->doc != NULL) &&
(ctxt->insert->doc->dict == ctxt->dict))
{
copyTxt = xmlNewText(NULL);
if (copyTxt == NULL) /* TODO: report error */
goto error;
/*
* This is a safe scenario where we don't need to lookup
* the dict.
*/
copyTxt->content = origTxt->content;
/*
* Copy "disable-output-escaping" information.
* TODO: Does this have any effect for attribute values
* anyway?
*/
if (origTxt->name == xmlStringTextNoenc)
copyTxt->name = xmlStringTextNoenc;
} else {
/*
* Copy the value.
*/
copyTxt = xmlNewText(origTxt->content);
if (copyTxt == NULL) /* TODO: report error */
goto error;
/*
* Copy "disable-output-escaping" information.
* TODO: Does this have any effect for attribute values
* anyway?
*/
if (origTxt->name == xmlStringTextNoenc)
copyTxt->name = xmlStringTextNoenc;
}
if (copyTxt != NULL) {
copyTxt->doc = attr->doc;
xmlAddChild((xmlNodePtr) attr, copyTxt);
}
} else {
/*
* The sequence constructor might be complex, so instantiate it.
*/
value = xsltEvalTemplateString(ctxt, node, inst);
if (value != NULL) {
attr = xmlSetNsProp(ctxt->insert, ns, name, value);
xmlFree(value);
} else {
/*
* TODO: Do we have to add the empty string to the attr?
*/
attr = xmlSetNsProp(ctxt->insert, ns, name,
(const xmlChar *) "");
}
}
error:
return;
}
