#define IN_LIBEXSLT
#include "libexslt/libexslt.h"
#include <libxml/tree.h>
#include <libxml/xpath.h>
#include <libxml/xpathInternals.h>
#include <libxml/parser.h>
#include <libxml/encoding.h>
#include <libxml/uri.h>
#include <libxslt/xsltutils.h>
#include <libxslt/xsltInternals.h>
#include <libxslt/extensions.h>
#include "exslt.h"
/**
* exsltStrTokenizeFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Splits up a string on the characters of the delimiter string and returns a
* node set of token elements, each containing one token from the string.
*/
static void
exsltStrTokenizeFunction(xmlXPathParserContextPtr ctxt, int nargs)
{
xsltTransformContextPtr tctxt;
xmlChar *str, *delimiters, *cur;
const xmlChar *token, *delimiter;
xmlNodePtr node;
xmlDocPtr container;
xmlXPathObjectPtr ret = NULL;
int clen;
if ((nargs < 1) || (nargs > 2)) {
xmlXPathSetArityError(ctxt);
return;
}
if (nargs == 2) {
delimiters = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt))
return;
} else {
delimiters = xmlStrdup((const xmlChar *) "\t\r\n ");
}
if (delimiters == NULL)
return;
str = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt) || (str == NULL)) {
xmlFree(delimiters);
return;
}
/* Return a result tree fragment */
tctxt = xsltXPathGetTransformContext(ctxt);
if (tctxt == NULL) {
xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
"exslt:tokenize : internal error tctxt == NULL\n");
goto fail;
}
container = xsltCreateRVT(tctxt);
if (container != NULL) {
xsltRegisterLocalRVT(tctxt, container);
ret = xmlXPathNewNodeSet(NULL);
if (ret != NULL) {
for (cur = str, token = str; *cur != 0; cur += clen) {
clen = xmlUTF8Strsize(cur, 1);
if (*delimiters == 0) { /* empty string case */
xmlChar ctmp;
ctmp = *(cur+clen);
*(cur+clen) = 0;
node = xmlNewDocRawNode(container, NULL,
(const xmlChar *) "token", cur);
xmlAddChild((xmlNodePtr) container, node);
xmlXPathNodeSetAddUnique(ret->nodesetval, node);
*(cur+clen) = ctmp; /* restore the changed byte */
token = cur + clen;
} else for (delimiter = delimiters; *delimiter != 0;
delimiter += xmlUTF8Strsize(delimiter, 1)) {
if (!xmlUTF8Charcmp(cur, delimiter)) {
if (cur == token) {
/* discard empty tokens */
token = cur + clen;
break;
}
*cur = 0; /* terminate the token */
node = xmlNewDocRawNode(container, NULL,
(const xmlChar *) "token", token);
xmlAddChild((xmlNodePtr) container, node);
xmlXPathNodeSetAddUnique(ret->nodesetval, node);
*cur = *delimiter; /* restore the changed byte */
token = cur + clen;
break;
}
}
}
if (token != cur) {
node = xmlNewDocRawNode(container, NULL,
(const xmlChar *) "token", token);
xmlAddChild((xmlNodePtr) container, node);
xmlXPathNodeSetAddUnique(ret->nodesetval, node);
}
}
}
fail:
if (str != NULL)
xmlFree(str);
if (delimiters != NULL)
xmlFree(delimiters);
if (ret != NULL)
valuePush(ctxt, ret);
else
valuePush(ctxt, xmlXPathNewNodeSet(NULL));
}
/**
* exsltStrSplitFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Splits up a string on a delimiting string and returns a node set of token
* elements, each containing one token from the string.
*/
static void
exsltStrSplitFunction(xmlXPathParserContextPtr ctxt, int nargs) {
xsltTransformContextPtr tctxt;
xmlChar *str, *delimiter, *cur;
const xmlChar *token;
xmlNodePtr node;
xmlDocPtr container;
xmlXPathObjectPtr ret = NULL;
int delimiterLength;
if ((nargs < 1) || (nargs > 2)) {
xmlXPathSetArityError(ctxt);
return;
}
if (nargs == 2) {
delimiter = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt))
return;
} else {
delimiter = xmlStrdup((const xmlChar *) " ");
}
if (delimiter == NULL)
return;
delimiterLength = xmlStrlen (delimiter);
str = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt) || (str == NULL)) {
xmlFree(delimiter);
return;
}
/* Return a result tree fragment */
tctxt = xsltXPathGetTransformContext(ctxt);
if (tctxt == NULL) {
xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
"exslt:tokenize : internal error tctxt == NULL\n");
goto fail;
}
/*
* OPTIMIZE TODO: We are creating an xmlDoc for every split!
*/
container = xsltCreateRVT(tctxt);
if (container != NULL) {
xsltRegisterLocalRVT(tctxt, container);
ret = xmlXPathNewNodeSet(NULL);
if (ret != NULL) {
for (cur = str, token = str; *cur != 0; cur++) {
if (delimiterLength == 0) {
if (cur != token) {
xmlChar tmp = *cur;
*cur = 0;
node = xmlNewDocRawNode(container, NULL,
(const xmlChar *) "token", token);
xmlAddChild((xmlNodePtr) container, node);
xmlXPathNodeSetAddUnique(ret->nodesetval, node);
*cur = tmp;
token++;
}
}
else if (!xmlStrncasecmp(cur, delimiter, delimiterLength)) {
if (cur == token) {
/* discard empty tokens */
cur = cur + delimiterLength - 1;
token = cur + 1;
continue;
}
*cur = 0;
node = xmlNewDocRawNode(container, NULL,
(const xmlChar *) "token", token);
xmlAddChild((xmlNodePtr) container, node);
xmlXPathNodeSetAddUnique(ret->nodesetval, node);
*cur = *delimiter;
cur = cur + delimiterLength - 1;
token = cur + 1;
}
}
if (token != cur) {
node = xmlNewDocRawNode(container, NULL,
(const xmlChar *) "token", token);
xmlAddChild((xmlNodePtr) container, node);
xmlXPathNodeSetAddUnique(ret->nodesetval, node);
}
}
}
fail:
if (str != NULL)
xmlFree(str);
if (delimiter != NULL)
xmlFree(delimiter);
if (ret != NULL)
valuePush(ctxt, ret);
else
valuePush(ctxt, xmlXPathNewNodeSet(NULL));
}
/**
* exsltStrEncodeUriFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* URI-Escapes a string
*/
static void
exsltStrEncodeUriFunction (xmlXPathParserContextPtr ctxt, int nargs) {
int escape_all = 1, str_len = 0;
xmlChar *str = NULL, *ret = NULL, *tmp;
if ((nargs < 2) || (nargs > 3)) {
xmlXPathSetArityError(ctxt);
return;
}
if (nargs >= 3) {
/* check for UTF-8 if encoding was explicitly given;
we don't support anything else yet */
tmp = xmlXPathPopString(ctxt);
if (xmlUTF8Strlen(tmp) != 5 || xmlStrcmp((const xmlChar *)"UTF-8",tmp)) {
xmlXPathReturnEmptyString(ctxt);
xmlFree(tmp);
return;
}
xmlFree(tmp);
}
escape_all = xmlXPathPopBoolean(ctxt);
str = xmlXPathPopString(ctxt);
str_len = xmlUTF8Strlen(str);
if (str_len <= 0) {
if (str_len < 0)
xsltGenericError(xsltGenericErrorContext,
"exsltStrEncodeUriFunction: invalid UTF-8\n");
xmlXPathReturnEmptyString(ctxt);
xmlFree(str);
return;
}
ret = xmlURIEscapeStr(str,(const xmlChar *)(escape_all?"-_.!~*'()":"-_.!~*'();/?:@&=+$,[]"));
xmlXPathReturnString(ctxt, ret);
if (str != NULL)
xmlFree(str);
}
/**
* exsltStrDecodeUriFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* reverses URI-Escaping of a string
*/
static void
exsltStrDecodeUriFunction (xmlXPathParserContextPtr ctxt, int nargs) {
int str_len = 0;
xmlChar *str = NULL, *ret = NULL, *tmp;
if ((nargs < 1) || (nargs > 2)) {
xmlXPathSetArityError(ctxt);
return;
}
if (nargs >= 2) {
/* check for UTF-8 if encoding was explicitly given;
we don't support anything else yet */
tmp = xmlXPathPopString(ctxt);
if (xmlUTF8Strlen(tmp) != 5 || xmlStrcmp((const xmlChar *)"UTF-8",tmp)) {
xmlXPathReturnEmptyString(ctxt);
xmlFree(tmp);
return;
}
xmlFree(tmp);
}
str = xmlXPathPopString(ctxt);
str_len = xmlUTF8Strlen(str);
if (str_len <= 0) {
if (str_len < 0)
xsltGenericError(xsltGenericErrorContext,
"exsltStrDecodeUriFunction: invalid UTF-8\n");
xmlXPathReturnEmptyString(ctxt);
xmlFree(str);
return;
}
ret = (xmlChar *) xmlURIUnescapeString((const char *)str,0,NULL);
if (!xmlCheckUTF8(ret)) {
/* FIXME: instead of throwing away the whole URI, we should
only discard the invalid sequence(s). How to do that? */
xmlXPathReturnEmptyString(ctxt);
xmlFree(str);
xmlFree(ret);
return;
}
xmlXPathReturnString(ctxt, ret);
if (str != NULL)
xmlFree(str);
}
/**
* 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, str_size = 0;
double floatval;
xmlChar *str = NULL;
xmlBufferPtr buf;
if ((nargs < 1) || (nargs > 2)) {
xmlXPathSetArityError(ctxt);
return;
}
if (nargs == 2) {
str = xmlXPathPopString(ctxt);
str_len = xmlUTF8Strlen(str);
str_size = xmlStrlen(str);
}
floatval = xmlXPathPopNumber(ctxt);
if (str_len <= 0) {
if (str_len < 0) {
xsltGenericError(xsltGenericErrorContext,
"exsltStrPaddingFunction: invalid UTF-8\n");
xmlXPathReturnEmptyString(ctxt);
xmlFree(str);
return;
}
if (str != NULL) xmlFree(str);
str = xmlStrdup((const xmlChar *) " ");
str_len = 1;
str_size = 1;
}
if (xmlXPathIsNaN(floatval) || floatval < 0.0) {
number = 0;
} else if (floatval >= 100000.0) {
number = 100000;
}
else {
number = (int) floatval;
}
if (number <= 0) {
xmlXPathReturnEmptyString(ctxt);
xmlFree(str);
return;
}
buf = xmlBufferCreateSize(number);
if (buf == NULL) {
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
xmlFree(str);
return;
}
xmlBufferSetAllocationScheme(buf, XML_BUFFER_ALLOC_DOUBLEIT);
while (number >= str_len) {
xmlBufferAdd(buf, str, str_size);
number -= str_len;
}
if (number > 0) {
str_size = xmlUTF8Strsize(str, number);
xmlBufferAdd(buf, str, str_size);
}
xmlXPathReturnString(ctxt, xmlBufferDetach(buf));
xmlBufferFree(buf);
if (str != NULL)
xmlFree(str);
}
/**
* 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 < 0 || padding_l < 0) {
xsltGenericError(xsltGenericErrorContext,
"exsltStrAlignFunction: invalid UTF-8\n");
xmlXPathReturnEmptyString(ctxt);
xmlFree(str);
xmlFree(padding);
xmlFree(alignment);
return;
}
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);
}
/**
* 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;
xmlBufferPtr buf;
int i;
if (nargs != 1) {
xmlXPathSetArityError(ctxt);
return;
}
if (!xmlXPathStackIsNodeSet(ctxt)) {
xmlXPathSetTypeError(ctxt);
return;
}
obj = valuePop (ctxt);
if (xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
xmlXPathFreeObject(obj);
xmlXPathReturnEmptyString(ctxt);
return;
}
buf = xmlBufferCreate();
if (buf == NULL) {
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
xmlXPathFreeObject(obj);
return;
}
xmlBufferSetAllocationScheme(buf, XML_BUFFER_ALLOC_DOUBLEIT);
for (i = 0; i < obj->nodesetval->nodeNr; i++) {
xmlChar *tmp;
tmp = xmlXPathCastNodeToString(obj->nodesetval->nodeTab[i]);
xmlBufferCat(buf, tmp);
xmlFree(tmp);
}
xmlXPathFreeObject (obj);
xmlXPathReturnString(ctxt, xmlBufferDetach(buf));
xmlBufferFree(buf);
}
/**
* exsltStrReturnString:
* @ctxt: an XPath parser context
* @str: a string
* @len: length of string
*
* Returns a string as a node set.
*/
static int
exsltStrReturnString(xmlXPathParserContextPtr ctxt, const xmlChar *str,
int len)
{
xsltTransformContextPtr tctxt = xsltXPathGetTransformContext(ctxt);
xmlDocPtr container;
xmlNodePtr text_node;
xmlXPathObjectPtr ret;
container = xsltCreateRVT(tctxt);
if (container == NULL) {
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
return(-1);
}
xsltRegisterLocalRVT(tctxt, container);
text_node = xmlNewTextLen(str, len);
if (text_node == NULL) {
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
return(-1);
}
xmlAddChild((xmlNodePtr) container, text_node);
ret = xmlXPathNewNodeSet(text_node);
if (ret == NULL) {
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
return(-1);
}
valuePush(ctxt, ret);
return(0);
}
/**
* exsltStrReplaceFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Takes a string, and two node sets and returns the string with all strings in
* the first node set replaced by all strings in the second node set.
*/
static void
exsltStrReplaceFunction (xmlXPathParserContextPtr ctxt, int nargs) {
int i, i_empty, n, slen0, rlen0, *slen, *rlen;
void *mem = NULL;
const xmlChar *src, *start;
xmlChar *string, *search_str = NULL, *replace_str = NULL;
xmlChar **search, **replace;
xmlNodeSetPtr search_set = NULL, replace_set = NULL;
xmlBufferPtr buf;
if (nargs != 3) {
xmlXPathSetArityError(ctxt);
return;
}
/* get replace argument */
if (!xmlXPathStackIsNodeSet(ctxt))
replace_str = xmlXPathPopString(ctxt);
else
replace_set = xmlXPathPopNodeSet(ctxt);
if (xmlXPathCheckError(ctxt))
goto fail_replace;
/* get search argument */
if (!xmlXPathStackIsNodeSet(ctxt)) {
search_str = xmlXPathPopString(ctxt);
n = 1;
}
else {
search_set = xmlXPathPopNodeSet(ctxt);
n = search_set != NULL ? search_set->nodeNr : 0;
}
if (xmlXPathCheckError(ctxt))
goto fail_search;
/* get string argument */
string = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt))
goto fail_string;
/* check for empty search node list */
if (n <= 0) {
exsltStrReturnString(ctxt, string, xmlStrlen(string));
goto done_empty_search;
}
/* allocate memory for string pointer and length arrays */
if (n == 1) {
search = &search_str;
replace = &replace_str;
slen = &slen0;
rlen = &rlen0;
}
else {
mem = xmlMalloc(2 * n * (sizeof(const xmlChar *) + sizeof(int)));
if (mem == NULL) {
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
goto fail_malloc;
}
search = (xmlChar **) mem;
replace = search + n;
slen = (int *) (replace + n);
rlen = slen + n;
}
/* process arguments */
i_empty = -1;
for (i=0; i<n; ++i) {
if (search_set != NULL) {
search[i] = xmlXPathCastNodeToString(search_set->nodeTab[i]);
if (search[i] == NULL) {
n = i;
goto fail_process_args;
}
}
slen[i] = xmlStrlen(search[i]);
if (i_empty < 0 && slen[i] == 0)
i_empty = i;
if (replace_set != NULL) {
if (i < replace_set->nodeNr) {
replace[i] = xmlXPathCastNodeToString(replace_set->nodeTab[i]);
if (replace[i] == NULL) {
n = i + 1;
goto fail_process_args;
}
}
else
replace[i] = NULL;
}
else {
if (i == 0)
replace[i] = replace_str;
else
replace[i] = NULL;
}
if (replace[i] == NULL)
rlen[i] = 0;
else
rlen[i] = xmlStrlen(replace[i]);
}
if (i_empty >= 0 && rlen[i_empty] == 0)
i_empty = -1;
/* replace operation */
buf = xmlBufferCreate();
if (buf == NULL) {
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
goto fail_buffer;
}
xmlBufferSetAllocationScheme(buf, XML_BUFFER_ALLOC_DOUBLEIT);
src = string;
start = string;
while (*src != 0) {
int max_len = 0, i_match = 0;
for (i=0; i<n; ++i) {
if (*src == search[i][0] &&
slen[i] > max_len &&
xmlStrncmp(src, search[i], slen[i]) == 0)
{
i_match = i;
max_len = slen[i];
}
}
if (max_len == 0) {
if (i_empty >= 0 && start < src) {
if (xmlBufferAdd(buf, start, src - start) ||
xmlBufferAdd(buf, replace[i_empty], rlen[i_empty]))
{
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
goto fail_buffer_add;
}
start = src;
}
src += xmlUTF8Strsize(src, 1);
}
else {
if ((start < src &&
xmlBufferAdd(buf, start, src - start)) ||
(rlen[i_match] &&
xmlBufferAdd(buf, replace[i_match], rlen[i_match])))
{
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
goto fail_buffer_add;
}
src += slen[i_match];
start = src;
}
}
if (start < src && xmlBufferAdd(buf, start, src - start)) {
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
goto fail_buffer_add;
}
/* create result node set */
exsltStrReturnString(ctxt, xmlBufferContent(buf), xmlBufferLength(buf));
/* clean up */
fail_buffer_add:
xmlBufferFree(buf);
fail_buffer:
fail_process_args:
if (search_set != NULL) {
for (i=0; i<n; ++i)
xmlFree(search[i]);
}
if (replace_set != NULL) {
for (i=0; i<n; ++i) {
if (replace[i] != NULL)
xmlFree(replace[i]);
}
}
if (mem != NULL)
xmlFree(mem);
fail_malloc:
done_empty_search:
xmlFree(string);
fail_string:
if (search_set != NULL)
xmlXPathFreeNodeSet(search_set);
else
xmlFree(search_str);
fail_search:
if (replace_set != NULL)
xmlXPathFreeNodeSet(replace_set);
else
xmlFree(replace_str);
fail_replace:
return;
}
/**
* exsltStrRegister:
*
* Registers the EXSLT - Strings module
*/
void
exsltStrRegister (void) {
xsltRegisterExtModuleFunction ((const xmlChar *) "tokenize",
EXSLT_STRINGS_NAMESPACE,
exsltStrTokenizeFunction);
xsltRegisterExtModuleFunction ((const xmlChar *) "split",
EXSLT_STRINGS_NAMESPACE,
exsltStrSplitFunction);
xsltRegisterExtModuleFunction ((const xmlChar *) "encode-uri",
EXSLT_STRINGS_NAMESPACE,
exsltStrEncodeUriFunction);
xsltRegisterExtModuleFunction ((const xmlChar *) "decode-uri",
EXSLT_STRINGS_NAMESPACE,
exsltStrDecodeUriFunction);
xsltRegisterExtModuleFunction ((const xmlChar *) "padding",
EXSLT_STRINGS_NAMESPACE,
exsltStrPaddingFunction);
xsltRegisterExtModuleFunction ((const xmlChar *) "align",
EXSLT_STRINGS_NAMESPACE,
exsltStrAlignFunction);
xsltRegisterExtModuleFunction ((const xmlChar *) "concat",
EXSLT_STRINGS_NAMESPACE,
exsltStrConcatFunction);
xsltRegisterExtModuleFunction ((const xmlChar *) "replace",
EXSLT_STRINGS_NAMESPACE,
exsltStrReplaceFunction);
}
/**
* exsltStrXpathCtxtRegister:
*
* Registers the EXSLT - Strings module for use outside XSLT
*/
int
exsltStrXpathCtxtRegister (xmlXPathContextPtr ctxt, const xmlChar *prefix)
{
if (ctxt
&& prefix
&& !xmlXPathRegisterNs(ctxt,
prefix,
(const xmlChar *) EXSLT_STRINGS_NAMESPACE)
&& !xmlXPathRegisterFuncNS(ctxt,
(const xmlChar *) "encode-uri",
(const xmlChar *) EXSLT_STRINGS_NAMESPACE,
exsltStrEncodeUriFunction)
&& !xmlXPathRegisterFuncNS(ctxt,
(const xmlChar *) "decode-uri",
(const xmlChar *) EXSLT_STRINGS_NAMESPACE,
exsltStrDecodeUriFunction)
&& !xmlXPathRegisterFuncNS(ctxt,
(const xmlChar *) "padding",
(const xmlChar *) EXSLT_STRINGS_NAMESPACE,
exsltStrPaddingFunction)
&& !xmlXPathRegisterFuncNS(ctxt,
(const xmlChar *) "align",
(const xmlChar *) EXSLT_STRINGS_NAMESPACE,
exsltStrAlignFunction)
&& !xmlXPathRegisterFuncNS(ctxt,
(const xmlChar *) "concat",
(const xmlChar *) EXSLT_STRINGS_NAMESPACE,
exsltStrConcatFunction)) {
return 0;
}
return -1;
}
Codebase Browser
chromium