/**
* exsltMathLowestFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Wraps #exsltMathLowest for use by the XPath processor
*/
static void
exsltMathLowestFunction (xmlXPathParserContextPtr ctxt, int nargs) {
xmlNodeSetPtr ns, ret;
void *user = NULL;
if (nargs != 1) {
xmlXPathSetArityError(ctxt);
return;
}
/* We need to delay the freeing of value->user */
if ((ctxt->value != NULL) && (ctxt->value->boolval != 0)) {
user = ctxt->value->user;
ctxt->value->boolval = 0;
ctxt->value->user = NULL;
}
ns = xmlXPathPopNodeSet(ctxt);
if (xmlXPathCheckError(ctxt))
return;
ret = exsltMathLowest(ns);
xmlXPathFreeNodeSet(ns);
if (user != NULL)
xmlFreeNodeList((xmlNodePtr)user);
xmlXPathReturnNodeSet(ctxt, ret);
}
static void
extBitNot (xmlXPathParserContextPtr ctxt, int nargs)
{
xmlChar *res;
int width, i;
xmlXPathObjectPtr xop;
if (nargs != 1) {
xmlXPathSetArityError(ctxt);
return;
}
/* Pop args in reverse order */
xop = valuePop(ctxt);
if (xop == NULL || xmlXPathCheckError(ctxt))
return;
res = extBitStringVal(ctxt, xop);
if (res == NULL)
return;
width = xmlStrlen(res);
for (i = 0; i < width; i++) {
xmlChar lb = res[i];
res[i] = (lb == '0') ? '1' : '0';
}
xmlXPathReturnString(ctxt, res);
}
static void
exsltMathMaxFunction (xmlXPathParserContextPtr ctxt, int nargs) {
xmlNodeSetPtr ns;
double ret;
void *user = NULL;
if (nargs != 1) {
xmlXPathSetArityError(ctxt);
return;
}
if ((ctxt->value != NULL) && (ctxt->value->boolval != 0)) {
user = ctxt->value->user;
ctxt->value->boolval = 0;
ctxt->value->user = 0;
}
ns = xmlXPathPopNodeSet(ctxt);
if (xmlXPathCheckError(ctxt))
return;
ret = exsltMathMax(ns);
xmlXPathFreeNodeSet(ns);
if (user != NULL)
xmlFreeNodeList((xmlNodePtr)user);
xmlXPathReturnNumber(ctxt, ret);
}
// FIXME: This code is taken from libexslt 1.1.11; should sync with newer versions.
static void exsltNodeSetFunction(xmlXPathParserContextPtr ctxt, int nargs)
{
xmlChar *strval;
xmlNodePtr retNode;
xmlXPathObjectPtr ret;
if (nargs != 1) {
xmlXPathSetArityError(ctxt);
return;
}
if (xmlXPathStackIsNodeSet(ctxt)) {
xsltFunctionNodeSet(ctxt, nargs);
return;
}
strval = xmlXPathPopString(ctxt);
retNode = xmlNewDocText(NULL, strval);
ret = xmlXPathNewValueTree(retNode);
if (ret == NULL) {
xsltGenericError(xsltGenericErrorContext,
"exsltNodeSetFunction: ret == NULL\n");
} else {
ret->type = XPATH_NODESET;
}
if (strval != NULL)
xmlFree(strval);
valuePush(ctxt, ret);
}
// FIXME: This code is taken from libexslt 1.1.11; should sync with newer
// versions.
static void exsltNodeSetFunction(xmlXPathParserContextPtr ctxt, int nargs)
{
xmlChar* strval;
xmlNodePtr retNode;
xmlXPathObjectPtr ret;
if (nargs != 1) {
xmlXPathSetArityError(ctxt);
return;
}
if (xmlXPathStackIsNodeSet(ctxt)) {
xsltFunctionNodeSet(ctxt, nargs);
return;
}
strval = xmlXPathPopString(ctxt);
retNode = xmlNewDocText(0, strval);
ret = xmlXPathNewValueTree(retNode);
// FIXME: It might be helpful to push any errors from xmlXPathNewValueTree
// up to the Javascript Console.
if (ret)
ret->type = XPATH_NODESET;
if (strval)
xmlFree(strval);
valuePush(ctxt, ret);
}
static void
extBitToInt (xmlXPathParserContextPtr ctxt, int nargs)
{
xmlChar *res;
xmlXPathObjectPtr xop;
unsigned long long val;
int i;
if (nargs != 1) {
xmlXPathSetArityError(ctxt);
return;
}
xop = valuePop(ctxt);
if (xop == NULL || xmlXPathCheckError(ctxt))
return;
res = extBitStringVal(ctxt, xop);
if (res == NULL)
return;
for (i = 0, val = 0; i <= 64 && res[i]; i++) {
val <<= 1;
if (res[i] == '1')
val += 1;
}
if (i > 64)
xmlXPathReturnNumber(ctxt, (double) -1);
else
xmlXPathReturnNumber(ctxt, (double) val);
}
static void
xsltp_extension_string_rtrim(xmlXPathParserContextPtr ctxt, int nargs) {
if (nargs != 1) {
xmlXPathSetArityError(ctxt);
return;
}
xmlXPathReturnString(ctxt, _xsltp_extension_string_rtrim(xmlXPathPopString(ctxt)));
}
static void
extBitCompare (xmlXPathParserContextPtr ctxt, int nargs)
{
xmlChar *res1, *res2;
xmlXPathObjectPtr xop;
int width1, width2, off1, off2, rc, delta;
if (nargs != 2) {
xmlXPathSetArityError(ctxt);
return;
}
/* Pop args in reverse order */
xop = valuePop(ctxt);
if (xop == NULL || xmlXPathCheckError(ctxt))
return;
res2 = extBitStringVal(ctxt, xop);
if (res2 == NULL)
return;
xop = valuePop(ctxt);
if (xop == NULL || xmlXPathCheckError(ctxt))
return;
res1 = extBitStringVal(ctxt, xop);
if (res1 == NULL)
return;
width1 = xmlStrlen(res1);
width2 = xmlStrlen(res2);
delta = width1 - width2;
rc = 0;
off1 = off2 = 0;
if (delta < 0) {
for ( ; delta < 0; delta++, off2++) {
if (res2[off2] != '0') {
rc = -1;
goto done;
}
}
} else if (delta > 0) {
for ( ; delta > 0; delta--, off1++) {
if (res1[off1] != '0') {
rc = 1;
goto done;
}
}
}
rc = xmlStrcmp(res1 + off1, res2 + off2);
done:
xmlFree(res1);
xmlFree(res2);
xmlXPathReturnNumber(ctxt, rc);
}
/**
* 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);
}
/**
* exsltCryptoRc4DecryptFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* computes the sha1 hash of a string and returns as hex
*/
static void
exsltCryptoRc4DecryptFunction (xmlXPathParserContextPtr ctxt, int nargs) {
int key_len = 0, key_size = 0;
int str_len = 0, bin_len = 0, ret_len = 0;
xmlChar *key = NULL, *str = NULL, *padkey = NULL, *bin =
NULL, *ret = NULL;
if ((nargs < 1) || (nargs > 3)) {
xmlXPathSetArityError (ctxt);
return;
}
str = xmlXPathPopString (ctxt);
str_len = xmlUTF8Strlen (str);
if (str_len == 0) {
xmlXPathReturnEmptyString (ctxt);
xmlFree (str);
return;
}
key = xmlXPathPopString (ctxt);
key_len = xmlUTF8Strlen (str);
if (key_len == 0) {
xmlXPathReturnEmptyString (ctxt);
xmlFree (key);
xmlFree (str);
return;
}
padkey = xmlMallocAtomic (RC4_KEY_LENGTH);
key_size = xmlUTF8Strsize (key, key_len);
memcpy (padkey, key, key_size);
memset (padkey + key_size, '\0', sizeof (padkey));
/* decode hex to binary */
bin_len = str_len;
bin = xmlMallocAtomic (bin_len);
ret_len = exsltCryptoHex2Bin (str, str_len, bin, bin_len);
/* decrypt the binary blob */
ret = xmlMallocAtomic (ret_len);
PLATFORM_RC4_DECRYPT (ctxt, padkey, bin, ret_len, ret, ret_len);
xmlXPathReturnString (ctxt, ret);
if (key != NULL)
xmlFree (key);
if (str != NULL)
xmlFree (str);
if (padkey != NULL)
xmlFree (padkey);
if (bin != NULL)
xmlFree (bin);
}
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));
}
static void
exsltNodeSetFunction (xmlXPathParserContextPtr ctxt, int nargs) {
if (nargs != 1) {
xmlXPathSetArityError(ctxt);
return;
}
if (xmlXPathStackIsNodeSet (ctxt)) {
xsltFunctionNodeSet (ctxt, nargs);
return;
} else {
xmlDocPtr fragment;
xsltTransformContextPtr tctxt = xsltXPathGetTransformContext(ctxt);
xmlNodePtr txt;
xmlChar *strval;
xmlXPathObjectPtr obj;
/*
* SPEC EXSLT:
* "You can also use this function to turn a string into a text
* node, which is helpful if you want to pass a string to a
* function that only accepts a node-set."
*/
fragment = xsltCreateRVT(tctxt);
if (fragment == NULL) {
xsltTransformError(tctxt, NULL, tctxt->inst,
"exsltNodeSetFunction: Failed to create a tree fragment.\n");
tctxt->state = XSLT_STATE_STOPPED;
return;
}
xsltRegisterLocalRVT(tctxt, fragment);
strval = xmlXPathPopString (ctxt);
txt = xmlNewDocText (fragment, strval);
xmlAddChild((xmlNodePtr) fragment, txt);
obj = xmlXPathNewNodeSet(txt);
if (obj == NULL) {
xsltTransformError(tctxt, NULL, tctxt->inst,
"exsltNodeSetFunction: Failed to create a node set object.\n");
tctxt->state = XSLT_STATE_STOPPED;
} else {
/*
* Mark it as a function result in order to avoid garbage
* collecting of tree fragments
*/
xsltExtensionInstructionResultRegister(tctxt, obj);
}
if (strval != NULL)
xmlFree (strval);
valuePush (ctxt, obj);
}
}
/**
* exsltMathRandomFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Wraps #exsltMathRandom for use by the XPath processor.
*/
static void
exsltMathRandomFunction (xmlXPathParserContextPtr ctxt, int nargs) {
double ret;
if (nargs != 0) {
xmlXPathSetArityError(ctxt);
return;
}
ret = exsltMathRandom();
xmlXPathReturnNumber(ctxt, ret);
}
static void
extBitOperation (xmlXPathParserContextPtr ctxt, int nargs,
slax_bit_callback_t func, const char *name)
{
xmlChar *lv, *rv, *res;
int llen, rlen, width, i;
xmlXPathObjectPtr xop;
if (nargs != 2) {
xmlXPathSetArityError(ctxt);
return;
}
/* Pop args in reverse order */
xop = valuePop(ctxt);
if (xop == NULL || xmlXPathCheckError(ctxt))
return;
rv = extBitStringVal(ctxt, xop);
if (rv == NULL)
return;
xop = valuePop(ctxt);
if (xop == NULL || xmlXPathCheckError(ctxt))
return;
lv = extBitStringVal(ctxt, xop);
if (lv == NULL) {
xmlFree(rv);
return;
}
llen = xmlStrlen(lv);
rlen = xmlStrlen(rv);
width = (llen > rlen) ? llen : rlen;
res = xmlMalloc(width + 1);
if (res) {
res[width] = '\0';
for (i = 0; i < width; i++) {
xmlChar lb = (i >= width - llen) ? lv[i - (width - llen)] : '0';
xmlChar rb = (i >= width - rlen) ? rv[i - (width - rlen)] : '0';
res[i] = (*func)(lb, rb);
}
}
slaxLog("bit:%s:: %d [%s] -> [%s] == [%s]", name, width, lv, rv, res);
xmlFree(lv);
xmlFree(rv);
xmlXPathReturnString(ctxt, res);
}
static void
extBitFromHex (xmlXPathParserContextPtr ctxt, int nargs)
{
xmlChar *res;
int maxw = 0, width = 0, i;
unsigned long long val, v2;
if (nargs != 1 && nargs != 2) {
xmlXPathSetArityError(ctxt);
return;
}
/* Pop args in reverse order */
if (nargs == 2) {
maxw = xmlXPathPopNumber(ctxt);
if (maxw < 0 || xmlXPathCheckError(ctxt))
return;
}
res = xmlXPathPopString(ctxt);
if (res == NULL || xmlXPathCheckError(ctxt))
return;
val = strtoull((char *) res, 0, 0x10);
for (width = 0, v2 = val; v2; width++, v2 /= 2)
continue;
if (width == 0) /* Gotta have one zero */
width = 1;
if (maxw < width)
maxw = width;
res = xmlRealloc(res, maxw + 1);
if (res) {
res[maxw] = '\0';
for (i = maxw - 1, v2 = val; i >= 0; i--) {
if (width-- <= 0)
res[i] = '0';
else {
res[i] = (v2 & 1) ? '1' : '0';
v2 /= 2;
}
}
}
xmlXPathReturnString(ctxt, res);
}
static void
xsltp_extension_string_lc(xmlXPathParserContextPtr ctxt, int nargs) {
xmlChar *str;
if (nargs != 1) {
xmlXPathSetArityError(ctxt);
return;
}
str = xmlXPathPopString(ctxt);
xmlXPathReturnString(ctxt, (xmlChar *) g_utf8_strdown((const gchar *) str, -1));
xmlFree(str);
}
/**
* exsltMathAtanFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Wraps #exsltMathAtan for use by the XPath processor.
*/
static void
exsltMathAtanFunction (xmlXPathParserContextPtr ctxt, int nargs) {
double ret;
if (nargs != 1) {
xmlXPathSetArityError(ctxt);
return;
}
ret = xmlXPathPopNumber(ctxt);
if (xmlXPathCheckError(ctxt))
return;
ret = exsltMathAtan(ret);
xmlXPathReturnNumber(ctxt, ret);
}
static void
extBitClearOrSet (xmlXPathParserContextPtr ctxt, int nargs, xmlChar value)
{
xmlChar *res;
int width, bitnum = 0, delta;
xmlXPathObjectPtr xop;
if (nargs != 1 && nargs != 2) {
xmlXPathSetArityError(ctxt);
return;
}
/* Pop args in reverse order */
if (nargs == 2) {
bitnum = xmlXPathPopNumber(ctxt);
if (bitnum < 0 || xmlXPathCheckError(ctxt))
return;
}
xop = valuePop(ctxt);
if (xop == NULL || xmlXPathCheckError(ctxt))
return;
res = extBitStringVal(ctxt, xop);
if (res == NULL)
return;
width = xmlStrlen(res);
delta = width - bitnum - 1;
if (delta < 0) {
xmlChar *newp = xmlRealloc(res, bitnum + 2);
if (newp == NULL)
return;
delta = -delta;
memmove(newp + delta, newp, width + 1);
newp[0] = value;
memset(newp + 1, '0', delta - 1);
res = newp;
} else {
res[delta] = value;
}
xmlXPathReturnString(ctxt, res);
}
/**
* 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) {
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;
xmlChar *str = NULL, *ret = NULL;
if ((nargs < 1) || (nargs > 2)) {
xmlXPathSetArityError(ctxt);
return;
}
if (nargs == 2) {
str = xmlXPathPopString(ctxt);
str_len = xmlUTF8Strlen(str);
str_size = xmlStrlen(str);
}
if (str_len == 0) {
if (str != NULL) xmlFree(str);
str = xmlStrdup((const xmlChar *) " ");
str_len = 1;
str_size = 1;
}
number = (int) xmlXPathPopNumber(ctxt);
if (number <= 0) {
xmlXPathReturnEmptyString(ctxt);
xmlFree(str);
return;
}
while (number >= str_len) {
ret = xmlStrncat(ret, str, str_size);
number -= str_len;
}
if (number > 0) {
str_size = xmlUTF8Strsize(str, number);
ret = xmlStrncat(ret, str, str_size);
}
xmlXPathReturnString(ctxt, ret);
if (str != NULL)
xmlFree(str);
}
static void
extBitToHex (xmlXPathParserContextPtr ctxt, int nargs)
{
xmlChar *res;
xmlXPathObjectPtr xop;
unsigned long long val;
int i, len1, len2;
if (nargs != 1) {
xmlXPathSetArityError(ctxt);
return;
}
/* Pop args in reverse order */
xop = valuePop(ctxt);
if (xop == NULL || xmlXPathCheckError(ctxt))
return;
res = extBitStringVal(ctxt, xop);
if (res == NULL)
return;
for (i = 0, val = 0; i <= 64 && res[i]; i++) {
val <<= 1;
if (res[i] == '1')
val += 1;
}
if (i > 64)
xmlXPathReturnNumber(ctxt, (double) -1);
else {
len1 = xmlStrlen(res);
len2 = snprintf((char *) res, len1 + 1, "0x%qx", val);
if (len2 > len1) {
res = xmlRealloc(res, len2 + 1);
if (res)
snprintf((char *) res, len2 + 1, "0x%qx", val);
}
xmlXPathReturnString(ctxt, res);
}
}
/**
* exsltMathConstantFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Wraps #exsltMathConstant for use by the XPath processor.
*/
static void
exsltMathConstantFunction (xmlXPathParserContextPtr ctxt, int nargs) {
double ret;
xmlChar *name;
if (nargs != 2) {
xmlXPathSetArityError(ctxt);
return;
}
ret = xmlXPathPopNumber(ctxt);
if (xmlXPathCheckError(ctxt))
return;
name = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt))
return;
ret = exsltMathConstant(name, ret);
xmlXPathReturnNumber(ctxt, ret);
}
/**
* exsltMathPower:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Wraps #exsltMathPower for use by the XPath processor.
*/
static void
exsltMathPowerFunction (xmlXPathParserContextPtr ctxt, int nargs) {
double ret, base;
if (nargs != 2) {
xmlXPathSetArityError(ctxt);
return;
}
ret = xmlXPathPopNumber(ctxt);
if (xmlXPathCheckError(ctxt))
return;
/* power */
base = xmlXPathPopNumber(ctxt);
if (xmlXPathCheckError(ctxt))
return;
ret = exsltMathPower(base, ret);
xmlXPathReturnNumber(ctxt, ret);
}
static void
exsltObjectTypeFunction (xmlXPathParserContextPtr ctxt, int nargs) {
xmlXPathObjectPtr obj, ret;
if (nargs != 1) {
xmlXPathSetArityError(ctxt);
return;
}
obj = valuePop(ctxt);
switch (obj->type) {
case XPATH_STRING:
ret = xmlXPathNewCString("string");
break;
case XPATH_NUMBER:
ret = xmlXPathNewCString("number");
break;
case XPATH_BOOLEAN:
ret = xmlXPathNewCString("boolean");
break;
case XPATH_NODESET:
ret = xmlXPathNewCString("node-set");
break;
case XPATH_XSLT_TREE:
ret = xmlXPathNewCString("RTF");
break;
case XPATH_USERS:
ret = xmlXPathNewCString("external");
break;
default:
xsltGenericError(xsltGenericErrorContext,
"object-type() invalid arg\n");
ctxt->error = XPATH_INVALID_TYPE;
xmlXPathFreeObject(obj);
return;
}
xmlXPathFreeObject(obj);
valuePush(ctxt, ret);
}
/**
* exsltCryptoPopString:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Helper function which checks for and returns first string argument and its length
*/
static int
exsltCryptoPopString (xmlXPathParserContextPtr ctxt, int nargs,
xmlChar ** str) {
int str_len = 0;
if ((nargs < 1) || (nargs > 2)) {
xmlXPathSetArityError (ctxt);
return 0;
}
*str = xmlXPathPopString (ctxt);
str_len = xmlUTF8Strlen (*str);
if (str_len == 0) {
xmlXPathReturnEmptyString (ctxt);
xmlFree (*str);
return 0;
}
return str_len;
}
/**
* 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) {
xmlXPathReturnEmptyString(ctxt);
xmlFree(str);
return;
}
ret = xmlURIEscapeStr(str,(const xmlChar *)(escape_all?"-_.!~*'()":"-_.!~*'();/?:@&=+$,[]"));
xmlXPathReturnString(ctxt, ret);
if (str != NULL)
xmlFree(str);
}
static void
extBitFromInt (xmlXPathParserContextPtr ctxt, int nargs)
{
xmlChar *res;
xmlXPathObjectPtr xop;
int width = 0, len;
if (nargs != 1 && nargs != 2) {
xmlXPathSetArityError(ctxt);
return;
}
/* Pop args in reverse order */
if (nargs == 2) {
width = xmlXPathPopNumber(ctxt);
if (width < 0 || xmlXPathCheckError(ctxt))
return;
}
xop = valuePop(ctxt);
if (xop == NULL || xmlXPathCheckError(ctxt))
return;
res = extBitStringVal(ctxt, xop);
if (res == NULL)
return;
len = xmlStrlen(res);
if (width > len) {
res = xmlRealloc(res, width + 1);
if (res) {
int count = width - len;
memmove(res + count, res, len + 1);
memset(res, '0', count);
}
}
xmlXPathReturnString(ctxt, res);
}
static void
extBitMask (xmlXPathParserContextPtr ctxt, int nargs)
{
xmlChar *res;
int width, maxw = 0;
if (nargs != 1 && nargs != 2) {
xmlXPathSetArityError(ctxt);
return;
}
/* Pop args in reverse order */
if (nargs == 2) {
maxw = xmlXPathPopNumber(ctxt);
if (maxw < 0 || xmlXPathCheckError(ctxt))
return;
}
width = xmlXPathPopNumber(ctxt);
if (width < 0 || xmlXPathCheckError(ctxt))
return;
if (maxw < width) /* maxw cannot be < width */
maxw = width;
if (maxw < 1) /* At least make one zero */
maxw = 1;
res = xmlMalloc(maxw + 1);
if (res) {
res[maxw] = '\0';
if (maxw > width)
memset(res, '0', maxw - width);
memset(res + maxw - width, '1', width);
}
xmlXPathReturnString(ctxt, res);
}
/**
* 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);
}
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);
}
