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

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

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

/** * exsltMathMinFunction: * @ctxt:  an XPath parser context * @nargs:  the number of arguments * * Wraps #exsltMathMin for use by the XPath processor. */static voidexsltMathMinFunction (xmlXPathParserContextPtr ctxt, int nargs) {    xmlNodeSetPtr ns;    double ret;    void *user = NULL;    if (nargs != 1) {	xsltGenericError(xsltGenericErrorContext,			 "math:min: invalid number of arguments/n");	ctxt->error = XPATH_INVALID_ARITY;	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 = exsltMathMin(ns);    xmlXPathFreeNodeSet(ns);    if (user != NULL)        xmlFreeNodeList((xmlNodePtr)user);    xmlXPathReturnNumber(ctxt, ret);}

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

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

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

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

/** * exsltMathAtan2Function: * @ctxt:  an XPath parser context * @nargs:  the number of arguments * * Wraps #exsltMathAtan2 for use by the XPath processor. */static voidexsltMathAtan2Function (xmlXPathParserContextPtr ctxt, int nargs) {    double ret, y;    if (nargs != 2) {	xmlXPathSetArityError(ctxt);	return;    }    y = xmlXPathPopNumber(ctxt);    if (xmlXPathCheckError(ctxt))	return;    /* x */    ret = xmlXPathPopNumber(ctxt);    if (xmlXPathCheckError(ctxt))	return;    ret = exsltMathAtan2(y, ret);    xmlXPathReturnNumber(ctxt, ret);}

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

/** * exsltMathAcosFunction: * @ctxt:  an XPath parser context * @nargs:  the number of arguments * * Wraps #exsltMathAcos for use by the XPath processor. */static voidexsltMathAcosFunction (xmlXPathParserContextPtr ctxt, int nargs) {    double ret;    if (nargs != 1) {	xmlXPathSetArityError(ctxt);	return;    }    ret = xmlXPathPopNumber(ctxt);    if (xmlXPathCheckError(ctxt))	return;    ret = exsltMathAcos(ret);    xmlXPathReturnNumber(ctxt, ret);}

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

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

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

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

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

/** * 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,//.........这里部分代码省略.........

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

/** This extension function is designed to be used in a sanity test with an * XPath expression like this: * "//entry[ fd:unbalanced-braces(.//orth | .//tr | .//note | .//def | .//q) ]" * Before its use, a namespace prefix like "fd" has to be bound to * FREEDICT_EDITOR_NAMESPACE. */static void freedict_xpath_extension_unbalanced_braces(    xmlXPathParserContextPtr ctxt, const int nargs){  if(nargs != 1)  {    xmlXPathSetArityError(ctxt);    return;  }  xmlNodeSetPtr ns = xmlXPathPopNodeSet(ctxt);  if(xmlXPathCheckError(ctxt) || !ns)  {    xmlXPathFreeNodeSet(ns);    return;  }  // function that does the actual parsing  // returns TRUE if a brace of the string in c does not have  // a corresponding brace  gboolean contains_unbalanced_braces(xmlChar *c)  {    if(!c) return FALSE;    char stack[100];    int stackend = sizeof(stack);    // returns FALSE on stack full    gboolean cub_push(const char b)    {      if(!stackend)      {        g_printerr(G_STRLOC ": Too many open braces");        return FALSE;      }      stack[--stackend] = b;      return TRUE;    }    gchar cub_pop()    {      // stack is empty      if(stackend>=sizeof(stack)) return 'E';      return stack[stackend++];    }    do    {      switch(*c)      {        case '(': if(!cub_push('(')) return TRUE; break;        case '[': if(!cub_push('[')) return TRUE; break;        case '{': if(!cub_push('{')) return TRUE; break;        case ')': if(cub_pop()!='(') return TRUE;break;        case ']': if(cub_pop()!='[') return TRUE;break;        case '}': if(cub_pop()!='{') return TRUE;break;        // all other characters are skipped      }      c++;    }    while(*c);    // braces left open?    if(cub_pop()!='E') return TRUE;    // this string is well formed in regard of braces    return FALSE;  }  int result = FALSE;  int i;  for(i=0; i < xmlXPathNodeSetGetLength(ns); i++)  {    xmlNodePtr n = xmlXPathNodeSetItem(ns, i);    xmlChar* c = xmlNodeGetContent(n);    if(!c) continue;    result = contains_unbalanced_braces(c);    xmlFree(c);    if(result) break;  }  if(ns) xmlXPathFreeNodeSet(ns);  xmlXPathReturnBoolean(ctxt, result);}

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

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