Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxslt/libxslt/templates.c

 /*
  * templates.c: Implementation of the template processing
  *
  * Reference:
  *   http://www.w3.org/TR/1999/REC-xslt-19991116
  *
  * See Copyright for the status of this software.
  *
  * daniel@veillard.com
  */
@@ skipping 22 matching lines @@
 
 #ifdef WITH_XSLT_DEBUG
 #define WITH_XSLT_DEBUG_TEMPLATES
 #endif
 
 /************************************************************************
  *                                                                      *
  *                      Module interfaces                               *
  *                                                                      *
  ************************************************************************/
- 
+
 /**
  * xsltEvalXPathPredicate:
  * @ctxt:  the XSLT transformation context
  * @comp:  the XPath compiled expression
  * @nsList:  the namespaces in scope
  * @nsNr:  the number of namespaces in scope
  *
  * Process the expression using XPath and evaluate the result as
  * an XPath predicate
  *
@@ skipping 138 matching lines @@
  *         free the result.
  */
 xmlChar *
 xsltEvalTemplateString(xsltTransformContextPtr ctxt,
                        xmlNodePtr contextNode,
                        xmlNodePtr inst)
 {
     xmlNodePtr oldInsert, insert = NULL;
     xmlChar *ret;
 
-    if ((ctxt == NULL) || (contextNode == NULL) || (inst == NULL))
+    if ((ctxt == NULL) || (contextNode == NULL) || (inst == NULL) ||
+        (inst->type != XML_ELEMENT_NODE))
         return(NULL);
 
     if (inst->children == NULL)
         return(NULL);
 
     /*
     * This creates a temporary element-node to add the resulting
     * text content to.
     * OPTIMIZE TODO: Keep such an element-node in the transformation
     *  context to avoid creating it every time.
@@ skipping 60 matching lines @@
             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++;
+            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(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);
@@ skipping 80 matching lines @@
  * Returns the computed string value or NULL, must be deallocated by the
  *    caller.
  */
 xmlChar *
 xsltEvalAttrValueTemplate(xsltTransformContextPtr ctxt, xmlNodePtr inst,
                           const xmlChar *name, const xmlChar *ns)
 {
     xmlChar *ret;
     xmlChar *expr;
 
-    if ((ctxt == NULL) || (inst == NULL) || (name == NULL))
+    if ((ctxt == NULL) || (inst == NULL) || (name == NULL) ||
+        (inst->type != XML_ELEMENT_NODE))
         return(NULL);
 
     expr = xsltGetNsProp(inst, name, ns);
     if (expr == NULL)
         return(NULL);
 
     /*
      * TODO: though now {} is detected ahead, it would still be good to
      *       optimize both functions to keep the splitted value if the
      *       attribute content and the XPath precompiled expressions around
@@ skipping 23 matching lines @@
  *
  * Returns the static string value or NULL, must be deallocated by the
  *    caller.
  */
 const xmlChar *
 xsltEvalStaticAttrValueTemplate(xsltStylesheetPtr style, xmlNodePtr inst,
                         const xmlChar *name, const xmlChar *ns, int *found) {
     const xmlChar *ret;
     xmlChar *expr;
 
-    if ((style == NULL) || (inst == NULL) || (name == NULL))
+    if ((style == NULL) || (inst == NULL) || (name == NULL) ||
+        (inst->type != XML_ELEMENT_NODE))
         return(NULL);
 
     expr = xsltGetNsProp(inst, name, ns);
     if (expr == NULL) {
         *found = 0;
         return(NULL);
     }
     *found = 1;
 
     ret = xmlStrchr(expr, '{');
     if (ret != NULL) {
         xmlFree(expr);
         return(NULL);
     }
     ret = xmlDictLookup(style->dict, expr, -1);
     xmlFree(expr);
     return(ret);
 }
 
 /**
  * xsltAttrTemplateProcess:
  * @ctxt:  the XSLT transformation context
  * @target:  the element where the attribute will be grafted
  * @attr:  the attribute node of a literal result element
  *
  * Process one attribute of a Literal Result Element (in the stylesheet).
  * Evaluates Attribute Value Templates and copies the attribute over to
  * the result element.
  * This does *not* process attribute sets (xsl:use-attribute-set).
- * 
+ *
  *
  * Returns the generated attribute node.
  */
 xmlAttrPtr
 xsltAttrTemplateProcess(xsltTransformContextPtr ctxt, xmlNodePtr target,
                         xmlAttrPtr attr)
 {
     const xmlChar *value;
     xmlAttrPtr ret;
 
-    if ((ctxt == NULL) || (attr == NULL) || (target == NULL))
+    if ((ctxt == NULL) || (attr == NULL) || (target == NULL) ||
+        (target->type != XML_ELEMENT_NODE))
         return(NULL);
-    
+
     if (attr->type != XML_ATTRIBUTE_NODE)
         return(NULL);
 
     /*
     * Skip all XSLT attributes.
     */
-#ifdef XSLT_REFACTORED    
+#ifdef XSLT_REFACTORED
     if (attr->psvi == xsltXSLTAttrMarker)
         return(NULL);
 #else
     if ((attr->ns != NULL) && xmlStrEqual(attr->ns->href, XSLT_NAMESPACE))
         return(NULL);
 #endif
     /*
     * Get the value.
     */
     if (attr->children != NULL) {
@@ skipping 16 matching lines @@
     ret = target->properties;
     while (ret != NULL) {
         if (((attr->ns != NULL) == (ret->ns != NULL)) &&
             xmlStrEqual(ret->name, attr->name) &&
             ((attr->ns == NULL) || xmlStrEqual(ret->ns->href, attr->ns->href)))
         {
             break;
         }
         ret = ret->next;
     }
-    if (ret != NULL) {  
+    if (ret != NULL) {
         /* free the existing value */
         xmlFreeNodeList(ret->children);
         ret->children = ret->last = NULL;
         /*
         * Adjust ns-prefix if needed.
         */
         if ((ret->ns != NULL) &&
             (! xmlStrEqual(ret->ns->prefix, attr->ns->prefix)))
         {
             ret->ns = xsltGetNamespace(ctxt, attr->parent, attr->ns, target);
         }
     } else {
         /* create a new attribute */
         if (attr->ns != NULL)
             ret = xmlNewNsProp(target,
                 xsltGetNamespace(ctxt, attr->parent, attr->ns, target),
                     attr->name, NULL);
         else
-            ret = xmlNewNsProp(target, NULL, attr->name, NULL); 
+            ret = xmlNewNsProp(target, NULL, attr->name, NULL);
     }
     /*
     * Set the value.
     */
     if (ret != NULL) {
         xmlNodePtr text;
 
         text = xmlNewText(NULL);
         if (text != NULL) {
             ret->last = ret->children = text;
@@ skipping 31 matching lines @@
                        (target->doc->dict == ctxt->dict) &&
                        xmlDictOwns(ctxt->dict, value)) {
                 text->content = (xmlChar *) value;
             } else {
                 text->content = xmlStrdup(value);
             }
         }
     } else {
         if (attr->ns) {
             xsltTransformError(ctxt, NULL, attr->parent,
-                "Internal error: Failed to create attribute '{%s}%s'.\n",
+                "Internal error: Failed to create attribute '{%s}%s'.\n",
                 attr->ns->href, attr->name);
         } else {
             xsltTransformError(ctxt, NULL, attr->parent,
-                "Internal error: Failed to create attribute '%s'.\n",
+                "Internal error: Failed to create attribute '%s'.\n",
                 attr->name);
         }
     }
     return(ret);
 }
 
 
 /**
  * xsltAttrListTemplateProcess:
  * @ctxt:  the XSLT transformation context
  * @target:  the element where the attributes will be grafted
  * @attrs:  the first attribute
  *
  * Processes all attributes of a Literal Result Element.
  * Attribute references are applied via xsl:use-attribute-set
  * attributes.
  * Copies all non XSLT-attributes over to the @target element
  * and evaluates Attribute Value Templates.
  *
  * Called by xsltApplySequenceConstructor() (transform.c).
  *
  * Returns a new list of attribute nodes, or NULL in case of error.
  *         (Don't assign the result to @target->properties; if
  *         the result is NULL, you'll get memory leaks, since the
  *         attributes will be disattached.)
  */
 xmlAttrPtr
-xsltAttrListTemplateProcess(xsltTransformContextPtr ctxt, 
+xsltAttrListTemplateProcess(xsltTransformContextPtr ctxt,
                             xmlNodePtr target, xmlAttrPtr attrs)
 {
     xmlAttrPtr attr, copy, last;
     xmlNodePtr oldInsert, text;
     xmlNsPtr origNs = NULL, copyNs = NULL;
     const xmlChar *value;
     xmlChar *valueAVT;
 
-    if ((ctxt == NULL) || (target == NULL) || (attrs == NULL))
+    if ((ctxt == NULL) || (target == NULL) || (attrs == NULL) ||
+        (target->type != XML_ELEMENT_NODE))
         return(NULL);
 
     oldInsert = ctxt->insert;
-    ctxt->insert = target;        
+    ctxt->insert = target;
 
     /*
     * Instantiate LRE-attributes.
     */
     if (target->properties) {
         last = target->properties;
         while (last->next != NULL)
             last = last->next;
     } else {
         last = NULL;
@@ skipping 172 matching lines @@
  * @node:  the attribute template node
  *
  * Obsolete. Don't use it.
  *
  * Returns NULL.
  */
 xmlNodePtr *
 xsltTemplateProcess(xsltTransformContextPtr ctxt ATTRIBUTE_UNUSED, xmlNodePtr node) {
     if (node == NULL)
         return(NULL);
-    
+
     return(0);
 }