+Thu Jul 12 21:31:06 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
+
+ * libxslt/documents.c libxslt/extensions.c libxslt/extra.c
+ libxslt/functions.c libxslt/imports.c libxslt/keys.c
+ libxslt/namespaces.c libxslt/numbers.c libxslt/pattern.c
+ libxslt/preproc.c libxslt/templates.c libxslt/transform.c
+ libxslt/variables.c libxslt/xslt.c: provide context for
+ error messages. Requires libxml head changes.
+ * libxslt/xsltutils.c libxslt/xsltutils.h: fixed a --profile
+ problem
+
Wed Jul 11 00:32:21 CEST 2001 Daniel Veillard <Daniel.Veillard@imag.fr>
* libexslt/Makefile.am: initial EXSLT framework
Design:
- seems that saving back XSLT stylesheet from a compiled form might
- be a bit ugly ...
+ be a bit ugly ... Yes forget about it, it's just twaeked to the extreme
ID and Key support:
-> done but namespace support in keys is not defined
- put a page at http://xmlsoft.org/XSLT/
- generate/transform the DocBook to HTML
- add HTML to package
+
+Error handling:
+ -> check the version stuff, design a separate module for error interfacing
+ and default handling, parsing vs. runtime, fatal / compat / warning,
+ and lack of optionnal features.
+ -> reports context
+
+Profiler:
+ -> added looks good enough
+ -> autocorrection of initial calibration loop
cur = (xsltDocumentPtr) xmlMalloc(sizeof(xsltDocument));
if (cur == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, (xmlNodePtr) doc);
xsltGenericError(xsltGenericErrorContext,
"xsltNewDocument : malloc failed\n");
return(NULL);
cur = (xsltDocumentPtr) xmlMalloc(sizeof(xsltDocument));
if (cur == NULL) {
+ xsltPrintErrorContext(NULL, style, (xmlNodePtr) doc);
xsltGenericError(xsltGenericErrorContext,
"xsltNewStyleDocument : malloc failed\n");
return(NULL);
#ifdef LIBXML_XINCLUDE_ENABLED
xmlXIncludeProcess(doc);
#else
+ xsltPrintErrorContext(ctxt, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltLoadDocument(%s) : XInclude processing not compiled in\n",
URI);
cur = (xsltExtDefPtr) xmlMalloc(sizeof(xsltExtDef));
if (cur == NULL) {
+ xsltPrintErrorContext(NULL, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltNewExtDef : malloc failed\n");
return (NULL);
cur = (xsltExtModulePtr) xmlMalloc(sizeof(xsltExtModule));
if (cur == NULL) {
+ xsltPrintErrorContext(NULL, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltNewExtModule : malloc failed\n");
return (NULL);
return(NULL);
cur = (xsltExtDataPtr) xmlMalloc(sizeof(xsltExtData));
if (cur == NULL) {
+ xsltPrintErrorContext(NULL, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltNewExtData : malloc failed\n");
return (NULL);
return (-1);
if (xmlHashAddEntry(ctxt->extInfos, def->URI,
(void *) data) < 0) {
+ xsltPrintErrorContext(ctxt, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"Failed to register module : %s\n",
def->URI);
void
xsltFunctionNodeSet(xmlXPathParserContextPtr ctxt, int nargs){
if (nargs != 1) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"node-set() : expects one result-tree arg\n");
ctxt->error = XPATH_INVALID_ARITY;
return;
}
if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_XSLT_TREE)) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"node-set() invalid arg expecting a result tree\n");
ctxt->error = XPATH_INVALID_TYPE;
static void
xsltFunctionLocalTime(xmlXPathParserContextPtr ctxt, int nargs) {
if ((nargs < 0) || (nargs > 1)) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"localTime() : invalid number of args %d\n", nargs);
ctxt->error = XPATH_INVALID_ARITY;
if ((nargs < 1) || (nargs > 2)) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"document() : invalid number of args %d\n", nargs);
ctxt->error = XPATH_INVALID_ARITY;
return;
}
if (ctxt->value == NULL) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"document() : invalid arg value\n");
ctxt->error = XPATH_INVALID_TYPE;
if (nargs == 2) {
if (ctxt->value->type != XPATH_NODESET) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt),
+ NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"document() : invalid arg expecting a nodeset\n");
ctxt->error = XPATH_INVALID_TYPE;
*/
xmlXPathStringFunction(ctxt, 1);
if (ctxt->value->type != XPATH_STRING) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"document() : invalid arg expecting a string\n");
ctxt->error = XPATH_INVALID_TYPE;
tctxt = xsltXPathGetTransformContext(ctxt);
if (tctxt == NULL) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt),
+ NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"document() : internal error tctxt == NULL\n");
valuePush(ctxt, xmlXPathNewNodeSet(NULL));
xsltTransformContextPtr tctxt;
if (nargs != 2) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"key() : expects two arguments\n");
ctxt->error = XPATH_INVALID_ARITY;
obj2 = valuePop(ctxt);
if ((obj2 == NULL) ||
(ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"key() : invalid arg expecting a string\n");
ctxt->error = XPATH_INVALID_TYPE;
if (prefix != NULL) {
keyURI = xmlXPathNsLookup(ctxt->context, prefix);
if (keyURI == NULL) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt),
+ NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"key() : prefix %s is not bound\n", prefix);
}
valuePush(ctxt, obj2);
xmlXPathStringFunction(ctxt, 1);
if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt),
+ NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"key() : invalid arg expecting a string\n");
ctxt->error = XPATH_INVALID_TYPE;
if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_NODESET)) {
ctxt->error = XPATH_INVALID_TYPE;
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt),
+ NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"generate-id() : invalid arg expecting a node-set\n");
return;
}
xmlXPathFreeObject(obj);
} else {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"generate-id() : invalid number of args %d\n", nargs);
ctxt->error = XPATH_INVALID_ARITY;
const xmlChar *nsURI = NULL;
if (nargs != 1) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"system-property() : expects one string arg\n");
ctxt->error = XPATH_INVALID_ARITY;
return;
}
if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"system-property() : invalid arg expecting a string\n");
ctxt->error = XPATH_INVALID_TYPE;
} else {
nsURI = xmlXPathNsLookup(ctxt->context, prefix);
if (nsURI == NULL) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt),
+ NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"system-property() : prefix %s is not bound\n", prefix);
}
xsltTransformContextPtr tctxt;
if (nargs != 1) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"element-available() : expects one string arg\n");
ctxt->error = XPATH_INVALID_ARITY;
return;
}
if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"element-available() : invalid arg expecting a string\n");
ctxt->error = XPATH_INVALID_TYPE;
obj = valuePop(ctxt);
tctxt = xsltXPathGetTransformContext(ctxt);
if (tctxt == NULL) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"element-available() : internal error tctxt == NULL\n");
xmlXPathFreeObject(obj);
} else {
nsURI = xmlXPathNsLookup(ctxt->context, prefix);
if (nsURI == NULL) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt),
+ NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"element-available() : prefix %s is not bound\n", prefix);
}
const xmlChar *nsURI = NULL;
if (nargs != 1) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"function-available() : expects one string arg\n");
ctxt->error = XPATH_INVALID_ARITY;
return;
}
if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"function-available() : invalid arg expecting a string\n");
ctxt->error = XPATH_INVALID_TYPE;
} else {
nsURI = xmlXPathNsLookup(ctxt->context, prefix);
if (nsURI == NULL) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt),
+ NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"function-available() : prefix %s is not bound\n", prefix);
}
xsltTransformContextPtr tctxt;
if (nargs != 0) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"current() : function uses no argument\n");
ctxt->error = XPATH_INVALID_ARITY;
}
tctxt = xsltXPathGetTransformContext(ctxt);
if (tctxt == NULL) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"current() : internal error tctxt == NULL\n");
valuePush(ctxt, xmlXPathNewNodeSet(NULL));
void *data;
if (testData == NULL) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltExtFunctionTest: not initialized\n");
return;
}
tctxt = xsltXPathGetTransformContext(ctxt);
if (tctxt == NULL) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltExtFunctionTest: failed to get the transformation context\n");
return;
}
data = xsltGetExtData(tctxt, (const xmlChar *) XSLT_DEFAULT_URL);
if (data == NULL) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltExtFunctionTest: failed to get module data\n");
return;
}
if (data != testData) {
+ xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltExtFunctionTest: got wrong module data\n");
return;
xmlNodePtr comment;
if (testData == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsltExtElementTest: not initialized\n");
return;
}
if (ctxt == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsltExtElementTest: no transformation context\n");
return;
}
if (node == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsltExtElementTest: no current node\n");
return;
}
if (inst == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsltExtElementTest: no instruction\n");
return;
}
if (ctxt->insert == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsltExtElementTest: no insertion point\n");
return;
xsltExtInitTest(xsltTransformContextPtr ctxt, const xmlChar * URI)
{
if (testData != NULL) {
+ xsltPrintErrorContext(ctxt, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltExtInitTest: already initialized\n");
return (NULL);
const xmlChar * URI, void *data)
{
if (testData == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltExtShutdownTest: not initialized\n");
return;
}
if (data != testData) {
+ xsltPrintErrorContext(ctxt, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltExtShutdownTest: wrong data\n");
}
uriRef = xsltGetNsProp(cur, (const xmlChar *)"href", XSLT_NAMESPACE);
if (uriRef == NULL) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:import : missing href attribute\n");
goto error;
base = xmlNodeGetBase(style->doc, cur);
URI = xmlBuildURI(uriRef, base);
if (URI == NULL) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:import : invalid URI reference %s\n", uriRef);
goto error;
}
import = xmlParseFile((const char *)URI);
if (import == NULL) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:import : unable to load %s\n", URI);
goto error;
uriRef = xsltGetNsProp(cur, (const xmlChar *)"href", XSLT_NAMESPACE);
if (uriRef == NULL) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:include : missing href attribute\n");
goto error;
base = xmlNodeGetBase(style->doc, cur);
URI = xmlBuildURI(uriRef, base);
if (URI == NULL) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:include : invalid URI reference %s\n", uriRef);
goto error;
include = xsltLoadStyleDocument(style, URI);
if (include == NULL) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:include : unable to load %s\n", URI);
goto error;
cur = (xsltKeyDefPtr) xmlMalloc(sizeof(xsltKeyDef));
if (cur == NULL) {
+ xsltPrintErrorContext(NULL, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltNewKeyDef : malloc failed\n");
return(NULL);
cur = (xsltKeyTablePtr) xmlMalloc(sizeof(xsltKeyTable));
if (cur == NULL) {
+ xsltPrintErrorContext(NULL, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltNewKeyTable : malloc failed\n");
return(NULL);
}
key->comp = xmlXPathCompile(pattern);
if (key->comp == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:key : XPath pattern compilation failed '%s'\n",
pattern);
}
key->usecomp = xmlXPathCompile(use);
if (key->usecomp == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:key : XPath pattern compilation failed '%s'\n",
use);
sprefix = xsltGetNsProp(node, (const xmlChar *)"stylesheet-prefix",
XSLT_NAMESPACE);
if (sprefix == NULL) {
+ xsltPrintErrorContext(NULL, style, node);
xsltGenericError(xsltGenericErrorContext,
"namespace-alias: stylesheet-prefix attribute missing\n");
return;
rprefix = xsltGetNsProp(node, (const xmlChar *)"result-prefix",
XSLT_NAMESPACE);
if (rprefix == NULL) {
+ xsltPrintErrorContext(NULL, style, node);
xsltGenericError(xsltGenericErrorContext,
"namespace-alias: result-prefix attribute missing\n");
goto error;
sNs = xmlSearchNs(node->doc, node, sprefix);
}
if ((sNs == NULL) || (sNs->href == NULL)) {
+ xsltPrintErrorContext(NULL, style, node);
xsltGenericError(xsltGenericErrorContext,
"namespace-alias: prefix %s not bound to any namespace\n",
sprefix);
rNs = xmlSearchNs(node->doc, node, rprefix);
}
if ((rNs == NULL) || (rNs->href == NULL)) {
+ xsltPrintErrorContext(NULL, style, node);
xsltGenericError(xsltGenericErrorContext,
"namespace-alias: prefix %s not bound to any namespace\n",
rprefix);
if (style->nsAliases == NULL)
style->nsAliases = xmlHashCreate(10);
if (style->nsAliases == NULL) {
+ xsltPrintErrorContext(NULL, style, node);
xsltGenericError(xsltGenericErrorContext,
"namespace-alias: cannot create hash table\n");
goto error;
OUTPUT_NUMBER:
if (found_error != 0) {
+ xsltPrintErrorContext(NULL, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltFormatNumberConversion : error in format string, using default\n");
default_sign = (number < 0.0) ? 1 : 0;
cur = (xsltCompMatchPtr) xmlMalloc(sizeof(xsltCompMatch));
if (cur == NULL) {
+ xsltPrintErrorContext(NULL, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltNewCompMatch : malloc failed\n");
return(NULL);
cur = (xsltParserContextPtr) xmlMalloc(sizeof(xsltParserContext));
if (cur == NULL) {
+ xsltPrintErrorContext(NULL, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltNewParserContext : malloc failed\n");
return(NULL);
xsltCompMatchAdd(xsltCompMatchPtr comp, xsltOp op, xmlChar *value,
xmlChar *value2) {
if (comp->nbStep >= 20) {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompMatchAdd: overflow\n");
return(-1);
xsltStepOpPtr step, select = NULL;
if ((comp == NULL) || (node == NULL) || (ctxt == NULL)) {
+ xsltPrintErrorContext(ctxt, NULL, node);
xsltGenericError(xsltGenericErrorContext,
"xsltTestCompMatch: null arg\n");
return(-1);
xmlChar *lit2 = NULL;
if (CUR != '(') {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompileIdKeyPattern : ( expected\n");
ctxt->error = 1;
return;
SKIP_BLANKS;
if (CUR != ')') {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompileIdKeyPattern : ) expected\n");
ctxt->error = 1;
return;
SKIP_BLANKS;
if (CUR != ',') {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompileIdKeyPattern : , expected\n");
ctxt->error = 1;
return;
SKIP_BLANKS;
if (CUR != ')') {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompileIdKeyPattern : ) expected\n");
ctxt->error = 1;
return;
SKIP_BLANKS;
if (CUR != ')') {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompileIdKeyPattern : ) expected\n");
ctxt->error = 1;
NEXT;
SKIP_BLANKS;
if (CUR != ')') {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompileIdKeyPattern : ) expected\n");
ctxt->error = 1;
NEXT;
SKIP_BLANKS;
if (CUR != ')') {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompileIdKeyPattern : ) expected\n");
ctxt->error = 1;
NEXT;
SKIP_BLANKS;
if (CUR != ')') {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompileIdKeyPattern : ) expected\n");
ctxt->error = 1;
NEXT;
PUSH(XSLT_OP_NODE, NULL, NULL);
} else if (aid) {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompileIdKeyPattern : expecting 'key' or 'id' or node type\n");
ctxt->error = 1;
return;
} else {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompileIdKeyPattern : node type\n");
ctxt->error = 1;
ns = xmlSearchNs(ctxt->doc, ctxt->elem, prefix);
if (ns == NULL) {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
- "xsltCompileStepPattern : no namespace bound to prefix %s\n",
+ "xsltCompileStepPattern : no namespace bound to prefix %s\n",
prefix);
} else {
URL = xmlStrdup(ns->href);
PUSH(XSLT_OP_ATTR, NULL, URL);
return;
}
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompileStepPattern : Name expected\n");
ctxt->error = 1;
PUSH(XSLT_OP_ALL, token, NULL);
goto parse_predicate;
} else {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompileStepPattern : Name expected\n");
ctxt->error = 1;
} else if (CUR == ':') {
NEXT;
if (NXT(1) != ':') {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompileStepPattern : sequence '::' expected\n");
ctxt->error = 1;
if (xmlStrEqual(token, (const xmlChar *) "child")) {
name = xsltScanName(ctxt);
if (name == NULL) {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompileStepPattern : QName expected\n");
ctxt->error = 1;
} else if (xmlStrEqual(token, (const xmlChar *) "attribute")) {
name = xsltScanName(ctxt);
if (name == NULL) {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompileStepPattern : QName expected\n");
ctxt->error = 1;
}
PUSH(XSLT_OP_ATTR, name, URL);
} else {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompileStepPattern : 'child' or 'attribute' expected\n");
ctxt->error = 1;
NEXT;
}
if (!IS_CHAR(CUR)) {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompileStepPattern : ']' expected\n");
ctxt->error = 1;
xmlChar *name;
name = xsltScanName(ctxt);
if (name == NULL) {
+ xsltPrintErrorContext(NULL, NULL, NULL); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompileLocationPathPattern : Name expected\n");
ctxt->error = 1;
int current, start, end;
if (pattern == NULL) {
+ xsltPrintErrorContext(NULL, NULL, node); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompilePattern : NULL pattern\n");
return(NULL);
while ((pattern[end] != 0) && (pattern[end] != '|'))
end++;
if (current == end) {
+ xsltPrintErrorContext(NULL, NULL, node); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompilePattern : NULL pattern\n");
goto error;
current = end;
}
if (end == 0) {
+ xsltPrintErrorContext(NULL, NULL, node); /* TODO */
xsltGenericError(xsltGenericErrorContext,
"xsltCompilePattern : NULL pattern\n");
goto error;
break;
case XSLT_OP_END:
case XSLT_OP_PREDICATE:
+ xsltPrintErrorContext(NULL, style, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltAddTemplate: invalid compiled pattern\n");
xsltFreeCompMatch(pat);
list->next = pat;
}
} else {
+ xsltPrintErrorContext(NULL, style, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltAddTemplate: invalid compiled pattern\n");
xsltFreeCompMatch(pat);
cur = (xsltStylePreCompPtr) xmlMalloc(sizeof(xsltStylePreComp));
if (cur == NULL) {
+ xsltPrintErrorContext(NULL, style, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltNewStylePreComp : malloc failed\n");
style->errors++;
cur->func = NULL;break;
default:
if (cur->func == NULL) {
+ xsltPrintErrorContext(NULL, style, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltNewStylePreComp : no function for type %d\n", type);
style->errors++;
base = xmlNodeGetBase(inst->doc, inst);
URL = xmlBuildURI(filename, base);
if (URL == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsltDocumentComp: URL computation failed %s\n", filename);
style->warnings++;
else if (xmlStrEqual(comp->stype, (const xmlChar *) "number"))
comp->number = 1;
else {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsltSortComp: no support for data-type = %s\n", comp->stype);
comp->number = -1;
else if (xmlStrEqual(comp->order, (const xmlChar *) "descending"))
comp->descending = 1;
else {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsltSortComp: invalid value %s for order\n", comp->order);
comp->descending = -1;
}
comp->comp = xmlXPathCompile(comp->select);
if (comp->comp == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsltSortComp: could not compile select expression '%s'\n",
comp->select);
comp->noescape = 1;
} else if (!xmlStrEqual(prop,
(const xmlChar *)"no")){
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:text: disable-output-escaping allows only yes or no\n");
style->warnings++;
comp->select = xsltGetNsProp(inst, (const xmlChar *)"select",
XSLT_NAMESPACE);
if (comp->select == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:copy-of : select is missing\n");
style->errors++;
}
comp->comp = xmlXPathCompile(comp->select);
if (comp->comp == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:copy-of : could not compile select expression '%s'\n",
comp->select);
comp->noescape = 1;
} else if (!xmlStrEqual(prop,
(const xmlChar *)"no")){
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:value-of : disable-output-escaping allows only yes or no\n");
style->warnings++;
comp->select = xsltGetNsProp(inst, (const xmlChar *)"select",
XSLT_NAMESPACE);
if (comp->select == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:value-of : select is missing\n");
style->errors++;
}
comp->comp = xmlXPathCompile(comp->select);
if (comp->comp == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:value-of : could not compile select expression '%s'\n",
comp->select);
*/
prop = xsltGetNsProp(inst, (const xmlChar *)"name", XSLT_NAMESPACE);
if (prop == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:with-param : name is missing\n");
style->errors++;
if (comp->select != NULL) {
comp->comp = xmlXPathCompile(comp->select);
if (comp->comp == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:param : could not compile select expression '%s'\n",
comp->select);
style->errors++;
}
- if (inst->children != NULL)
+ if (inst->children != NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:param : content should be empty since select is present \n");
- style->warnings++;
+ style->warnings++;
+ }
}
}
xmlStrEqual(prop, BAD_CAST("any"))) {
comp->numdata.level = prop;
} else {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:number : invalid value %s for level\n", prop);
style->warnings++;
prop = xsltGetNsProp(cur, (const xmlChar *)"letter-value", XSLT_NAMESPACE);
if (prop != NULL) {
if (xmlStrEqual(prop, BAD_CAST("alphabetic"))) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:number : letter-value 'alphabetic' not implemented\n");
style->warnings++;
TODO; /* xsl:number letter-value attribute alphabetic */
} else if (xmlStrEqual(prop, BAD_CAST("traditional"))) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:number : letter-value 'traditional' not implemented\n");
style->warnings++;
TODO; /* xsl:number letter-value attribute traditional */
} else {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:number : invalid value %s for letter-value\n", prop);
style->warnings++;
*/
prop = xsltGetNsProp(inst, (const xmlChar *)"name", XSLT_NAMESPACE);
if (prop == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:call-template : name is missing\n");
style->errors++;
if (comp->select != NULL) {
comp->comp = xmlXPathCompile(comp->select);
if (comp->comp == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:apply-templates : could not compile select expression '%s'\n",
comp->select);
comp->test = xsltGetNsProp(inst, (const xmlChar *)"test", XSLT_NAMESPACE);
if (comp->test == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:if : test is not defined\n");
style->errors++;
}
comp->comp = xmlXPathCompile(comp->test);
if (comp->comp == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:if : could not compile test expression '%s'\n",
comp->test);
comp->test = xsltGetNsProp(inst, (const xmlChar *)"test", XSLT_NAMESPACE);
if (comp->test == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:when : test is not defined\n");
style->errors++;
}
comp->comp = xmlXPathCompile(comp->test);
if (comp->comp == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:when : could not compile test expression '%s'\n",
comp->test);
comp->select = xsltGetNsProp(inst, (const xmlChar *)"select",
XSLT_NAMESPACE);
if (comp->select == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:for-each : select is missing\n");
style->errors++;
} else {
comp->comp = xmlXPathCompile(comp->select);
if (comp->comp == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:for-each : could not compile select expression '%s'\n",
comp->select);
*/
prop = xsltGetNsProp(inst, (const xmlChar *)"name", XSLT_NAMESPACE);
if (prop == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:variable : name is missing\n");
style->errors++;
if (comp->select != NULL) {
comp->comp = xmlXPathCompile(comp->select);
if (comp->comp == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:variable : could not compile select expression '%s'\n",
comp->select);
style->errors++;
}
- if (inst->children != NULL)
+ if (inst->children != NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:variable : content should be empty since select is present \n");
- style->warnings++;
+ style->warnings++;
+ }
}
}
*/
prop = xsltGetNsProp(inst, (const xmlChar *)"name", XSLT_NAMESPACE);
if (prop == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:param : name is missing\n");
style->errors++;
if (comp->select != NULL) {
comp->comp = xmlXPathCompile(comp->select);
if (comp->comp == NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:param : could not compile select expression '%s'\n",
comp->select);
style->errors++;
}
- if (inst->children != NULL)
+ if (inst->children != NULL) {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:param : content should be empty since select is present \n");
- style->warnings++;
+ style->warnings++;
+ }
}
}
} else if (IS_XSLT_NAME(inst, "document")) {
xsltDocumentComp(style, inst);
} else {
+ xsltPrintErrorContext(NULL, style, inst);
xsltGenericError(xsltGenericDebugContext,
"xsltStylePreCompute: unknown xsl:%s\n", inst->name);
style->warnings++;
ret = res->stringval;
res->stringval = NULL;
} else {
+ xsltPrintErrorContext(ctxt, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xpath : string() function didn't return a String\n");
}
cur = (xsltTransformContextPtr) xmlMalloc(sizeof(xsltTransformContext));
if (cur == NULL) {
+ xsltPrintErrorContext(NULL, NULL, (xmlNodePtr)doc);
xsltGenericError(xsltGenericErrorContext,
"xsltNewTransformContext : malloc failed\n");
return(NULL);
cur->templTab = (xsltTemplatePtr *)
xmlMalloc(10 * sizeof(xsltTemplatePtr));
if (cur->templTab == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xsltPrintErrorContext(NULL, NULL, (xmlNodePtr) doc);
+ xsltGenericError(xsltGenericErrorContext,
"xsltNewTransformContext: out of memory\n");
xmlFree(cur);
return(NULL);
xmlXPathInit();
cur->xpathCtxt = xmlXPathNewContext(doc);
if (cur->xpathCtxt == NULL) {
+ xsltPrintErrorContext(NULL, NULL, (xmlNodePtr) doc);
xsltGenericError(xsltGenericErrorContext,
"xsltNewTransformContext : xmlXPathNewContext failed\n");
xmlFree(cur->templTab);
cur->xpathCtxt->nsHash = style->nsHash;
docu = xsltNewDocument(cur, doc);
if (docu == NULL) {
+ xsltPrintErrorContext(cur, NULL, (xmlNodePtr)doc);
xsltGenericError(xsltGenericErrorContext,
"xsltNewTransformContext : xsltNewDocument failed\n");
xmlFree(cur->templTab);
if (target != NULL)
xmlAddChild(target, copy);
} else {
+ xsltPrintErrorContext(ctxt, NULL, target);
xsltGenericError(xsltGenericErrorContext,
"xsltCopyTextString: text copy failed\n");
}
return(copy);
}
+
/**
* xsltCopyText:
* @ctxt: a XSLT process context
if ((cur->type != XML_TEXT_NODE) &&
(cur->type != XML_CDATA_SECTION_NODE))
return(NULL);
- if (cur->content == NULL)
+ if (cur->content == NULL)
return(NULL);
#ifdef WITH_XSLT_DEBUG_PROCESS
if (target != NULL)
xmlAddChild(target, copy);
} else {
+ xsltPrintErrorContext(ctxt, NULL, target);
xsltGenericError(xsltGenericErrorContext,
"xsltCopyText: text copy failed\n");
}
copy->ns = xsltGetNamespace(ctxt, node, node->ns, copy);
}
} else {
+ xsltPrintErrorContext(ctxt, NULL, node);
xsltGenericError(xsltGenericErrorContext,
"xsltCopyNode: copy %s failed\n", node->name);
}
if (node->children != NULL)
xsltCopyTreeList(ctxt, node->children, copy);
} else {
+ xsltPrintErrorContext(ctxt, NULL, node);
xsltGenericError(xsltGenericErrorContext,
"xsltCopyTree: copy %s failed\n", node->name);
}
if (copy != NULL) {
xmlAddChild(ctxt->insert, copy);
} else {
+ xsltPrintErrorContext(ctxt, NULL, node);
xsltGenericError(xsltGenericErrorContext,
"xsltDefaultProcessOneNode: cdata copy failed\n");
}
if (copy != NULL) {
xmlAddChild(ctxt->insert, copy);
} else {
+ xsltPrintErrorContext(ctxt, NULL, node);
xsltGenericError(xsltGenericErrorContext,
"xsltDefaultProcessOneNode: text copy failed\n");
}
while ((cur != NULL) && (cur->type != XML_TEXT_NODE))
cur = cur->next;
if (cur == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, node);
xsltGenericError(xsltGenericErrorContext,
"xsltDefaultProcessOneNode: no text for attribute\n");
} else {
if (copy != NULL) {
xmlAddChild(ctxt->insert, copy);
} else {
+ xsltPrintErrorContext(ctxt, NULL, node);
xsltGenericError(xsltGenericErrorContext,
"xsltDefaultProcessOneNode: text copy failed\n");
}
if (copy != NULL) {
xmlAddChild(ctxt->insert, copy);
} else {
+ xsltPrintErrorContext(ctxt, NULL, node);
xsltGenericError(xsltGenericErrorContext,
"xsltDefaultProcessOneNode: cdata copy failed\n");
}
if (copy != NULL) {
xmlAddChild(ctxt->insert, copy);
} else {
+ xsltPrintErrorContext(ctxt, NULL, node);
xsltGenericError(xsltGenericErrorContext,
"xsltDefaultProcessOneNode: text copy failed\n");
}
CHECK_STOPPED;
if (ctxt->templNr >= xsltMaxDepth) {
+ xsltPrintErrorContext(ctxt, NULL, list);
xsltGenericError(xsltGenericErrorContext,
"xsltApplyOneTemplate: loop found ???\n");
xsltGenericError(xsltGenericErrorContext,
}
if (!found) {
+ xsltPrintErrorContext(ctxt, NULL, cur);
xsltGenericError(xsltGenericErrorContext,
"xsltApplyOneTemplate: failed to find extension %s\n",
cur->name);
child = profPop(ctxt);
total = end - start;
spent = total - child;
+ if (spent <= 0) {
+ /*
+ * Not possible unless the original calibration failed
+ * we can try to corret it on the fly.
+ */
+ xsltCalibrateAdjust(spent);
+ spent = 0;
+ }
templ->time += spent;
if (ctxt->profNr > 0)
}
if (URL == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsltDocumentElem: href/URI-Reference not found\n");
return;
}
filename = xmlBuildURI(URL, (const xmlChar *) ctxt->outputFile);
if (filename == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsltDocumentElem: URL computation failed for %s\n",
URL);
style = xsltNewStylesheet();
if (style == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsltDocumentElem: out of memory\n");
goto error;
(xmlStrEqual(prop, (const xmlChar *) "text"))) {
style->method = prop;
} else {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"invalid value for method: %s\n", prop);
style->warnings++;
} else if (xmlStrEqual(prop, (const xmlChar *) "no")) {
style->standalone = 0;
} else {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"invalid value for standalone: %s\n",
prop);
} else if (xmlStrEqual(prop, (const xmlChar *) "no")) {
style->indent = 0;
} else {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"invalid value for indent: %s\n", prop);
style->warnings++;
} else if (xmlStrEqual(prop, (const xmlChar *) "no")) {
style->omitXmlDeclaration = 0;
} else {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"invalid value for omit-xml-declaration: %s\n",
prop);
if (res == NULL)
goto error;
} else if (xmlStrEqual(method, (const xmlChar *) "xhtml")) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsltDocumentElem: unsupported method xhtml, using html\n",
style->method);
if (res == NULL)
goto error;
} else {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsltDocumentElem: unsupported method %s\n",
style->method);
ret = xsltSaveResultToFilename((const char *) filename,
res, style, 0);
if (ret < 0) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsltDocumentElem: unable to save to %s\n",
filename);
* called directly
*/
void
-xsltSort(xsltTransformContextPtr ctxt ATTRIBUTE_UNUSED,
- xmlNodePtr node ATTRIBUTE_UNUSED, xmlNodePtr inst ATTRIBUTE_UNUSED,
+xsltSort(xsltTransformContextPtr ctxt,
+ xmlNodePtr node ATTRIBUTE_UNUSED, xmlNodePtr inst,
xsltStylePreCompPtr comp) {
if (comp == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:sort : compilation failed\n");
return;
}
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:sort : improper use this should not be reached\n");
}
while (text != NULL) {
if ((text->type != XML_TEXT_NODE) &&
(text->type != XML_CDATA_SECTION_NODE)) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:text content problem\n");
break;
prop = xsltEvalAttrValueTemplate(ctxt, inst,
(const xmlChar *)"name", XSLT_NAMESPACE);
if (prop == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:element : name is missing\n");
goto error;
}
oldns = xmlSearchNs(inst->doc, inst, prefix);
if (oldns == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:element : no namespace bound to prefix %s\n", prefix);
} else {
copy = xmlNewDocNode(ctxt->output, ns, name, NULL);
if (copy == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:element : creation of %s failed\n", name);
goto error;
if (ctxt->insert == NULL)
return;
if (comp == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:attribute : compilation failed\n");
return;
return;
}
if (ctxt->insert->children != NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:attribute : node already has children\n");
return;
prop = xsltEvalAttrValueTemplate(ctxt, inst, (const xmlChar *)"name",
XSLT_NAMESPACE);
if (prop == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:attribute : name is missing\n");
goto error;
if (prefix != NULL) {
ns = xmlSearchNs(inst->doc, inst, prefix);
if (ns == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:attribute : no namespace bound to prefix %s\n", prefix);
} else {
ncname = xsltEvalAttrValueTemplate(ctxt, inst,
(const xmlChar *)"name", XSLT_NAMESPACE);
if (ncname == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:processing-instruction : name is missing\n");
goto error;
if ((ctxt == NULL) || (node == NULL) || (inst == NULL))
return;
if ((comp == NULL) || (comp->select == NULL) || (comp->comp == NULL)) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:copy-of : compilation failed\n");
return;
if ((ctxt == NULL) || (node == NULL) || (inst == NULL))
return;
if ((comp == NULL) || (comp->select == NULL) || (comp->comp == NULL)) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:value-of : compilation failed\n");
return;
}
}
if (copy == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsltValueOf: text copy failed\n");
}
xmlNodePtr inst, xsltStylePreCompPtr comp)
{
if (comp == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:number : compilation failed\n");
return;
*/
void
xsltApplyImports(xsltTransformContextPtr ctxt, xmlNodePtr node,
- xmlNodePtr inst ATTRIBUTE_UNUSED,
+ xmlNodePtr inst,
xsltStylePreCompPtr comp ATTRIBUTE_UNUSED) {
xsltTemplatePtr template;
if ((ctxt->templ == NULL) || (ctxt->templ->style == NULL)) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:apply-imports : internal error no current template\n");
return;
if (ctxt->insert == NULL)
return;
if (comp == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:call-template : compilation failed\n");
return;
if (comp->templ == NULL) {
comp->templ = xsltFindTemplate(ctxt, comp->name, comp->ns);
if (comp->templ == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:call-template : template %s not found\n", comp->name);
return;
xmlNsPtr *oldNamespaces;
if (comp == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:apply-templates : compilation failed\n");
return;
if (comp->select != NULL) {
if (comp->comp == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:apply-templates : compilation failed\n");
goto error;
ctxt->xpathCtxt->doc=list->nodeTab[i]->doc->doc;
if ((ctxt->document =
xsltFindDocument(ctxt,list->nodeTab[i]->doc->doc))==NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:apply-templates : can't find doc\n");
goto error;
*/
replacement = inst->children;
if (replacement == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:choose: empty content not allowed\n");
goto error;
}
if ((!IS_XSLT_ELEM(replacement)) ||
(!IS_XSLT_NAME(replacement, "when"))) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:choose: xsl:when expected first\n");
goto error;
xsltStylePreCompPtr wcomp = replacement->_private;
if ((wcomp == NULL) || (wcomp->test == NULL) || (wcomp->comp == NULL)) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:choose: compilation failed !\n");
goto error;
replacement = replacement->next;
}
if (replacement != NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:choose: unexpected content %s\n", replacement->name);
goto error;
if ((ctxt == NULL) || (node == NULL) || (inst == NULL))
return;
if ((comp == NULL) || (comp->test == NULL) || (comp->comp == NULL)) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:if : compilation failed\n");
return;
if ((ctxt == NULL) || (node == NULL) || (inst == NULL))
return;
if ((comp == NULL) || (comp->select == NULL) || (comp->comp == NULL)) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:for-each : compilation failed\n");
return;
ctxt->xpathCtxt->doc=list->nodeTab[i]->doc->doc;
if ((ctxt->document =
xsltFindDocument(ctxt,list->nodeTab[i]->doc->doc))==NULL) {
+ xsltPrintErrorContext(ctxt, NULL, inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:for-each : can't find doc\n");
goto error;
if (res == NULL)
goto error;
} else if (xmlStrEqual(method, (const xmlChar *) "xhtml")) {
+ xsltPrintErrorContext(ctxt, NULL, (xmlNodePtr) doc);
xsltGenericError(xsltGenericErrorContext,
"xsltApplyStylesheetInternal: unsupported method xhtml, using html\n",
style->method);
if (res == NULL)
goto error;
} else {
+ xsltPrintErrorContext(ctxt, NULL, (xmlNodePtr) doc);
xsltGenericError(xsltGenericErrorContext,
"xsltApplyStylesheetInternal: unsupported method %s\n",
style->method);
tmp = xsltApplyStylesheetInternal(style, doc, params, output, NULL);
if (tmp == NULL) {
+ xsltPrintErrorContext(NULL, NULL, (xmlNodePtr) doc);
xsltGenericError(xsltGenericErrorContext,
"xsltRunStylesheet : run failed\n");
return (-1);
cur = (xsltStackElemPtr) xmlMalloc(sizeof(xsltStackElem));
if (cur == NULL) {
+ xsltPrintErrorContext(NULL, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltNewStackElem : malloc failed\n");
return(NULL);
cur = (xsltStackElemPtr) xmlMalloc(sizeof(xsltStackElem));
if (cur == NULL) {
+ xsltPrintErrorContext(NULL, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltCopyStackElem : malloc failed\n");
return(NULL);
if ((precomp == NULL) || (precomp->comp == NULL))
xmlXPathFreeCompExpr(comp);
if (result == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, precomp->inst);
xsltGenericError(xsltGenericErrorContext,
"Evaluating variable %s failed\n", elem->name);
#ifdef WITH_XSLT_DEBUG_VARIABLE
if ((precomp == NULL) || (precomp->comp == NULL))
xmlXPathFreeCompExpr(comp);
if (result == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, precomp->inst);
xsltGenericError(xsltGenericErrorContext,
"Evaluating global variable %s failed\n", elem->name);
#ifdef WITH_XSLT_DEBUG_VARIABLE
elem->name, elem->nameURI, def);
} else if ((elem->comp != NULL) &&
(elem->comp->type == XSLT_FUNC_VARIABLE)) {
+ xsltPrintErrorContext(ctxt, style, elem->comp->inst);
xsltGenericError(xsltGenericErrorContext,
"Global variable %s already defined\n", elem->name);
}
ns = xmlSearchNs(style->doc, xmlDocGetRootElement(style->doc),
prefix);
if (ns == NULL) {
+ xsltPrintErrorContext(ctxt, style, NULL);
xsltGenericError(xsltGenericErrorContext,
"user param : no namespace bound to prefix %s\n", prefix);
href = NULL;
xmlXPathFreeCompExpr(comp);
}
if (result == NULL) {
+ xsltPrintErrorContext(ctxt, style, NULL);
xsltGenericError(xsltGenericErrorContext,
"Evaluating user parameter %s failed\n", name);
} else {
ncname, href, elem);
if (res != 0) {
xsltFreeStackElem(elem);
+ xsltPrintErrorContext(ctxt, style, NULL);
xsltGenericError(xsltGenericErrorContext,
"Global parameter %s already defined\n", ncname);
}
if (xsltCheckStackElem(ctxt, comp->name, comp->ns) != 0) {
if (!param) {
+ xsltPrintErrorContext(ctxt, NULL, comp->inst);
xsltGenericError(xsltGenericErrorContext,
"xsl:variable : redefining %s\n", comp->name);
}
return(NULL);
comp = (xsltStylePreCompPtr) cur->_private;
if (comp == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:param : compilation error\n");
return(NULL);
}
if (comp->name == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:param : missing name attribute\n");
return(NULL);
xsltStylePreCompute(style, cur);
comp = (xsltStylePreCompPtr) cur->_private;
if (comp == NULL) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:variable : compilation failed\n");
return;
}
if (comp->name == NULL) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:variable : missing name attribute\n");
return;
xsltStylePreCompute(style, cur);
comp = (xsltStylePreCompPtr) cur->_private;
if (comp == NULL) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:param : compilation failed\n");
return;
}
if (comp->name == NULL) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:param : missing name attribute\n");
return;
comp = (xsltStylePreCompPtr) cur->_private;
if (comp == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:variable : compilation failed\n");
return;
}
if (comp->name == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:variable : missing name attribute\n");
return;
comp = (xsltStylePreCompPtr) cur->_private;
if (comp == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:param : compilation failed\n");
return;
}
if (comp->name == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:param : missing name attribute\n");
return;
context = (xsltTransformContextPtr) ctxt;
ret = xsltVariableLookup(context, name, ns_uri);
if (ret == NULL) {
+ xsltPrintErrorContext(ctxt, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"unregistered variable %s\n", name);
}
cur = (xsltTemplatePtr) xmlMalloc(sizeof(xsltTemplate));
if (cur == NULL) {
+ xsltPrintErrorContext(NULL, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltNewTemplate : malloc failed\n");
return(NULL);
cur = (xsltStylesheetPtr) xmlMalloc(sizeof(xsltStylesheet));
if (cur == NULL) {
+ xsltPrintErrorContext(NULL, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltNewStylesheet : malloc failed\n");
return(NULL);
(xmlStrEqual(prop, (const xmlChar *) "text"))) {
style->method = prop;
} else {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"invalid value for method: %s\n", prop);
style->warnings++;
} else if (xmlStrEqual(prop, (const xmlChar *) "no")) {
style->standalone = 0;
} else {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"invalid value for standalone: %s\n", prop);
style->warnings++;
} else if (xmlStrEqual(prop, (const xmlChar *) "no")) {
style->indent = 0;
} else {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"invalid value for indent: %s\n", prop);
style->warnings++;
} else if (xmlStrEqual(prop, (const xmlChar *) "no")) {
style->omitXmlDeclaration = 0;
} else {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"invalid value for omit-xml-declaration: %s\n",
prop);
if (prop != NULL) {
format = xsltDecimalFormatGetByName(style, prop);
if (format != NULL) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsltParseStylestyleDecimalFormat: %s already exists\n", prop);
style->warnings++;
}
format = xsltNewDecimalFormat(prop);
if (format == NULL) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsltParseStylestyleDecimalFormat: failed creating new decimal-format\n");
style->errors++;
elements = xsltGetNsProp(cur, (const xmlChar *)"elements", XSLT_NAMESPACE);
if (elements == NULL) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsltParseStylesheetPreserveSpace: missing elements attribute\n");
style->warnings++;
else
ns = xmlSearchNs(style->doc, cur, prefix);
if (ns == NULL) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:extension-element-prefix : undefined namespace %s\n",
prefix);
elements = xsltGetNsProp(cur, (const xmlChar *)"elements", XSLT_NAMESPACE);
if (elements == NULL) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsltParseStylesheetStripSpace: missing elements attribute\n");
style->warnings++;
else
ns = xmlSearchNs(style->doc, cur, prefix);
if (ns == NULL) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:exclude-result-prefixes : undefined namespace %s\n",
prefix);
if (style->nsHash == NULL) {
style->nsHash = xmlHashCreate(10);
if (style->nsHash == NULL) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsltGatherNamespaces: failed to create hash table\n");
style->errors++;
}
URI = xmlHashLookup(style->nsHash, ns->prefix);
if ((URI != NULL) && (!xmlStrEqual(URI, ns->href))) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"Namespaces prefix %s used for multiple namespaces\n");
style->warnings++;
noesc = 1;
} else if (!xmlStrEqual(prop,
(const xmlChar *)"no")){
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:text: disable-output-escaping allows only yes or no\n");
style->warnings++;
while (text != NULL) {
if ((text->type != XML_TEXT_NODE) &&
(text->type != XML_CDATA_SECTION_NODE)) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsltParseTemplateContent: xslt:text content problem\n");
style->errors++;
xmlNodePtr param = cur;
cur = cur->next;
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsltParseTemplateContent: ignoring misplaced param element\n");
style->warnings++;
"xsltParseStylesheetKey: name %s\n", name);
#endif
} else {
+ xsltPrintErrorContext(NULL, style, key);
xsltGenericError(xsltGenericErrorContext,
"xsl:key : error missing name\n");
style->errors++;
match = xsltGetNsProp(key, (const xmlChar *)"match", XSLT_NAMESPACE);
if (match == NULL) {
+ xsltPrintErrorContext(NULL, style, key);
xsltGenericError(xsltGenericErrorContext,
"xsl:key : error missing match\n");
style->errors++;
use = xsltGetNsProp(key, (const xmlChar *)"use", XSLT_NAMESPACE);
if (use == NULL) {
+ xsltPrintErrorContext(NULL, style, key);
xsltGenericError(xsltGenericErrorContext,
"xsl:key : error missing use\n");
style->errors++;
prop = xsltGetNsProp(top, (const xmlChar *)"version", XSLT_NAMESPACE);
if (prop == NULL) {
+ xsltPrintErrorContext(NULL, style, top);
xsltGenericError(xsltGenericErrorContext,
"xsl:version is missing: document may not be a stylesheet\n");
style->warnings++;
} else {
if ((!xmlStrEqual(prop, (const xmlChar *)"1.0")) &&
(!xmlStrEqual(prop, (const xmlChar *)"1.1"))) {
+ xsltPrintErrorContext(NULL, style, top);
xsltGenericError(xsltGenericErrorContext,
"xsl:version: only 1.0 features are supported\n");
/* TODO set up compatibility when not XSLT 1.0 */
continue;
}
if (IS_XSLT_NAME(cur, "import")) {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsltParseStylesheetTop: ignoring misplaced import element\n");
style->errors++;
} else if (IS_XSLT_NAME(cur, "namespace-alias")) {
xsltNamespaceAlias(style, cur);
} else {
+ xsltPrintErrorContext(NULL, style, cur);
xsltGenericError(xsltGenericErrorContext,
"xsltParseStylesheetTop: ignoring unknown %s element\n",
cur->name);
*/
cur = xmlDocGetRootElement(doc);
if (cur == NULL) {
+ xsltPrintErrorContext(NULL, ret, (xmlNodePtr) doc);
xsltGenericError(xsltGenericErrorContext,
"xsltParseStylesheetProcess : empty stylesheet\n");
ret->doc = NULL;
*/
prop = xsltGetNsProp(cur, (const xmlChar *)"version", XSLT_NAMESPACE);
if (prop == NULL) {
+ xsltPrintErrorContext(NULL, ret, cur);
xsltGenericError(xsltGenericErrorContext,
"xsltParseStylesheetProcess : document is not a stylesheet\n");
ret->doc = NULL;
#endif
if (!xmlStrEqual(prop, (const xmlChar *)"1.0")) {
+ xsltPrintErrorContext(NULL, ret, cur);
xsltGenericError(xsltGenericErrorContext,
"xsl:version: only 1.0 features are supported\n");
/* TODO set up compatibility when not XSLT 1.0 */
doc = xmlParseFile((const char *) filename);
if (doc == NULL) {
+ xsltPrintErrorContext(NULL, NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"xsltParseStylesheetFile : cannot parse %s\n", filename);
return(NULL);
#endif
URI = xmlParseURI((const char *) href);
if (URI == NULL) {
+ xsltPrintErrorContext(NULL, NULL, child);
xsltGenericError(xsltGenericErrorContext,
"xml-stylesheet : href %s is not valid\n", href);
xmlFree(href);
else
ID = xmlGetID(doc, (const xmlChar *) URI->fragment);
if (ID == NULL) {
+ xsltPrintErrorContext(NULL, NULL, child);
xsltGenericError(xsltGenericErrorContext,
"xml-stylesheet : no ID %s found\n", URI->fragment);
} else {
xsltGenericDebug = xsltGenericDebugDefaultFunc;
}
+/**
+ * xsltPrintErrorContext:
+ * @ctxt: the transformation context
+ * @style: the stylesheet
+ * @node: the current node being processed
+ *
+ * Display the context of an error.
+ */
+void
+xsltPrintErrorContext(xsltTransformContextPtr ctxt,
+ xsltStylesheetPtr style, xmlNodePtr node) {
+ int line = 0;
+ const xmlChar *file = NULL;
+ const xmlChar *name = NULL;
+ const char *type = "error";
+
+ if ((node != NULL) && (ctxt != NULL))
+ node = ctxt->inst;
+
+ if (node != NULL) {
+ if ((node->type == XML_DOCUMENT_NODE) ||
+ (node->type == XML_HTML_DOCUMENT_NODE)) {
+ xmlDocPtr doc = (xmlDocPtr) node;
+
+ file = doc->URL;
+ } else {
+ if (node->type == XML_ELEMENT_NODE) {
+ line = (int) node->content;
+ }
+ if ((node->doc != NULL) && (node->doc->URL != NULL))
+ file = node->doc->URL;
+ if (node->name != NULL)
+ name = node->name;
+ }
+ }
+
+ if (ctxt != NULL)
+ type = "runtime error";
+ else if (style != NULL)
+ type = "compilation error";
+
+ if ((file != NULL) && (line != 0) && (name != NULL))
+ xsltGenericError(xsltGenericErrorContext,
+ "%s: file %s line %d element %s\n",
+ type, file, line, name);
+ else if ((file != NULL) && (name != NULL))
+ xsltGenericError(xsltGenericErrorContext,
+ "%s: file %s element %s\n",
+ type, file, name);
+ else if ((file != NULL) && (line != 0))
+ xsltGenericError(xsltGenericErrorContext,
+ "%s: file %s line %d\n",
+ type, file, line);
+ else if (file != NULL)
+ xsltGenericError(xsltGenericErrorContext,
+ "%s: file %s\n",
+ type, file);
+ else if (name != NULL)
+ xsltGenericError(xsltGenericErrorContext,
+ "%s: element %s\n",
+ type, name);
+ else
+ xsltGenericError(xsltGenericErrorContext,
+ "%s\n",
+ type);
+}
+
/************************************************************************
* *
* QNames *
* *
************************************************************************/
+static long calibration = -1;
+
/**
* xsltCalibrateTimestamps:
*
}
/**
+ * xsltCalibrateAdjust:
+ * @delta: a negative dealy value found
+ *
+ * Used for to correct the calibration for xsltTimestamp()
+ */
+void
+xsltCalibrateAdjust(long delta) {
+ calibration += delta;
+}
+
+/**
* xsltTimestamp:
*
* Used for gathering profiling data
long
xsltTimestamp(void) {
#ifdef HAVE_GETTIMEOFDAY
- static long calibration = -1;
static struct timeval startup;
struct timeval cur;
long msec;
- if (calibration == -1) {
+ if (calibration < 0) {
gettimeofday(&startup, NULL);
calibration = 0;
calibration = xsltCalibrateTimestamps();
extern xmlGenericErrorFunc xsltGenericDebug;
extern void *xsltGenericDebugContext;
+void xsltPrintErrorContext (xsltTransformContextPtr ctxt,
+ xsltStylesheetPtr style,
+ xmlNodePtr node);
void xsltMessage (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst);
FILE *output);
long xsltTimestamp (void);
+void xsltCalibrateAdjust (long delta);
#ifdef __cplusplus
}
projects / platform / upstream / libxslt.git / commitdiff