static void
addIntegerPropToNode (xmlNodePtr node,
const char *name,
int value)
{
xmlChar *string = xmlXPathCastNumberToString (value);
if (!string)
return;
xmlNewProp (node, BAD_CAST name, string);
xmlFree (string);
}
int
printXPathAtomic (xmlXPathObjectPtr objset, char **printBuffPtr, int printBuffSize)
{
int retValue;
char *res = NULL;
int size = printBuffSize;
char *newSpace;
int n;
if (objset == NULL) return -1;
switch (objset->type){
case XPATH_STRING:
res = strdup ((char *)objset->stringval);
break;
case XPATH_BOOLEAN:
res = (char *)xmlXPathCastBooleanToString(objset->boolval);
break;
case XPATH_NUMBER:
res = (char *) xmlXPathCastNumberToString(objset->floatval);
break;
}
if (res == NULL || strlen (res) == 0){
if (res) free (res);
return 0;
}
if (size < (strlen(res) + 1)){
size = strlen(res) + 1;
newSpace = (char *)realloc (*printBuffPtr, size);
if (newSpace){
*printBuffPtr = newSpace;
} else {
// unable to allocate space
if (res) free (res);
return -1;
}
}
n = sprintf (*printBuffPtr, "%s", res);
if (res) free (res);
return n;
}
bool gpl::xml::getXPathResultSet(std::multimap<std::string, std::string>& resultSet)
{
resultSet.clear();
//added by shandy 20041208
if (m_xml->resource == NULL)
return true;
std::vector<std::string> strVector;
std::string str, name;
int i;
xmlNodeSetPtr tmpPtr = 0;
//cout<<"resource->type:"<<m_xml->resource->type<<endl;
switch (m_xml->resource->type)
{
case XPATH_UNDEFINED://Object is uninitialized
return false;
break;
case XPATH_NODESET://Object is a Node Set
tmpPtr = m_xml->resource->nodesetval;
if (tmpPtr == NULL)
break;
for (i = 0; i < tmpPtr->nodeNr; i++)
m_xml->getDumpNode(tmpPtr->nodeTab[i], resultSet);
break;
case XPATH_XSLT_TREE://Object is an XSLT value tree
return false;
break;
case XPATH_BOOLEAN://Object is a Boolean
str = m_xml->getStringByXmlCharPtr(xmlXPathCastBooleanToString(m_xml->resource->boolval), 1);
resultSet.insert(std::multimap<std::string, std::string>::value_type(std::string("boolean"), str));
break;
case XPATH_NUMBER://Object is a number
str = m_xml->getStringByXmlCharPtr(xmlXPathCastNumberToString(m_xml->resource->floatval), 1);
resultSet.insert(std::multimap<std::string, std::string>::value_type(std::string("number"), str));
break;
case XPATH_STRING://Object is a string
if (m_xml->resource->stringval != NULL)
{
std::string str = m_xml->getStringByXmlCharPtr(m_xml->resource->stringval);
resultSet.insert(std::multimap<std::string, std::string>::value_type(std::string("string"), str));
}
break;
case XPATH_POINT://Object is a point
//fprintf(output, " : index %d in node", m_xml->resource->index);
m_xml->getDumpNode((xmlNodePtr)m_xml->resource->user, resultSet);
break;
case XPATH_RANGE:
if ((m_xml->resource->user2 == NULL) ||
((m_xml->resource->user2 == m_xml->resource->user) && (m_xml->resource->index == m_xml->resource->index2)))
{
//Object is a collapsed range
//if (m_xml->resource->index >= 0)
// fprintf(output, "index %d in ", m_xml->resource->index);
//fprintf(output, "node\n");
m_xml->getDumpNode((xmlNodePtr)m_xml->resource->user, resultSet);
}
else
{
//Object is a range from
//if (m_xml->resource->index >= 0)
// fprintf(output, "index %d in ", m_xml->resource->index);
m_xml->getDumpNode((xmlNodePtr)m_xml->resource->user, resultSet);
// to
//if (m_xml->resource->index2 >= 0)
// fprintf(output, "index %d in ", m_xml->resource->index2);
m_xml->getDumpNode((xmlNodePtr)m_xml->resource->user2, resultSet);
}
break;
case XPATH_LOCATIONSET://Object is a Location Set
return false;
break;
case XPATH_USERS://Object is user defined
return false;
break;
}
return true;
}
static void
exsltDynMapFunction(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,
cur);
}
xsltExtensionInstructionResultRegister(tctxt, ret);
}
break;
case XPATH_NUMBER:
if (container != NULL) {
xmlChar *val =
xmlXPathCastNumberToString(subResult->
floatval);
xmlNodePtr cur =
xmlNewChild((xmlNodePtr) container, NULL,
BAD_CAST "number", val);
if (val != NULL)
xmlFree(val);
if (cur != NULL) {
cur->ns =
xmlNewNs(cur,
BAD_CAST
"http://exslt.org/common",
BAD_CAST "exsl");
xmlXPathNodeSetAddUnique(ret->nodesetval,
cur);
}
xsltExtensionInstructionResultRegister(tctxt, ret);
}
break;
case XPATH_STRING:
if (container != NULL) {
xmlNodePtr cur =
xmlNewChild((xmlNodePtr) container, NULL,
BAD_CAST "string",
subResult->stringval);
if (cur != NULL) {
cur->ns =
xmlNewNs(cur,
BAD_CAST
"http://exslt.org/common",
BAD_CAST "exsl");
xmlXPathNodeSetAddUnique(ret->nodesetval,
cur);
}
xsltExtensionInstructionResultRegister(tctxt, ret);
}
break;
default:
break;
}
xmlXPathFreeObject(subResult);
}
}
}
ctxt->context->doc = oldDoc;
ctxt->context->node = oldNode;
ctxt->context->contextSize = oldContextSize;
ctxt->context->proximityPosition = oldProximityPosition;
cleanup:
if (comp != NULL)
xmlXPathFreeCompExpr(comp);
if (nodeset != NULL)
xmlXPathFreeNodeSet(nodeset);
if (str != NULL)
xmlFree(str);
valuePush(ctxt, ret);
return;
}
