void oseacomm_xml_add_vresponse_service (OseaCommXmlObject * object,
OseaCommCodeType status_code,
gchar * explanation,
va_list args)
{
xmlNodePtr cursor;
OseaCommDataSet * table = NULL;
OseaCommCode *code_information = NULL;
// Check for incorrect params.
g_return_if_fail (object);
g_return_if_fail (explanation);
// set the cursor to the right position
cursor = object->doc->children->children;
while (cursor->next) {
cursor = cursor->next;
}
// insert the node of the service response
cursor->next = xmlNewDocRawNode (object->doc, NULL, "response_service", NULL);
// prepare for insert data, access to myself
cursor = cursor->next;
// Insert the response status
cursor->children = xmlNewDocRawNode (object->doc, NULL, "status", NULL);
// Create the correct code information
code_information = oseacomm_code_new (status_code, (const gchar *) explanation);
xmlSetProp (cursor->children, "code", (xmlChar *) code_information->status_code);
xmlSetProp (cursor->children, "text", (xmlChar *) code_information->status_text);
oseacomm_code_free (code_information);
cursor = cursor->children;
// parse the unknown-number-of params
// For each recieved table
while ( (table = va_arg (args, OseaCommDataSet *))) {
cursor->next = __oseacomm_xml_create_table (table, object->doc);
cursor = cursor->next;
}
return;
}
xmlNodePtr __oseacomm_xml_create_table (OseaCommDataSet * data_set, xmlDocPtr doc)
{
gint i;
gint j;
xmlNodePtr result;
xmlNodePtr cursor;
xmlNodePtr cursor_aux;
g_return_val_if_fail (data_set, NULL);
// Create the initial node table
result = xmlNewDocRawNode (doc, NULL, "table", NULL);
cursor = result;
for (i = 0; i < oseacomm_dataset_get_height (data_set); i++) {
// Create a row
if (i == 0) {
// if first param is set, the following node must be inserted as a child
cursor->children = xmlNewDocRawNode (doc, NULL, "row", NULL);
cursor = cursor->children;
}else {
cursor->next = xmlNewDocRawNode (doc, NULL, "row", NULL);
cursor = cursor->next;
}
cursor_aux = cursor;
for (j = 0; j < oseacomm_dataset_get_width (data_set); j++) {
// insert each param
if (j == 0) {
// if is the first param, this must be inserted as a child
cursor_aux->children = xmlNewDocRawNode (doc, NULL, "data",
(xmlChar *)oseacomm_dataset_get (data_set, i,j));
cursor_aux = cursor_aux->children;
} else {
// in other case, the insertion is made as a siblin
cursor_aux->next = xmlNewDocRawNode (doc, NULL, "data",
(xmlChar *)oseacomm_dataset_get (data_set, i,j));
cursor_aux = cursor_aux->next;
}
}
}
return result;
}
TEG_STATUS xmlscores_save( PLIST_ENTRY pL_orig )
{
xmlDocPtr doc;
xmlNodePtr child;
PLIST_ENTRY pL = pL_orig->Flink;
char filename[512];
PSCORES pS;
doc = xmlNewDoc((xmlChar*)"1.0");
child = xmlNewDocRawNode( doc, NULL, (xmlChar*)"teg_scores", NULL );
/* whats the difference between xmlNewDocRawNode & SetRootElement */
xmlDocSetRootElement( doc, child );
while( !IsListEmpty( pL_orig ) && (pL != pL_orig) ) {
pS = (PSCORES) pL;
xmlscores_add( child, pS );
pL = LIST_NEXT(pL);
}
snprintf( filename, sizeof(filename)-1,"%s/%s/server_scores.xml",g_get_home_dir(),TEG_DIRRC);
filename[ sizeof(filename)-1 ] = 0;
xmlSaveFile( filename , doc );
return TEG_STATUS_SUCCESS;
}
/**
* Prepare XSLT stylesheet based on command line options
*/
int
selPrepareXslt(xmlDocPtr style, selOptionsPtr ops, xmlChar *ns_arr[],
int start, int argc, char **argv)
{
int i, t, ns, use_inputfile = 0, use_value_of = 0;
xmlNodePtr root, root_template = NULL;
xmlNsPtr xslns;
xmlBufferPtr attr_buf;
root = xmlNewDocRawNode(style, NULL, BAD_CAST "stylesheet", NULL);
xmlDocSetRootElement(style, root);
xmlNewProp(root, BAD_CAST "version", BAD_CAST "1.0");
xslns = xmlNewNs(root, XSLT_NAMESPACE, BAD_CAST "xsl");
xmlSetNs(root, xslns);
ns = 0;
while(ns_arr[ns])
{
xmlNewNs(root, ns_arr[ns+1], xmlStrlen(ns_arr[ns])?ns_arr[ns] : NULL);
ns += 2;
}
cleanupNSArr(ns_arr);
{
xmlNodePtr output;
output = xmlNewChild(root, xslns, BAD_CAST "output", NULL);
xmlNewProp(output, BAD_CAST "omit-xml-declaration",
BAD_CAST ((ops->no_omit_decl)?"no":"yes"));
xmlNewProp(output, BAD_CAST "indent",
BAD_CAST ((ops->indent)?"yes":"no"));
if (ops->encoding) xmlNewProp(output, BAD_CAST "encoding", ops->encoding);
if (ops->outText) xmlNewProp(output, BAD_CAST "method", BAD_CAST "text");
}
for (i = start, t = 0; i < argc; i++)
if(!strcmp(argv[i], "-t") || !strcmp(argv[i], "--template"))
t++;
/*
* At least one -t option must be found
*/
if (t == 0)
{
fprintf(stderr, "error in arguments:");
fprintf(stderr, " no -t or --template options found\n");
exit(EXIT_BAD_ARGS);
}
if (t > 1)
root_template = xmlNewChild(root, xslns, BAD_CAST "template", NULL);
t = 0;
i = start;
while(i < argc)
{
if(!strcmp(argv[i], "-t") || !strcmp(argv[i], "--template"))
{
xmlNodePtr call_template, template;
int lastTempl = 0;
t++;
// all output ends up through here
void FPrintf (int flag, char *buf)
{
xmlNodePtr node;
static qboolean bGotXML = false;
char level[2];
printf(buf);
// the following part is XML stuff only.. but maybe we don't want that message to go down the XML pipe?
if (flag == SYS_NOXML)
return;
// ouput an XML file of the run
// use the DOM interface to build a tree
/*
<message level='flag'>
message string
.. various nodes to describe corresponding geometry ..
</message>
*/
if (!bGotXML)
{
// initialize
doc = xmlNewDoc("1.0");
doc->children = xmlNewDocRawNode(doc, NULL, "q3map_feedback", NULL);
bGotXML = true;
}
node = xmlNewNode (NULL, "message");
xmlNodeSetContent (node, buf);
level[0] = (int)'0' + flag;
level[1] = 0;
xmlSetProp (node, "level", (char *)&level );
xml_SendNode (node);
}
xmlNodePtr __oseacomm_xml_insert_arg (xmlDocPtr doc, gchar *attrib, OseaCommXmlArgType type, gpointer value)
{
xmlNodePtr node = NULL;
switch (type) {
case OSEACOMM_XML_ARG_STRING:
g_log (LOG_DOMAIN, G_LOG_LEVEL_DEBUG, " param: %s, %s", attrib, (gchar *)value);
node = xmlNewDocRawNode (doc, NULL, "param", NULL);
xmlSetProp (node, "attrib", (xmlChar *)attrib);
xmlSetProp (node, "value", (xmlChar *)value);
break;
case OSEACOMM_XML_ARG_DATASET:
g_log (LOG_DOMAIN, G_LOG_LEVEL_DEBUG, " paramtable: %s, DATASET", attrib);
node = xmlNewDocRawNode (doc, NULL, "paramtable", NULL);
xmlSetProp (node, "attrib", (xmlChar *)attrib);
node->children = __oseacomm_xml_create_table ((OseaCommDataSet *)value, doc);
break;
}
return node;
}
void oseacomm_xml_add_vrequest_service (OseaCommXmlObject *object, gchar *name_of_service, va_list args)
{
xmlNodePtr cursor;
gboolean first_param = TRUE;
gchar *attrib = NULL;
OseaCommXmlArgType type;
gpointer value = NULL;
g_return_if_fail (object);
g_return_if_fail (name_of_service);
// set the cursor to the right position
cursor = object->doc->children->children;
while (cursor->next) {
cursor = cursor->next;
}
// insert the node of the service request
g_log (LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "New request service: %s", name_of_service);
cursor->next = xmlNewDocRawNode (object->doc, NULL, "request_service", NULL);
xmlSetProp (cursor->next, "name", (xmlChar *)name_of_service);
// prepare for insert params
cursor = cursor->next;
// parse the unknown-number-of params
while ((attrib = va_arg (args, gchar *))) {
type = va_arg (args, OseaCommXmlArgType);
switch (type) {
case OSEACOMM_XML_ARG_STRING:
value = va_arg (args, gchar *);
break;
case OSEACOMM_XML_ARG_DATASET:
value = va_arg (args, OseaCommDataSet *);
break;
}
if (first_param) {
// if this is the first, this must be inserted as a child
cursor->children = __oseacomm_xml_insert_arg (object->doc, attrib, type, value);
cursor = cursor->children;
first_param = FALSE;
} else {
// in other case, the insertion is made as a siblin
cursor->next = __oseacomm_xml_insert_arg (object->doc, attrib, type, value);
cursor = cursor->next;
}
}
g_log (LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Exiting from oseacomm_xml_add_vrequest");
return;
}
void bg_chapter_list_save(gavl_chapter_list_t * list, const char * filename)
{
xmlDocPtr xml_doc;
xmlNodePtr xml_list;
xml_doc = xmlNewDoc((xmlChar*)"1.0");
xml_list = xmlNewDocRawNode(xml_doc, NULL, (xmlChar*)CHAPTERS_KEY, NULL);
xmlDocSetRootElement(xml_doc, xml_list);
bg_chapter_list_2_xml(list, xml_list);
bg_xml_save_file(xml_doc, filename, 1);
xmlFreeDoc(xml_doc);
}
void kbd_table_save(const char * filename, kbd_table_t * keys, int len)
{
char * tmp_string;
xmlDocPtr xml_doc;
xmlNodePtr node;
xmlNodePtr xml_child;
xmlNodePtr xml_key;
int i;
xml_doc = xmlNewDoc((xmlChar*)"1.0");
node = xmlNewDocRawNode(xml_doc, NULL, (xmlChar*)root_name, NULL);
xmlDocSetRootElement(xml_doc, node);
xmlAddChild(node, BG_XML_NEW_TEXT("\n"));
for(i = 0; i < len; i++)
{
xml_key = xmlNewTextChild(node, NULL, (xmlChar*)key_name, NULL);
xml_child =
xmlNewTextChild(xml_key, NULL, (xmlChar*)scancode_name, NULL);
tmp_string = bg_sprintf("%d", keys[i].scancode);
xmlAddChild(xml_child, BG_XML_NEW_TEXT(tmp_string));
free(tmp_string);
if(keys[i].modifiers)
{
xml_child =
xmlNewTextChild(xml_key, NULL, (xmlChar*)modifiers_name, NULL);
xmlAddChild(xml_child, BG_XML_NEW_TEXT(keys[i].modifiers));
}
if(keys[i].command)
{
xml_child =
xmlNewTextChild(xml_key, NULL, (xmlChar*)command_name, NULL);
xmlAddChild(xml_child, BG_XML_NEW_TEXT(keys[i].command));
}
xmlAddChild(node, BG_XML_NEW_TEXT("\n"));
}
xmlSaveFile(filename, xml_doc);
xmlFreeDoc(xml_doc);
}
xmlDocPtr bg_upnp_device_description_create(const char * url_base,
const char * type, int version)
{
xmlDocPtr ret;
xmlNodePtr root;
xmlNodePtr node;
xmlNsPtr ns;
char * tmp_string;
ret = xmlNewDoc((xmlChar*)"1.0");
root = xmlNewDocRawNode(ret, NULL, (xmlChar*)"root", NULL);
xmlDocSetRootElement(ret, root);
ns =
xmlNewNs(root,
(xmlChar*)"urn:schemas-upnp-org:device-1-0",
NULL);
xmlSetNs(root, ns);
xmlAddChild(root, BG_XML_NEW_TEXT("\n"));
node = bg_xml_append_child_node(root, "specVersion", NULL);
bg_xml_append_child_node(node, "major", "1");
bg_xml_append_child_node(node, "minor", "0");
bg_xml_append_child_node(root, "URLBase", url_base);
node = bg_xml_append_child_node(root, "device", NULL);
tmp_string = bg_sprintf("urn:schemas-upnp-org:device:%s:%d", type, version);
bg_xml_append_child_node(node, "deviceType", tmp_string);
free(tmp_string);
bg_xml_append_child_node(node, "presentationURL", url_base);
return ret;
}
xmlDocPtr make_xml_for_datatype(MYX_DBM_DATATYPES *obj)
{
xmlDocPtr doc;
xmlNodePtr parent;
unsigned int i;
g_return_val_if_fail(obj, NULL);
doc= xmlNewDoc((xmlChar*)"1.0");
parent= doc->children= xmlNewDocRawNode(doc, NULL, (xmlChar*)"datatype", NULL);
for (i= 0; i < obj->datatypes_num; i++)
store_datatype_MYX_DBM_DATATYPE(obj->datatypes+i, parent);
for (i= 0; i < obj->substitutes_num; i++)
{
xmlNodePtr vp= xmlNewTextChild(parent, NULL, (xmlChar*)"substitution", NULL);
xmlNewProp(vp, (xmlChar*)"name", (xmlChar*)obj->substitutes[i].name);
xmlNewProp(vp, (xmlChar*)"value", (xmlChar*)obj->substitutes[i].value);
}
return doc;
}
/**
* Store xml config to file.
*/
XmlStore::XmlStore(const char *rootName)
{
m_doc = xmlNewDoc((const xmlChar*)"1.0");
m_node = xmlNewDocRawNode(m_doc, 0, (const xmlChar*)rootName, 0);
xmlDocSetRootElement(m_doc, m_node);
}
/**
* 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));
}
/**
* 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));
}
static void
exsltRegexpMatchFunction (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));
}
