/* {{{ tagName string
readonly=yes
URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-104682815
Since:
*/
int dom_element_tag_name_read(dom_object *obj, zval *retval)
{
xmlNodePtr nodep;
xmlNsPtr ns;
xmlChar *qname;
nodep = dom_object_get_node(obj);
if (nodep == NULL) {
php_dom_throw_error(INVALID_STATE_ERR, 0);
return FAILURE;
}
ns = nodep->ns;
if (ns != NULL && ns->prefix) {
qname = xmlStrdup(ns->prefix);
qname = xmlStrcat(qname, (xmlChar *)":");
qname = xmlStrcat(qname, nodep->name);
ZVAL_STRING(retval, (char *)qname);
xmlFree(qname);
} else {
ZVAL_STRING(retval, (char *) nodep->name);
}
return SUCCESS;
}
/**
* exsltStrReplaceInternal:
* @str: string to modify
* @searchStr: string to find
* @replaceStr: string to replace occurrences of searchStr
*
* Search and replace string function used by exsltStrReplaceFunction
*/
static xmlChar*
exsltStrReplaceInternal(const xmlChar* str, const xmlChar* searchStr,
const xmlChar* replaceStr)
{
const xmlChar *curr, *next;
xmlChar *ret = NULL;
int searchStrSize;
curr = str;
searchStrSize = xmlStrlen(searchStr);
do {
next = xmlStrstr(curr, searchStr);
if (next == NULL) {
ret = xmlStrcat (ret, curr);
break;
}
ret = xmlStrncat (ret, curr, next - curr);
ret = xmlStrcat (ret, replaceStr);
curr = next + searchStrSize;
} while (*curr != 0);
return ret;
}
/**
* exsltStrAlignFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Aligns a string within another string.
*/
static void
exsltStrAlignFunction (xmlXPathParserContextPtr ctxt, int nargs) {
xmlChar *str, *padding, *alignment, *ret;
int str_l, padding_l;
if ((nargs < 2) || (nargs > 3)) {
xmlXPathSetArityError(ctxt);
return;
}
if (nargs == 3)
alignment = xmlXPathPopString(ctxt);
else
alignment = NULL;
padding = xmlXPathPopString(ctxt);
str = xmlXPathPopString(ctxt);
str_l = xmlUTF8Strlen (str);
padding_l = xmlUTF8Strlen (padding);
if (str_l == padding_l) {
xmlXPathReturnString (ctxt, str);
xmlFree(padding);
xmlFree(alignment);
return;
}
if (str_l > padding_l) {
ret = xmlUTF8Strndup (str, padding_l);
} else {
if (xmlStrEqual(alignment, (const xmlChar *) "right")) {
ret = xmlUTF8Strndup (padding, padding_l - str_l);
ret = xmlStrcat (ret, str);
} else if (xmlStrEqual(alignment, (const xmlChar *) "center")) {
int left = (padding_l - str_l) / 2;
int right_start;
ret = xmlUTF8Strndup (padding, left);
ret = xmlStrcat (ret, str);
right_start = xmlUTF8Strsize (padding, left + str_l);
ret = xmlStrcat (ret, padding + right_start);
} else {
int str_s;
str_s = xmlUTF8Strsize(padding, str_l);
ret = xmlStrdup (str);
ret = xmlStrcat (ret, padding + str_s);
}
}
xmlXPathReturnString (ctxt, ret);
xmlFree(str);
xmlFree(padding);
xmlFree(alignment);
}
/***********************************************************************
* Function Name : PSPReturnXMLResultString
* Description : This function appends given result XML string(xmlStr)
* to the Result XML buffer.
* Input : pTrSet - Transaction Set
* xmlStr - Result XML string to be appended
* Output : none
* Return value : CNTRLXML_SUCCESS, CNTRLXML_BADPARAM, CNTRLXML_FAILURE
***********************************************************************/
t_int32
PSPReturnXMLResultString (PSPTransactionId_t * pTrSet, XML_STR pInXMLStr)
{
t_char8 xmlDeclare[] =
"<?xml version=\"1.0\"encoding=\"UTF-8\"?>\n<result><Transaction status=\'ok\'>";
t_char8 xmlEndDecl[] = "</Transaction></result>";
if (!pInXMLStr)
{
XML_Error ("BAD Input Parameters");
return CNTRLXML_BADPARAM;
}
if (IsValidTransaction (pTrSet))
{
/*
* Transaction based XML processing.
*/
if (pXMLResultStr == NULL)
{
pXMLResultStr = xmlStrdup ((const xmlChar *) xmlDeclare);
}
if (!pTransList) /*If no transaction in progress */
{
pXMLResultStr = xmlStrcat (pXMLResultStr, (const xmlChar *) pInXMLStr);
pXMLResultStr = xmlStrcat (pXMLResultStr, (const xmlChar *) xmlEndDecl);
}
else
{
pXMLResultStr = xmlStrcat (pXMLResultStr, (const xmlChar *) pInXMLStr);
}
}
else
{
/*
* Non-Transaction XML processing.
*/
XML_Debug ("Non-Transaction based XML processing");
/* XML_DebugArg ("pInXMLStr =", pInXMLStr);*/
if (pXMLResultStr == NULL ||
T_strnicmp (pInXMLStr, "<html>", 6) == 0)
{
pXMLResultStr = xmlStrdup ((const xmlChar *) pInXMLStr);
}
else
{
if (T_strnicmp (pXMLResultStr, "<html>", 6) != 0)
pXMLResultStr = xmlStrcat (pXMLResultStr, (const xmlChar *) pInXMLStr);
}
}
return CNTRLXML_SUCCESS;
}
static void
exsltRegexpTestFunction (xmlXPathParserContextPtr ctxt, int nargs)
{
xmlChar *haystack, *regexp_middle, *regexp, *flagstr;
int rc = 0, flags, global, ovector[3];
if ((nargs < 1) || (nargs > 3)) {
xmlXPathSetArityError(ctxt);
return;
}
if(nargs > 2) {
flagstr = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt) || (flagstr == NULL)) {
return;
}
} else {
flagstr = xmlStrdup("");
}
regexp_middle = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt) || (regexp_middle == NULL)) {
xmlFree(flagstr);
return;
}
haystack = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt) || (haystack == NULL)) {
xmlFree(regexp_middle);
xmlFree(flagstr);
return;
}
/* build the regexp */
regexp = xmlStrdup("\\A");
regexp = xmlStrcat(regexp, regexp_middle);
regexp = xmlStrcat(regexp, "\\Z");
exsltRegexpFlagsFromString(flagstr, &global, &flags);
rc = exsltRegexpExecute(ctxt, haystack, regexp, flags,
ovector, sizeof(ovector)/sizeof(int));
fail:
if (flagstr != NULL)
xmlFree(flagstr);
if (regexp != NULL)
xmlFree(regexp);
if (regexp_middle != NULL)
xmlFree(regexp_middle);
if (haystack != NULL)
xmlFree(haystack);
xmlXPathReturnBoolean(ctxt, (rc > 0));
}
t_void
CNTRLXMLGenerateResultString (t_char8 * pInXMLFile,
t_char8 * url, t_char8 ** ppOutXMLResultStr)
{
*ppOutXMLResultStr = xmlStrdup ((const xmlChar *) redirectURLTag);
*ppOutXMLResultStr = xmlStrcat (*ppOutXMLResultStr, url);
*ppOutXMLResultStr = xmlStrcat (*ppOutXMLResultStr, redirectURLEndTag);
XML_DebugArg ("XML-STR = %s", *ppOutXMLResultStr);
}
static void par(context_t *ctx, int level, changemode_t *parMode, changemode_t *cellMode, changemode_t *rowMode) {
if (NULL!=rowMode && NULL!=rowMode->mode) {
xmlChar *modeTxt=NULL;;
modeTxt=xmlStrcat(modeTxt, rowMode->mode);
modeTxt=xmlStrcat(modeTxt, _X(": row mark\n"));
ctx->modeTxt=xmlStrcat(ctx->modeTxt, modeTxt);
xmlFree(modeTxt);
}
if (NULL!=parMode && NULL!=parMode->mode) {
xmlChar *modeTxt=NULL;;
modeTxt=xmlStrcat(modeTxt, parMode->mode);
modeTxt=xmlStrcat(modeTxt, _X(": paragraph mark\n"));
ctx->modeTxt=xmlStrcat(ctx->modeTxt, modeTxt);
xmlFree(modeTxt);
}
if (NULL!=parMode && parMode->deleted) {
if (!ctx->deleted) {
ctx->parTxt=xmlStrcat(ctx->parTxt, _X("[]"));
}
ctx->deleted=OPC_TRUE;
} else {
ctx->parTxt=xmlStrcat(ctx->parTxt, _X("\n"));
ctx->deleted=OPC_FALSE;
flush(ctx, level);
}
}
/* {{{ wholeText string
readonly=yes
URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-Text3-wholeText
Since: DOM Level 3
*/
int dom_text_whole_text_read(dom_object *obj, zval *retval)
{
xmlNodePtr node;
xmlChar *wholetext = NULL;
node = dom_object_get_node(obj);
if (node == NULL) {
php_dom_throw_error(INVALID_STATE_ERR, 0);
return FAILURE;
}
/* Find starting text node */
while (node->prev && ((node->prev->type == XML_TEXT_NODE) || (node->prev->type == XML_CDATA_SECTION_NODE))) {
node = node->prev;
}
/* concatenate all adjacent text and cdata nodes */
while (node && ((node->type == XML_TEXT_NODE) || (node->type == XML_CDATA_SECTION_NODE))) {
wholetext = xmlStrcat(wholetext, node->content);
node = node->next;
}
if (wholetext != NULL) {
ZVAL_STRING(retval, (char *) wholetext);
xmlFree(wholetext);
} else {
ZVAL_EMPTY_STRING(retval);
}
return SUCCESS;
}
const char * linphone_get_xml_attribute_text_content(xmlparsing_context_t *xml_ctx, const char *xpath_expression, const char *attribute_name) {
xmlXPathObjectPtr xpath_obj;
xmlChar *text = NULL;
xpath_obj = xmlXPathEvalExpression((const xmlChar *)xpath_expression, xml_ctx->xpath_ctx);
if (xpath_obj != NULL) {
if (xpath_obj->nodesetval != NULL) {
xmlNodeSetPtr nodes = xpath_obj->nodesetval;
if ((nodes != NULL) && (nodes->nodeNr >= 1)) {
xmlNodePtr node = nodes->nodeTab[0];
xmlAttr *attr = node->properties;
while (attr) {
if (strcmp((char *)attr->name, attribute_name) == 0) {
text = xmlStrcat(text, attr->children->content);
attr = NULL;
} else {
attr = attr->next;
}
}
}
}
xmlXPathFreeObject(xpath_obj);
}
return (const char *)text;
}
static HRESULT WINAPI domcomment_appendData(
IXMLDOMComment *iface,
BSTR p)
{
domcomment *This = impl_from_IXMLDOMComment( iface );
xmlnode *pDOMNode = impl_from_IXMLDOMNode( This->node );
xmlChar *pContent;
HRESULT hr = S_FALSE;
TRACE("%p\n", iface);
/* Nothing to do if NULL or an Empty string passed in. */
if(p == NULL || SysStringLen(p) == 0)
return S_OK;
pContent = xmlChar_from_wchar( (WCHAR*)p );
if(pContent)
{
/* Older versions of libxml < 2.6.27 didn't correctly support
xmlTextConcat on Comment nodes. Fallback to setting the
contents directly if xmlTextConcat fails.
NOTE: if xmlTextConcat fails, pContent is destroyed.
*/
if(xmlTextConcat(pDOMNode->node, pContent, SysStringLen(p) ) == 0)
hr = S_OK;
else
{
xmlChar *pNew;
pContent = xmlChar_from_wchar( (WCHAR*)p );
if(pContent)
{
pNew = xmlStrcat(xmlNodeGetContent(pDOMNode->node), pContent);
if(pNew)
{
xmlNodeSetContent(pDOMNode->node, pNew);
hr = S_OK;
}
else
hr = E_FAIL;
}
else
hr = E_FAIL;
}
}
else
hr = E_FAIL;
return hr;
}
static xmlChar *xmlTextReaderReadEntireNodeValue(xmlTextReaderPtr reader) {
xmlChar *buffer = calloc(1, sizeof(xmlChar));
const xmlChar *snippet;
int status;
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ATTRIBUTE) {
return xmlTextReaderValue(reader);
}
else if (xmlTextReaderIsEmptyElement(reader) == 0) {
status = xmlTextReaderRead(reader);
while (status && (xmlTextReaderNodeType(reader) == XML_READER_TYPE_TEXT || xmlTextReaderNodeType(reader) == XML_READER_TYPE_CDATA || xmlTextReaderNodeType(reader) == XML_READER_TYPE_ENTITY_REFERENCE)) {
snippet = xmlTextReaderConstValue(reader);
buffer = realloc(buffer, (xmlStrlen(buffer) + xmlStrlen(snippet) + 1) * sizeof(xmlChar));
xmlStrcat(buffer, snippet);
status = xmlTextReaderRead(reader);
}
}
return buffer;
}
/**
* exsltStrPaddingFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Creates a padding string of a certain length.
*/
static void
exsltStrPaddingFunction (xmlXPathParserContextPtr ctxt, int nargs) {
int number, str_len = 0;
xmlChar *str = NULL, *ret = NULL, *tmp;
if ((nargs < 1) || (nargs > 2)) {
xmlXPathSetArityError(ctxt);
return;
}
if (nargs == 2) {
str = xmlXPathPopString(ctxt);
str_len = xmlUTF8Strlen(str);
}
if (str_len == 0) {
if (str != NULL) xmlFree(str);
str = xmlStrdup((const xmlChar *) " ");
str_len = 1;
}
number = (int) xmlXPathPopNumber(ctxt);
if (number <= 0) {
xmlXPathReturnEmptyString(ctxt);
xmlFree(str);
return;
}
while (number >= str_len) {
ret = xmlStrncat(ret, str, str_len);
number -= str_len;
}
tmp = xmlUTF8Strndup (str, number);
ret = xmlStrcat(ret, tmp);
if (tmp != NULL)
xmlFree (tmp);
xmlXPathReturnString(ctxt, ret);
if (str != NULL)
xmlFree(str);
}
static void text(context_t *ctx, const xmlChar *text, changemode_t *textMode) {
if (NULL!=textMode) {
ctx->modeTxt=xmlStrcat(ctx->modeTxt, textMode->mode);
ctx->modeTxt=xmlStrcat(ctx->modeTxt, _X(": \""));
ctx->modeTxt=xmlStrcat(ctx->modeTxt, text);
ctx->modeTxt=xmlStrcat(ctx->modeTxt, _X("\"\n"));
}
if (NULL!=textMode && textMode->deleted) {
if (!ctx->deleted) {
ctx->parTxt=xmlStrcat(ctx->parTxt, _X("[]"));
}
ctx->deleted=OPC_TRUE;
} else {
ctx->parTxt=xmlStrcat(ctx->parTxt, text);
ctx->deleted=OPC_FALSE;
}
}
/**
* exsltStrConcatFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Takes a node set and returns the concatenation of the string values
* of the nodes in that node set. If the node set is empty, it
* returns an empty string.
*/
static void
exsltStrConcatFunction (xmlXPathParserContextPtr ctxt, int nargs) {
xmlXPathObjectPtr obj;
xmlChar *ret = NULL;
int i;
if (nargs != 1) {
xmlXPathSetArityError(ctxt);
return;
}
if (!xmlXPathStackIsNodeSet(ctxt)) {
xmlXPathSetTypeError(ctxt);
return;
}
obj = valuePop (ctxt);
if (xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
xmlXPathReturnEmptyString(ctxt);
return;
}
for (i = 0; i < obj->nodesetval->nodeNr; i++) {
xmlChar *tmp;
tmp = xmlXPathCastNodeToString(obj->nodesetval->nodeTab[i]);
ret = xmlStrcat (ret, tmp);
xmlFree(tmp);
}
xmlXPathFreeObject (obj);
xmlXPathReturnString(ctxt, ret);
}
/**
* xsltAddKey:
* @style: an XSLT stylesheet
* @name: the key name or NULL
* @nameURI: the name URI or NULL
* @match: the match value
* @use: the use value
* @inst: the key instruction
*
* add a key definition to a stylesheet
*
* Returns 0 in case of success, and -1 in case of failure.
*/
int
xsltAddKey(xsltStylesheetPtr style, const xmlChar *name,
const xmlChar *nameURI, const xmlChar *match,
const xmlChar *use, xmlNodePtr inst) {
xsltKeyDefPtr key;
xmlChar *pattern = NULL;
int current, end, start, i = 0;
if ((style == NULL) || (name == NULL) || (match == NULL) || (use == NULL))
return(-1);
#ifdef WITH_XSLT_DEBUG_KEYS
xsltGenericDebug(xsltGenericDebugContext,
"Add key %s, match %s, use %s\n", name, match, use);
#endif
key = xsltNewKeyDef(name, nameURI);
key->match = xmlStrdup(match);
key->use = xmlStrdup(use);
key->inst = inst;
key->nsList = xmlGetNsList(inst->doc, inst);
if (key->nsList != NULL) {
while (key->nsList[i] != NULL)
i++;
}
key->nsNr = i;
/*
* Split the | and register it as as many keys
*/
current = end = 0;
while (match[current] != 0) {
start = current;
while (IS_BLANK_CH(match[current]))
current++;
end = current;
while ((match[end] != 0) && (match[end] != '|')) {
if (match[end] == '[') {
end = skipPredicate(match, end);
if (end <= 0) {
xsltTransformError(NULL, style, inst,
"xsl:key : 'match' pattern is malformed: %s",
key->match);
if (style != NULL) style->errors++;
goto error;
}
} else
end++;
}
if (current == end) {
xsltTransformError(NULL, style, inst,
"xsl:key : 'match' pattern is empty\n");
if (style != NULL) style->errors++;
goto error;
}
if (match[start] != '/') {
pattern = xmlStrcat(pattern, (xmlChar *)"//");
if (pattern == NULL) {
if (style != NULL) style->errors++;
goto error;
}
}
pattern = xmlStrncat(pattern, &match[start], end - start);
if (pattern == NULL) {
if (style != NULL) style->errors++;
goto error;
}
if (match[end] == '|') {
pattern = xmlStrcat(pattern, (xmlChar *)"|");
end++;
}
current = end;
}
if (pattern == NULL) {
xsltTransformError(NULL, style, inst,
"xsl:key : 'match' pattern is empty\n");
if (style != NULL) style->errors++;
goto error;
}
#ifdef WITH_XSLT_DEBUG_KEYS
xsltGenericDebug(xsltGenericDebugContext,
" resulting pattern %s\n", pattern);
#endif
/*
* XSLT-1: "It is an error for the value of either the use
* attribute or the match attribute to contain a
* VariableReference."
* TODO: We should report a variable-reference at compile-time.
* Maybe a search for "$", if it occurs outside of quotation
* marks, could be sufficient.
*/
#ifdef XML_XPATH_NOVAR
key->comp = xsltXPathCompileFlags(style, pattern, XML_XPATH_NOVAR);
#else
key->comp = xsltXPathCompile(style, pattern);
#endif
if (key->comp == NULL) {
xsltTransformError(NULL, style, inst,
"xsl:key : 'match' pattern compilation failed '%s'\n",
pattern);
if (style != NULL) style->errors++;
}
#ifdef XML_XPATH_NOVAR
key->usecomp = xsltXPathCompileFlags(style, use, XML_XPATH_NOVAR);
#else
key->usecomp = xsltXPathCompile(style, use);
#endif
if (key->usecomp == NULL) {
xsltTransformError(NULL, style, inst,
"xsl:key : 'use' expression compilation failed '%s'\n",
use);
if (style != NULL) style->errors++;
}
/*
* Sometimes the stylesheet writer use the order to ease the
* resolution of keys when they are dependant, keep the provided
* order so add the new one at the end.
*/
if (style->keys == NULL) {
style->keys = key;
} else {
xsltKeyDefPtr prev = style->keys;
while (prev->next != NULL)
prev = prev->next;
prev->next = key;
}
key->next = NULL;
error:
if (pattern != NULL)
xmlFree(pattern);
return(0);
}
static void
xsltp_extension_string_join(xmlXPathParserContextPtr ctxt, int nargs) {
xmlChar *ret = NULL, *sep = NULL, *str = NULL;
xmlNodeSetPtr nodeSet = NULL;
int i, j;
if (nargs < 2) {
xmlXPathSetArityError(ctxt);
return;
}
if (xmlXPathStackIsNodeSet(ctxt)) {
xmlXPathSetTypeError(ctxt);
return;
}
sep = xmlXPathPopString(ctxt);
for (i = 1; i < nargs; i++) {
if (!xmlXPathStackIsNodeSet(ctxt)) {
str = xmlXPathPopString(ctxt);
if (i == 1) {
ret = str;
}
else {
str = xmlStrcat(str, sep);
str = xmlStrcat(str, ret);
xmlFree(ret);
ret = str;
}
}
else {
nodeSet = xmlXPathPopNodeSet(ctxt);
if (xmlXPathCheckError(ctxt)) {
xmlXPathSetTypeError(ctxt);
goto fail;
}
for (j = nodeSet->nodeNr - 1; j >= 0; j--) {
str = xmlXPathCastNodeToString(nodeSet->nodeTab[j]);
if (i == 1 && j == (nodeSet->nodeNr - 1)) {
ret = str;
}
else {
str = xmlStrcat(str, sep);
str = xmlStrcat(str, ret);
xmlFree(ret);
ret = str;
}
}
xmlXPathFreeNodeSet(nodeSet);
}
}
xmlXPathReturnString(ctxt, ret);
fail:
if (sep != NULL)
xmlFree(sep);
}
/**
* xmlSchematronFormatReport:
* @ctxt: the validation context
* @test: the test node
* @cur: the current node tested
*
* Build the string being reported to the user.
*
* Returns a report string or NULL in case of error. The string needs
* to be deallocated by teh caller
*/
static xmlChar *
xmlSchematronFormatReport(xmlSchematronValidCtxtPtr ctxt,
xmlNodePtr test, xmlNodePtr cur) {
xmlChar *ret = NULL;
xmlNodePtr child, node;
if ((test == NULL) || (cur == NULL))
return(ret);
child = test->children;
while (child != NULL) {
if ((child->type == XML_TEXT_NODE) ||
(child->type == XML_CDATA_SECTION_NODE))
ret = xmlStrcat(ret, child->content);
else if (IS_SCHEMATRON(child, "name")) {
xmlChar *path;
path = xmlGetNoNsProp(child, BAD_CAST "path");
node = cur;
if (path != NULL) {
node = xmlSchematronGetNode(ctxt, cur, path);
if (node == NULL)
node = cur;
xmlFree(path);
}
if ((node->ns == NULL) || (node->ns->prefix == NULL))
ret = xmlStrcat(ret, node->name);
else {
ret = xmlStrcat(ret, node->ns->prefix);
ret = xmlStrcat(ret, BAD_CAST ":");
ret = xmlStrcat(ret, node->name);
}
} else {
child = child->next;
continue;
}
/*
* remove superfluous \n
*/
if (ret != NULL) {
int len = xmlStrlen(ret);
xmlChar c;
if (len > 0) {
c = ret[len - 1];
if ((c == ' ') || (c == '\n') || (c == '\r') || (c == '\t')) {
while ((c == ' ') || (c == '\n') ||
(c == '\r') || (c == '\t')) {
len--;
if (len == 0)
break;
c = ret[len - 1];
}
ret[len] = ' ';
ret[len + 1] = 0;
}
}
}
child = child->next;
}
return(ret);
}
static xmlChar* do_get_text(xmlNodePtr node)
{
xmlNodePtr child;
xmlChar* str;
BOOL preserving = is_preserving_whitespace(node);
if (!node->children)
{
str = xmlNodeGetContent(node);
}
else
{
xmlElementType prev_type = XML_TEXT_NODE;
xmlChar* tmp;
str = xmlStrdup(BAD_CAST "");
for (child = node->children; child != NULL; child = child->next)
{
switch (child->type)
{
case XML_ELEMENT_NODE:
tmp = do_get_text(child);
break;
case XML_TEXT_NODE:
case XML_CDATA_SECTION_NODE:
case XML_ENTITY_REF_NODE:
case XML_ENTITY_NODE:
tmp = xmlNodeGetContent(child);
break;
default:
tmp = NULL;
break;
}
if (tmp)
{
if (*tmp)
{
if (prev_type == XML_ELEMENT_NODE && child->type == XML_ELEMENT_NODE)
str = xmlStrcat(str, BAD_CAST " ");
str = xmlStrcat(str, tmp);
prev_type = child->type;
}
xmlFree(tmp);
}
}
}
switch (node->type)
{
case XML_ELEMENT_NODE:
case XML_TEXT_NODE:
case XML_ENTITY_REF_NODE:
case XML_ENTITY_NODE:
case XML_DOCUMENT_NODE:
case XML_DOCUMENT_FRAG_NODE:
if (!preserving)
str = trim_whitespace(str);
break;
default:
break;
}
return str;
}
/**
* Parse command line for XSLT parameters
*/
int
trParseParams(const char** params, int* plen,
int count, char **argv)
{
int i;
*plen = 0;
params[0] = 0;
for (i=0; i<count; i++)
{
if (argv[i][0] == '-')
{
if (!strcmp(argv[i], "-p"))
{
int j;
xmlChar *name, *value;
i++;
if (i >= count) trUsage(argv[0], EXIT_BAD_ARGS);
for(j=0; argv[i][j] && (argv[i][j] != '='); j++);
if (argv[i][j] != '=') trUsage(argv[0], EXIT_BAD_ARGS);
name = xmlStrndup((const xmlChar *) argv[i], j);
value = xmlStrdup((const xmlChar *) argv[i]+j+1);
if (*plen >= MAX_PARAMETERS)
{
fprintf(stderr, "too many params increase MAX_PARAMETERS\n");
exit(EXIT_INTERNAL_ERROR);
}
params[*plen] = (char *)name;
(*plen)++;
params[*plen] = (char *)value;
(*plen)++;
params[*plen] = 0;
}
else if (!strcmp(argv[i], "-s"))
{
int j;
const xmlChar *string;
xmlChar *name, *value;
i++;
if (i >= count) trUsage(argv[0], EXIT_BAD_ARGS);
for(j=0; argv[i][j] && (argv[i][j] != '='); j++);
if (argv[i][j] != '=') trUsage(argv[0], EXIT_BAD_ARGS);
name = xmlStrndup((const xmlChar *)argv[i], j);
string = (const xmlChar *)(argv[i]+j+1);
if (xmlStrchr(string, '"'))
{
if (xmlStrchr(string, '\''))
{
fprintf(stderr,
"string parameter contains both quote and double-quotes\n");
exit(EXIT_INTERNAL_ERROR);
}
value = xmlStrdup((const xmlChar *)"'");
value = xmlStrcat(value, string);
value = xmlStrcat(value, (const xmlChar *)"'");
}
else
{
value = xmlStrdup((const xmlChar *)"\"");
value = xmlStrcat(value, string);
value = xmlStrcat(value, (const xmlChar *)"\"");
}
if (*plen >= MAX_PARAMETERS)
{
fprintf(stderr, "too many params increase MAX_PARAMETERS\n");
exit(EXIT_INTERNAL_ERROR);
}
params[*plen] = (char *)name;
(*plen)++;
params[*plen] = (char *)value;
(*plen)++;
params[*plen] = 0;
}
}
else
break;
}
return i;
}
/**
* xsltAttrTemplateValueProcessNode:
* @ctxt: the XSLT transformation context
* @str: the attribute template node value
* @inst: the instruction (or LRE) in the stylesheet holding the
* attribute with an AVT
*
* Process the given string, allowing to pass a namespace mapping
* context and return the new string value.
*
* Called by:
* - xsltAttrTemplateValueProcess() (templates.c)
* - xsltEvalAttrValueTemplate() (templates.c)
*
* QUESTION: Why is this function public? It is not used outside
* of templates.c.
*
* Returns the computed string value or NULL, must be deallocated by the
* caller.
*/
xmlChar *
xsltAttrTemplateValueProcessNode(xsltTransformContextPtr ctxt,
const xmlChar *str, xmlNodePtr inst)
{
xmlChar *ret = NULL;
const xmlChar *cur;
xmlChar *expr, *val;
xmlNsPtr *nsList = NULL;
int nsNr = 0;
if (str == NULL) return(NULL);
if (*str == 0)
return(xmlStrndup((xmlChar *)"", 0));
cur = str;
while (*cur != 0) {
if (*cur == '{') {
if (*(cur+1) == '{') { /* escaped '{' */
cur++;
ret = xmlStrncat(ret, str, cur - str);
cur++;
str = cur;
continue;
}
ret = xmlStrncat(ret, str, cur - str);
str = cur;
cur++;
while ((*cur != 0) && (*cur != '}')) cur++;
if (*cur == 0) {
xsltTransformError(ctxt, NULL, inst,
"xsltAttrTemplateValueProcessNode: unmatched '{'\n");
ret = xmlStrncat(ret, str, cur - str);
return(ret);
}
str++;
expr = xmlStrndup(str, cur - str);
if (expr == NULL)
return(ret);
else if (*expr == '{') {
ret = xmlStrcat(ret, expr);
xmlFree(expr);
} else {
xmlXPathCompExprPtr comp;
/*
* TODO: keep precompiled form around
*/
if ((nsList == NULL) && (inst != NULL)) {
int i = 0;
nsList = xmlGetNsList(inst->doc, inst);
if (nsList != NULL) {
while (nsList[i] != NULL)
i++;
nsNr = i;
}
}
comp = xmlXPathCompile(expr);
val = xsltEvalXPathStringNs(ctxt, comp, nsNr, nsList);
xmlXPathFreeCompExpr(comp);
xmlFree(expr);
if (val != NULL) {
ret = xmlStrcat(ret, val);
xmlFree(val);
}
}
cur++;
str = cur;
} else if (*cur == '}') {
cur++;
if (*cur == '}') { /* escaped '}' */
ret = xmlStrncat(ret, str, cur - str);
cur++;
str = cur;
continue;
} else {
xsltTransformError(ctxt, NULL, inst,
"xsltAttrTemplateValueProcessNode: unmatched '}'\n");
}
} else
cur++;
}
if (cur != str) {
ret = xmlStrncat(ret, str, cur - str);
}
if (nsList != NULL)
xmlFree(nsList);
return(ret);
}
/**
* read file and print element paths
*/
int
parse_xml_file(const char *filename)
{
int ret, prev_depth = 0;
xmlTextReaderPtr reader;
for (reader = xmlReaderForFile(filename, NULL, 0);;)
{
int depth;
const xmlChar *name;
xmlReaderTypes type;
if (!reader) {
fprintf(stderr, "couldn't read file '%s'\n", filename);
exit(EXIT_BAD_FILE);
}
ret = xmlTextReaderRead(reader);
if (ret <= 0) break;
type = xmlTextReaderNodeType(reader);
depth = xmlTextReaderDepth(reader);
name = xmlTextReaderConstName(reader);
if (type != XML_READER_TYPE_ELEMENT)
continue;
while (curXPath && depth <= prev_depth)
{
xmlChar *slash = BAD_CAST strrchr((char*) curXPath, '/');
if (slash) *slash = '\0';
prev_depth--;
}
prev_depth = depth;
if (depth > 0) curXPath = xmlStrcat(curXPath, BAD_CAST "/");
curXPath = xmlStrcat(curXPath, name);
if (elOps.show_attr)
{
int have_attr;
fprintf(stdout, "%s\n", curXPath);
for (have_attr = xmlTextReaderMoveToFirstAttribute(reader);
have_attr;
have_attr = xmlTextReaderMoveToNextAttribute(reader))
{
const xmlChar *aname = xmlTextReaderConstName(reader);
fprintf(stdout, "%s/@%s\n", curXPath, aname);
}
}
else if (elOps.show_attr_and_val)
{
fprintf(stdout, "%s", curXPath);
if (xmlTextReaderHasAttributes(reader))
{
int have_attr, first = 1;
fprintf(stdout, "[");
for (have_attr = xmlTextReaderMoveToFirstAttribute(reader);
have_attr;
have_attr = xmlTextReaderMoveToNextAttribute(reader))
{
const xmlChar *aname = xmlTextReaderConstName(reader),
*avalue = xmlTextReaderConstValue(reader);
char quote;
if (!first)
fprintf(stdout, " and ");
first = 0;
quote = xmlStrchr(avalue, '\'')? '"' : '\'';
fprintf(stdout, "@%s=%c%s%c", aname, quote, avalue, quote);
}
fprintf(stdout, "]");
}
fprintf(stdout, "\n");
}
else if (elOps.sort_uniq)
{
if ((elOps.check_depth == 0) || (elOps.check_depth != 0 && depth < elOps.check_depth))
{
xmlHashAddEntry(uniq, curXPath, (void*) 1);
}
}
else fprintf(stdout, "%s\n", curXPath);
}
return ret == -1? EXIT_LIB_ERROR : ret;
}
/* {{{ nodeName string
readonly=yes
URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-F68D095
Since:
*/
int dom_node_node_name_read(dom_object *obj, zval *retval)
{
xmlNode *nodep;
xmlNsPtr ns;
char *str = NULL;
xmlChar *qname = NULL;
nodep = dom_object_get_node(obj);
if (nodep == NULL) {
php_dom_throw_error(INVALID_STATE_ERR, 0);
return FAILURE;
}
switch (nodep->type) {
case XML_ATTRIBUTE_NODE:
case XML_ELEMENT_NODE:
ns = nodep->ns;
if (ns != NULL && ns->prefix) {
qname = xmlStrdup(ns->prefix);
qname = xmlStrcat(qname, (xmlChar *) ":");
qname = xmlStrcat(qname, nodep->name);
str = (char *) qname;
} else {
str = (char *) nodep->name;
}
break;
case XML_NAMESPACE_DECL:
ns = nodep->ns;
if (ns != NULL && ns->prefix) {
qname = xmlStrdup((xmlChar *) "xmlns");
qname = xmlStrcat(qname, (xmlChar *) ":");
qname = xmlStrcat(qname, nodep->name);
str = (char *) qname;
} else {
str = (char *) nodep->name;
}
break;
case XML_DOCUMENT_TYPE_NODE:
case XML_DTD_NODE:
case XML_PI_NODE:
case XML_ENTITY_DECL:
case XML_ENTITY_REF_NODE:
case XML_NOTATION_NODE:
str = (char *) nodep->name;
break;
case XML_CDATA_SECTION_NODE:
str = "#cdata-section";
break;
case XML_COMMENT_NODE:
str = "#comment";
break;
case XML_HTML_DOCUMENT_NODE:
case XML_DOCUMENT_NODE:
str = "#document";
break;
case XML_DOCUMENT_FRAG_NODE:
str = "#document-fragment";
break;
case XML_TEXT_NODE:
str = "#text";
break;
default:
php_error_docref(NULL, E_WARNING, "Invalid Node Type");
}
if (str != NULL) {
ZVAL_STRING(retval, str);
} else {
ZVAL_EMPTY_STRING(retval);
}
if (qname != NULL) {
xmlFree(qname);
}
return SUCCESS;
}
/**
* xsltFormatNumberConversion:
* @self: the decimal format
* @format: the format requested
* @number: the value to format
* @result: the place to ouput the result
*
* format-number() uses the JDK 1.1 DecimalFormat class:
*
* http://java.sun.com/products/jdk/1.1/docs/api/java.text.DecimalFormat.html
*
* Structure:
*
* pattern := subpattern{;subpattern}
* subpattern := {prefix}integer{.fraction}{suffix}
* prefix := '\\u0000'..'\\uFFFD' - specialCharacters
* suffix := '\\u0000'..'\\uFFFD' - specialCharacters
* integer := '#'* '0'* '0'
* fraction := '0'* '#'*
*
* Notation:
* X* 0 or more instances of X
* (X | Y) either X or Y.
* X..Y any character from X up to Y, inclusive.
* S - T characters in S, except those in T
*
* Special Characters:
*
* Symbol Meaning
* 0 a digit
* # a digit, zero shows as absent
* . placeholder for decimal separator
* , placeholder for grouping separator.
* ; separates formats.
* - default negative prefix.
* % multiply by 100 and show as percentage
* ? multiply by 1000 and show as per mille
* X any other characters can be used in the prefix or suffix
* ' used to quote special characters in a prefix or suffix.
*
* Returns a possible XPath error
*/
xmlXPathError
xsltFormatNumberConversion(xsltDecimalFormatPtr self,
xmlChar *format,
double number,
xmlChar **result)
{
xmlXPathError status = XPATH_EXPRESSION_OK;
xmlBufferPtr buffer;
xmlChar *the_format, *prefix = NULL, *suffix = NULL;
xmlChar *nprefix, *nsuffix = NULL;
xmlChar pchar;
int prefix_length, suffix_length = 0, nprefix_length, nsuffix_length;
double scale;
int j, len;
int self_grouping_len;
xsltFormatNumberInfo format_info;
/*
* delayed_multiplier allows a 'trailing' percent or
* permille to be treated as suffix
*/
int delayed_multiplier = 0;
/* flag to show no -ve format present for -ve number */
char default_sign = 0;
/* flag to show error found, should use default format */
char found_error = 0;
if (xmlStrlen(format) <= 0) {
xsltTransformError(NULL, NULL, NULL,
"xsltFormatNumberConversion : "
"Invalid format (0-length)\n");
}
*result = NULL;
switch (xmlXPathIsInf(number)) {
case -1:
if (self->minusSign == NULL)
*result = xmlStrdup(BAD_CAST "-");
else
*result = xmlStrdup(self->minusSign);
/* no-break on purpose */
case 1:
if ((self == NULL) || (self->infinity == NULL))
*result = xmlStrcat(*result, BAD_CAST "Infinity");
else
*result = xmlStrcat(*result, self->infinity);
return(status);
default:
if (xmlXPathIsNaN(number)) {
if ((self == NULL) || (self->noNumber == NULL))
*result = xmlStrdup(BAD_CAST "NaN");
else
*result = xmlStrdup(self->noNumber);
return(status);
}
}
buffer = xmlBufferCreate();
if (buffer == NULL) {
return XPATH_MEMORY_ERROR;
}
format_info.integer_hash = 0;
format_info.integer_digits = 0;
format_info.frac_digits = 0;
format_info.frac_hash = 0;
format_info.group = -1;
format_info.multiplier = 1;
format_info.add_decimal = FALSE;
format_info.is_multiplier_set = FALSE;
format_info.is_negative_pattern = FALSE;
the_format = format;
/*
* First we process the +ve pattern to get percent / permille,
* as well as main format
*/
prefix = the_format;
prefix_length = xsltFormatNumberPreSuffix(self, &the_format, &format_info);
if (prefix_length < 0) {
found_error = 1;
goto OUTPUT_NUMBER;
}
/*
* Here we process the "number" part of the format. It gets
* a little messy because of the percent/per-mille - if that
* appears at the end, it may be part of the suffix instead
* of part of the number, so the variable delayed_multiplier
* is used to handle it
*/
self_grouping_len = xmlStrlen(self->grouping);
while ((*the_format != 0) &&
(xsltUTF8Charcmp(the_format, self->decimalPoint) != 0) &&
(xsltUTF8Charcmp(the_format, self->patternSeparator) != 0)) {
if (delayed_multiplier != 0) {
format_info.multiplier = delayed_multiplier;
format_info.is_multiplier_set = TRUE;
delayed_multiplier = 0;
}
if (xsltUTF8Charcmp(the_format, self->digit) == 0) {
if (format_info.integer_digits > 0) {
found_error = 1;
goto OUTPUT_NUMBER;
}
format_info.integer_hash++;
if (format_info.group >= 0)
format_info.group++;
} else if (xsltUTF8Charcmp(the_format, self->zeroDigit) == 0) {
format_info.integer_digits++;
if (format_info.group >= 0)
format_info.group++;
} else if ((self_grouping_len > 0) &&
(!xmlStrncmp(the_format, self->grouping, self_grouping_len))) {
/* Reset group count */
format_info.group = 0;
the_format += self_grouping_len;
continue;
} else if (xsltUTF8Charcmp(the_format, self->percent) == 0) {
if (format_info.is_multiplier_set) {
found_error = 1;
goto OUTPUT_NUMBER;
}
delayed_multiplier = 100;
} else if (xsltUTF8Charcmp(the_format, self->permille) == 0) {
if (format_info.is_multiplier_set) {
found_error = 1;
goto OUTPUT_NUMBER;
}
delayed_multiplier = 1000;
} else
break; /* while */
if ((len=xmlUTF8Strsize(the_format, 1)) < 1) {
found_error = 1;
goto OUTPUT_NUMBER;
}
the_format += len;
}
/* We have finished the integer part, now work on fraction */
if ( (*the_format != 0) &&
(xsltUTF8Charcmp(the_format, self->decimalPoint) == 0) ) {
format_info.add_decimal = TRUE;
if ((len = xmlUTF8Strsize(the_format, 1)) < 1) {
found_error = 1;
goto OUTPUT_NUMBER;
}
the_format += len; /* Skip over the decimal */
}
while (*the_format != 0) {
if (xsltUTF8Charcmp(the_format, self->zeroDigit) == 0) {
if (format_info.frac_hash != 0) {
found_error = 1;
goto OUTPUT_NUMBER;
}
format_info.frac_digits++;
} else if (xsltUTF8Charcmp(the_format, self->digit) == 0) {
format_info.frac_hash++;
} else if (xsltUTF8Charcmp(the_format, self->percent) == 0) {
if (format_info.is_multiplier_set) {
found_error = 1;
goto OUTPUT_NUMBER;
}
delayed_multiplier = 100;
if ((len = xmlUTF8Strsize(the_format, 1)) < 1) {
found_error = 1;
goto OUTPUT_NUMBER;
}
the_format += len;
continue; /* while */
} else if (xsltUTF8Charcmp(the_format, self->permille) == 0) {
if (format_info.is_multiplier_set) {
found_error = 1;
goto OUTPUT_NUMBER;
}
delayed_multiplier = 1000;
if ((len = xmlUTF8Strsize(the_format, 1)) < 1) {
found_error = 1;
goto OUTPUT_NUMBER;
}
the_format += len;
continue; /* while */
} else if (xsltUTF8Charcmp(the_format, self->grouping) != 0) {
break; /* while */
}
if ((len = xmlUTF8Strsize(the_format, 1)) < 1) {
found_error = 1;
goto OUTPUT_NUMBER;
}
the_format += len;
if (delayed_multiplier != 0) {
format_info.multiplier = delayed_multiplier;
delayed_multiplier = 0;
format_info.is_multiplier_set = TRUE;
}
}
/*
* If delayed_multiplier is set after processing the
* "number" part, should be in suffix
*/
if (delayed_multiplier != 0) {
the_format -= len;
delayed_multiplier = 0;
}
suffix = the_format;
suffix_length = xsltFormatNumberPreSuffix(self, &the_format, &format_info);
if ( (suffix_length < 0) ||
((*the_format != 0) &&
(xsltUTF8Charcmp(the_format, self->patternSeparator) != 0)) ) {
found_error = 1;
goto OUTPUT_NUMBER;
}
/*
* We have processed the +ve prefix, number part and +ve suffix.
* If the number is -ve, we must substitute the -ve prefix / suffix
*/
if (number < 0) {
/*
* Note that j is the number of UTF8 chars before the separator,
* not the number of bytes! (bug 151975)
*/
j = xmlUTF8Strloc(format, self->patternSeparator);
if (j < 0) {
/* No -ve pattern present, so use default signing */
default_sign = 1;
}
else {
/* Skip over pattern separator (accounting for UTF8) */
the_format = (xmlChar *)xmlUTF8Strpos(format, j + 1);
/*
* Flag changes interpretation of percent/permille
* in -ve pattern
*/
format_info.is_negative_pattern = TRUE;
format_info.is_multiplier_set = FALSE;
/* First do the -ve prefix */
nprefix = the_format;
nprefix_length = xsltFormatNumberPreSuffix(self,
&the_format, &format_info);
if (nprefix_length<0) {
found_error = 1;
goto OUTPUT_NUMBER;
}
while (*the_format != 0) {
if ( (xsltUTF8Charcmp(the_format, (self)->percent) == 0) ||
(xsltUTF8Charcmp(the_format, (self)->permille)== 0) ) {
if (format_info.is_multiplier_set) {
found_error = 1;
goto OUTPUT_NUMBER;
}
format_info.is_multiplier_set = TRUE;
delayed_multiplier = 1;
}
else if (IS_SPECIAL(self, the_format))
delayed_multiplier = 0;
else
break; /* while */
if ((len = xmlUTF8Strsize(the_format, 1)) < 1) {
found_error = 1;
goto OUTPUT_NUMBER;
}
the_format += len;
}
if (delayed_multiplier != 0) {
format_info.is_multiplier_set = FALSE;
the_format -= len;
}
/* Finally do the -ve suffix */
if (*the_format != 0) {
nsuffix = the_format;
nsuffix_length = xsltFormatNumberPreSuffix(self,
&the_format, &format_info);
if (nsuffix_length < 0) {
found_error = 1;
goto OUTPUT_NUMBER;
}
}
else
nsuffix_length = 0;
if (*the_format != 0) {
found_error = 1;
goto OUTPUT_NUMBER;
}
/*
* Here's another Java peculiarity:
* if -ve prefix/suffix == +ve ones, discard & use default
*/
if ((nprefix_length != prefix_length) ||
(nsuffix_length != suffix_length) ||
((nprefix_length > 0) &&
(xmlStrncmp(nprefix, prefix, prefix_length) !=0 )) ||
((nsuffix_length > 0) &&
(xmlStrncmp(nsuffix, suffix, suffix_length) !=0 ))) {
prefix = nprefix;
prefix_length = nprefix_length;
suffix = nsuffix;
suffix_length = nsuffix_length;
} /* else {
default_sign = 1;
}
*/
}
}
OUTPUT_NUMBER:
if (found_error != 0) {
xsltTransformError(NULL, NULL, NULL,
"xsltFormatNumberConversion : "
"error in format string '%s', using default\n", format);
default_sign = (number < 0.0) ? 1 : 0;
prefix_length = suffix_length = 0;
format_info.integer_hash = 0;
format_info.integer_digits = 1;
format_info.frac_digits = 1;
format_info.frac_hash = 4;
format_info.group = -1;
format_info.multiplier = 1;
format_info.add_decimal = TRUE;
}
/* Ready to output our number. First see if "default sign" is required */
if (default_sign != 0)
xmlBufferAdd(buffer, self->minusSign, xmlUTF8Strsize(self->minusSign, 1));
/* Put the prefix into the buffer */
for (j = 0; j < prefix_length; j++) {
if ((pchar = *prefix++) == SYMBOL_QUOTE) {
len = xmlUTF8Strsize(prefix, 1);
xmlBufferAdd(buffer, prefix, len);
prefix += len;
j += len - 1; /* length of symbol less length of quote */
} else
xmlBufferAdd(buffer, &pchar, 1);
}
/* Next do the integer part of the number */
number = fabs(number) * (double)format_info.multiplier;
scale = pow(10.0, (double)(format_info.frac_digits + format_info.frac_hash));
number = floor((scale * number + 0.5)) / scale;
if ((self->grouping != NULL) &&
(self->grouping[0] != 0)) {
len = xmlStrlen(self->grouping);
pchar = xsltGetUTF8Char(self->grouping, &len);
xsltNumberFormatDecimal(buffer, floor(number), self->zeroDigit[0],
format_info.integer_digits,
format_info.group,
pchar, len);
} else
xsltNumberFormatDecimal(buffer, floor(number), self->zeroDigit[0],
format_info.integer_digits,
format_info.group,
',', 1);
/* Special case: java treats '.#' like '.0', '.##' like '.0#', etc. */
if ((format_info.integer_digits + format_info.integer_hash +
format_info.frac_digits == 0) && (format_info.frac_hash > 0)) {
++format_info.frac_digits;
--format_info.frac_hash;
}
/* Add leading zero, if required */
if ((floor(number) == 0) &&
(format_info.integer_digits + format_info.frac_digits == 0)) {
xmlBufferAdd(buffer, self->zeroDigit, xmlUTF8Strsize(self->zeroDigit, 1));
}
/* Next the fractional part, if required */
if (format_info.frac_digits + format_info.frac_hash == 0) {
if (format_info.add_decimal)
xmlBufferAdd(buffer, self->decimalPoint,
xmlUTF8Strsize(self->decimalPoint, 1));
}
else {
number -= floor(number);
if ((number != 0) || (format_info.frac_digits != 0)) {
xmlBufferAdd(buffer, self->decimalPoint,
xmlUTF8Strsize(self->decimalPoint, 1));
number = floor(scale * number + 0.5);
for (j = format_info.frac_hash; j > 0; j--) {
if (fmod(number, 10.0) >= 1.0)
break; /* for */
number /= 10.0;
}
xsltNumberFormatDecimal(buffer, floor(number), self->zeroDigit[0],
format_info.frac_digits + j,
0, 0, 0);
}
}
/* Put the suffix into the buffer */
for (j = 0; j < suffix_length; j++) {
if ((pchar = *suffix++) == SYMBOL_QUOTE) {
len = xmlUTF8Strsize(suffix, 1);
xmlBufferAdd(buffer, suffix, len);
suffix += len;
j += len - 1; /* length of symbol less length of escape */
} else
xmlBufferAdd(buffer, &pchar, 1);
}
*result = xmlStrdup(xmlBufferContent(buffer));
xmlBufferFree(buffer);
return status;
}
static void
xmlNanoHTTPScanAnswer(xmlNanoHTTPCtxtPtr ctxt, const char *line) {
const char *cur = line;
if (line == NULL) return;
if (!strncmp(line, "HTTP/", 5)) {
int version = 0;
int ret = 0;
cur += 5;
while ((*cur >= '0') && (*cur <= '9')) {
version *= 10;
version += *cur - '0';
cur++;
}
if (*cur == '.') {
cur++;
if ((*cur >= '0') && (*cur <= '9')) {
version *= 10;
version += *cur - '0';
cur++;
}
while ((*cur >= '0') && (*cur <= '9'))
cur++;
} else
version *= 10;
if ((*cur != ' ') && (*cur != '\t')) return;
while ((*cur == ' ') || (*cur == '\t')) cur++;
if ((*cur < '0') || (*cur > '9')) return;
while ((*cur >= '0') && (*cur <= '9')) {
ret *= 10;
ret += *cur - '0';
cur++;
}
if ((*cur != 0) && (*cur != ' ') && (*cur != '\t')) return;
ctxt->returnValue = ret;
ctxt->version = version;
} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Content-Type:", 13)) {
const xmlChar *charset, *last, *mime;
cur += 13;
while ((*cur == ' ') || (*cur == '\t')) cur++;
if (ctxt->contentType != NULL)
xmlFree(ctxt->contentType);
ctxt->contentType = xmlMemStrdup(cur);
mime = (const xmlChar *) cur;
last = mime;
while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
(*last != ';') && (*last != ','))
last++;
if (ctxt->mimeType != NULL)
xmlFree(ctxt->mimeType);
ctxt->mimeType = (char *) xmlStrndup(mime, last - mime);
charset = xmlStrstr(BAD_CAST ctxt->contentType, BAD_CAST "charset=");
if (charset != NULL) {
charset += 8;
last = charset;
while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
(*last != ';') && (*last != ','))
last++;
if (ctxt->encoding != NULL)
xmlFree(ctxt->encoding);
ctxt->encoding = (char *) xmlStrndup(charset, last - charset);
}
} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"ContentType:", 12)) {
const xmlChar *charset, *last, *mime;
cur += 12;
if (ctxt->contentType != NULL) return;
while ((*cur == ' ') || (*cur == '\t')) cur++;
ctxt->contentType = xmlMemStrdup(cur);
mime = (const xmlChar *) cur;
last = mime;
while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
(*last != ';') && (*last != ','))
last++;
if (ctxt->mimeType != NULL)
xmlFree(ctxt->mimeType);
ctxt->mimeType = (char *) xmlStrndup(mime, last - mime);
charset = xmlStrstr(BAD_CAST ctxt->contentType, BAD_CAST "charset=");
if (charset != NULL) {
charset += 8;
last = charset;
while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
(*last != ';') && (*last != ','))
last++;
if (ctxt->encoding != NULL)
xmlFree(ctxt->encoding);
ctxt->encoding = (char *) xmlStrndup(charset, last - charset);
}
} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Location:", 9)) {
cur += 9;
while ((*cur == ' ') || (*cur == '\t')) cur++;
if (ctxt->location != NULL)
xmlFree(ctxt->location);
if (*cur == '/') {
xmlChar *tmp_http = xmlStrdup(BAD_CAST "http://");
xmlChar *tmp_loc =
xmlStrcat(tmp_http, (const xmlChar *) ctxt->hostname);
ctxt->location =
(char *) xmlStrcat (tmp_loc, (const xmlChar *) cur);
} else {
ctxt->location = xmlMemStrdup(cur);
}
} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"WWW-Authenticate:", 17)) {
cur += 17;
while ((*cur == ' ') || (*cur == '\t')) cur++;
if (ctxt->authHeader != NULL)
xmlFree(ctxt->authHeader);
ctxt->authHeader = xmlMemStrdup(cur);
} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Proxy-Authenticate:", 19)) {
cur += 19;
while ((*cur == ' ') || (*cur == '\t')) cur++;
if (ctxt->authHeader != NULL)
xmlFree(ctxt->authHeader);
ctxt->authHeader = xmlMemStrdup(cur);
#ifdef HAVE_ZLIB_H
} else if ( !xmlStrncasecmp( BAD_CAST line, BAD_CAST"Content-Encoding:", 17) ) {
cur += 17;
while ((*cur == ' ') || (*cur == '\t')) cur++;
if ( !xmlStrncasecmp( BAD_CAST cur, BAD_CAST"gzip", 4) ) {
ctxt->usesGzip = 1;
ctxt->strm = xmlMalloc(sizeof(z_stream));
if (ctxt->strm != NULL) {
ctxt->strm->zalloc = Z_NULL;
ctxt->strm->zfree = Z_NULL;
ctxt->strm->opaque = Z_NULL;
ctxt->strm->avail_in = 0;
ctxt->strm->next_in = Z_NULL;
inflateInit2( ctxt->strm, 31 );
}
}
#endif
} else if ( !xmlStrncasecmp( BAD_CAST line, BAD_CAST"Content-Length:", 15) ) {
cur += 15;
ctxt->ContentLength = strtol( cur, NULL, 10 );
}
}
/**
* xsltFormatNumberConversion:
* @self: the decimal format
* @format: the format requested
* @number: the value to format
* @result: the place to ouput the result
*
* format-number() uses the JDK 1.1 DecimalFormat class:
*
* http://java.sun.com/products/jdk/1.1/docs/api/java.text.DecimalFormat.html
*
* Structure:
*
* pattern := subpattern{;subpattern}
* subpattern := {prefix}integer{.fraction}{suffix}
* prefix := '\\u0000'..'\\uFFFD' - specialCharacters
* suffix := '\\u0000'..'\\uFFFD' - specialCharacters
* integer := '#'* '0'* '0'
* fraction := '0'* '#'*
*
* Notation:
* X* 0 or more instances of X
* (X | Y) either X or Y.
* X..Y any character from X up to Y, inclusive.
* S - T characters in S, except those in T
*
* Special Characters:
*
* Symbol Meaning
* 0 a digit
* # a digit, zero shows as absent
* . placeholder for decimal separator
* , placeholder for grouping separator.
* ; separates formats.
* - default negative prefix.
* % multiply by 100 and show as percentage
* ? multiply by 1000 and show as per mille
* X any other characters can be used in the prefix or suffix
* ' used to quote special characters in a prefix or suffix.
*/
xmlXPathError
xsltFormatNumberConversion(xsltDecimalFormatPtr self,
xmlChar *format,
double number,
xmlChar **result)
{
xmlXPathError status = XPATH_EXPRESSION_OK;
xmlBufferPtr buffer;
xmlChar *the_format, *prefix = NULL, *suffix = NULL;
xmlChar *nprefix, *nsuffix = NULL;
xmlChar pchar;
int prefix_length, suffix_length = 0, nprefix_length, nsuffix_length;
double scale;
int j;
xsltFormatNumberInfo format_info;
/* delayed_multiplier allows a 'trailing' percent or permille to be treated as suffix */
int delayed_multiplier = 0;
/* flag to show no -ve format present for -ve number */
char default_sign = 0;
/* flag to show error found, should use default format */
char found_error = 0;
*result = NULL;
switch (xmlXPathIsInf(number)) {
case -1:
if (self->minusSign == NULL)
*result = xmlStrdup(BAD_CAST "-");
else
*result = xmlStrdup(self->minusSign);
/* no-break on purpose */
case 1:
if ((self == NULL) || (self->infinity == NULL))
*result = xmlStrcat(*result, BAD_CAST "Infinity");
else
*result = xmlStrcat(*result, self->infinity);
return(status);
default:
if (xmlXPathIsNaN(number)) {
if ((self == NULL) || (self->noNumber == NULL))
*result = xmlStrdup(BAD_CAST "NaN");
else
*result = xmlStrdup(self->noNumber);
return(status);
}
}
buffer = xmlBufferCreate();
if (buffer == NULL) {
return XPATH_MEMORY_ERROR;
}
format_info.integer_digits = 0;
format_info.frac_digits = 0;
format_info.frac_hash = 0;
format_info.group = -1;
format_info.multiplier = 1;
format_info.is_multiplier_set = FALSE;
format_info.is_negative_pattern = FALSE;
the_format = format;
/* First we process the +ve pattern to get percent / permille, as well as main format */
prefix = the_format;
prefix_length = xsltFormatNumberPreSuffix(self, &the_format, &format_info);
if (prefix_length < 0) {
found_error = 1;
goto OUTPUT_NUMBER;
}
/* Here we process the "number" part of the format. It gets a little messy because of */
/* the percent/per-mille - if that appears at the end, it may be part of the suffix */
/* instead of part of the number, so the variable delayed_multiplier is used to handle it */
while ((*the_format != 0) &&
(*the_format != self->decimalPoint[0]) &&
(*the_format != self->patternSeparator[0])) {
if (delayed_multiplier != 0) {
format_info.multiplier = delayed_multiplier;
format_info.is_multiplier_set = TRUE;
delayed_multiplier = 0;
}
if (*the_format == self->digit[0]) {
if (format_info.integer_digits > 0) {
found_error = 1;
goto OUTPUT_NUMBER;
}
if (format_info.group >= 0)
format_info.group++;
} else if (*the_format == self->zeroDigit[0]) {
format_info.integer_digits++;
if (format_info.group >= 0)
format_info.group++;
} else if (*the_format == self->grouping[0]) {
/* Reset group count */
format_info.group = 0;
} else if (*the_format == self->percent[0]) {
if (format_info.is_multiplier_set) {
found_error = 1;
goto OUTPUT_NUMBER;
}
delayed_multiplier = 100;
} else if (*the_format == self->permille[0]) {
if (format_info.is_multiplier_set) {
found_error = 1;
goto OUTPUT_NUMBER;
}
delayed_multiplier = 1000;
} else
break; /* while */
the_format++;
}
/* We have finished the integer part, now work on fraction */
if (*the_format == self->decimalPoint[0])
the_format++; /* Skip over the decimal */
while (*the_format != 0) {
if (*the_format == self->zeroDigit[0]) {
if (format_info.frac_hash != 0) {
found_error = 1;
goto OUTPUT_NUMBER;
}
format_info.frac_digits++;
} else if (*the_format == self->digit[0]) {
format_info.frac_hash++;
} else if (*the_format == self->percent[0]) {
if (format_info.is_multiplier_set) {
found_error = 1;
goto OUTPUT_NUMBER;
}
delayed_multiplier = 100;
the_format++;
continue; /* while */
} else if (*the_format == self->permille[0]) {
if (format_info.is_multiplier_set) {
found_error = 1;
goto OUTPUT_NUMBER;
}
delayed_multiplier = 1000;
the_format++;
continue; /* while */
} else if (*the_format != self->grouping[0]) {
break; /* while */
}
the_format++;
if (delayed_multiplier != 0) {
format_info.multiplier = delayed_multiplier;
delayed_multiplier = 0;
format_info.is_multiplier_set = TRUE;
}
}
/* If delayed_multiplier is set after processing the "number" part, should be in suffix */
if (delayed_multiplier != 0) {
the_format--;
delayed_multiplier = 0;
}
suffix = the_format;
suffix_length = xsltFormatNumberPreSuffix(self, &the_format, &format_info);
if ( (suffix_length < 0) ||
((*the_format != 0) && (*the_format != self->patternSeparator[0])) ) {
found_error = 1;
goto OUTPUT_NUMBER;
}
/* We have processed the +ve prefix, number part and +ve suffix. */
/* If the number is -ve, we must substitute the -ve prefix / suffix */
if (number < 0) {
the_format = (xmlChar *)xmlStrchr(format, self->patternSeparator[0]);
if (the_format == NULL) { /* No -ve pattern present, so use default signing */
default_sign = 1;
}
else {
/* Flag changes interpretation of percent/permille in -ve pattern */
the_format++; /* Skip over pattern separator */
format_info.is_negative_pattern = TRUE;
format_info.is_multiplier_set = FALSE;
/* First do the -ve prefix */
nprefix = the_format;
nprefix_length = xsltFormatNumberPreSuffix(self, &the_format, &format_info);
if (nprefix_length<0) {
found_error = 1;
goto OUTPUT_NUMBER;
}
/* Next skip over the -ve number info */
the_format += prefix_length;
while (*the_format != 0) {
if ( (*the_format == (self)->percent[0]) ||
(*the_format == (self)->permille[0]) ) {
if (format_info.is_multiplier_set) {
found_error = 1;
goto OUTPUT_NUMBER;
}
format_info.is_multiplier_set = TRUE;
delayed_multiplier = 1;
}
else if (IS_SPECIAL(self, *the_format))
delayed_multiplier = 0;
else
break; /* while */
the_format++;
}
if (delayed_multiplier != 0) {
format_info.is_multiplier_set = FALSE;
the_format--;
}
/* Finally do the -ve suffix */
if (*the_format != 0) {
nsuffix = the_format;
nsuffix_length = xsltFormatNumberPreSuffix(self, &the_format, &format_info);
if (nsuffix_length < 0) {
found_error = 1;
goto OUTPUT_NUMBER;
}
}
else
nsuffix_length = 0;
if (*the_format != 0) {
found_error = 1;
goto OUTPUT_NUMBER;
}
/* Here's another Java peculiarity:
* if -ve prefix/suffix == +ve ones, discard & use default
*/
if ((nprefix_length != prefix_length) || (nsuffix_length != suffix_length) ||
((nprefix_length > 0) && (xmlStrncmp(nprefix, prefix, prefix_length) !=0 )) ||
((nsuffix_length > 0) && (xmlStrncmp(nsuffix, suffix, suffix_length) !=0 ))) {
prefix = nprefix;
prefix_length = nprefix_length;
suffix = nsuffix;
suffix_length = nsuffix_length;
} else {
default_sign = 1;
}
}
}
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;
prefix_length = suffix_length = 0;
format_info.integer_digits = 1;
format_info.frac_digits = 1;
format_info.frac_hash = 4;
format_info.group = -1;
format_info.multiplier = 1;
}
/* Ready to output our number. First see if "default sign" is required */
if (default_sign != 0)
xmlBufferAdd(buffer, self->minusSign, 1);
/* Put the prefix into the buffer */
for (j = 0; j < prefix_length; j++) {
if ((pchar = *prefix++) == SYMBOL_QUOTE) {
pchar = *prefix++;
prefix++;
}
xmlBufferAdd(buffer, &pchar, 1);
}
/* Next do the integer part of the number */
number = fabs(number) * (double)format_info.multiplier;
scale = pow(10.0, (double)(format_info.frac_digits + format_info.frac_hash));
number = floor((scale * number + 0.5)) / scale;
if ((self->grouping != NULL) && (self->grouping[0] != 0))
xsltNumberFormatDecimal(buffer, floor(number), self->zeroDigit[0],
format_info.integer_digits,
format_info.group,
(xmlChar) self->grouping[0]);
else
xsltNumberFormatDecimal(buffer, floor(number), self->zeroDigit[0],
format_info.integer_digits,
format_info.group,
(xmlChar) ',');
/* Next the fractional part, if required */
if (format_info.frac_digits + format_info.frac_hash > 0) {
number -= floor(number);
if ((number != 0) || (format_info.frac_digits != 0)) {
xmlBufferAdd(buffer, self->decimalPoint, 1);
number = floor(scale * number + 0.5);
for (j = format_info.frac_hash; j > 0; j--) {
if (fmod(number, 10.0) >= 1.0)
break; /* for */
number /= 10.0;
}
xsltNumberFormatDecimal(buffer, floor(number), self->zeroDigit[0],
format_info.frac_digits + j,
0, (xmlChar)0);
}
}
/* Put the suffix into the buffer */
for (j = 0; j < suffix_length; j++) {
if ((pchar = *suffix++) == SYMBOL_QUOTE) {
pchar = *suffix++;
suffix++;
}
xmlBufferAdd(buffer, &pchar, 1);
}
*result = xmlStrdup(xmlBufferContent(buffer));
xmlBufferFree(buffer);
return status;
}
/* This snippet is borrowed from the xsltproc source
* and adapted to help the xsl transform find our temporary
* files in $HOME/.gnc-migration-tmp/
*/
static xmlParserInputPtr
xsltprocExternalEntityLoader(const char *URL, const char *ID,
xmlParserCtxtPtr ctxt)
{
xmlParserInputPtr ret;
warningSAXFunc warning = NULL;
xmlChar *newURL;
gchar *tmpdir = g_build_filename (g_get_home_dir (), ".gnc-migration-tmp", NULL);
const char *lastsegment = URL;
const char *iter = URL;
while (*iter != 0)
{
if (*iter == '/')
lastsegment = iter + 1;
iter++;
}
if ((ctxt != NULL) && (ctxt->sax != NULL))
{
warning = ctxt->sax->warning;
ctxt->sax->warning = NULL;
}
if (defaultEntityLoader != NULL)
{
ret = defaultEntityLoader(URL, ID, ctxt);
if (ret != NULL)
{
if (warning != NULL)
ctxt->sax->warning = warning;
return(ret);
}
}
newURL = xmlStrdup((const xmlChar *) tmpdir);
newURL = xmlStrcat(newURL, (const xmlChar *) "/");
newURL = xmlStrcat(newURL, (const xmlChar *) lastsegment);
g_free (tmpdir);
if (newURL != NULL)
{
ret = defaultEntityLoader((const char *)newURL, ID, ctxt);
if (ret != NULL)
{
if (warning != NULL)
ctxt->sax->warning = warning;
xmlFree(newURL);
return(ret);
}
xmlFree(newURL);
}
if (warning != NULL)
{
ctxt->sax->warning = warning;
if (URL != NULL)
DEBUG ("External entity \"%s\" not loaded", URL);
else if (ID != NULL)
DEBUG ("External entity \"%s\" not loaded", ID);
}
return(NULL);
}
/***********************************************************************
* Function Name : PSPReturnXMLErrorString
* Description : This function appends given error XML string(xmlStr)
* to the Result XML buffer.
* Input : pTrSet - Transaction Set
* xmlStr - Error XML string to be appended
* Output : none
* Return value : CNTRLXML_SUCCESS, CNTRLXML_BADPARAM, CNTRLXML_FAILURE
***********************************************************************/
t_int32
PSPReturnXMLErrorString (PSPTransactionId_t * pTrSet, XML_STR pInXMLStr)
{
t_char8 xmlDeclare[] =
"<?xml version=\"1.0\"encoding=\"UTF-8\"?>\n<result><Transaction status=\'error\'>";
t_char8 xmlEndDecl[] = "</Transaction></result>";
if (!pInXMLStr)
{
XML_Error ("Bad Input Parameters");
return CNTRLXML_BADPARAM;
}
if (IsValidTransaction (pTrSet))
{
/*
* Transaction based XML processing.
*/
XML_Debug ("Transaction based XML processing.");
/* XML_Debug("Master tr_id = %d", (int)pTrSet->MasterTrId); */
if (pXMLErrorStr == NULL)
{
/*of_strcpy(pXMLErrorStr, xmlDeclare); */
pXMLErrorStr = xmlStrdup ((const xmlChar *) xmlDeclare);
}
if (!pTransList) /*If no transaction in progress */
{
/*T_strcat(pXMLErrorStr, pInXMLStr);
T_strcat(pXMLErrorStr, xmlEndDecl); */
pXMLErrorStr = xmlStrcat (pXMLErrorStr, pInXMLStr);
pXMLErrorStr = xmlStrcat (pXMLErrorStr, xmlEndDecl);
}
else
{
/*T_strcat(pXMLErrorStr, pInXMLStr); */
pXMLErrorStr = xmlStrcat (pXMLErrorStr, pInXMLStr);
}
}
else
{
/*
* Non-Transaction XML processing.
*/
XML_Debug ("Non-Transaction XML processing.");
if (pXMLErrorStr == NULL)
{
pXMLErrorStr = xmlStrdup ((const xmlChar *) pInXMLStr);
}
else
{
/*pXMLErrorStr = (XML_STR) T_malloc(T_strlen(pInXMLStr) + 1); */
/*of_strcpy(pXMLErrorStr, pInXMLStr); */
pXMLErrorStr = xmlStrcat (pXMLErrorStr, pInXMLStr);
/*free(pInXMLStr); */
}
}
XML_DebugArg ("pXMLErrorStr = ", pXMLErrorStr);
return CNTRLXML_SUCCESS;
}
static void
exsltRegexpReplaceFunction (xmlXPathParserContextPtr ctxt, int nargs)
{
xmlChar *haystack, *regexp, *flagstr, *replace, *tmp;
xmlChar *result = NULL, *working, *end;
int rc, x, flags, global, ovector[3];
if ((nargs < 1) || (nargs > 4)) {
xmlXPathSetArityError(ctxt);
return;
}
replace = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt) || (replace == NULL)) {
return;
}
flagstr = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt) || (flagstr == NULL)) {
xmlFree(replace);
return;
}
regexp = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt) || (regexp == NULL)) {
xmlFree(flagstr);
xmlFree(replace);
return;
}
haystack = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt) || (haystack == NULL)) {
xmlFree(regexp);
xmlFree(flagstr);
xmlFree(replace);
return;
}
exsltRegexpFlagsFromString(flagstr, &global, &flags);
working = haystack;
rc = exsltRegexpExecute(ctxt, working, regexp, flags,
ovector, sizeof(ovector)/sizeof(int));
while (rc > 0 ) {
if (0==ovector[0]) {
if (NULL==result) result = xmlStrdup(replace);
else result = xmlStrcat(result, replace);
}
else {
tmp = xmlStrsub(working, 0, ovector[0]);
if (NULL==result) result = tmp;
else {
result = xmlStrcat(result, tmp);
xmlFree(tmp);
}
result = xmlStrcat(result, replace);
}
working = working + ovector[1];
if (!global) break;
rc = exsltRegexpExecute(ctxt, working, regexp, flags,
ovector, sizeof(ovector)/sizeof(int));
}
end = haystack + xmlUTF8Strlen(haystack);
if (working < end ) {
if (NULL==result) result = xmlStrdup(working);
else {
result = xmlStrcat(result, working);
}
}
fail:
if (replace != NULL)
xmlFree(replace);
if (flagstr != NULL)
xmlFree(flagstr);
if (regexp != NULL)
xmlFree(regexp);
if (haystack != NULL)
xmlFree(haystack);
xmlXPathReturnString(ctxt, result);
}
static xmlParserInputPtr
xsltprocExternalEntityLoader(const char *URL, const char *ID,
xmlParserCtxtPtr ctxt)
{
xmlParserInputPtr ret;
warningSAXFunc warning = NULL;
int i;
const char *lastsegment = URL;
const char *iter = URL;
if (nbpaths > 0) {
while (*iter != 0) {
if (*iter == '/')
lastsegment = iter + 1;
iter++;
}
}
if ((ctxt != NULL) && (ctxt->sax != NULL)) {
warning = ctxt->sax->warning;
ctxt->sax->warning = NULL;
}
if (defaultEntityLoader != NULL) {
ret = defaultEntityLoader(URL, ID, ctxt);
if (ret != NULL) {
if (warning != NULL)
ctxt->sax->warning = warning;
if (load_trace) {
fprintf \
(stderr,
"Loaded URL=\"%s\" ID=\"%s\"\n",
URL ? URL : "(null)",
ID ? ID : "(null)");
}
return(ret);
}
}
for (i = 0; i < nbpaths; i++) {
xmlChar *newURL;
newURL = xmlStrdup((const xmlChar *) paths[i]);
newURL = xmlStrcat(newURL, (const xmlChar *) "/");
newURL = xmlStrcat(newURL, (const xmlChar *) lastsegment);
if (newURL != NULL) {
ret = defaultEntityLoader((const char *)newURL, ID, ctxt);
if (ret != NULL) {
if (warning != NULL)
ctxt->sax->warning = warning;
if (load_trace) {
fprintf \
(stderr,
"Loaded URL=\"%s\" ID=\"%s\"\n",
newURL,
ID ? ID : "(null)");
}
xmlFree(newURL);
return(ret);
}
xmlFree(newURL);
}
}
if (warning != NULL) {
ctxt->sax->warning = warning;
if (URL != NULL)
warning(ctxt, "failed to load external entity \"%s\"\n", URL);
else if (ID != NULL)
warning(ctxt, "failed to load external entity \"%s\"\n", ID);
}
return(NULL);
}
/*
* Entity loading control and customization.
* taken from xsltproc.c
*/
static xmlParserInputPtr xsltprocExternalEntityLoader(const char *_URL, const char *ID, xmlParserCtxtPtr ctxt)
{
xmlParserInputPtr ret;
warningSAXFunc warning = NULL;
// use local available dtd versions instead of fetching it every time from the internet
QString url = QLatin1String(_URL);
QHash<QString, QString>::const_iterator i;
for (i = replaceURLList.constBegin(); i != replaceURLList.constEnd(); i++) {
if (url.startsWith(i.key())) {
url.replace(i.key(), i.value());
qDebug() << "converted" << _URL << "to" << url;
}
}
char URL[1024];
strcpy(URL, url.toLatin1().constData());
const char *lastsegment = URL;
const char *iter = URL;
if (nbpaths > 0) {
while (*iter != 0) {
if (*iter == '/') {
lastsegment = iter + 1;
}
iter++;
}
}
if ((ctxt != NULL) && (ctxt->sax != NULL)) {
warning = ctxt->sax->warning;
ctxt->sax->warning = NULL;
}
if (defaultEntityLoader != NULL) {
ret = defaultEntityLoader(URL, ID, ctxt);
if (ret != NULL) {
if (warning != NULL) {
ctxt->sax->warning = warning;
}
qDebug() << "Loaded URL=\"" << URL << "\" ID=\"" << ID << "\"";
return (ret);
}
}
for (int i = 0; i < nbpaths; i++) {
xmlChar *newURL;
newURL = xmlStrdup((const xmlChar *) paths[i]);
newURL = xmlStrcat(newURL, (const xmlChar *) "/");
newURL = xmlStrcat(newURL, (const xmlChar *) lastsegment);
if (newURL != NULL) {
ret = defaultEntityLoader((const char *)newURL, ID, ctxt);
if (ret != NULL) {
if (warning != NULL) {
ctxt->sax->warning = warning;
}
qDebug() << "Loaded URL=\"" << newURL << "\" ID=\"" << ID << "\"";
xmlFree(newURL);
return (ret);
}
xmlFree(newURL);
}
}
if (warning != NULL) {
ctxt->sax->warning = warning;
if (URL != NULL) {
warning(ctxt, "failed to load external entity \"%s\"\n", URL);
} else if (ID != NULL) {
warning(ctxt, "failed to load external entity \"%s\"\n", ID);
}
}
return (NULL);
}