static xmlXPathObjectPtr evaluate_xpath(xmlDoc *doc, gchar *xpath) {
g_return_val_if_fail(doc != NULL, NULL);
g_return_val_if_fail(xpath != NULL, NULL);
xmlXPathContextPtr xpathCtx;
xmlXPathObjectPtr xpathObj;
int i = 0;
/* Create xpath evaluation context */
xpathCtx = xmlXPathNewContext(doc);
g_return_val_if_fail(xpathCtx != NULL, NULL);
xmlNsPtr *nsp;
nsp = xmlGetNsList(doc,xmlDocGetRootElement(doc));
if (nsp != NULL) {
while (nsp[i] != NULL)
i++;
}
xpathCtx->namespaces = nsp;
xpathCtx->nsNr = i;
/* Evaluate xpath expression */
xpathObj = xmlXPathEvalExpression((xmlChar *)xpath, xpathCtx);
xmlFree(nsp);
xmlXPathFreeContext(xpathCtx);
return xpathObj;
}
/*
* Same prefix but not same URI
*/
static bool ows_libxml_check_namespace_node(ows *o, xmlNodePtr n, xmlNsPtr *ns_doc)
{
xmlNsPtr *ns_node, *pn, *pd;
bool ret= true;
assert(o);
assert(n);
assert(ns_doc);
ns_node = xmlGetNsList(n->doc, n);
if (!ns_node) return ret;
for (pn = ns_node ; *(pn) ; pn++) {
for (pd = ns_doc ; *(pd) ; pd++) {
if ( (*pn)->prefix && (*pd)->prefix && (*pn)->href && (*pd)->href
&& !strcmp((char *) (*pn)->prefix, (char *) (*pd)->prefix)
&& strcmp((char *) (*pn)->href, (char *) (*pd)->href )) {
ret = false;
break;
}
}
}
xmlFree(ns_node);
return ret;
}
/**
* Return false if current element namespace is not a KML one
* Return true otherwise.
*/
static bool is_kml_namespace(xmlNodePtr xnode, bool is_strict)
{
xmlNsPtr *ns, *p;
ns = xmlGetNsList(xnode->doc, xnode);
/*
* If no namespace is available we could return true anyway
* (because we work only on KML fragment, we don't want to
* 'oblige' to add namespace on the geometry root node)
*/
if (ns == NULL) return !is_strict;
for (p=ns ; *p ; p++)
{
if ((*p)->href == NULL) continue;
if (!strcmp((char *) (*p)->href, KML_NS))
{
if ( (*p)->prefix == NULL ||
!xmlStrcmp(xnode->ns->prefix, (*p)->prefix))
{
xmlFree(ns);
return true;
}
}
}
xmlFree(ns);
return false;
}
/**@ingroup tsk_xml_group
* Get an XML namespace from an XML document
* @param docPtr A pointer to the XML document
* @param node The XML node from which to extract the namespace
* @param href The namespace href
* @retval The Namespace value matching our criteria (href)
*/
xmlNsPtr tsk_xml_get_namespace(xmlDocPtr docPtr, xmlNodePtr node, const char *href)
{
xmlNs *ns = *xmlGetNsList(docPtr, node);
while (ns)
{
if (tsk_striequals(ns->href, href)) return ns;
else ns = ns->next;
}
return 0;
}
/* call-seq:
* context.register_namespaces_from_node(node) -> self
*
* Helper method to read in namespaces defined on a node.
*
* doc = XML::Document.string('<header><first>hi</first></header>')
* context = XPath::Context.new(doc)
* context.register_namespaces_from_node(doc.root)
*/
static VALUE rxml_xpath_context_register_namespaces_from_node(VALUE self,
VALUE node)
{
xmlXPathContextPtr xctxt;
xmlNodePtr xnode;
xmlNsPtr *xnsArr;
Data_Get_Struct(self, xmlXPathContext, xctxt);
if (rb_obj_is_kind_of(node, cXMLDocument) == Qtrue)
{
xmlDocPtr xdoc;
Data_Get_Struct(node, xmlDoc, xdoc);
xnode = xmlDocGetRootElement(xdoc);
}
else if (rb_obj_is_kind_of(node, cXMLNode) == Qtrue)
{
Data_Get_Struct(node, xmlNode, xnode);
}
else
{
rb_raise(rb_eTypeError, "The first argument must be a document or node.");
}
xnsArr = xmlGetNsList(xnode->doc, xnode);
if (xnsArr)
{
xmlNsPtr xns = *xnsArr;
while (xns)
{
/* If there is no prefix, then this is the default namespace.
Skip it for now. */
if (xns->prefix)
{
VALUE prefix = rxml_str_new2((const char*)xns->prefix, xctxt->doc->encoding);
VALUE uri = rxml_str_new2((const char*)xns->href, xctxt->doc->encoding);
rxml_xpath_context_register_namespace(self, prefix, uri);
}
xns = xns->next;
}
xmlFree(xnsArr);
}
return self;
}
NamespaceList Node::NamespacesInScope() const
{
NamespaceList result;
xmlNsPtr *pNamespaces = xmlGetNsList(_xml->doc, _xml);
if ( pNamespaces == nullptr )
return result;
for ( int i = 0; pNamespaces[i] != nullptr; i++ )
{
xmlNsPtr xmlNs = pNamespaces[i];
result.push_back(Wrapped<class Namespace, _xmlNs>(xmlNs));
}
xmlMemFree(pNamespaces);
return result;
}
static void
register_namespaces(xmlXPathContextPtr ctxt, WsXmlDocH doc,
WsXmlNodeH node)
{
xmlNsPtr *nsList, *cur;
xmlDocPtr d = (xmlDocPtr) doc->parserDoc;
nsList = xmlGetNsList(d, (xmlNodePtr) node);
if (nsList == NULL) {
return;
}
for (cur = nsList; *cur != NULL; cur++) {
if (xmlXPathRegisterNs(ctxt, (*cur)->prefix, (*cur)->href)
!= 0) {
return;
}
}
xmlFree(nsList);
}
/*
* TODO
*/
bool ows_libxml_check_namespace(ows *o, xmlNodePtr n)
{
xmlNsPtr *ns_doc;
xmlNodePtr node;
bool ret = true;
assert(o);
assert(n);
ns_doc = xmlGetNsList(n->doc, xmlDocGetRootElement(n->doc));
if (!ns_doc) return false;
for (node = n ; node ; node = node->next) {
if (node->type != XML_ELEMENT_NODE) continue;
if (node->children && !(ret = ows_libxml_check_namespace(o, node->children))) break;
if (!(ret = ows_libxml_check_namespace_node(o, node, ns_doc))) break;
}
xmlFree(ns_doc);
return ret;
}
/*
* Add the whole xml element into the buffer
*/
buffer *cgi_add_xml_into_buffer(buffer * element, xmlNodePtr n)
{
xmlBufferPtr buf;
xmlNsPtr * ns;
int i;
assert(element);
assert(n);
ns = xmlGetNsList(n->doc, n);
for (i = 0 ; ns[i] ; i++)
xmlNewNs(n, ns[i]->href, ns[i]->prefix);
buf = xmlBufferCreate();
xmlNodeDump(buf, n->doc, n, 0, 0);
buffer_add_str(element, (char *) buf->content);
xmlBufferFree(buf);
xmlFree(ns);
return element;
}
bool gpl::xml::insertNodeByXPath(const char* nodeName, const char* nodeValue, int length /*= -1*/)
{
if (m_xml->resource == NULL)
return false;
int len = strlen(nodeValue);
if (length == 0 || len < length)
return false;
if (length == -1)
{
length = len;
}
//cout<<"resource->type:"<<m_xml->resource->type<<endl;
switch (m_xml->resource->type)
{
case XPATH_NODESET://Object is a Node Set
if (m_xml->resource->nodesetval == NULL)
return false;
xmlNodePtr cur, newNode;
//取得第一个节点
if ((cur = (*(m_xml->resource->nodesetval->nodeTab))) == NULL)
return false;
if (strlen(nodeName) == 0)
{
if (cur->children == NULL)
{
cur->children = xmlNewText((const xmlChar*)nodeValue);
cur->last = cur->children;
if (cur->last == NULL)
return false;
}
else
if (xmlTextConcat(cur->children, (const xmlChar *)nodeValue, length) < 0)
return false;
}
else
{
if (strcmp(nodeName, XML_CDATA) == 0)
{
if ((newNode = xmlNewCDataBlock(m_xml->doc, (const xmlChar*)nodeValue, length)) == NULL)
return false;
}
else
{
xmlNsPtr* ns = xmlGetNsList(m_xml->doc, cur);
if ((newNode = xmlNewNode((ns == NULL ? NULL : (*ns)), (const xmlChar *)nodeName)) == NULL)
return false;
xmlNodeSetContent(newNode, (const xmlChar*)nodeValue);
}
//从最后的字节点位置进行追加
if ((xmlAddChild(cur, newNode)) == NULL)
return false;
}
break;
case XPATH_XSLT_TREE://Object is an XSLT value tree
case XPATH_BOOLEAN://Object is a Boolean
case XPATH_NUMBER://Object is a number
case XPATH_STRING://Object is a string
case XPATH_POINT://Object is a point
case XPATH_RANGE://是一个范围
case XPATH_LOCATIONSET://Object is a Location Set
case XPATH_USERS://Object is user defined
case XPATH_UNDEFINED://Object is uninitialized
return false;
break;
}
return true;
}
/**
* xsltAttrTemplateValueProcessNode:
* @ctxt: the XSLT transformation context
* @str: the attribute template node value
* @inst: the instruction (or LRE) in the stylesheet holding the
* attribute with an AVT
*
* Process the given string, allowing to pass a namespace mapping
* context and return the new string value.
*
* Called by:
* - xsltAttrTemplateValueProcess() (templates.c)
* - xsltEvalAttrValueTemplate() (templates.c)
*
* QUESTION: Why is this function public? It is not used outside
* of templates.c.
*
* Returns the computed string value or NULL, must be deallocated by the
* caller.
*/
xmlChar *
xsltAttrTemplateValueProcessNode(xsltTransformContextPtr ctxt,
const xmlChar *str, xmlNodePtr inst)
{
xmlChar *ret = NULL;
const xmlChar *cur;
xmlChar *expr, *val;
xmlNsPtr *nsList = NULL;
int nsNr = 0;
if (str == NULL) return(NULL);
if (*str == 0)
return(xmlStrndup((xmlChar *)"", 0));
cur = str;
while (*cur != 0) {
if (*cur == '{') {
if (*(cur+1) == '{') { /* escaped '{' */
cur++;
ret = xmlStrncat(ret, str, cur - str);
cur++;
str = cur;
continue;
}
ret = xmlStrncat(ret, str, cur - str);
str = cur;
cur++;
while ((*cur != 0) && (*cur != '}')) cur++;
if (*cur == 0) {
xsltTransformError(ctxt, NULL, inst,
"xsltAttrTemplateValueProcessNode: unmatched '{'\n");
ret = xmlStrncat(ret, str, cur - str);
return(ret);
}
str++;
expr = xmlStrndup(str, cur - str);
if (expr == NULL)
return(ret);
else if (*expr == '{') {
ret = xmlStrcat(ret, expr);
xmlFree(expr);
} else {
xmlXPathCompExprPtr comp;
/*
* TODO: keep precompiled form around
*/
if ((nsList == NULL) && (inst != NULL)) {
int i = 0;
nsList = xmlGetNsList(inst->doc, inst);
if (nsList != NULL) {
while (nsList[i] != NULL)
i++;
nsNr = i;
}
}
comp = xmlXPathCompile(expr);
val = xsltEvalXPathStringNs(ctxt, comp, nsNr, nsList);
xmlXPathFreeCompExpr(comp);
xmlFree(expr);
if (val != NULL) {
ret = xmlStrcat(ret, val);
xmlFree(val);
}
}
cur++;
str = cur;
} else if (*cur == '}') {
cur++;
if (*cur == '}') { /* escaped '}' */
ret = xmlStrncat(ret, str, cur - str);
cur++;
str = cur;
continue;
} else {
xsltTransformError(ctxt, NULL, inst,
"xsltAttrTemplateValueProcessNode: unmatched '}'\n");
}
} else
cur++;
}
if (cur != str) {
ret = xmlStrncat(ret, str, cur - str);
}
if (nsList != NULL)
xmlFree(nsList);
return(ret);
}
static void php_xpath_eval(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
{
zval *id, retval, *context = NULL;
xmlXPathContextPtr ctxp;
xmlNodePtr nodep = NULL;
xmlXPathObjectPtr xpathobjp;
size_t expr_len, nsnbr = 0, xpath_type;
dom_xpath_object *intern;
dom_object *nodeobj;
char *expr;
xmlDoc *docp = NULL;
xmlNsPtr *ns = NULL;
zend_bool register_node_ns = 1;
if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "Os|O!b", &id, dom_xpath_class_entry, &expr, &expr_len, &context, dom_node_class_entry, ®ister_node_ns) == FAILURE) {
return;
}
intern = Z_XPATHOBJ_P(id);
ctxp = (xmlXPathContextPtr) intern->dom.ptr;
if (ctxp == NULL) {
php_error_docref(NULL, E_WARNING, "Invalid XPath Context");
RETURN_FALSE;
}
docp = (xmlDocPtr) ctxp->doc;
if (docp == NULL) {
php_error_docref(NULL, E_WARNING, "Invalid XPath Document Pointer");
RETURN_FALSE;
}
if (context != NULL) {
DOM_GET_OBJ(nodep, context, xmlNodePtr, nodeobj);
}
if (!nodep) {
nodep = xmlDocGetRootElement(docp);
}
if (nodep && docp != nodep->doc) {
php_error_docref(NULL, E_WARNING, "Node From Wrong Document");
RETURN_FALSE;
}
ctxp->node = nodep;
if (register_node_ns) {
/* Register namespaces in the node */
ns = xmlGetNsList(docp, nodep);
if (ns != NULL) {
while (ns[nsnbr] != NULL)
nsnbr++;
}
}
ctxp->namespaces = ns;
ctxp->nsNr = nsnbr;
xpathobjp = xmlXPathEvalExpression((xmlChar *) expr, ctxp);
ctxp->node = NULL;
if (ns != NULL) {
xmlFree(ns);
ctxp->namespaces = NULL;
ctxp->nsNr = 0;
}
if (! xpathobjp) {
RETURN_FALSE;
}
if (type == PHP_DOM_XPATH_QUERY) {
xpath_type = XPATH_NODESET;
} else {
xpath_type = xpathobjp->type;
}
switch (xpath_type) {
case XPATH_NODESET:
{
int i;
xmlNodeSetPtr nodesetp;
array_init(&retval);
if (xpathobjp->type == XPATH_NODESET && NULL != (nodesetp = xpathobjp->nodesetval)) {
for (i = 0; i < nodesetp->nodeNr; i++) {
xmlNodePtr node = nodesetp->nodeTab[i];
zval child;
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(docp, NULL, (xmlChar *) node->children, node->name);
} else {
node = xmlNewDocNode(docp, 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(&retval, &child);
}
}
php_dom_create_interator(return_value, DOM_NODELIST);
nodeobj = Z_DOMOBJ_P(return_value);
dom_xpath_iter(&retval, nodeobj);
break;
}
case XPATH_BOOLEAN:
RETVAL_BOOL(xpathobjp->boolval);
break;
case XPATH_NUMBER:
RETVAL_DOUBLE(xpathobjp->floatval)
break;
case XPATH_STRING:
RETVAL_STRING((char *) xpathobjp->stringval);
break;
default:
RETVAL_NULL();
break;
}
xmlXPathFreeObject(xpathobjp);
}
/**
* xsltAddKey:
* @style: an XSLT stylesheet
* @name: the key name or NULL
* @nameURI: the name URI or NULL
* @match: the match value
* @use: the use value
* @inst: the key instruction
*
* add a key definition to a stylesheet
*
* Returns 0 in case of success, and -1 in case of failure.
*/
int
xsltAddKey(xsltStylesheetPtr style, const xmlChar *name,
const xmlChar *nameURI, const xmlChar *match,
const xmlChar *use, xmlNodePtr inst) {
xsltKeyDefPtr key;
xmlChar *pattern = NULL;
int current, end, start, i = 0;
if ((style == NULL) || (name == NULL) || (match == NULL) || (use == NULL))
return(-1);
#ifdef WITH_XSLT_DEBUG_KEYS
xsltGenericDebug(xsltGenericDebugContext,
"Add key %s, match %s, use %s\n", name, match, use);
#endif
key = xsltNewKeyDef(name, nameURI);
key->match = xmlStrdup(match);
key->use = xmlStrdup(use);
key->inst = inst;
key->nsList = xmlGetNsList(inst->doc, inst);
if (key->nsList != NULL) {
while (key->nsList[i] != NULL)
i++;
}
key->nsNr = i;
/*
* Split the | and register it as as many keys
*/
current = end = 0;
while (match[current] != 0) {
start = current;
while (IS_BLANK_CH(match[current]))
current++;
end = current;
while ((match[end] != 0) && (match[end] != '|')) {
if (match[end] == '[') {
end = skipPredicate(match, end);
if (end <= 0) {
xsltTransformError(NULL, style, inst,
"xsl:key : 'match' pattern is malformed: %s",
key->match);
if (style != NULL) style->errors++;
goto error;
}
} else
end++;
}
if (current == end) {
xsltTransformError(NULL, style, inst,
"xsl:key : 'match' pattern is empty\n");
if (style != NULL) style->errors++;
goto error;
}
if (match[start] != '/') {
pattern = xmlStrcat(pattern, (xmlChar *)"//");
if (pattern == NULL) {
if (style != NULL) style->errors++;
goto error;
}
}
pattern = xmlStrncat(pattern, &match[start], end - start);
if (pattern == NULL) {
if (style != NULL) style->errors++;
goto error;
}
if (match[end] == '|') {
pattern = xmlStrcat(pattern, (xmlChar *)"|");
end++;
}
current = end;
}
if (pattern == NULL) {
xsltTransformError(NULL, style, inst,
"xsl:key : 'match' pattern is empty\n");
if (style != NULL) style->errors++;
goto error;
}
#ifdef WITH_XSLT_DEBUG_KEYS
xsltGenericDebug(xsltGenericDebugContext,
" resulting pattern %s\n", pattern);
#endif
/*
* XSLT-1: "It is an error for the value of either the use
* attribute or the match attribute to contain a
* VariableReference."
* TODO: We should report a variable-reference at compile-time.
* Maybe a search for "$", if it occurs outside of quotation
* marks, could be sufficient.
*/
#ifdef XML_XPATH_NOVAR
key->comp = xsltXPathCompileFlags(style, pattern, XML_XPATH_NOVAR);
#else
key->comp = xsltXPathCompile(style, pattern);
#endif
if (key->comp == NULL) {
xsltTransformError(NULL, style, inst,
"xsl:key : 'match' pattern compilation failed '%s'\n",
pattern);
if (style != NULL) style->errors++;
}
#ifdef XML_XPATH_NOVAR
key->usecomp = xsltXPathCompileFlags(style, use, XML_XPATH_NOVAR);
#else
key->usecomp = xsltXPathCompile(style, use);
#endif
if (key->usecomp == NULL) {
xsltTransformError(NULL, style, inst,
"xsl:key : 'use' expression compilation failed '%s'\n",
use);
if (style != NULL) style->errors++;
}
/*
* Sometimes the stylesheet writer use the order to ease the
* resolution of keys when they are dependant, keep the provided
* order so add the new one at the end.
*/
if (style->keys == NULL) {
style->keys = key;
} else {
xsltKeyDefPtr prev = style->keys;
while (prev->next != NULL)
prev = prev->next;
prev->next = key;
}
key->next = NULL;
error:
if (pattern != NULL)
xmlFree(pattern);
return(0);
}
/**
* fastxml_xpath_search provides a common xpath search function for
* the libraries bits (node, doc). it handles mangling non-namespaced
* xpath queries into something libxml will play nice with
*/
VALUE fastxml_xpath_search(VALUE self, VALUE raw_xpath, VALUE blk)
{
VALUE ret, dv, xpath_s;
xmlXPathCompExprPtr xpath_xpr;
xmlXPathContextPtr xpath_ctx;
xmlXPathObjectPtr xpath_obj;
fxml_data_t *data;
xmlChar *xpath_expr;
xmlNodePtr root = NULL;
xmlNsPtr *ns_list = NULL;
xmlNsPtr *cur_ns = NULL;
xmlChar *root_ns = NULL;
int ns_cnt = 0;
if (NIL_P(raw_xpath))
rb_raise(rb_eArgError, "nil passed as xpath");
dv = rb_iv_get( self, "@lxml_doc" );
Data_Get_Struct( dv, fxml_data_t, data );
xpath_ctx = xmlXPathNewContext( data->doc );
if (xpath_ctx == NULL)
rb_raise( rb_eRuntimeError, "unable to create xpath context" );
root = data->node;
if (root == NULL)
root = xmlDocGetRootElement( data->doc );
xpath_ctx->node = root;
cur_ns = ns_list = xmlGetNsList( data->doc, root );
while (cur_ns != NULL && (*cur_ns) != NULL) {
xmlXPathRegisterNs( xpath_ctx, (*cur_ns)->prefix, (*cur_ns)->href );
cur_ns++;
}
if (ns_list != NULL) {
xpath_ctx->namespaces = ns_list;
xpath_ctx->nsNr = ns_cnt;
}
xpath_s = rb_obj_as_string( raw_xpath );
if (root->ns != NULL) { // we have a base namespace, this is going to get "interesting"
root_ns = (xmlChar*)root->ns->prefix;
if (root_ns == NULL)
root_ns = (xmlChar*)"__myFunkyLittleRootNsNotToBeUseByAnyoneElseIHope__";
// alternatives? how do other xpath processors handle root/default namespaces?
xmlXPathRegisterNs( xpath_ctx, root_ns, root->ns->href );
// need to update the xpath expression
xpath_s = munge_xpath_namespace( xpath_s, root_ns );
xpath_ctx->nsNr++;
}
xpath_expr = (xmlChar*)RSTRING_PTR(xpath_s);
xpath_xpr = xmlXPathCompile( xpath_expr );
if (xpath_xpr == NULL) {
xmlXPathFreeContext( xpath_ctx );
xmlFree( ns_list );
rb_raise( rb_eRuntimeError, "unable to evaluate xpath expression" );
}
xpath_obj = xmlXPathCompiledEval( xpath_xpr, xpath_ctx );
if (xpath_obj == NULL) {
rb_raise( rb_eRuntimeError, "unable to evaluate xpath expression" );
xmlXPathFreeCompExpr( xpath_xpr );
xmlXPathFreeContext( xpath_ctx );
xmlFree( ns_list );
return Qnil;
}
ret = fastxml_nodeset_to_obj( xpath_obj, data );
xmlFree( ns_list );
xmlXPathFreeCompExpr( xpath_xpr );
xmlXPathFreeContext( xpath_ctx );
return ret;
}
/**
* xsltCompileAttr:
* @style: a XSLT process context
* @attr: the attribute coming from the stylesheet.
*
* Precompile an attribute in a stylesheet, basically it checks if it is
* an attrubute value template, and if yes establish some structures needed
* to process it at transformation time.
*/
void
xsltCompileAttr(xsltStylesheetPtr style, xmlAttrPtr attr) {
const xmlChar *str;
const xmlChar *cur;
xmlChar *ret = NULL;
xmlChar *expr = NULL;
xsltAttrVTPtr avt;
int i = 0, lastavt = 0;
if ((style == NULL) || (attr == NULL) || (attr->children == NULL))
return;
if ((attr->children->type != XML_TEXT_NODE) ||
(attr->children->next != NULL)) {
xsltTransformError(NULL, style, attr->parent,
"Attribute '%s': The content is expected to be a single text "
"node when compiling an AVT.\n", attr->name);
style->errors++;
return;
}
str = attr->children->content;
if ((xmlStrchr(str, '{') == NULL) &&
(xmlStrchr(str, '}') == NULL)) return;
#ifdef WITH_XSLT_DEBUG_AVT
xsltGenericDebug(xsltGenericDebugContext,
"Found AVT %s: %s\n", attr->name, str);
#endif
if (attr->psvi != NULL) {
#ifdef WITH_XSLT_DEBUG_AVT
xsltGenericDebug(xsltGenericDebugContext,
"AVT %s: already compiled\n", attr->name);
#endif
return;
}
/*
* Create a new AVT object.
*/
avt = xsltNewAttrVT(style);
if (avt == NULL)
return;
attr->psvi = avt;
avt->nsList = xmlGetNsList(attr->doc, attr->parent);
if (avt->nsList != NULL) {
while (avt->nsList[i] != NULL)
i++;
}
avt->nsNr = i;
cur = str;
while (*cur != 0) {
if (*cur == '{') {
if (*(cur+1) == '{') { /* escaped '{' */
cur++;
ret = xmlStrncat(ret, str, cur - str);
cur++;
str = cur;
continue;
}
if (*(cur+1) == '}') { /* skip empty AVT */
ret = xmlStrncat(ret, str, cur - str);
cur += 2;
str = cur;
continue;
}
if ((ret != NULL) || (cur - str > 0)) {
ret = xmlStrncat(ret, str, cur - str);
str = cur;
if (avt->nb_seg == 0)
avt->strstart = 1;
if ((avt = xsltSetAttrVTsegment(avt, (void *) ret)) == NULL)
goto error;
ret = NULL;
lastavt = 0;
}
cur++;
while ((*cur != 0) && (*cur != '}')) {
/* Need to check for literal (bug539741) */
if ((*cur == '\'') || (*cur == '"')) {
char delim = *(cur++);
while ((*cur != 0) && (*cur != delim))
cur++;
if (*cur != 0)
cur++; /* skip the ending delimiter */
} else
cur++;
}
if (*cur == 0) {
xsltTransformError(NULL, style, attr->parent,
"Attribute '%s': The AVT has an unmatched '{'.\n",
attr->name);
style->errors++;
goto error;
}
str++;
expr = xmlStrndup(str, cur - str);
if (expr == NULL) {
/*
* TODO: What needs to be done here?
*/
XSLT_TODO
goto error;
} else {
xmlXPathCompExprPtr comp;
comp = xsltXPathCompile(style, expr);
if (comp == NULL) {
xsltTransformError(NULL, style, attr->parent,
"Attribute '%s': Failed to compile the expression "
"'%s' in the AVT.\n", attr->name, expr);
style->errors++;
goto error;
}
if (avt->nb_seg == 0)
avt->strstart = 0;
if (lastavt == 1) {
if ((avt = xsltSetAttrVTsegment(avt, NULL)) == NULL)
goto error;
}
if ((avt = xsltSetAttrVTsegment(avt, (void *) comp)) == NULL)
goto error;
lastavt = 1;
xmlFree(expr);
expr = NULL;
}
cur++;
str = cur;
} else if (*cur == '}') {
/**
* gxml_doc_get_ns_list:
*
* Deprecated: 0.15
*/
xmlNsPtr* gxml_doc_get_ns_list (xmlDoc* doc, xmlNode* node)
{
g_return_val_if_fail (doc != NULL, NULL);
g_return_val_if_fail (node != NULL, NULL);
return xmlGetNsList (doc, node);
}
