/**
* xsltUnparsedEntityURIFunction:
* @ctxt: the XPath Parser context
* @nargs: the number of arguments
*
* Implement the unparsed-entity-uri() XSLT function
* string unparsed-entity-uri(string)
*/
void
xsltUnparsedEntityURIFunction(xmlXPathParserContextPtr ctxt, int nargs){
xmlXPathObjectPtr obj;
xmlChar *str;
if ((nargs != 1) || (ctxt->value == NULL)) {
xsltGenericError(xsltGenericErrorContext,
"unparsed-entity-uri() : expects one string arg\n");
ctxt->error = XPATH_INVALID_ARITY;
return;
}
obj = valuePop(ctxt);
if (obj->type != XPATH_STRING) {
obj = xmlXPathConvertString(obj);
}
str = obj->stringval;
if (str == NULL) {
valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
} else {
xmlEntityPtr entity;
entity = xmlGetDocEntity(ctxt->context->doc, str);
if (entity == NULL) {
valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
} else {
if (entity->URI != NULL)
valuePush(ctxt, xmlXPathNewString(entity->URI));
else
valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
}
}
xmlXPathFreeObject(obj);
}
static void
exsltDynEvaluateFunction(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;
}
/**
* xsltElementAvailableFunction:
* @ctxt: the XPath Parser context
* @nargs: the number of arguments
*
* Implement the element-available() XSLT function
* boolean element-available(string)
*/
void
xsltElementAvailableFunction(xmlXPathParserContextPtr ctxt, int nargs){
xmlXPathObjectPtr obj;
xmlChar *prefix, *name;
const xmlChar *nsURI = NULL;
xsltTransformContextPtr tctxt;
if (nargs != 1) {
xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
"element-available() : expects one string arg\n");
ctxt->error = XPATH_INVALID_ARITY;
return;
}
xmlXPathStringFunction(ctxt, 1);
if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
"element-available() : invalid arg expecting a string\n");
ctxt->error = XPATH_INVALID_TYPE;
return;
}
obj = valuePop(ctxt);
tctxt = xsltXPathGetTransformContext(ctxt);
if (tctxt == NULL) {
xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
"element-available() : internal error tctxt == NULL\n");
xmlXPathFreeObject(obj);
valuePush(ctxt, xmlXPathNewBoolean(0));
return;
}
name = xmlSplitQName2(obj->stringval, &prefix);
if (name == NULL) {
xmlNsPtr ns;
name = xmlStrdup(obj->stringval);
ns = xmlSearchNs(tctxt->inst->doc, tctxt->inst, NULL);
if (ns != NULL) nsURI = xmlStrdup(ns->href);
} else {
nsURI = xmlXPathNsLookup(ctxt->context, prefix);
if (nsURI == NULL) {
xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
"element-available() : prefix %s is not bound\n", prefix);
}
}
if (xsltExtElementLookup(tctxt, name, nsURI) != NULL) {
valuePush(ctxt, xmlXPathNewBoolean(1));
} else {
valuePush(ctxt, xmlXPathNewBoolean(0));
}
xmlXPathFreeObject(obj);
if (name != NULL)
xmlFree(name);
if (prefix != NULL)
xmlFree(prefix);
}
static void
gda_xslt_getnodeset_function (xmlXPathParserContextPtr ctxt, int nargs)
{
GdaXsltIntCont *data;
xsltTransformContextPtr tctxt;
xmlXPathObjectPtr setname, nodeset;
GdaXsltExCont *execc;
if (nargs != 1) {
xsltGenericError (xsltGenericErrorContext,
"gda_xslt_getnodeset_function: invalid number of arguments\n");
return;
}
tctxt = xsltXPathGetTransformContext (ctxt);
if (tctxt == NULL) {
xsltGenericError (xsltGenericErrorContext,
"sqlxslt: failed to get the transformation context\n");
return;
}
execc = (GdaXsltExCont *) tctxt->_private;
data = (GdaXsltIntCont *) xsltGetExtData (tctxt,
BAD_CAST GDA_XSLT_EXTENSION_URI);
if (data == NULL) {
xsltGenericError (xsltGenericErrorContext,
"sqlxslt: failed to get module data\n");
return;
}
setname = valuePop (ctxt);
if (setname == NULL) {
xsltGenericError (xsltGenericErrorContext,
"sqlxslt: internal error\n");
return;
}
if (setname->type != XPATH_STRING) {
valuePush (ctxt, setname);
xmlXPathStringFunction (ctxt, 1);
setname = valuePop (ctxt);
if (setname == NULL) {
xsltGenericError (xsltGenericErrorContext,
"sqlxslt: internal error\n");
return;
}
}
nodeset =
_gda_xslt_bk_fun_getnodeset (setname->stringval, execc, data);
if (nodeset == NULL) {
xsltGenericError (xsltGenericErrorContext,
"exsltDynMapFunctoin: ret == NULL\n");
return;
}
valuePush (ctxt, nodeset);
}
/**
* xsltGenerateIdFunction:
* @ctxt: the XPath Parser context
* @nargs: the number of arguments
*
* Implement the generate-id() XSLT function
* string generate-id(node-set?)
*/
void
xsltGenerateIdFunction(xmlXPathParserContextPtr ctxt, int nargs){
static char base_address;
xmlNodePtr cur = NULL;
xmlXPathObjectPtr obj = NULL;
long val;
xmlChar str[30];
if (nargs == 0) {
cur = ctxt->context->node;
} else if (nargs == 1) {
xmlNodeSetPtr nodelist;
int i, ret;
if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_NODESET)) {
ctxt->error = XPATH_INVALID_TYPE;
xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
"generate-id() : invalid arg expecting a node-set\n");
return;
}
obj = valuePop(ctxt);
nodelist = obj->nodesetval;
if ((nodelist == NULL) || (nodelist->nodeNr <= 0)) {
xmlXPathFreeObject(obj);
valuePush(ctxt, xmlXPathNewCString(""));
return;
}
cur = nodelist->nodeTab[0];
for (i = 1;i < nodelist->nodeNr;i++) {
ret = xmlXPathCmpNodes(cur, nodelist->nodeTab[i]);
if (ret == -1)
cur = nodelist->nodeTab[i];
}
} else {
xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
"generate-id() : invalid number of args %d\n", nargs);
ctxt->error = XPATH_INVALID_ARITY;
return;
}
if (obj)
xmlXPathFreeObject(obj);
val = (long)((char *)cur - (char *)&base_address);
if (val >= 0) {
snprintf((char *)str, sizeof(str), "idp%ld", val);
} else {
snprintf((char *)str, sizeof(str), "idm%ld", -val);
}
valuePush(ctxt, xmlXPathNewString(str));
}
/**
* xsltGenerateIdFunction:
* @ctxt: the XPath Parser context
* @nargs: the number of arguments
*
* Implement the generate-id() XSLT function
* string generate-id(node-set?)
*/
void
xsltGenerateIdFunction(xmlXPathParserContextPtr ctxt, int nargs){
xmlNodePtr cur = NULL;
unsigned long val;
xmlChar str[20];
if (nargs == 0) {
cur = ctxt->context->node;
} else if (nargs == 1) {
xmlXPathObjectPtr obj;
xmlNodeSetPtr nodelist;
int i, ret;
if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_NODESET)) {
ctxt->error = XPATH_INVALID_TYPE;
xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt),
NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"generate-id() : invalid arg expecting a node-set\n");
return;
}
obj = valuePop(ctxt);
nodelist = obj->nodesetval;
if ((nodelist == NULL) || (nodelist->nodeNr <= 0)) {
xmlXPathFreeObject(obj);
valuePush(ctxt, xmlXPathNewCString(""));
return;
}
cur = nodelist->nodeTab[0];
for (i = 1;i < nodelist->nodeNr;i++) {
ret = xmlXPathCmpNodes(cur, nodelist->nodeTab[i]);
if (ret == -1)
cur = nodelist->nodeTab[i];
}
xmlXPathFreeObject(obj);
} else {
xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"generate-id() : invalid number of args %d\n", nargs);
ctxt->error = XPATH_INVALID_ARITY;
return;
}
/*
* Okay this is ugly but should work, use the NodePtr address
* to forge the ID
*/
val = (unsigned long)((char *)cur - (char *)0);
val /= sizeof(xmlNode);
sprintf((char *)str, "id%ld", val);
valuePush(ctxt, xmlXPathNewString(str));
}
static void GDALGMLJP2XPathUUID(xmlXPathParserContextPtr ctxt, int nargs)
{
CHECK_ARITY(0);
CPLString osRet;
static int nCounter = 0;
srand(static_cast<unsigned int>(time(nullptr)) + nCounter);
++nCounter;
for( int i=0; i<4; i ++ )
osRet += GDALGMLJP2HexFormatter(rand() & 0xFF);
osRet += "-";
osRet += GDALGMLJP2HexFormatter(rand() & 0xFF);
osRet += GDALGMLJP2HexFormatter(rand() & 0xFF);
osRet += "-";
// Set the version number bits (4 == random).
osRet += GDALGMLJP2HexFormatter((rand() & 0x0F) | 0x40);
osRet += GDALGMLJP2HexFormatter(rand() & 0xFF);
osRet += "-";
// Set the variant bits.
osRet += GDALGMLJP2HexFormatter((rand() & 0x3F) | 0x80);
osRet += GDALGMLJP2HexFormatter(rand() & 0xFF);
osRet += "-";
for( int i = 0; i < 6; ++i )
{
// coverity[dont_call]
osRet += GDALGMLJP2HexFormatter(rand() & 0xFF);
}
valuePush(ctxt,
xmlXPathNewString(
reinterpret_cast<const xmlChar *>(osRet.c_str())));
}
/**
* exsltStrReturnString:
* @ctxt: an XPath parser context
* @str: a string
* @len: length of string
*
* Returns a string as a node set.
*/
static int
exsltStrReturnString(xmlXPathParserContextPtr ctxt, const xmlChar *str,
int len)
{
xsltTransformContextPtr tctxt = xsltXPathGetTransformContext(ctxt);
xmlDocPtr container;
xmlNodePtr text_node;
xmlXPathObjectPtr ret;
container = xsltCreateRVT(tctxt);
if (container == NULL) {
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
return(-1);
}
xsltRegisterLocalRVT(tctxt, container);
text_node = xmlNewTextLen(str, len);
if (text_node == NULL) {
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
return(-1);
}
xmlAddChild((xmlNodePtr) container, text_node);
ret = xmlXPathNewNodeSet(text_node);
if (ret == NULL) {
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
return(-1);
}
xsltExtensionInstructionResultRegister(tctxt, ret);
valuePush(ctxt, ret);
return(0);
}
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);
}
// 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);
}
/**
* xsltFunctionAvailableFunction:
* @ctxt: the XPath Parser context
* @nargs: the number of arguments
*
* Implement the function-available() XSLT function
* boolean function-available(string)
*/
void
xsltFunctionAvailableFunction(xmlXPathParserContextPtr ctxt, int nargs){
xmlXPathObjectPtr obj;
xmlChar *prefix, *name;
const xmlChar *nsURI = NULL;
if (nargs != 1) {
xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"function-available() : expects one string arg\n");
ctxt->error = XPATH_INVALID_ARITY;
return;
}
if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"function-available() : invalid arg expecting a string\n");
ctxt->error = XPATH_INVALID_TYPE;
return;
}
obj = valuePop(ctxt);
name = xmlSplitQName2(obj->stringval, &prefix);
if (name == NULL) {
name = xmlStrdup(obj->stringval);
} else {
nsURI = xmlXPathNsLookup(ctxt->context, prefix);
if (nsURI == NULL) {
xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt),
NULL, NULL);
xsltGenericError(xsltGenericErrorContext,
"function-available() : prefix %s is not bound\n", prefix);
}
}
if (xmlXPathFunctionLookupNS(ctxt->context, name, nsURI) != NULL) {
valuePush(ctxt, xmlXPathNewBoolean(1));
} else {
valuePush(ctxt, xmlXPathNewBoolean(0));
}
xmlXPathFreeObject(obj);
if (name != NULL)
xmlFree(name);
if (prefix != NULL)
xmlFree(prefix);
}
/**************************************************************************
*
* xmlSecXPathHereFunction:
* @ctxt: the ponter to XPath context.
* @nargs: the arguments nubmer.
*
* The implementation of XPath "here()" function.
* See xmlXPtrHereFunction() in xpointer.c. the only change is that
* we return NodeSet instead of NodeInterval.
*
*****************************************************************************/
static void
xmlSecXPathHereFunction(xmlXPathParserContextPtr ctxt, int nargs) {
CHECK_ARITY(0);
if((ctxt == NULL) || (ctxt->context == NULL) || (ctxt->context->here == NULL)) {
XP_ERROR(XPTR_SYNTAX_ERROR);
}
valuePush(ctxt, xmlXPathNewNodeSet(ctxt->context->here));
}
/**
* xsltCurrentFunction:
* @ctxt: the XPath Parser context
* @nargs: the number of arguments
*
* Implement the current() XSLT function
* node-set current()
*/
static void
xsltCurrentFunction(xmlXPathParserContextPtr ctxt, int nargs){
xsltTransformContextPtr tctxt;
if (nargs != 0) {
xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
"current() : function uses no argument\n");
ctxt->error = XPATH_INVALID_ARITY;
return;
}
tctxt = xsltXPathGetTransformContext(ctxt);
if (tctxt == NULL) {
xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
"current() : internal error tctxt == NULL\n");
valuePush(ctxt, xmlXPathNewNodeSet(NULL));
} else {
valuePush(ctxt, xmlXPathNewNodeSet(tctxt->node)); /* current */
}
}
void
RXSLT_source(xmlXPathParserContextPtr ctxt, int nargs)
{
Rboolean ok;
xmlXPathObjectPtr obj;
obj = valuePop(ctxt);
ok = RXSLT_internalSource(xmlXPathCastToString(obj));
valuePush(ctxt, xmlXPathNewBoolean(ok));
}
/**
* xsltFormatNumberFunction:
* @ctxt: the XPath Parser context
* @nargs: the number of arguments
*
* Implement the format-number() XSLT function
* string format-number(number, string, string?)
*/
void
xsltFormatNumberFunction(xmlXPathParserContextPtr ctxt, int nargs)
{
xmlXPathObjectPtr numberObj = NULL;
xmlXPathObjectPtr formatObj = NULL;
xmlXPathObjectPtr decimalObj = NULL;
xsltStylesheetPtr sheet;
xsltDecimalFormatPtr formatValues;
xmlChar *result;
xsltTransformContextPtr tctxt;
tctxt = xsltXPathGetTransformContext(ctxt);
if (tctxt == NULL)
return;
sheet = tctxt->style;
if (sheet == NULL)
return;
formatValues = sheet->decimalFormat;
switch (nargs) {
case 3:
CAST_TO_STRING;
decimalObj = valuePop(ctxt);
formatValues = xsltDecimalFormatGetByName(sheet, decimalObj->stringval);
if (formatValues == NULL) {
xsltTransformError(tctxt, NULL, NULL,
"format-number() : undeclared decimal format '%s'\n",
decimalObj->stringval);
}
/* Intentional fall-through */
case 2:
CAST_TO_STRING;
formatObj = valuePop(ctxt);
CAST_TO_NUMBER;
numberObj = valuePop(ctxt);
break;
default:
XP_ERROR(XPATH_INVALID_ARITY);
}
if (formatValues != NULL) {
if (xsltFormatNumberConversion(formatValues,
formatObj->stringval,
numberObj->floatval,
&result) == XPATH_EXPRESSION_OK) {
valuePush(ctxt, xmlXPathNewString(result));
xmlFree(result);
}
}
xmlXPathFreeObject(numberObj);
xmlXPathFreeObject(formatObj);
xmlXPathFreeObject(decimalObj);
}
static void
exsltNodeSetFunction (xmlXPathParserContextPtr ctxt, int nargs) {
if (nargs != 1) {
xmlXPathSetArityError(ctxt);
return;
}
if (xmlXPathStackIsNodeSet (ctxt)) {
xsltFunctionNodeSet (ctxt, nargs);
return;
} else {
xmlDocPtr fragment;
xsltTransformContextPtr tctxt = xsltXPathGetTransformContext(ctxt);
xmlNodePtr txt;
xmlChar *strval;
xmlXPathObjectPtr obj;
/*
* SPEC EXSLT:
* "You can also use this function to turn a string into a text
* node, which is helpful if you want to pass a string to a
* function that only accepts a node-set."
*/
fragment = xsltCreateRVT(tctxt);
if (fragment == NULL) {
xsltTransformError(tctxt, NULL, tctxt->inst,
"exsltNodeSetFunction: Failed to create a tree fragment.\n");
tctxt->state = XSLT_STATE_STOPPED;
return;
}
xsltRegisterLocalRVT(tctxt, fragment);
strval = xmlXPathPopString (ctxt);
txt = xmlNewDocText (fragment, strval);
xmlAddChild((xmlNodePtr) fragment, txt);
obj = xmlXPathNewNodeSet(txt);
if (obj == NULL) {
xsltTransformError(tctxt, NULL, tctxt->inst,
"exsltNodeSetFunction: Failed to create a node set object.\n");
tctxt->state = XSLT_STATE_STOPPED;
} else {
/*
* Mark it as a function result in order to avoid garbage
* collecting of tree fragments
*/
xsltExtensionInstructionResultRegister(tctxt, obj);
}
if (strval != NULL)
xmlFree (strval);
valuePush (ctxt, obj);
}
}
static void GDALGMLJP2XPathIf(xmlXPathParserContextPtr ctxt, int nargs)
{
xmlXPathObjectPtr cond_val,then_val,else_val;
CHECK_ARITY(3);
else_val = valuePop(ctxt);
then_val = valuePop(ctxt);
CAST_TO_BOOLEAN
cond_val = valuePop(ctxt);
if( cond_val->boolval )
{
xmlXPathFreeObject(else_val);
valuePush(ctxt, then_val);
}
else
{
xmlXPathFreeObject(then_val);
valuePush(ctxt, else_val);
}
xmlXPathFreeObject(cond_val);
}
void
RXSLT_callNamedFunction(const char *name, xmlXPathParserContextPtr ctxt, int nargs, int leaveAsRObject)
{
USER_OBJECT_ e, ans;
// xmlXPathObjectPtr obj;
int errorOccurred;
int i, j;
#if 0
PROTECT(e = allocVector(LANGSXP, 2));
SETCAR(e, Rf_install((char *) name));
SETCAR(CDR(e), tmp = NEW_CHARACTER(1));
obj = valuePop(ctxt);
SET_STRING_ELT(tmp, 0, COPY_TO_USER_STRING(xmlXPathCastToString(obj)));
#else
PROTECT(e = allocVector(LANGSXP, nargs+1));
SETCAR(e, Rf_install((char *) name));
#if 0
for(i = 0; i < nargs; i++) {
ans = CDR(e);
for(j = nargs-1; j > i ; j--) {
ans = CDR(ans);
}
SETCAR(ans, tmp = NEW_CHARACTER(1));
obj = valuePop(ctxt);
SET_STRING_ELT(tmp, 0, COPY_TO_USER_STRING(xmlXPathCastToString(obj)));
}
#else
for(i = 0; i < nargs; i++) {
ans = CDR(e);
for(j = nargs-1; j > i ; j--) {
ans = CDR(ans);
}
SETCAR(ans, convertFromXPath(ctxt, valuePop(ctxt)));
}
#endif
#endif
ans = R_tryEval(e, R_GlobalEnv, &errorOccurred);
if(errorOccurred) {
RXSLT_Error(ctxt, "error in call to R function");
} else {
PROTECT(ans);
valuePush(ctxt, convertToXPath(ctxt, ans));
UNPROTECT(1);
}
UNPROTECT(1);
return;
}
void
RXSLT_init(xmlXPathParserContextPtr ctxt, int nargs)
{
const char *defaultArgs[] = {"Rxsltproc", "--silent"};
char **args;
int argc, i;
int mustFree;
if(R_alreadyInitialized)
return;
#ifdef XSLT_DEBUG
fprintf(stderr, "in RXSLT_init %d\n", nargs);fflush(stderr);
#endif
if(nargs == 0) {
argc = sizeof(defaultArgs)/sizeof(defaultArgs[0]);
args = (char **)defaultArgs;
} else {
args = (char **) malloc((nargs+1) * sizeof(char*));
args[0] = strdup("Rxsltproc");
argc = nargs+1;
for(i = 0; i < nargs; i++) {
xmlXPathObjectPtr obj = valuePop(ctxt);
if(obj->type) {
args[i+1] = strdup(xmlXPathCastToString(obj));
}
}
mustFree = TRUE;
}
Rf_initEmbeddedR(argc, args);
loadXSLPackage();
valuePush(ctxt, xmlXPathNewBoolean(1));
if(mustFree) {
for(i = 0; i < nargs+1; i++) {
free(args[i]);
}
free(args);
}
#if DEBUG_REGISTRATION
xsltRegisterExtFunction(getTransformCtxt(), "foo", R_URI, RXSLT_genericFunctionCall);
RXSLT_addFunction("foo", NULL_USER_OBJECT);
#endif
R_alreadyInitialized = 1;
return;
}
static void
xslt_yelp_input (xmlXPathParserContextPtr ctxt, int nargs)
{
xsltTransformContextPtr tctxt;
xmlXPathObjectPtr ret;
YelpTransform *transform;
tctxt = xsltXPathGetTransformContext (ctxt);
transform = (YelpTransform *) tctxt->_private;
/* FIXME: pretty sure this eats transform->input, memory corruption will follow */
transform->input_xslt = xsltNewDocument (tctxt, transform->input);
ret = xmlXPathNewNodeSet (xmlDocGetRootElement (transform->input));
xsltExtensionInstructionResultRegister (tctxt, ret);
valuePush (ctxt, ret);
}
static void
xslt_yelp_aux (xmlXPathParserContextPtr ctxt, int nargs)
{
xsltTransformContextPtr tctxt;
xmlXPathObjectPtr ret;
YelpTransform *transform;
YelpTransformPrivate *priv;
tctxt = xsltXPathGetTransformContext (ctxt);
transform = YELP_TRANSFORM (tctxt->_private);
priv = GET_PRIV (transform);
priv->aux_xslt = xsltNewDocument (tctxt, priv->aux);
ret = xmlXPathNewNodeSet (xmlDocGetRootElement (priv->aux));
xsltExtensionInstructionResultRegister (tctxt, ret);
valuePush (ctxt, ret);
}
static void
exsltObjectTypeFunction (xmlXPathParserContextPtr ctxt, int nargs) {
xmlXPathObjectPtr obj, ret;
if (nargs != 1) {
xmlXPathSetArityError(ctxt);
return;
}
obj = valuePop(ctxt);
switch (obj->type) {
case XPATH_STRING:
ret = xmlXPathNewCString("string");
break;
case XPATH_NUMBER:
ret = xmlXPathNewCString("number");
break;
case XPATH_BOOLEAN:
ret = xmlXPathNewCString("boolean");
break;
case XPATH_NODESET:
ret = xmlXPathNewCString("node-set");
break;
case XPATH_XSLT_TREE:
ret = xmlXPathNewCString("RTF");
break;
case XPATH_USERS:
ret = xmlXPathNewCString("external");
break;
default:
xsltGenericError(xsltGenericErrorContext,
"object-type() invalid arg\n");
ctxt->error = XPATH_INVALID_TYPE;
xmlXPathFreeObject(obj);
return;
}
xmlXPathFreeObject(obj);
valuePush(ctxt, ret);
}
/**
* xsltFunctionLocalTime:
* @ctxt: the XPath Parser context
* @nargs: the number of arguments
*
* Implement the localTime XSLT function used by NORM
* string localTime(???)
*
* This function is available in Norm's extension namespace
* Code (and comments) contributed by Norm
*/
static void
xsltFunctionLocalTime(xmlXPathParserContextPtr ctxt, int nargs) {
xmlXPathObjectPtr obj;
char *str;
char digits[5];
char result[29];
long int field;
time_t gmt, lmt;
struct tm gmt_tm;
struct tm *local_tm;
if (nargs != 1) {
xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
"localTime() : invalid number of args %d\n", nargs);
ctxt->error = XPATH_INVALID_ARITY;
return;
}
obj = valuePop(ctxt);
if (obj->type != XPATH_STRING) {
obj = xmlXPathConvertString(obj);
}
if (obj == NULL) {
valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
return;
}
str = (char *) obj->stringval;
/* str = "$Date: Tuesday, November 03, 2009 11:37:25 AM$" */
memset(digits, 0, sizeof(digits));
strncpy(digits, str+7, 4);
field = strtol(digits, NULL, 10);
gmt_tm.tm_year = field - 1900;
memset(digits, 0, sizeof(digits));
strncpy(digits, str+12, 2);
field = strtol(digits, NULL, 10);
gmt_tm.tm_mon = field - 1;
memset(digits, 0, sizeof(digits));
strncpy(digits, str+15, 2);
field = strtol(digits, NULL, 10);
gmt_tm.tm_mday = field;
memset(digits, 0, sizeof(digits));
strncpy(digits, str+18, 2);
field = strtol(digits, NULL, 10);
gmt_tm.tm_hour = field;
memset(digits, 0, sizeof(digits));
strncpy(digits, str+21, 2);
field = strtol(digits, NULL, 10);
gmt_tm.tm_min = field;
memset(digits, 0, sizeof(digits));
strncpy(digits, str+24, 2);
field = strtol(digits, NULL, 10);
gmt_tm.tm_sec = field;
/* Now turn gmt_tm into a time. */
gmt = mktime(&gmt_tm);
/*
* FIXME: it's been too long since I did manual memory management.
* (I swore never to do it again.) Does this introduce a memory leak?
*/
local_tm = localtime(&gmt);
/*
* Calling localtime() has the side-effect of setting timezone.
* After we know the timezone, we can adjust for it
*/
lmt = gmt - timezone;
/*
* FIXME: it's been too long since I did manual memory management.
* (I swore never to do it again.) Does this introduce a memory leak?
*/
local_tm = localtime(&lmt);
/*
* Now convert local_tm back into a string. This doesn't introduce
* a memory leak, so says asctime(3).
*/
str = asctime(local_tm); /* "Tue Jun 26 05:02:16 2001" */
/* 0123456789 123456789 123 */
memset(result, 0, sizeof(result)); /* "Thu, 26 Jun 2001" */
/* 0123456789 12345 */
strncpy(result, str, 20);
strcpy(result+20, "???"); /* tzname doesn't work, fake it */
strncpy(result+23, str+19, 5);
/* Ok, now result contains the string I want to send back. */
valuePush(ctxt, xmlXPathNewString((xmlChar *)result));
}
/**
* exsltStrTokenizeFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Splits up a string on the characters of the delimiter string and returns a
* node set of token elements, each containing one token from the string.
*/
static void
exsltStrTokenizeFunction(xmlXPathParserContextPtr ctxt, int nargs)
{
xsltTransformContextPtr tctxt;
xmlChar *str, *delimiters, *cur;
const xmlChar *token, *delimiter;
xmlNodePtr node;
xmlDocPtr container;
xmlXPathObjectPtr ret = NULL;
int clen;
if ((nargs < 1) || (nargs > 2)) {
xmlXPathSetArityError(ctxt);
return;
}
if (nargs == 2) {
delimiters = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt))
return;
} else {
delimiters = xmlStrdup((const xmlChar *) "\t\r\n ");
}
if (delimiters == NULL)
return;
str = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt) || (str == NULL)) {
xmlFree(delimiters);
return;
}
/* Return a result tree fragment */
tctxt = xsltXPathGetTransformContext(ctxt);
if (tctxt == NULL) {
xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
"exslt:tokenize : internal error tctxt == NULL\n");
goto fail;
}
container = xsltCreateRVT(tctxt);
if (container != NULL) {
xsltRegisterLocalRVT(tctxt, container);
ret = xmlXPathNewNodeSet(NULL);
if (ret != NULL) {
for (cur = str, token = str; *cur != 0; cur += clen) {
clen = 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)
xmlFree(str);
if (delimiters != NULL)
xmlFree(delimiters);
if (ret != NULL)
valuePush(ctxt, ret);
else
valuePush(ctxt, xmlXPathNewNodeSet(NULL));
}
/**
* exsltStrSplitFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Splits up a string on a delimiting string and returns a node set of token
* elements, each containing one token from the string.
*/
static void
exsltStrSplitFunction(xmlXPathParserContextPtr ctxt, int nargs) {
xsltTransformContextPtr tctxt;
xmlChar *str, *delimiter, *cur;
const xmlChar *token;
xmlNodePtr node;
xmlDocPtr container;
xmlXPathObjectPtr ret = NULL;
int delimiterLength;
if ((nargs < 1) || (nargs > 2)) {
xmlXPathSetArityError(ctxt);
return;
}
if (nargs == 2) {
delimiter = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt))
return;
} else {
delimiter = xmlStrdup((const xmlChar *) " ");
}
if (delimiter == NULL)
return;
delimiterLength = xmlStrlen (delimiter);
str = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt) || (str == NULL)) {
xmlFree(delimiter);
return;
}
/* Return a result tree fragment */
tctxt = xsltXPathGetTransformContext(ctxt);
if (tctxt == NULL) {
xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
"exslt:tokenize : internal error tctxt == NULL\n");
goto fail;
}
/*
* OPTIMIZE TODO: We are creating an xmlDoc for every split!
*/
container = xsltCreateRVT(tctxt);
if (container != NULL) {
xsltRegisterLocalRVT(tctxt, container);
ret = xmlXPathNewNodeSet(NULL);
if (ret != NULL) {
for (cur = str, token = str; *cur != 0; cur++) {
if (delimiterLength == 0) {
if (cur != token) {
xmlChar tmp = *cur;
*cur = 0;
node = xmlNewDocRawNode(container, NULL,
(const xmlChar *) "token", token);
xmlAddChild((xmlNodePtr) container, node);
xmlXPathNodeSetAddUnique(ret->nodesetval, node);
*cur = tmp;
token++;
}
}
else if (!xmlStrncasecmp(cur, delimiter, delimiterLength)) {
if (cur == token) {
/* discard empty tokens */
cur = cur + delimiterLength - 1;
token = cur + 1;
continue;
}
*cur = 0;
node = xmlNewDocRawNode(container, NULL,
(const xmlChar *) "token", token);
xmlAddChild((xmlNodePtr) container, node);
xmlXPathNodeSetAddUnique(ret->nodesetval, node);
*cur = *delimiter;
cur = cur + delimiterLength - 1;
token = cur + 1;
}
}
if (token != cur) {
node = xmlNewDocRawNode(container, NULL,
(const xmlChar *) "token", token);
xmlAddChild((xmlNodePtr) container, node);
xmlXPathNodeSetAddUnique(ret->nodesetval, node);
}
/*
* Mark it as a function result in order to avoid garbage
* collecting of tree fragments
*/
xsltExtensionInstructionResultRegister(tctxt, ret);
}
}
fail:
if (str != NULL)
xmlFree(str);
if (delimiter != NULL)
xmlFree(delimiter);
if (ret != NULL)
valuePush(ctxt, ret);
else
valuePush(ctxt, xmlXPathNewNodeSet(NULL));
}
static void xsl_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs, int type) /* {{{ */
{
xsltTransformContextPtr tctxt;
zval *args;
zval retval;
int result, i;
int error = 0;
zend_fcall_info fci;
zval handler;
xmlXPathObjectPtr obj;
char *str;
xsl_object *intern;
zend_string *callable = NULL;
if (! zend_is_executing()) {
xsltGenericError(xsltGenericErrorContext,
"xsltExtFunctionTest: Function called from outside of PHP\n");
error = 1;
} else {
tctxt = xsltXPathGetTransformContext(ctxt);
if (tctxt == NULL) {
xsltGenericError(xsltGenericErrorContext,
"xsltExtFunctionTest: failed to get the transformation context\n");
error = 1;
} else {
intern = (xsl_object*)tctxt->_private;
if (intern == NULL) {
xsltGenericError(xsltGenericErrorContext,
"xsltExtFunctionTest: failed to get the internal object\n");
error = 1;
}
else if (intern->registerPhpFunctions == 0) {
xsltGenericError(xsltGenericErrorContext,
"xsltExtFunctionTest: PHP Object did not register PHP functions\n");
error = 1;
}
}
}
if (error == 1) {
for (i = nargs - 1; i >= 0; i--) {
obj = valuePop(ctxt);
xmlXPathFreeObject(obj);
}
return;
}
fci.param_count = nargs - 1;
if (fci.param_count > 0) {
args = safe_emalloc(fci.param_count, sizeof(zval), 0);
}
/* Reverse order to pop values off ctxt stack */
for (i = nargs - 2; i >= 0; i--) {
obj = valuePop(ctxt);
switch (obj->type) {
case XPATH_STRING:
ZVAL_STRING(&args[i], (char *)obj->stringval);
break;
case XPATH_BOOLEAN:
ZVAL_BOOL(&args[i], obj->boolval);
break;
case XPATH_NUMBER:
ZVAL_DOUBLE(&args[i], obj->floatval);
break;
case XPATH_NODESET:
if (type == 1) {
str = (char*)xmlXPathCastToString(obj);
ZVAL_STRING(&args[i], str);
xmlFree(str);
} else if (type == 2) {
int j;
dom_object *domintern = (dom_object *)intern->doc;
array_init(&args[i]);
if (obj->nodesetval && obj->nodesetval->nodeNr > 0) {
for (j = 0; j < obj->nodesetval->nodeNr; j++) {
xmlNodePtr node = obj->nodesetval->nodeTab[j];
zval child;
/* not sure, if we need this... it's copied from xpath.c */
if (node->type == XML_NAMESPACE_DECL) {
xmlNsPtr curns;
xmlNodePtr nsparent;
nsparent = node->_private;
curns = xmlNewNs(NULL, node->name, NULL);
if (node->children) {
curns->prefix = xmlStrdup((char *)node->children);
}
if (node->children) {
node = xmlNewDocNode(node->doc, NULL, (char *) node->children, node->name);
} else {
node = xmlNewDocNode(node->doc, NULL, (const xmlChar *) "xmlns", node->name);
}
node->type = XML_NAMESPACE_DECL;
node->parent = nsparent;
node->ns = curns;
} else {
node = xmlDocCopyNodeList(domintern->document->ptr, node);
}
php_dom_create_object(node, &child, domintern);
add_next_index_zval(&args[i], &child);
}
}
}
break;
default:
str = (char *) xmlXPathCastToString(obj);
ZVAL_STRING(&args[i], str);
xmlFree(str);
}
xmlXPathFreeObject(obj);
}
fci.size = sizeof(fci);
fci.function_table = EG(function_table);
if (fci.param_count > 0) {
fci.params = args;
} else {
fci.params = NULL;
}
obj = valuePop(ctxt);
if (obj->stringval == NULL) {
php_error_docref(NULL, E_WARNING, "Handler name must be a string");
xmlXPathFreeObject(obj);
valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));
if (fci.param_count > 0) {
for (i = 0; i < nargs - 1; i++) {
zval_ptr_dtor(&args[i]);
}
efree(args);
}
return;
}
ZVAL_STRING(&handler, (char *) obj->stringval);
xmlXPathFreeObject(obj);
ZVAL_COPY_VALUE(&fci.function_name, &handler);
fci.symbol_table = NULL;
fci.object = NULL;
fci.retval = &retval;
fci.no_separation = 0;
/*fci.function_handler_cache = &function_ptr;*/
if (!zend_make_callable(&handler, &callable)) {
php_error_docref(NULL, E_WARNING, "Unable to call handler %s()", ZSTR_VAL(callable));
valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));
} else if ( intern->registerPhpFunctions == 2 && zend_hash_exists(intern->registered_phpfunctions, callable) == 0) {
php_error_docref(NULL, E_WARNING, "Not allowed to call handler '%s()'", ZSTR_VAL(callable));
/* Push an empty string, so that we at least have an xslt result... */
valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));
} else {
result = zend_call_function(&fci, NULL);
if (result == FAILURE) {
if (Z_TYPE(handler) == IS_STRING) {
php_error_docref(NULL, E_WARNING, "Unable to call handler %s()", Z_STRVAL(handler));
valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));
}
/* retval is == NULL, when an exception occurred, don't report anything, because PHP itself will handle that */
} else if (Z_ISUNDEF(retval)) {
} else {
if (Z_TYPE(retval) == IS_OBJECT && instanceof_function(Z_OBJCE(retval), dom_node_class_entry)) {
xmlNode *nodep;
dom_object *obj;
if (intern->node_list == NULL) {
ALLOC_HASHTABLE(intern->node_list);
zend_hash_init(intern->node_list, 0, NULL, ZVAL_PTR_DTOR, 0);
}
Z_ADDREF(retval);
zend_hash_next_index_insert(intern->node_list, &retval);
obj = Z_DOMOBJ_P(&retval);
nodep = dom_object_get_node(obj);
valuePush(ctxt, xmlXPathNewNodeSet(nodep));
} else if (Z_TYPE(retval) == IS_TRUE || Z_TYPE(retval) == IS_FALSE) {
valuePush(ctxt, xmlXPathNewBoolean(Z_LVAL(retval)));
} else if (Z_TYPE(retval) == IS_OBJECT) {
php_error_docref(NULL, E_WARNING, "A PHP Object cannot be converted to a XPath-string");
valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));
} else {
convert_to_string_ex(&retval);
valuePush(ctxt, xmlXPathNewString((xmlChar *) Z_STRVAL(retval)));
}
zval_ptr_dtor(&retval);
}
}
zend_string_release(callable);
zval_ptr_dtor(&handler);
if (fci.param_count > 0) {
for (i = 0; i < nargs - 1; i++) {
zval_ptr_dtor(&args[i]);
}
efree(args);
}
}
static void xslt_ext_function_php(xmlXPathParserContextPtr ctxt,
int nargs,
int type) {
XSLTProcessorData *intern = nullptr;
int error = 0;
xsltTransformContextPtr tctxt = xsltXPathGetTransformContext (ctxt);
if (tctxt == nullptr) {
xsltGenericError(xsltGenericErrorContext,
"xsltExtFunctionTest: failed to get the transformation context\n"
);
error = 1;
} else {
intern = (XSLTProcessorData*)tctxt->_private;
if (intern == nullptr) {
xsltGenericError(xsltGenericErrorContext,
"xsltExtFunctionTest: failed to get the internal object\n"
);
error = 1;
} else {
if (intern->m_registerPhpFunctions == 0) {
xsltGenericError(xsltGenericErrorContext,
"xsltExtFunctionTest: PHP Object did not register PHP functions\n"
);
error = 1;
}
}
}
xmlXPathObjectPtr obj;
if (error == 1) {
for (int i = nargs - 1; i >= 0; i--) {
obj = valuePop(ctxt);
xmlXPathFreeObject(obj);
}
return;
}
Array args;
// Reverse order to pop values off ctxt stack
for (int i = nargs - 2; i >= 0; i--) {
Variant arg;
obj = valuePop(ctxt);
switch (obj->type) {
case XPATH_STRING:
arg = String((char*)obj->stringval, CopyString);
break;
case XPATH_BOOLEAN:
arg = (bool)obj->boolval;
break;
case XPATH_NUMBER:
arg = (double)obj->floatval;
break;
case XPATH_NODESET:
if (type == 1) {
char *str = (char*)xmlXPathCastToString(obj);
arg = String(str, CopyString);
xmlFree(str);
} else if (type == 2) {
arg = Array::Create();
if (obj->nodesetval && obj->nodesetval->nodeNr > 0) {
for (int j = 0; j < obj->nodesetval->nodeNr; j++) {
// TODO: not sure this is the right thing to do.
xmlNodePtr node = obj->nodesetval->nodeTab[j];
if (node->type == XML_ELEMENT_NODE) {
Object element = newNode(s_DOMElement,
xmlCopyNode(node, /*extended*/ 1));
arg.toArrRef().append(element);
} else if (node->type == XML_ATTRIBUTE_NODE) {
Object attribute =
newNode(s_DOMAttr,
(xmlNodePtr)xmlCopyProp(nullptr, (xmlAttrPtr)node));
arg.toArrRef().append(attribute);
} else if (node->type == XML_TEXT_NODE) {
Object text =
newNode(s_DOMText,
(xmlNodePtr)xmlNewText(xmlNodeGetContent(node)));
arg.toArrRef().append(text);
} else {
raise_warning("Unhandled node type '%d'", node->type);
// Use a generic DOMNode as fallback for now.
Object nodeobj = newNode(s_DOMNode,
xmlCopyNode(node, /*extended*/ 1));
arg.toArrRef().append(nodeobj);
}
}
}
}
break;
default:
arg = String((char*)xmlXPathCastToString(obj), CopyString);
}
xmlXPathFreeObject(obj);
args.prepend(arg);
}
obj = valuePop(ctxt);
if (obj->stringval == nullptr) {
raise_warning("Handler name must be a string");
xmlXPathFreeObject(obj);
// Push an empty string to get an xslt result.
valuePush(ctxt, xmlXPathNewString((xmlChar*)""));
return;
}
String handler((char*)obj->stringval, CopyString);
xmlXPathFreeObject(obj);
if (!HHVM_FN(is_callable)(handler)) {
raise_warning("Unable to call handler %s()", handler.data());
// Push an empty string to get an xslt result.
valuePush(ctxt, xmlXPathNewString((xmlChar*)""));
} else if (intern->m_registerPhpFunctions == 2 &&
!intern->m_registered_phpfunctions.exists(handler)) {
raise_warning("Not allowed to call handler '%s()'", handler.data());
// Push an empty string to get an xslt result.
valuePush(ctxt, xmlXPathNewString((xmlChar*)""));
} else {
Variant retval = vm_call_user_func(handler, args);
if (retval.isObject() &&
retval.getObjectData()->instanceof(s_DOMNode)) {
ObjectData *retval_data = retval.asCObjRef().get();
xmlNode* nodep = Native::data<DOMNode>(retval_data)->nodep();
valuePush(ctxt, xmlXPathNewNodeSet(nodep));
intern->m_usedElements.prepend(retval);
} else if (retval.is(KindOfBoolean)) {
valuePush(ctxt, xmlXPathNewBoolean(retval.toBoolean()));
} else if (retval.isObject()) {
raise_warning("A PHP Object cannot be converted to an XPath-string");
// Push an empty string to get an xslt result.
valuePush(ctxt, xmlXPathNewString((xmlChar*)""));
} else {
String sretval = retval.toString();
valuePush(ctxt, xmlXPathNewString((xmlChar*)sretval.data()));
}
}
}
static void dom_xpath_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs, int type) /* {{{ */
{
zval retval;
int result, i;
int error = 0;
zend_fcall_info fci;
xmlXPathObjectPtr obj;
char *str;
zend_string *callable = NULL;
dom_xpath_object *intern;
if (! zend_is_executing()) {
xmlGenericError(xmlGenericErrorContext,
"xmlExtFunctionTest: Function called from outside of PHP\n");
error = 1;
} else {
intern = (dom_xpath_object *) ctxt->context->userData;
if (intern == NULL) {
xmlGenericError(xmlGenericErrorContext,
"xmlExtFunctionTest: failed to get the internal object\n");
error = 1;
}
else if (intern->registerPhpFunctions == 0) {
xmlGenericError(xmlGenericErrorContext,
"xmlExtFunctionTest: PHP Object did not register PHP functions\n");
error = 1;
}
}
if (error == 1) {
for (i = nargs - 1; i >= 0; i--) {
obj = valuePop(ctxt);
xmlXPathFreeObject(obj);
}
return;
}
fci.param_count = nargs - 1;
if (fci.param_count > 0) {
fci.params = safe_emalloc(fci.param_count, sizeof(zval), 0);
}
/* Reverse order to pop values off ctxt stack */
for (i = nargs - 2; i >= 0; i--) {
obj = valuePop(ctxt);
switch (obj->type) {
case XPATH_STRING:
ZVAL_STRING(&fci.params[i], (char *)obj->stringval);
break;
case XPATH_BOOLEAN:
ZVAL_BOOL(&fci.params[i], obj->boolval);
break;
case XPATH_NUMBER:
ZVAL_DOUBLE(&fci.params[i], obj->floatval);
break;
case XPATH_NODESET:
if (type == 1) {
str = (char *)xmlXPathCastToString(obj);
ZVAL_STRING(&fci.params[i], str);
xmlFree(str);
} else if (type == 2) {
int j;
array_init(&fci.params[i]);
if (obj->nodesetval && obj->nodesetval->nodeNr > 0) {
for (j = 0; j < obj->nodesetval->nodeNr; j++) {
xmlNodePtr node = obj->nodesetval->nodeTab[j];
zval child;
/* not sure, if we need this... it's copied from xpath.c */
if (node->type == XML_NAMESPACE_DECL) {
xmlNsPtr curns;
xmlNodePtr nsparent;
nsparent = node->_private;
curns = xmlNewNs(NULL, node->name, NULL);
if (node->children) {
curns->prefix = xmlStrdup((xmlChar *) node->children);
}
if (node->children) {
node = xmlNewDocNode(node->doc, NULL, (xmlChar *) node->children, node->name);
} else {
node = xmlNewDocNode(node->doc, NULL, (xmlChar *) "xmlns", node->name);
}
node->type = XML_NAMESPACE_DECL;
node->parent = nsparent;
node->ns = curns;
}
php_dom_create_object(node, &child, &intern->dom);
add_next_index_zval(&fci.params[i], &child);
}
}
}
break;
default:
ZVAL_STRING(&fci.params[i], (char *)xmlXPathCastToString(obj));
}
xmlXPathFreeObject(obj);
}
fci.size = sizeof(fci);
fci.function_table = EG(function_table);
obj = valuePop(ctxt);
if (obj->stringval == NULL) {
php_error_docref(NULL, E_WARNING, "Handler name must be a string");
xmlXPathFreeObject(obj);
if (fci.param_count > 0) {
for (i = 0; i < nargs - 1; i++) {
zval_ptr_dtor(&fci.params[i]);
}
efree(fci.params);
}
return;
}
ZVAL_STRING(&fci.function_name, (char *) obj->stringval);
xmlXPathFreeObject(obj);
fci.symbol_table = NULL;
fci.object = NULL;
fci.retval = &retval;
fci.no_separation = 0;
if (!zend_make_callable(&fci.function_name, &callable)) {
php_error_docref(NULL, E_WARNING, "Unable to call handler %s()", callable->val);
} else if (intern->registerPhpFunctions == 2 && zend_hash_exists(intern->registered_phpfunctions, callable) == 0) {
php_error_docref(NULL, E_WARNING, "Not allowed to call handler '%s()'.", callable->val);
/* Push an empty string, so that we at least have an xslt result... */
valuePush(ctxt, xmlXPathNewString((xmlChar *)""));
} else {
result = zend_call_function(&fci, NULL);
if (result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
if (Z_TYPE(retval) == IS_OBJECT && instanceof_function(Z_OBJCE(retval), dom_node_class_entry)) {
xmlNode *nodep;
dom_object *obj;
if (intern->node_list == NULL) {
ALLOC_HASHTABLE(intern->node_list);
zend_hash_init(intern->node_list, 0, NULL, ZVAL_PTR_DTOR, 0);
}
GC_REFCOUNT(&retval)++;
zend_hash_next_index_insert(intern->node_list, &retval);
obj = Z_DOMOBJ_P(&retval);
nodep = dom_object_get_node(obj);
valuePush(ctxt, xmlXPathNewNodeSet(nodep));
} else if (Z_TYPE(retval) == IS_FALSE || Z_TYPE(retval) == IS_TRUE) {
valuePush(ctxt, xmlXPathNewBoolean(Z_TYPE(retval) == IS_TRUE));
} else if (Z_TYPE(retval) == IS_OBJECT) {
php_error_docref(NULL, E_WARNING, "A PHP Object cannot be converted to a XPath-string");
valuePush(ctxt, xmlXPathNewString((xmlChar *)""));
} else {
zend_string *str = zval_get_string(&retval);
valuePush(ctxt, xmlXPathNewString((xmlChar *) str->val));
zend_string_release(str);
}
zval_ptr_dtor(&retval);
}
}
zend_string_release(callable);
zval_dtor(&fci.function_name);
if (fci.param_count > 0) {
for (i = 0; i < nargs - 1; i++) {
zval_ptr_dtor(&fci.params[i]);
}
efree(fci.params);
}
}
/**
* exsltStrTokenizeFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Splits up a string on the characters of the delimiter string and returns a
* node set of token elements, each containing one token from the string.
*/
static void
exsltStrTokenizeFunction(xmlXPathParserContextPtr ctxt, int nargs)
{
xsltTransformContextPtr tctxt;
xmlChar *str, *delimiters, *cur;
const xmlChar *token, *delimiter;
xmlNodePtr node;
xmlDocPtr container;
xmlXPathObjectPtr ret = NULL;
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));
}
