reactos/dll/3rdparty/libxslt/templates.c

   1 /*
   2  * templates.c: Implementation of the template processing
   3  *
   4  * Reference:
   5  *   http://www.w3.org/TR/1999/REC-xslt-19991116
   6  *
   7  * See Copyright for the status of this software.
   8  *
   9  * daniel@veillard.com
  10  */
  11
  12 #define IN_LIBXSLT
  13 #include "libxslt.h"
  14
  15 #include <string.h>
  16
  17 #include <libxml/xmlmemory.h>
  18 #include <libxml/globals.h>
  19 #include <libxml/xmlerror.h>
  20 #include <libxml/tree.h>
  21 #include <libxml/dict.h>
  22 #include <libxml/xpathInternals.h>
  23 #include <libxml/parserInternals.h>
  24 #include "xslt.h"
  25 #include "xsltInternals.h"
  26 #include "xsltutils.h"
  27 #include "variables.h"
  28 #include "functions.h"
  29 #include "templates.h"
  30 #include "transform.h"
  31 #include "namespaces.h"
  32 #include "attributes.h"
  33
  34 #ifdef WITH_XSLT_DEBUG
  35 #define WITH_XSLT_DEBUG_TEMPLATES
  36 #endif
  37
  38 /************************************************************************
  39  *                                                                      *
  40  *                      Module interfaces                               *
  41  *                                                                      *
  42  ************************************************************************/
  43
  44 /**
  45  * xsltEvalXPathPredicate:
  46  * @ctxt:  the XSLT transformation context
  47  * @comp:  the XPath compiled expression
  48  * @nsList:  the namespaces in scope
  49  * @nsNr:  the number of namespaces in scope
  50  *
  51  * Process the expression using XPath and evaluate the result as
  52  * an XPath predicate
  53  *
  54  * Returns 1 is the predicate was true, 0 otherwise
  55  */
  56 int
  57 xsltEvalXPathPredicate(xsltTransformContextPtr ctxt, xmlXPathCompExprPtr comp,
  58                        xmlNsPtr *nsList, int nsNr) {
  59     int ret;
  60     xmlXPathObjectPtr res;
  61     int oldNsNr;
  62     xmlNsPtr *oldNamespaces;
  63     xmlNodePtr oldInst;
  64     int oldProximityPosition, oldContextSize;
  65
  66     oldContextSize = ctxt->xpathCtxt->contextSize;
  67     oldProximityPosition = ctxt->xpathCtxt->proximityPosition;
  68     oldNsNr = ctxt->xpathCtxt->nsNr;
  69     oldNamespaces = ctxt->xpathCtxt->namespaces;
  70     oldInst = ctxt->inst;
  71
  72     ctxt->xpathCtxt->node = ctxt->node;
  73     ctxt->xpathCtxt->namespaces = nsList;
  74     ctxt->xpathCtxt->nsNr = nsNr;
  75
  76     res = xmlXPathCompiledEval(comp, ctxt->xpathCtxt);
  77
  78     if (res != NULL) {
  79         ret = xmlXPathEvalPredicate(ctxt->xpathCtxt, res);
  80         xmlXPathFreeObject(res);
  81 #ifdef WITH_XSLT_DEBUG_TEMPLATES
  82         XSLT_TRACE(ctxt,XSLT_TRACE_TEMPLATES,xsltGenericDebug(xsltGenericDebugContext,
  83              "xsltEvalXPathPredicate: returns %d\n", ret));
  84 #endif
  85     } else {
  86 #ifdef WITH_XSLT_DEBUG_TEMPLATES
  87         XSLT_TRACE(ctxt,XSLT_TRACE_TEMPLATES,xsltGenericDebug(xsltGenericDebugContext,
  88              "xsltEvalXPathPredicate: failed\n"));
  89 #endif
  90         ctxt->state = XSLT_STATE_STOPPED;
  91         ret = 0;
  92     }
  93     ctxt->xpathCtxt->nsNr = oldNsNr;
  94
  95     ctxt->xpathCtxt->namespaces = oldNamespaces;
  96     ctxt->inst = oldInst;
  97     ctxt->xpathCtxt->contextSize = oldContextSize;
  98     ctxt->xpathCtxt->proximityPosition = oldProximityPosition;
  99
 100     return(ret);
 101 }
 102
 103 /**
 104  * xsltEvalXPathStringNs:
 105  * @ctxt:  the XSLT transformation context
 106  * @comp:  the compiled XPath expression
 107  * @nsNr:  the number of namespaces in the list
 108  * @nsList:  the list of in-scope namespaces to use
 109  *
 110  * Process the expression using XPath, allowing to pass a namespace mapping
 111  * context and get a string
 112  *
 113  * Returns the computed string value or NULL, must be deallocated by the
 114  *    caller.
 115  */
 116 xmlChar *
 117 xsltEvalXPathStringNs(xsltTransformContextPtr ctxt, xmlXPathCompExprPtr comp,
 118                       int nsNr, xmlNsPtr *nsList) {
 119     xmlChar *ret = NULL;
 120     xmlXPathObjectPtr res;
 121     xmlNodePtr oldInst;
 122     xmlNodePtr oldNode;
 123     int oldPos, oldSize;
 124     int oldNsNr;
 125     xmlNsPtr *oldNamespaces;
 126
 127     oldInst = ctxt->inst;
 128     oldNode = ctxt->node;
 129     oldPos = ctxt->xpathCtxt->proximityPosition;
 130     oldSize = ctxt->xpathCtxt->contextSize;
 131     oldNsNr = ctxt->xpathCtxt->nsNr;
 132     oldNamespaces = ctxt->xpathCtxt->namespaces;
 133
 134     ctxt->xpathCtxt->node = ctxt->node;
 135     /* TODO: do we need to propagate the namespaces here ? */
 136     ctxt->xpathCtxt->namespaces = nsList;
 137     ctxt->xpathCtxt->nsNr = nsNr;
 138     res = xmlXPathCompiledEval(comp, ctxt->xpathCtxt);
 139     if (res != NULL) {
 140         if (res->type != XPATH_STRING)
 141             res = xmlXPathConvertString(res);
 142         if (res->type == XPATH_STRING) {
 143             ret = res->stringval;
 144             res->stringval = NULL;
 145         } else {
 146             xsltTransformError(ctxt, NULL, NULL,
 147                  "xpath : string() function didn't return a String\n");
 148         }
 149         xmlXPathFreeObject(res);
 150     } else {
 151         ctxt->state = XSLT_STATE_STOPPED;
 152     }
 153 #ifdef WITH_XSLT_DEBUG_TEMPLATES
 154     XSLT_TRACE(ctxt,XSLT_TRACE_TEMPLATES,xsltGenericDebug(xsltGenericDebugContext,
 155          "xsltEvalXPathString: returns %s\n", ret));
 156 #endif
 157     ctxt->inst = oldInst;
 158     ctxt->node = oldNode;
 159     ctxt->xpathCtxt->contextSize = oldSize;
 160     ctxt->xpathCtxt->proximityPosition = oldPos;
 161     ctxt->xpathCtxt->nsNr = oldNsNr;
 162     ctxt->xpathCtxt->namespaces = oldNamespaces;
 163     return(ret);
 164 }
 165
 166 /**
 167  * xsltEvalXPathString:
 168  * @ctxt:  the XSLT transformation context
 169  * @comp:  the compiled XPath expression
 170  *
 171  * Process the expression using XPath and get a string
 172  *
 173  * Returns the computed string value or NULL, must be deallocated by the
 174  *    caller.
 175  */
 176 xmlChar *
 177 xsltEvalXPathString(xsltTransformContextPtr ctxt, xmlXPathCompExprPtr comp) {
 178     return(xsltEvalXPathStringNs(ctxt, comp, 0, NULL));
 179 }
 180
 181 /**
 182  * xsltEvalTemplateString:
 183  * @ctxt:  the XSLT transformation context
 184  * @contextNode:  the current node in the source tree
 185  * @inst:  the XSLT instruction (xsl:comment, xsl:processing-instruction)
 186  *
 187  * Processes the sequence constructor of the given instruction on
 188  * @contextNode and converts the resulting tree to a string.
 189  * This is needed by e.g. xsl:comment and xsl:processing-instruction.
 190  *
 191  * Returns the computed string value or NULL; it's up to the caller to
 192  *         free the result.
 193  */
 194 xmlChar *
 195 xsltEvalTemplateString(xsltTransformContextPtr ctxt,
 196                        xmlNodePtr contextNode,
 197                        xmlNodePtr inst)
 198 {
 199     xmlNodePtr oldInsert, insert = NULL;
 200     xmlChar *ret;
 201
 202     if ((ctxt == NULL) || (contextNode == NULL) || (inst == NULL) ||
 203         (inst->type != XML_ELEMENT_NODE))
 204         return(NULL);
 205
 206     if (inst->children == NULL)
 207         return(NULL);
 208
 209     /*
 210     * This creates a temporary element-node to add the resulting
 211     * text content to.
 212     * OPTIMIZE TODO: Keep such an element-node in the transformation
 213     *  context to avoid creating it every time.
 214     */
 215     insert = xmlNewDocNode(ctxt->output, NULL,
 216                            (const xmlChar *)"fake", NULL);
 217     if (insert == NULL) {
 218         xsltTransformError(ctxt, NULL, contextNode,
 219                 "Failed to create temporary node\n");
 220         return(NULL);
 221     }
 222     oldInsert = ctxt->insert;
 223     ctxt->insert = insert;
 224     /*
 225     * OPTIMIZE TODO: if inst->children consists only of text-nodes.
 226     */
 227     xsltApplyOneTemplate(ctxt, contextNode, inst->children, NULL, NULL);
 228
 229     ctxt->insert = oldInsert;
 230
 231     ret = xmlNodeGetContent(insert);
 232     if (insert != NULL)
 233         xmlFreeNode(insert);
 234     return(ret);
 235 }
 236
 237 /**
 238  * xsltAttrTemplateValueProcessNode:
 239  * @ctxt:  the XSLT transformation context
 240  * @str:  the attribute template node value
 241  * @inst:  the instruction (or LRE) in the stylesheet holding the
 242  *         attribute with an AVT
 243  *
 244  * Process the given string, allowing to pass a namespace mapping
 245  * context and return the new string value.
 246  *
 247  * Called by:
 248  *  - xsltAttrTemplateValueProcess() (templates.c)
 249  *  - xsltEvalAttrValueTemplate() (templates.c)
 250  *
 251  * QUESTION: Why is this function public? It is not used outside
 252  *  of templates.c.
 253  *
 254  * Returns the computed string value or NULL, must be deallocated by the
 255  *    caller.
 256  */
 257 xmlChar *
 258 xsltAttrTemplateValueProcessNode(xsltTransformContextPtr ctxt,
 259           const xmlChar *str, xmlNodePtr inst)
 260 {
 261     xmlChar *ret = NULL;
 262     const xmlChar *cur;
 263     xmlChar *expr, *val;
 264     xmlNsPtr *nsList = NULL;
 265     int nsNr = 0;
 266
 267     if (str == NULL) return(NULL);
 268     if (*str == 0)
 269         return(xmlStrndup((xmlChar *)"", 0));
 270
 271     cur = str;
 272     while (*cur != 0) {
 273         if (*cur == '{') {
 274             if (*(cur+1) == '{') {      /* escaped '{' */
 275                 cur++;
 276                 ret = xmlStrncat(ret, str, cur - str);
 277                 cur++;
 278                 str = cur;
 279                 continue;
 280             }
 281             ret = xmlStrncat(ret, str, cur - str);
 282             str = cur;
 283             cur++;
 284             while ((*cur != 0) && (*cur != '}')) {
 285                 /* Need to check for literal (bug539741) */
 286                 if ((*cur == '\'') || (*cur == '"')) {
 287                     char delim = *(cur++);
 288                     while ((*cur != 0) && (*cur != delim))
 289                         cur++;
 290                     if (*cur != 0)
 291                         cur++;  /* skip the ending delimiter */
 292                 } else
 293                     cur++;
 294             }
 295             if (*cur == 0) {
 296                 xsltTransformError(ctxt, NULL, inst,
 297                         "xsltAttrTemplateValueProcessNode: unmatched '{'\n");
 298                 ret = xmlStrncat(ret, str, cur - str);
 299                 return(ret);
 300             }
 301             str++;
 302             expr = xmlStrndup(str, cur - str);
 303             if (expr == NULL)
 304                 return(ret);
 305             else if (*expr == '{') {
 306                 ret = xmlStrcat(ret, expr);
 307                 xmlFree(expr);
 308             } else {
 309                 xmlXPathCompExprPtr comp;
 310                 /*
 311                  * TODO: keep precompiled form around
 312                  */
 313                 if ((nsList == NULL) && (inst != NULL)) {
 314                     int i = 0;
 315
 316                     nsList = xmlGetNsList(inst->doc, inst);
 317                     if (nsList != NULL) {
 318                         while (nsList[i] != NULL)
 319                             i++;
 320                         nsNr = i;
 321                     }
 322                 }
 323                 comp = xmlXPathCompile(expr);
 324                 val = xsltEvalXPathStringNs(ctxt, comp, nsNr, nsList);
 325                 xmlXPathFreeCompExpr(comp);
 326                 xmlFree(expr);
 327                 if (val != NULL) {
 328                     ret = xmlStrcat(ret, val);
 329                     xmlFree(val);
 330                 }
 331             }
 332             cur++;
 333             str = cur;
 334         } else if (*cur == '}') {
 335             cur++;
 336             if (*cur == '}') {  /* escaped '}' */
 337                 ret = xmlStrncat(ret, str, cur - str);
 338                 cur++;
 339                 str = cur;
 340                 continue;
 341             } else {
 342                 xsltTransformError(ctxt, NULL, inst,
 343                      "xsltAttrTemplateValueProcessNode: unmatched '}'\n");
 344             }
 345         } else
 346             cur++;
 347     }
 348     if (cur != str) {
 349         ret = xmlStrncat(ret, str, cur - str);
 350     }
 351
 352     if (nsList != NULL)
 353         xmlFree(nsList);
 354
 355     return(ret);
 356 }
 357
 358 /**
 359  * xsltAttrTemplateValueProcess:
 360  * @ctxt:  the XSLT transformation context
 361  * @str:  the attribute template node value
 362  *
 363  * Process the given node and return the new string value.
 364  *
 365  * Returns the computed string value or NULL, must be deallocated by the
 366  *    caller.
 367  */
 368 xmlChar *
 369 xsltAttrTemplateValueProcess(xsltTransformContextPtr ctxt, const xmlChar *str) {
 370     return(xsltAttrTemplateValueProcessNode(ctxt, str, NULL));
 371 }
 372
 373 /**
 374  * xsltEvalAttrValueTemplate:
 375  * @ctxt:  the XSLT transformation context
 376  * @inst:  the instruction (or LRE) in the stylesheet holding the
 377  *         attribute with an AVT
 378  * @name:  the attribute QName
 379  * @ns:  the attribute namespace URI
 380  *
 381  * Evaluate a attribute value template, i.e. the attribute value can
 382  * contain expressions contained in curly braces ({}) and those are
 383  * substituted by they computed value.
 384  *
 385  * Returns the computed string value or NULL, must be deallocated by the
 386  *    caller.
 387  */
 388 xmlChar *
 389 xsltEvalAttrValueTemplate(xsltTransformContextPtr ctxt, xmlNodePtr inst,
 390                           const xmlChar *name, const xmlChar *ns)
 391 {
 392     xmlChar *ret;
 393     xmlChar *expr;
 394
 395     if ((ctxt == NULL) || (inst == NULL) || (name == NULL) ||
 396         (inst->type != XML_ELEMENT_NODE))
 397         return(NULL);
 398
 399     expr = xsltGetNsProp(inst, name, ns);
 400     if (expr == NULL)
 401         return(NULL);
 402
 403     /*
 404      * TODO: though now {} is detected ahead, it would still be good to
 405      *       optimize both functions to keep the splitted value if the
 406      *       attribute content and the XPath precompiled expressions around
 407      */
 408
 409     ret = xsltAttrTemplateValueProcessNode(ctxt, expr, inst);
 410 #ifdef WITH_XSLT_DEBUG_TEMPLATES
 411     XSLT_TRACE(ctxt,XSLT_TRACE_TEMPLATES,xsltGenericDebug(xsltGenericDebugContext,
 412          "xsltEvalAttrValueTemplate: %s returns %s\n", expr, ret));
 413 #endif
 414     if (expr != NULL)
 415         xmlFree(expr);
 416     return(ret);
 417 }
 418
 419 /**
 420  * xsltEvalStaticAttrValueTemplate:
 421  * @style:  the XSLT stylesheet
 422  * @inst:  the instruction (or LRE) in the stylesheet holding the
 423  *         attribute with an AVT
 424  * @name:  the attribute Name
 425  * @ns:  the attribute namespace URI
 426  * @found:  indicator whether the attribute is present
 427  *
 428  * Check if an attribute value template has a static value, i.e. the
 429  * attribute value does not contain expressions contained in curly braces ({})
 430  *
 431  * Returns the static string value or NULL, must be deallocated by the
 432  *    caller.
 433  */
 434 const xmlChar *
 435 xsltEvalStaticAttrValueTemplate(xsltStylesheetPtr style, xmlNodePtr inst,
 436                         const xmlChar *name, const xmlChar *ns, int *found) {
 437     const xmlChar *ret;
 438     xmlChar *expr;
 439
 440     if ((style == NULL) || (inst == NULL) || (name == NULL) ||
 441         (inst->type != XML_ELEMENT_NODE))
 442         return(NULL);
 443
 444     expr = xsltGetNsProp(inst, name, ns);
 445     if (expr == NULL) {
 446         *found = 0;
 447         return(NULL);
 448     }
 449     *found = 1;
 450
 451     ret = xmlStrchr(expr, '{');
 452     if (ret != NULL) {
 453         xmlFree(expr);
 454         return(NULL);
 455     }
 456     ret = xmlDictLookup(style->dict, expr, -1);
 457     xmlFree(expr);
 458     return(ret);
 459 }
 460
 461 /**
 462  * xsltAttrTemplateProcess:
 463  * @ctxt:  the XSLT transformation context
 464  * @target:  the element where the attribute will be grafted
 465  * @attr:  the attribute node of a literal result element
 466  *
 467  * Process one attribute of a Literal Result Element (in the stylesheet).
 468  * Evaluates Attribute Value Templates and copies the attribute over to
 469  * the result element.
 470  * This does *not* process attribute sets (xsl:use-attribute-set).
 471  *
 472  *
 473  * Returns the generated attribute node.
 474  */
 475 xmlAttrPtr
 476 xsltAttrTemplateProcess(xsltTransformContextPtr ctxt, xmlNodePtr target,
 477                         xmlAttrPtr attr)
 478 {
 479     const xmlChar *value;
 480     xmlAttrPtr ret;
 481
 482     if ((ctxt == NULL) || (attr == NULL) || (target == NULL) ||
 483         (target->type != XML_ELEMENT_NODE))
 484         return(NULL);
 485
 486     if (attr->type != XML_ATTRIBUTE_NODE)
 487         return(NULL);
 488
 489     /*
 490     * Skip all XSLT attributes.
 491     */
 492 #ifdef XSLT_REFACTORED
 493     if (attr->psvi == xsltXSLTAttrMarker)
 494         return(NULL);
 495 #else
 496     if ((attr->ns != NULL) && xmlStrEqual(attr->ns->href, XSLT_NAMESPACE))
 497         return(NULL);
 498 #endif
 499     /*
 500     * Get the value.
 501     */
 502     if (attr->children != NULL) {
 503         if ((attr->children->type != XML_TEXT_NODE) ||
 504             (attr->children->next != NULL))
 505         {
 506             xsltTransformError(ctxt, NULL, attr->parent,
 507                 "Internal error: The children of an attribute node of a "
 508                 "literal result element are not in the expected form.\n");
 509             return(NULL);
 510         }
 511         value = attr->children->content;
 512         if (value == NULL)
 513             value = xmlDictLookup(ctxt->dict, BAD_CAST "", 0);
 514     } else
 515         value = xmlDictLookup(ctxt->dict, BAD_CAST "", 0);
 516     /*
 517     * Overwrite duplicates.
 518     */
 519     ret = target->properties;
 520     while (ret != NULL) {
 521         if (((attr->ns != NULL) == (ret->ns != NULL)) &&
 522             xmlStrEqual(ret->name, attr->name) &&
 523             ((attr->ns == NULL) || xmlStrEqual(ret->ns->href, attr->ns->href)))
 524         {
 525             break;
 526         }
 527         ret = ret->next;
 528     }
 529     if (ret != NULL) {
 530         /* free the existing value */
 531         xmlFreeNodeList(ret->children);
 532         ret->children = ret->last = NULL;
 533         /*
 534         * Adjust ns-prefix if needed.
 535         */
 536         if ((ret->ns != NULL) &&
 537             (! xmlStrEqual(ret->ns->prefix, attr->ns->prefix)))
 538         {
 539             ret->ns = xsltGetNamespace(ctxt, attr->parent, attr->ns, target);
 540         }
 541     } else {
 542         /* create a new attribute */
 543         if (attr->ns != NULL)
 544             ret = xmlNewNsProp(target,
 545                 xsltGetNamespace(ctxt, attr->parent, attr->ns, target),
 546                     attr->name, NULL);
 547         else
 548             ret = xmlNewNsProp(target, NULL, attr->name, NULL);
 549     }
 550     /*
 551     * Set the value.
 552     */
 553     if (ret != NULL) {
 554         xmlNodePtr text;
 555
 556         text = xmlNewText(NULL);
 557         if (text != NULL) {
 558             ret->last = ret->children = text;
 559             text->parent = (xmlNodePtr) ret;
 560             text->doc = ret->doc;
 561
 562             if (attr->psvi != NULL) {
 563                 /*
 564                 * Evaluate the Attribute Value Template.
 565                 */
 566                 xmlChar *val;
 567                 val = xsltEvalAVT(ctxt, attr->psvi, attr->parent);
 568                 if (val == NULL) {
 569                     /*
 570                     * TODO: Damn, we need an easy mechanism to report
 571                     * qualified names!
 572                     */
 573                     if (attr->ns) {
 574                         xsltTransformError(ctxt, NULL, attr->parent,
 575                             "Internal error: Failed to evaluate the AVT "
 576                             "of attribute '{%s}%s'.\n",
 577                             attr->ns->href, attr->name);
 578                     } else {
 579                         xsltTransformError(ctxt, NULL, attr->parent,
 580                             "Internal error: Failed to evaluate the AVT "
 581                             "of attribute '%s'.\n",
 582                             attr->name);
 583                     }
 584                     text->content = xmlStrdup(BAD_CAST "");
 585                 } else {
 586                     text->content = val;
 587                 }
 588             } else if ((ctxt->internalized) && (target != NULL) &&
 589                        (target->doc != NULL) &&
 590                        (target->doc->dict == ctxt->dict) &&
 591                        xmlDictOwns(ctxt->dict, value)) {
 592                 text->content = (xmlChar *) value;
 593             } else {
 594                 text->content = xmlStrdup(value);
 595             }
 596         }
 597     } else {
 598         if (attr->ns) {
 599             xsltTransformError(ctxt, NULL, attr->parent,
 600                 "Internal error: Failed to create attribute '{%s}%s'.\n",
 601                 attr->ns->href, attr->name);
 602         } else {
 603             xsltTransformError(ctxt, NULL, attr->parent,
 604                 "Internal error: Failed to create attribute '%s'.\n",
 605                 attr->name);
 606         }
 607     }
 608     return(ret);
 609 }
 610
 611
 612 /**
 613  * xsltAttrListTemplateProcess:
 614  * @ctxt:  the XSLT transformation context
 615  * @target:  the element where the attributes will be grafted
 616  * @attrs:  the first attribute
 617  *
 618  * Processes all attributes of a Literal Result Element.
 619  * Attribute references are applied via xsl:use-attribute-set
 620  * attributes.
 621  * Copies all non XSLT-attributes over to the @target element
 622  * and evaluates Attribute Value Templates.
 623  *
 624  * Called by xsltApplySequenceConstructor() (transform.c).
 625  *
 626  * Returns a new list of attribute nodes, or NULL in case of error.
 627  *         (Don't assign the result to @target->properties; if
 628  *         the result is NULL, you'll get memory leaks, since the
 629  *         attributes will be disattached.)
 630  */
 631 xmlAttrPtr
 632 xsltAttrListTemplateProcess(xsltTransformContextPtr ctxt,
 633                             xmlNodePtr target, xmlAttrPtr attrs)
 634 {
 635     xmlAttrPtr attr, copy, last;
 636     xmlNodePtr oldInsert, text;
 637     xmlNsPtr origNs = NULL, copyNs = NULL;
 638     const xmlChar *value;
 639     xmlChar *valueAVT;
 640
 641     if ((ctxt == NULL) || (target == NULL) || (attrs == NULL) ||
 642         (target->type != XML_ELEMENT_NODE))
 643         return(NULL);
 644
 645     oldInsert = ctxt->insert;
 646     ctxt->insert = target;
 647
 648     /*
 649     * Instantiate LRE-attributes.
 650     */
 651     if (target->properties) {
 652         last = target->properties;
 653         while (last->next != NULL)
 654             last = last->next;
 655     } else {
 656         last = NULL;
 657     }
 658     attr = attrs;
 659     do {
 660         /*
 661         * Skip XSLT attributes.
 662         */
 663 #ifdef XSLT_REFACTORED
 664         if (attr->psvi == xsltXSLTAttrMarker) {
 665             goto next_attribute;
 666         }
 667 #else
 668         if ((attr->ns != NULL) &&
 669             xmlStrEqual(attr->ns->href, XSLT_NAMESPACE))
 670         {
 671             goto next_attribute;
 672         }
 673 #endif
 674         /*
 675         * Get the value.
 676         */
 677         if (attr->children != NULL) {
 678             if ((attr->children->type != XML_TEXT_NODE) ||
 679                 (attr->children->next != NULL))
 680             {
 681                 xsltTransformError(ctxt, NULL, attr->parent,
 682                     "Internal error: The children of an attribute node of a "
 683                     "literal result element are not in the expected form.\n");
 684                 goto error;
 685             }
 686             value = attr->children->content;
 687             if (value == NULL)
 688                 value = xmlDictLookup(ctxt->dict, BAD_CAST "", 0);
 689         } else
 690             value = xmlDictLookup(ctxt->dict, BAD_CAST "", 0);
 691
 692         /*
 693         * Create a new attribute.
 694         */
 695         copy = xmlNewDocProp(target->doc, attr->name, NULL);
 696         if (copy == NULL) {
 697             if (attr->ns) {
 698                 xsltTransformError(ctxt, NULL, attr->parent,
 699                     "Internal error: Failed to create attribute '{%s}%s'.\n",
 700                     attr->ns->href, attr->name);
 701             } else {
 702                 xsltTransformError(ctxt, NULL, attr->parent,
 703                     "Internal error: Failed to create attribute '%s'.\n",
 704                     attr->name);
 705             }
 706             goto error;
 707         }
 708         /*
 709         * Attach it to the target element.
 710         */
 711         copy->parent = target;
 712         if (last == NULL) {
 713             target->properties = copy;
 714             last = copy;
 715         } else {
 716             last->next = copy;
 717             copy->prev = last;
 718             last = copy;
 719         }
 720         /*
 721         * Set the namespace. Avoid lookups of same namespaces.
 722         */
 723         if (attr->ns != origNs) {
 724             origNs = attr->ns;
 725             if (attr->ns != NULL) {
 726 #ifdef XSLT_REFACTORED
 727                 copyNs = xsltGetSpecialNamespace(ctxt, attr->parent,
 728                     attr->ns->href, attr->ns->prefix, target);
 729 #else
 730                 copyNs = xsltGetNamespace(ctxt, attr->parent,
 731                     attr->ns, target);
 732 #endif
 733                 if (copyNs == NULL)
 734                     goto error;
 735             } else
 736                 copyNs = NULL;
 737         }
 738         copy->ns = copyNs;
 739
 740         /*
 741         * Set the value.
 742         */
 743         text = xmlNewText(NULL);
 744         if (text != NULL) {
 745             copy->last = copy->children = text;
 746             text->parent = (xmlNodePtr) copy;
 747             text->doc = copy->doc;
 748
 749             if (attr->psvi != NULL) {
 750                 /*
 751                 * Evaluate the Attribute Value Template.
 752                 */
 753                 valueAVT = xsltEvalAVT(ctxt, attr->psvi, attr->parent);
 754                 if (valueAVT == NULL) {
 755                     /*
 756                     * TODO: Damn, we need an easy mechanism to report
 757                     * qualified names!
 758                     */
 759                     if (attr->ns) {
 760                         xsltTransformError(ctxt, NULL, attr->parent,
 761                             "Internal error: Failed to evaluate the AVT "
 762                             "of attribute '{%s}%s'.\n",
 763                             attr->ns->href, attr->name);
 764                     } else {
 765                         xsltTransformError(ctxt, NULL, attr->parent,
 766                             "Internal error: Failed to evaluate the AVT "
 767                             "of attribute '%s'.\n",
 768                             attr->name);
 769                     }
 770                     text->content = xmlStrdup(BAD_CAST "");
 771                     goto error;
 772                 } else {
 773                     text->content = valueAVT;
 774                 }
 775             } else if ((ctxt->internalized) &&
 776                 (target->doc != NULL) &&
 777                 (target->doc->dict == ctxt->dict) &&
 778                 xmlDictOwns(ctxt->dict, value))
 779             {
 780                 text->content = (xmlChar *) value;
 781             } else {
 782                 text->content = xmlStrdup(value);
 783             }
 784             if ((copy != NULL) && (text != NULL) &&
 785                 (xmlIsID(copy->doc, copy->parent, copy)))
 786                 xmlAddID(NULL, copy->doc, text->content, copy);
 787         }
 788
 789 next_attribute:
 790         attr = attr->next;
 791     } while (attr != NULL);
 792
 793     /*
 794     * Apply attribute-sets.
 795     * The creation of such attributes will not overwrite any existing
 796     * attribute.
 797     */
 798     attr = attrs;
 799     do {
 800 #ifdef XSLT_REFACTORED
 801         if ((attr->psvi == xsltXSLTAttrMarker) &&
 802             xmlStrEqual(attr->name, (const xmlChar *)"use-attribute-sets"))
 803         {
 804             xsltApplyAttributeSet(ctxt, ctxt->node, (xmlNodePtr) attr, NULL);
 805         }
 806 #else
 807         if ((attr->ns != NULL) &&
 808             xmlStrEqual(attr->name, (const xmlChar *)"use-attribute-sets") &&
 809             xmlStrEqual(attr->ns->href, XSLT_NAMESPACE))
 810         {
 811             xsltApplyAttributeSet(ctxt, ctxt->node, (xmlNodePtr) attr, NULL);
 812         }
 813 #endif
 814         attr = attr->next;
 815     } while (attr != NULL);
 816
 817     ctxt->insert = oldInsert;
 818     return(target->properties);
 819
 820 error:
 821     ctxt->insert = oldInsert;
 822     return(NULL);
 823 }
 824
 825
 826 /**
 827  * xsltTemplateProcess:
 828  * @ctxt:  the XSLT transformation context
 829  * @node:  the attribute template node
 830  *
 831  * Obsolete. Don't use it.
 832  *
 833  * Returns NULL.
 834  */
 835 xmlNodePtr *
 836 xsltTemplateProcess(xsltTransformContextPtr ctxt ATTRIBUTE_UNUSED, xmlNodePtr node) {
 837     if (node == NULL)
 838         return(NULL);
 839
 840     return(0);
 841 }
 842
 843