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

/** * 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 void XSLPattern_OP_IGEq(xmlXPathParserContextPtr pctx, int nargs){    xmlChar *arg1, *arg2;    XSLPATTERN_CHECK_ARGS(2);    arg2 = xmlXPathPopString(pctx);    arg1 = xmlXPathPopString(pctx);    xmlXPathReturnBoolean(pctx, xmlStrcasecmp(arg1, arg2) >= 0);    xmlFree(arg1);    xmlFree(arg2);}

// 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 xmlChar *extBitStringVal (xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr xop){    if (xop->type == XPATH_NUMBER) {	xmlChar *res;	int width;	unsigned long long val = xop->floatval, v2;	if (xop->floatval >= pow(2, 64))	    val = (unsigned long long) -1;	xmlXPathFreeObject(xop);	for (width = 0, v2 = val; v2; width++, v2 /= 2)	    continue;	if (width == 0)		/* Gotta have one zero */	    width = 1;	res = xmlMalloc(width + 1);	if (res == NULL)	    return NULL;	res[width] = '/0';	for (width--, v2 = val; width >= 0; width--, v2 /= 2)	    res[width] = (v2 & 1) ? '1' : '0';	return res;    }    /* Make libxml do the work for us */    valuePush(ctxt, xop);    return xmlXPathPopString(ctxt);}

static voidexsltDynEvaluateFunction(xmlXPathParserContextPtr ctxt, int nargs) {	xmlChar *str = NULL;	xmlXPathObjectPtr ret = NULL;	if (ctxt == NULL)		return;	if (nargs != 1) {		xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);        xsltGenericError(xsltGenericErrorContext,			"dyn:evalute() : invalid number of args %d/n", nargs);		ctxt->error = XPATH_INVALID_ARITY;		return;	}	str = xmlXPathPopString(ctxt);		if (!str||!xmlStrlen(str)) {		if (str) xmlFree(str);		valuePush(ctxt,xmlXPathNewNodeSet(NULL));		return;	}	ret = xmlXPathEval(str,ctxt->context);	if (ret)		valuePush(ctxt,ret); 	else {		xsltGenericError(xsltGenericErrorContext,			"dyn:evaluate() : unable to evaluate expression '%s'/n",str);		valuePush(ctxt,xmlXPathNewNodeSet(NULL));	}		xmlFree(str);	return;}

// 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);}

/** * 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);}

static voidxsltp_extension_string_rtrim(xmlXPathParserContextPtr ctxt, int nargs) {    if (nargs != 1) {        xmlXPathSetArityError(ctxt);        return;    }    xmlXPathReturnString(ctxt, _xsltp_extension_string_rtrim(xmlXPathPopString(ctxt)));}

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);    }}

/** * 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 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);}

/** * 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);}

/** * 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);}

/** * 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;}

/** * exsltCryptoRc4EncryptFunction: * @ctxt: an XPath parser context * @nargs: the number of arguments * * computes the sha1 hash of a string and returns as hex */static voidexsltCryptoRc4EncryptFunction (xmlXPathParserContextPtr ctxt, int nargs) {    int key_len = 0, key_size = 0;    int str_len = 0, bin_len = 0, hex_len = 0;    xmlChar *key = NULL, *str = NULL, *padkey = NULL;    xmlChar *bin = NULL, *hex = 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));/* encrypt it */    bin_len = str_len;    bin = xmlStrdup (str);    if (bin == NULL) {	xmlXPathReturnEmptyString (ctxt);	goto done;    }    PLATFORM_RC4_ENCRYPT (ctxt, padkey, str, str_len, bin, bin_len);/* encode it */    hex_len = str_len * 2 + 1;    hex = xmlMallocAtomic (hex_len);    if (hex == NULL) {	xmlXPathReturnEmptyString (ctxt);	goto done;    }    exsltCryptoBin2Hex (bin, str_len, hex, hex_len);    xmlXPathReturnString (ctxt, hex);done:    if (key != NULL)	xmlFree (key);    if (str != NULL)	xmlFree (str);    if (padkey != NULL)	xmlFree (padkey);    if (bin != NULL)	xmlFree (bin);}

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);}

static voidexsltRegexpReplaceFunction (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);}

/** * 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 voidexsltStrReplaceFunction (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]);//.........这里部分代码省略.........

static voidexsltRegexpMatchFunction (xmlXPathParserContextPtr ctxt, int nargs){    xsltTransformContextPtr tctxt;    xmlNodePtr node;    xmlDocPtr container;    xmlXPathObjectPtr ret = NULL;    xmlChar *haystack, *regexp, *flagstr, *working, *match;    int rc, x, flags, global, ovector[30];    if ((nargs < 1) || (nargs > 3)) {        xmlXPathSetArityError(ctxt);        return;    }    if (nargs > 2) {      flagstr = xmlXPathPopString(ctxt);      if (xmlXPathCheckError(ctxt) || (flagstr == NULL)) {          return;      }    } else {     flagstr = xmlStrdup("");    }        regexp = xmlXPathPopString(ctxt);    if (xmlXPathCheckError(ctxt) || (regexp == NULL)) {        xmlFree(flagstr);        return;    }    haystack = xmlXPathPopString(ctxt);    if (xmlXPathCheckError(ctxt) || (haystack == NULL)) {        xmlFree(regexp);        xmlFree(flagstr);        return;    }    /* Return a result tree fragment */    tctxt = xsltXPathGetTransformContext(ctxt);    if (tctxt == NULL) {      xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,                         "exslt:regexp : internal error tctxt == NULL/n");      goto fail;    }    container = xsltCreateRVT(tctxt);    if (container != NULL) {      xsltRegisterTmpRVT(tctxt, container);      ret = xmlXPathNewNodeSet(NULL);      if (ret != NULL) {        ret->boolval = 0;         exsltRegexpFlagsFromString(flagstr, &global, &flags);        working = haystack;        rc = exsltRegexpExecute(ctxt, working, regexp, flags,                                 ovector, sizeof(ovector)/sizeof(int));        while (rc > 0) {          for(int group = 0; group < rc; group++) {            match = xmlStrsub(working, ovector[group*2], ovector[group*2+1]-ovector[group*2]);            if (NULL == match) goto fail;            node = xmlNewDocRawNode(container, NULL, "match", match);            xmlFree(match);            xmlAddChild((xmlNodePtr) container, node);            xmlXPathNodeSetAddUnique(ret->nodesetval, node);          }          if (!global) break;          working = working + ovector[1];          rc = exsltRegexpExecute(ctxt, working, regexp, flags,                                   ovector, sizeof(ovector)/sizeof(int));        }      }    }     fail:    if (flagstr != NULL)      xmlFree(flagstr);    if (regexp != NULL)      xmlFree(regexp);    if (haystack != NULL)      xmlFree(haystack);    if (ret != NULL)      valuePush(ctxt, ret);    else      valuePush(ctxt, xmlXPathNewNodeSet(NULL));}

/** * 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 voidexsltStrTokenizeFunction(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 = xmlUTF8Size(cur);		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 += xmlUTF8Size(delimiter)) {                    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);            }	    /*	     * Mark it as a function result in order to avoid garbage	     * collecting of tree fragments	     */	    xsltExtensionInstructionResultRegister(tctxt, ret);        }    }fail:    if (str != NULL)//.........这里部分代码省略.........

/** * 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;    xsltTransformContextPtr tctxt = NULL;    if (nargs != 2) {	xmlXPathSetArityError (ctxt);	return;    }    tctxt = xsltXPathGetTransformContext(ctxt);    str = xmlXPathPopString (ctxt);    str_len = xmlUTF8Strlen (str);    if (str_len == 0) {	xmlXPathReturnEmptyString (ctxt);	xmlFree (str);	return;    }    key = xmlXPathPopString (ctxt);    key_len = xmlUTF8Strlen (key);    if (key_len == 0) {	xmlXPathReturnEmptyString (ctxt);	xmlFree (key);	xmlFree (str);	return;    }    padkey = xmlMallocAtomic (RC4_KEY_LENGTH + 1);    if (padkey == NULL) {	xsltTransformError(tctxt, NULL, tctxt->inst,	    "exsltCryptoRc4EncryptFunction: Failed to allocate padkey/n");	tctxt->state = XSLT_STATE_STOPPED;	xmlXPathReturnEmptyString (ctxt);	goto done;    }    memset(padkey, 0, RC4_KEY_LENGTH + 1);    key_size = xmlUTF8Strsize (key, key_len);    if ((key_size > RC4_KEY_LENGTH) || (key_size < 0)) {	xsltTransformError(tctxt, NULL, tctxt->inst,	    "exsltCryptoRc4EncryptFunction: key size too long or key broken/n");	tctxt->state = XSLT_STATE_STOPPED;	xmlXPathReturnEmptyString (ctxt);	goto done;    }    memcpy (padkey, key, key_size);/* decode hex to binary */    bin_len = str_len;    bin = xmlMallocAtomic (bin_len);    if (bin == NULL) {	xsltTransformError(tctxt, NULL, tctxt->inst,	    "exsltCryptoRc4EncryptFunction: Failed to allocate string/n");	tctxt->state = XSLT_STATE_STOPPED;	xmlXPathReturnEmptyString (ctxt);	goto done;    }    ret_len = exsltCryptoHex2Bin (str, str_len, bin, bin_len);/* decrypt the binary blob */    ret = xmlMallocAtomic (ret_len);    if (ret == NULL) {	xsltTransformError(tctxt, NULL, tctxt->inst,	    "exsltCryptoRc4EncryptFunction: Failed to allocate result/n");	tctxt->state = XSLT_STATE_STOPPED;	xmlXPathReturnEmptyString (ctxt);	goto done;    }    PLATFORM_RC4_DECRYPT (ctxt, padkey, bin, ret_len, ret, ret_len);    xmlXPathReturnString (ctxt, ret);done:    if (key != NULL)	xmlFree (key);    if (str != NULL)	xmlFree (str);    if (padkey != NULL)	xmlFree (padkey);    if (bin != NULL)	xmlFree (bin);}

/** * 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 voidexsltStrSplitFunction(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);	    }	    /*	     * Mark it as a function result in order to avoid garbage	     * collecting of tree fragments	     */	    xsltExtensionInstructionResultRegister(tctxt, ret);        }    }//.........这里部分代码省略.........

/** * 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 voidexsltStrReplaceFunction (xmlXPathParserContextPtr ctxt, int nargs) {    xmlChar *str = NULL, *searchStr = NULL, *replaceStr = NULL;    xmlNodeSetPtr replaceSet = NULL, searchSet = NULL;    xmlChar *ret = NULL, *retSwap = NULL;    int i;    if (nargs  != 3) {        xmlXPathSetArityError(ctxt);        return;    }    /* pull out replace argument */    if (!xmlXPathStackIsNodeSet(ctxt)) {        replaceStr = xmlXPathPopString(ctxt);    }    else {        replaceSet = xmlXPathPopNodeSet(ctxt);        if (xmlXPathCheckError(ctxt)) {            xmlXPathSetTypeError(ctxt);            goto fail;        }    }    /* behavior driven by search argument from here on */    if (!xmlXPathStackIsNodeSet(ctxt)) {        searchStr = xmlXPathPopString(ctxt);        str = xmlXPathPopString(ctxt);        if (replaceStr == NULL) {            xmlXPathSetTypeError(ctxt);            goto fail;        }        ret = exsltStrReplaceInternal(str, searchStr, replaceStr);    }    else {        searchSet = xmlXPathPopNodeSet(ctxt);        if (searchSet == NULL || xmlXPathCheckError(ctxt)) {            xmlXPathSetTypeError(ctxt);            goto fail;        }        str = xmlXPathPopString(ctxt);        ret = xmlStrdup(str);        for (i = 0; i < searchSet->nodeNr; i++) {            searchStr = xmlXPathCastNodeToString(searchSet->nodeTab[i]);            if (replaceSet != NULL) {                replaceStr = NULL;                if (i < replaceSet->nodeNr) {                    replaceStr = xmlXPathCastNodeToString(replaceSet->nodeTab[i]);                }                retSwap = exsltStrReplaceInternal(ret, searchStr, replaceStr);                if (replaceStr != NULL) {                    xmlFree(replaceStr);                    replaceStr = NULL;                }            }            else {                retSwap = exsltStrReplaceInternal(ret, searchStr, replaceStr);            }            xmlFree(ret);            if (searchStr != NULL) {                xmlFree(searchStr);                searchStr = NULL;            }            ret = retSwap;        }        if (replaceSet != NULL)            xmlXPathFreeNodeSet(replaceSet);        if (searchSet != NULL)            xmlXPathFreeNodeSet(searchSet);    }    xmlXPathReturnString(ctxt, ret);fail:    if (replaceStr != NULL)        xmlFree(replaceStr);    if (searchStr != NULL)        xmlFree(searchStr);    if (str != NULL)//.........这里部分代码省略.........

static voidexsltDynMapFunction(xmlXPathParserContextPtr ctxt, int nargs){    xmlChar *str = NULL;    xmlNodeSetPtr nodeset = NULL;    xsltTransformContextPtr tctxt;    xmlXPathCompExprPtr comp = NULL;    xmlXPathObjectPtr ret = NULL;    xmlDocPtr oldDoc, container = NULL;    xmlNodePtr oldNode;    int oldContextSize;    int oldProximityPosition;    int i, j;    if (nargs != 2) {        xmlXPathSetArityError(ctxt);        return;    }    str = xmlXPathPopString(ctxt);    if (xmlXPathCheckError(ctxt)) {        xmlXPathSetTypeError(ctxt);        return;    }    nodeset = xmlXPathPopNodeSet(ctxt);    if (xmlXPathCheckError(ctxt)) {        xmlXPathSetTypeError(ctxt);        return;    }    if (str == NULL || !xmlStrlen(str) || !(comp = xmlXPathCompile(str))) {        if (nodeset != NULL)            xmlXPathFreeNodeSet(nodeset);        if (str != NULL)            xmlFree(str);        valuePush(ctxt, xmlXPathNewNodeSet(NULL));        return;    }    ret = xmlXPathNewNodeSet(NULL);    if (ret == NULL) {        xsltGenericError(xsltGenericErrorContext,                         "exsltDynMapFunction: ret == NULL/n");        goto cleanup;    }    oldDoc = ctxt->context->doc;    oldNode = ctxt->context->node;    oldContextSize = ctxt->context->contextSize;    oldProximityPosition = ctxt->context->proximityPosition;    tctxt = xsltXPathGetTransformContext(ctxt);    if (tctxt == NULL) {	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,	      "dyn:map : internal error tctxt == NULL/n");	goto cleanup;    }    container = xsltCreateRVT(tctxt);    if (container == NULL) {	xsltTransformError(tctxt, NULL, NULL,	      "dyn:map : internal error container == NULL/n");	goto cleanup;    }    xsltRegisterLocalRVT(tctxt, container);    if (nodeset && nodeset->nodeNr > 0) {        xmlXPathNodeSetSort(nodeset);        ctxt->context->contextSize = nodeset->nodeNr;        ctxt->context->proximityPosition = 0;        for (i = 0; i < nodeset->nodeNr; i++) {            xmlXPathObjectPtr subResult = NULL;            ctxt->context->proximityPosition++;            ctxt->context->node = nodeset->nodeTab[i];            ctxt->context->doc = nodeset->nodeTab[i]->doc;            subResult = xmlXPathCompiledEval(comp, ctxt->context);            if (subResult != NULL) {                switch (subResult->type) {                    case XPATH_NODESET:                        if (subResult->nodesetval != NULL)                            for (j = 0; j < subResult->nodesetval->nodeNr;                                 j++)                                xmlXPathNodeSetAdd(ret->nodesetval,                                                   subResult->nodesetval->                                                   nodeTab[j]);                        break;                    case XPATH_BOOLEAN:                        if (container != NULL) {                            xmlNodePtr cur =                                xmlNewChild((xmlNodePtr) container, NULL,                                            BAD_CAST "boolean",                                            BAD_CAST (subResult->                                            boolval ? "true" : ""));                            if (cur != NULL) {                                cur->ns =                                    xmlNewNs(cur,                                             BAD_CAST                                             "http://exslt.org/common",                                             BAD_CAST "exsl");                                xmlXPathNodeSetAddUnique(ret->nodesetval,//.........这里部分代码省略.........

/** * 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 voidexsltStrTokenizeFunction(xmlXPathParserContextPtr ctxt, int nargs){    xsltTransformContextPtr tctxt;    xmlChar *str, *delimiters, *cur;    const xmlChar *token, *delimiter;    xmlNodePtr node;    xmlDocPtr container;    xmlXPathObjectPtr ret = NULL;    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) {        xsltRegisterTmpRVT(tctxt, container);        ret = xmlXPathNewNodeSet(NULL);        if (ret != NULL) {            ret->boolval = 0; /* Freeing is not handled there anymore */            for (cur = str, token = str; *cur != 0; cur++) {                for (delimiter = delimiters; *delimiter != 0; delimiter++) {                    if (*cur == *delimiter) {                        if (cur == token) {                            /* discard empty tokens */                            token = cur + 1;                            break;                        }                        *cur = 0;                        node = xmlNewDocRawNode(container, NULL,                                           (const xmlChar *) "token", token);			xmlAddChild((xmlNodePtr) container, node);			xmlXPathNodeSetAddUnique(ret->nodesetval, node);                        *cur = *delimiter;                        token = cur + 1;                        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));}