自学教程：C++ xmlXPathSetArityError函数代码示例

/** * exsltMathLowestFunction: * @ctxt:  an XPath parser context * @nargs:  the number of arguments * * Wraps #exsltMathLowest for use by the XPath processor */static voidexsltMathLowestFunction (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 voidextBitNot (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 voidexsltMathMaxFunction (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 voidextBitToInt (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 voidxsltp_extension_string_rtrim(xmlXPathParserContextPtr ctxt, int nargs) {    if (nargs != 1) {        xmlXPathSetArityError(ctxt);        return;    }    xmlXPathReturnString(ctxt, _xsltp_extension_string_rtrim(xmlXPathPopString(ctxt)));}

static voidextBitCompare (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 voidexsltStrAlignFunction (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 voidexsltCryptoRc4DecryptFunction (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 voidexsltRegexpTestFunction (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 voidexsltNodeSetFunction (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 voidexsltMathRandomFunction (xmlXPathParserContextPtr ctxt, int nargs) {    double ret;    if (nargs != 0) {	xmlXPathSetArityError(ctxt);	return;    }    ret = exsltMathRandom();    xmlXPathReturnNumber(ctxt, ret);}

static voidextBitOperation (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 voidextBitFromHex (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 voidxsltp_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 voidexsltMathAtanFunction (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 voidextBitClearOrSet (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 voidexsltStrDecodeUriFunction (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 voidexsltStrPaddingFunction (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 voidextBitToHex (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 voidexsltMathConstantFunction (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 voidexsltMathPowerFunction (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 voidexsltObjectTypeFunction (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 intexsltCryptoPopString (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 voidexsltStrEncodeUriFunction (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 voidextBitFromInt (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 voidextBitMask (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 voidexsltStrConcatFunction (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 voidxsltp_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);}