dll/3rdparty/libxslt/attributes.c

   1 /*
   2  * attributes.c: Implementation of the XSLT attributes handling
   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 #ifdef HAVE_SYS_TYPES_H
  18 #include <sys/types.h>
  19 #endif
  20 #ifdef HAVE_MATH_H
  21 #include <math.h>
  22 #endif
  23 #ifdef HAVE_FLOAT_H
  24 #include <float.h>
  25 #endif
  26 #ifdef HAVE_IEEEFP_H
  27 #include <ieeefp.h>
  28 #endif
  29 #ifdef HAVE_NAN_H
  30 #include <nan.h>
  31 #endif
  32 #ifdef HAVE_CTYPE_H
  33 #include <ctype.h>
  34 #endif
  35
  36 #include <libxml/xmlmemory.h>
  37 #include <libxml/tree.h>
  38 #include <libxml/hash.h>
  39 #include <libxml/xmlerror.h>
  40 #include <libxml/uri.h>
  41 #include <libxml/parserInternals.h>
  42 #include "xslt.h"
  43 #include "xsltInternals.h"
  44 #include "xsltutils.h"
  45 #include "attributes.h"
  46 #include "namespaces.h"
  47 #include "templates.h"
  48 #include "imports.h"
  49 #include "transform.h"
  50 #include "preproc.h"
  51
  52 #define WITH_XSLT_DEBUG_ATTRIBUTES
  53 #ifdef WITH_XSLT_DEBUG
  54 #define WITH_XSLT_DEBUG_ATTRIBUTES
  55 #endif
  56
  57 /*
  58  * TODO: merge attribute sets from different import precedence.
  59  *       all this should be precomputed just before the transformation
  60  *       starts or at first hit with a cache in the context.
  61  *       The simple way for now would be to not allow redefinition of
  62  *       attributes once generated in the output tree, possibly costlier.
  63  */
  64
  65 /*
  66  * Useful macros
  67  */
  68 #ifdef IS_BLANK
  69 #undef IS_BLANK
  70 #endif
  71
  72 #define IS_BLANK(c) (((c) == 0x20) || ((c) == 0x09) || ((c) == 0xA) ||  \
  73                      ((c) == 0x0D))
  74
  75 #define IS_BLANK_NODE(n)                                                \
  76     (((n)->type == XML_TEXT_NODE) && (xsltIsBlank((n)->content)))
  77
  78
  79 /*
  80  * The in-memory structure corresponding to an XSLT Attribute in
  81  * an attribute set
  82  */
  83
  84
  85 typedef struct _xsltAttrElem xsltAttrElem;
  86 typedef xsltAttrElem *xsltAttrElemPtr;
  87 struct _xsltAttrElem {
  88     struct _xsltAttrElem *next;/* chained list */
  89     xmlNodePtr attr;    /* the xsl:attribute definition */
  90     const xmlChar *set; /* or the attribute set */
  91     const xmlChar *ns;  /* and its namespace */
  92 };
  93
  94 /************************************************************************
  95  *                                                                      *
  96  *                      XSLT Attribute handling                         *
  97  *                                                                      *
  98  ************************************************************************/
  99
 100 /**
 101  * xsltNewAttrElem:
 102  * @attr:  the new xsl:attribute node
 103  *
 104  * Create a new XSLT AttrElem
 105  *
 106  * Returns the newly allocated xsltAttrElemPtr or NULL in case of error
 107  */
 108 static xsltAttrElemPtr
 109 xsltNewAttrElem(xmlNodePtr attr) {
 110     xsltAttrElemPtr cur;
 111
 112     cur = (xsltAttrElemPtr) xmlMalloc(sizeof(xsltAttrElem));
 113     if (cur == NULL) {
 114         xsltGenericError(xsltGenericErrorContext,
 115                 "xsltNewAttrElem : malloc failed\n");
 116         return(NULL);
 117     }
 118     memset(cur, 0, sizeof(xsltAttrElem));
 119     cur->attr = attr;
 120     return(cur);
 121 }
 122
 123 /**
 124  * xsltFreeAttrElem:
 125  * @attr:  an XSLT AttrElem
 126  *
 127  * Free up the memory allocated by @attr
 128  */
 129 static void
 130 xsltFreeAttrElem(xsltAttrElemPtr attr) {
 131     xmlFree(attr);
 132 }
 133
 134 /**
 135  * xsltFreeAttrElemList:
 136  * @list:  an XSLT AttrElem list
 137  *
 138  * Free up the memory allocated by @list
 139  */
 140 static void
 141 xsltFreeAttrElemList(xsltAttrElemPtr list) {
 142     xsltAttrElemPtr next;
 143
 144     while (list != NULL) {
 145         next = list->next;
 146         xsltFreeAttrElem(list);
 147         list = next;
 148     }
 149 }
 150
 151 #ifdef XSLT_REFACTORED
 152     /*
 153     * This was moved to xsltParseStylesheetAttributeSet().
 154     */
 155 #else
 156 /**
 157  * xsltAddAttrElemList:
 158  * @list:  an XSLT AttrElem list
 159  * @attr:  the new xsl:attribute node
 160  *
 161  * Add the new attribute to the list.
 162  *
 163  * Returns the new list pointer
 164  */
 165 static xsltAttrElemPtr
 166 xsltAddAttrElemList(xsltAttrElemPtr list, xmlNodePtr attr) {
 167     xsltAttrElemPtr next, cur;
 168
 169     if (attr == NULL)
 170         return(list);
 171     if (list == NULL)
 172         return(xsltNewAttrElem(attr));
 173     cur = list;
 174     while (cur != NULL) {
 175         next = cur->next;
 176         if (cur->attr == attr)
 177             return(cur);
 178         if (cur->next == NULL) {
 179             cur->next = xsltNewAttrElem(attr);
 180             return(list);
 181         }
 182         cur = next;
 183     }
 184     return(list);
 185 }
 186 #endif /* XSLT_REFACTORED */
 187
 188 /**
 189  * xsltMergeAttrElemList:
 190  * @list:  an XSLT AttrElem list
 191  * @old:  another XSLT AttrElem list
 192  *
 193  * Add all the attributes from list @old to list @list,
 194  * but drop redefinition of existing values.
 195  *
 196  * Returns the new list pointer
 197  */
 198 static xsltAttrElemPtr
 199 xsltMergeAttrElemList(xsltStylesheetPtr style,
 200                       xsltAttrElemPtr list, xsltAttrElemPtr old) {
 201     xsltAttrElemPtr cur;
 202     int add;
 203
 204     while (old != NULL) {
 205         if ((old->attr == NULL) && (old->set == NULL)) {
 206             old = old->next;
 207             continue;
 208         }
 209         /*
 210          * Check that the attribute is not yet in the list
 211          */
 212         cur = list;
 213         add = 1;
 214         while (cur != NULL) {
 215             if ((cur->attr == NULL) && (cur->set == NULL)) {
 216                 if (cur->next == NULL)
 217                     break;
 218                 cur = cur->next;
 219                 continue;
 220             }
 221             if ((cur->set != NULL) && (cur->set == old->set)) {
 222                 add = 0;
 223                 break;
 224             }
 225             if (cur->set != NULL) {
 226                 if (cur->next == NULL)
 227                     break;
 228                 cur = cur->next;
 229                 continue;
 230             }
 231             if (old->set != NULL) {
 232                 if (cur->next == NULL)
 233                     break;
 234                 cur = cur->next;
 235                 continue;
 236             }
 237             if (cur->attr == old->attr) {
 238                 xsltGenericError(xsltGenericErrorContext,
 239              "xsl:attribute-set : use-attribute-sets recursion detected\n");
 240                 return(list);
 241             }
 242             if (cur->next == NULL)
 243                 break;
 244             cur = cur->next;
 245         }
 246
 247         if (add == 1) {
 248             /*
 249             * Changed to use the string-dict, rather than duplicating
 250             * @set and @ns; this fixes bug #340400.
 251             */
 252             if (cur == NULL) {
 253                 list = xsltNewAttrElem(old->attr);
 254                 if (old->set != NULL) {
 255                     list->set = xmlDictLookup(style->dict, old->set, -1);
 256                     if (old->ns != NULL)
 257                         list->ns = xmlDictLookup(style->dict, old->ns, -1);
 258                 }
 259             } else if (add) {
 260                 cur->next = xsltNewAttrElem(old->attr);
 261                 if (old->set != NULL) {
 262                     cur->next->set = xmlDictLookup(style->dict, old->set, -1);
 263                     if (old->ns != NULL)
 264                         cur->next->ns = xmlDictLookup(style->dict, old->ns, -1);
 265                 }
 266             }
 267         }
 268
 269         old = old->next;
 270     }
 271     return(list);
 272 }
 273
 274 /************************************************************************
 275  *                                                                      *
 276  *                      Module interfaces                               *
 277  *                                                                      *
 278  ************************************************************************/
 279
 280 /**
 281  * xsltParseStylesheetAttributeSet:
 282  * @style:  the XSLT stylesheet
 283  * @cur:  the "attribute-set" element
 284  *
 285  * parse an XSLT stylesheet attribute-set element
 286  */
 287
 288 void
 289 xsltParseStylesheetAttributeSet(xsltStylesheetPtr style, xmlNodePtr cur) {
 290     const xmlChar *ncname;
 291     const xmlChar *prefix;
 292     xmlChar *value;
 293     xmlNodePtr child;
 294     xsltAttrElemPtr attrItems;
 295
 296     if ((cur == NULL) || (style == NULL))
 297         return;
 298
 299     value = xmlGetNsProp(cur, (const xmlChar *)"name", NULL);
 300     if (value == NULL) {
 301         xsltGenericError(xsltGenericErrorContext,
 302              "xsl:attribute-set : name is missing\n");
 303         return;
 304     }
 305
 306     ncname = xsltSplitQName(style->dict, value, &prefix);
 307     xmlFree(value);
 308     value = NULL;
 309
 310     if (style->attributeSets == NULL) {
 311 #ifdef WITH_XSLT_DEBUG_ATTRIBUTES
 312         xsltGenericDebug(xsltGenericDebugContext,
 313             "creating attribute set table\n");
 314 #endif
 315         style->attributeSets = xmlHashCreate(10);
 316     }
 317     if (style->attributeSets == NULL)
 318         return;
 319
 320     attrItems = xmlHashLookup2(style->attributeSets, ncname, prefix);
 321
 322     /*
 323     * Parse the content. Only xsl:attribute elements are allowed.
 324     */
 325     child = cur->children;
 326     while (child != NULL) {
 327         /*
 328         * Report invalid nodes.
 329         */
 330         if ((child->type != XML_ELEMENT_NODE) ||
 331             (child->ns == NULL) ||
 332             (! IS_XSLT_ELEM(child)))
 333         {
 334             if (child->type == XML_ELEMENT_NODE)
 335                 xsltTransformError(NULL, style, child,
 336                         "xsl:attribute-set : unexpected child %s\n",
 337                                  child->name);
 338             else
 339                 xsltTransformError(NULL, style, child,
 340                         "xsl:attribute-set : child of unexpected type\n");
 341         } else if (!IS_XSLT_NAME(child, "attribute")) {
 342             xsltTransformError(NULL, style, child,
 343                 "xsl:attribute-set : unexpected child xsl:%s\n",
 344                 child->name);
 345         } else {
 346 #ifdef XSLT_REFACTORED
 347             xsltAttrElemPtr nextAttr, curAttr;
 348
 349             /*
 350             * Process xsl:attribute
 351             * ---------------------
 352             */
 353
 354 #ifdef WITH_XSLT_DEBUG_ATTRIBUTES
 355             xsltGenericDebug(xsltGenericDebugContext,
 356                 "add attribute to list %s\n", ncname);
 357 #endif
 358             /*
 359             * The following was taken over from
 360             * xsltAddAttrElemList().
 361             */
 362             if (attrItems == NULL) {
 363                 attrItems = xsltNewAttrElem(child);
 364             } else {
 365                 curAttr = attrItems;
 366                 while (curAttr != NULL) {
 367                     nextAttr = curAttr->next;
 368                     if (curAttr->attr == child) {
 369                         /*
 370                         * URGENT TODO: Can somebody explain
 371                         *  why attrItems is set to curAttr
 372                         *  here? Is this somehow related to
 373                         *  avoidance of recursions?
 374                         */
 375                         attrItems = curAttr;
 376                         goto next_child;
 377                     }
 378                     if (curAttr->next == NULL)
 379                         curAttr->next = xsltNewAttrElem(child);
 380                     curAttr = nextAttr;
 381                 }
 382             }
 383             /*
 384             * Parse the xsl:attribute and its content.
 385             */
 386             xsltParseAnyXSLTElem(XSLT_CCTXT(style), child);
 387 #else
 388 #ifdef WITH_XSLT_DEBUG_ATTRIBUTES
 389             xsltGenericDebug(xsltGenericDebugContext,
 390                 "add attribute to list %s\n", ncname);
 391 #endif
 392             /*
 393             * OLD behaviour:
 394             */
 395             attrItems = xsltAddAttrElemList(attrItems, child);
 396 #endif
 397         }
 398
 399 #ifdef XSLT_REFACTORED
 400 next_child:
 401 #endif
 402         child = child->next;
 403     }
 404
 405     /*
 406     * Process attribue "use-attribute-sets".
 407     */
 408     /* TODO check recursion */
 409     value = xmlGetNsProp(cur, (const xmlChar *)"use-attribute-sets",
 410         NULL);
 411     if (value != NULL) {
 412         const xmlChar *curval, *endval;
 413         curval = value;
 414         while (*curval != 0) {
 415             while (IS_BLANK(*curval)) curval++;
 416             if (*curval == 0)
 417                 break;
 418             endval = curval;
 419             while ((*endval != 0) && (!IS_BLANK(*endval))) endval++;
 420             curval = xmlDictLookup(style->dict, curval, endval - curval);
 421             if (curval) {
 422                 const xmlChar *ncname2 = NULL;
 423                 const xmlChar *prefix2 = NULL;
 424                 xsltAttrElemPtr refAttrItems;
 425
 426 #ifdef WITH_XSLT_DEBUG_ATTRIBUTES
 427                 xsltGenericDebug(xsltGenericDebugContext,
 428                     "xsl:attribute-set : %s adds use %s\n", ncname, curval);
 429 #endif
 430                 ncname2 = xsltSplitQName(style->dict, curval, &prefix2);
 431                 refAttrItems = xsltNewAttrElem(NULL);
 432                 if (refAttrItems != NULL) {
 433                     refAttrItems->set = ncname2;
 434                     refAttrItems->ns = prefix2;
 435                     attrItems = xsltMergeAttrElemList(style,
 436                         attrItems, refAttrItems);
 437                     xsltFreeAttrElem(refAttrItems);
 438                 }
 439             }
 440             curval = endval;
 441         }
 442         xmlFree(value);
 443         value = NULL;
 444     }
 445
 446     /*
 447      * Update the value
 448      */
 449     /*
 450     * TODO: Why is this dummy entry needed.?
 451     */
 452     if (attrItems == NULL)
 453         attrItems = xsltNewAttrElem(NULL);
 454     xmlHashUpdateEntry2(style->attributeSets, ncname, prefix, attrItems, NULL);
 455 #ifdef WITH_XSLT_DEBUG_ATTRIBUTES
 456     xsltGenericDebug(xsltGenericDebugContext,
 457         "updated attribute list %s\n", ncname);
 458 #endif
 459 }
 460
 461 /**
 462  * xsltGetSAS:
 463  * @style:  the XSLT stylesheet
 464  * @name:  the attribute list name
 465  * @ns:  the attribute list namespace
 466  *
 467  * lookup an attribute set based on the style cascade
 468  *
 469  * Returns the attribute set or NULL
 470  */
 471 static xsltAttrElemPtr
 472 xsltGetSAS(xsltStylesheetPtr style, const xmlChar *name, const xmlChar *ns) {
 473     xsltAttrElemPtr values;
 474
 475     while (style != NULL) {
 476         values = xmlHashLookup2(style->attributeSets, name, ns);
 477         if (values != NULL)
 478             return(values);
 479         style = xsltNextImport(style);
 480     }
 481     return(NULL);
 482 }
 483
 484 /**
 485  * xsltResolveSASCallback,:
 486  * @style:  the XSLT stylesheet
 487  *
 488  * resolve the references in an attribute set.
 489  */
 490 static void
 491 xsltResolveSASCallback(xsltAttrElemPtr values, xsltStylesheetPtr style,
 492                        const xmlChar *name, const xmlChar *ns,
 493                        ATTRIBUTE_UNUSED const xmlChar *ignored) {
 494     xsltAttrElemPtr tmp;
 495     xsltAttrElemPtr refs;
 496
 497     tmp = values;
 498     while (tmp != NULL) {
 499         if (tmp->set != NULL) {
 500             /*
 501              * Check against cycles !
 502              */
 503             if ((xmlStrEqual(name, tmp->set)) && (xmlStrEqual(ns, tmp->ns))) {
 504                 xsltGenericError(xsltGenericErrorContext,
 505      "xsl:attribute-set : use-attribute-sets recursion detected on %s\n",
 506                                  name);
 507             } else {
 508 #ifdef WITH_XSLT_DEBUG_ATTRIBUTES
 509                 xsltGenericDebug(xsltGenericDebugContext,
 510                         "Importing attribute list %s\n", tmp->set);
 511 #endif
 512
 513                 refs = xsltGetSAS(style, tmp->set, tmp->ns);
 514                 if (refs == NULL) {
 515                     xsltGenericError(xsltGenericErrorContext,
 516      "xsl:attribute-set : use-attribute-sets %s reference missing %s\n",
 517                                      name, tmp->set);
 518                 } else {
 519                     /*
 520                      * recurse first for cleanup
 521                      */
 522                     xsltResolveSASCallback(refs, style, name, ns, NULL);
 523                     /*
 524                      * Then merge
 525                      */
 526                     xsltMergeAttrElemList(style, values, refs);
 527                     /*
 528                      * Then suppress the reference
 529                      */
 530                     tmp->set = NULL;
 531                     tmp->ns = NULL;
 532                 }
 533             }
 534         }
 535         tmp = tmp->next;
 536     }
 537 }
 538
 539 /**
 540  * xsltMergeSASCallback,:
 541  * @style:  the XSLT stylesheet
 542  *
 543  * Merge an attribute set from an imported stylesheet.
 544  */
 545 static void
 546 xsltMergeSASCallback(xsltAttrElemPtr values, xsltStylesheetPtr style,
 547                        const xmlChar *name, const xmlChar *ns,
 548                        ATTRIBUTE_UNUSED const xmlChar *ignored) {
 549     int ret;
 550     xsltAttrElemPtr topSet;
 551
 552     ret = xmlHashAddEntry2(style->attributeSets, name, ns, values);
 553     if (ret < 0) {
 554         /*
 555          * Add failed, this attribute set can be removed.
 556          */
 557 #ifdef WITH_XSLT_DEBUG_ATTRIBUTES
 558         xsltGenericDebug(xsltGenericDebugContext,
 559                 "attribute set %s present already in top stylesheet"
 560                 " - merging\n", name);
 561 #endif
 562         topSet = xmlHashLookup2(style->attributeSets, name, ns);
 563         if (topSet==NULL) {
 564             xsltGenericError(xsltGenericErrorContext,
 565                 "xsl:attribute-set : logic error merging from imports for"
 566                 " attribute-set %s\n", name);
 567         } else {
 568             topSet = xsltMergeAttrElemList(style, topSet, values);
 569             xmlHashUpdateEntry2(style->attributeSets, name, ns, topSet, NULL);
 570         }
 571         xsltFreeAttrElemList(values);
 572 #ifdef WITH_XSLT_DEBUG_ATTRIBUTES
 573     } else {
 574         xsltGenericDebug(xsltGenericDebugContext,
 575                 "attribute set %s moved to top stylesheet\n",
 576                          name);
 577 #endif
 578     }
 579 }
 580
 581 /**
 582  * xsltResolveStylesheetAttributeSet:
 583  * @style:  the XSLT stylesheet
 584  *
 585  * resolve the references between attribute sets.
 586  */
 587 void
 588 xsltResolveStylesheetAttributeSet(xsltStylesheetPtr style) {
 589     xsltStylesheetPtr cur;
 590
 591 #ifdef WITH_XSLT_DEBUG_ATTRIBUTES
 592     xsltGenericDebug(xsltGenericDebugContext,
 593             "Resolving attribute sets references\n");
 594 #endif
 595     /*
 596      * First aggregate all the attribute sets definitions from the imports
 597      */
 598     cur = xsltNextImport(style);
 599     while (cur != NULL) {
 600         if (cur->attributeSets != NULL) {
 601             if (style->attributeSets == NULL) {
 602 #ifdef WITH_XSLT_DEBUG_ATTRIBUTES
 603                 xsltGenericDebug(xsltGenericDebugContext,
 604                     "creating attribute set table\n");
 605 #endif
 606                 style->attributeSets = xmlHashCreate(10);
 607             }
 608             xmlHashScanFull(cur->attributeSets,
 609                 (xmlHashScannerFull) xsltMergeSASCallback, style);
 610             /*
 611              * the attribute lists have either been migrated to style
 612              * or freed directly in xsltMergeSASCallback()
 613              */
 614             xmlHashFree(cur->attributeSets, NULL);
 615             cur->attributeSets = NULL;
 616         }
 617         cur = xsltNextImport(cur);
 618     }
 619
 620     /*
 621      * Then resolve all the references and computes the resulting sets
 622      */
 623     if (style->attributeSets != NULL) {
 624         xmlHashScanFull(style->attributeSets,
 625                 (xmlHashScannerFull) xsltResolveSASCallback, style);
 626     }
 627 }
 628
 629 /**
 630  * xsltAttributeInternal:
 631  * @ctxt:  a XSLT process context
 632  * @node:  the current node in the source tree
 633  * @inst:  the xsl:attribute element
 634  * @comp:  precomputed information
 635  * @fromAttributeSet:  the attribute comes from an attribute-set
 636  *
 637  * Process the xslt attribute node on the source node
 638  */
 639 static void
 640 xsltAttributeInternal(xsltTransformContextPtr ctxt,
 641                       xmlNodePtr contextNode,
 642                       xmlNodePtr inst,
 643                       xsltStylePreCompPtr castedComp,
 644                       int fromAttributeSet)
 645 {
 646 #ifdef XSLT_REFACTORED
 647     xsltStyleItemAttributePtr comp =
 648         (xsltStyleItemAttributePtr) castedComp;
 649 #else
 650     xsltStylePreCompPtr comp = castedComp;
 651 #endif
 652     xmlNodePtr targetElem;
 653     xmlChar *prop = NULL;
 654     const xmlChar *name = NULL, *prefix = NULL, *nsName = NULL;
 655     xmlChar *value = NULL;
 656     xmlNsPtr ns = NULL;
 657     xmlAttrPtr attr;
 658
 659     if ((ctxt == NULL) || (contextNode == NULL) || (inst == NULL))
 660         return;
 661
 662     /*
 663     * A comp->has_name == 0 indicates that we need to skip this instruction,
 664     * since it was evaluated to be invalid already during compilation.
 665     */
 666     if (!comp->has_name)
 667         return;
 668     /*
 669     * BIG NOTE: This previously used xsltGetSpecialNamespace() and
 670     *  xsltGetNamespace(), but since both are not appropriate, we
 671     *  will process namespace lookup here to avoid adding yet another
 672     *  ns-lookup function to namespaces.c.
 673     */
 674     /*
 675     * SPEC XSLT 1.0: Error cases:
 676     * - Creating nodes other than text nodes during the instantiation of
 677     *   the content of the xsl:attribute element; implementations may
 678     *   either signal the error or ignore the offending nodes."
 679     */
 680
 681     if (comp == NULL) {
 682         xsltTransformError(ctxt, NULL, inst,
 683             "Internal error in xsltAttributeInternal(): "
 684             "The XSLT 'attribute' instruction was not compiled.\n");
 685         return;
 686     }
 687     /*
 688     * TODO: Shouldn't ctxt->insert == NULL be treated as an internal error?
 689     *   So report an internal error?
 690     */
 691     if (ctxt->insert == NULL)
 692         return;
 693     /*
 694     * SPEC XSLT 1.0:
 695     *  "Adding an attribute to a node that is not an element;
 696     *  implementations may either signal the error or ignore the attribute."
 697     *
 698     * TODO: I think we should signal such errors in the future, and maybe
 699     *  provide an option to ignore such errors.
 700     */
 701     targetElem = ctxt->insert;
 702     if (targetElem->type != XML_ELEMENT_NODE)
 703         return;
 704
 705     /*
 706     * SPEC XSLT 1.0:
 707     * "Adding an attribute to an element after children have been added
 708     *  to it; implementations may either signal the error or ignore the
 709     *  attribute."
 710     *
 711     * TODO: We should decide whether not to report such errors or
 712     *  to ignore them; note that we *ignore* if the parent is not an
 713     *  element, but here we report an error.
 714     */
 715     if (targetElem->children != NULL) {
 716         /*
 717         * NOTE: Ah! This seems to be intended to support streamed
 718         *  result generation!.
 719         */
 720         xsltTransformError(ctxt, NULL, inst,
 721             "xsl:attribute: Cannot add attributes to an "
 722             "element if children have been already added "
 723             "to the element.\n");
 724         return;
 725     }
 726
 727     /*
 728     * Process the name
 729     * ----------------
 730     */
 731
 732 #ifdef WITH_DEBUGGER
 733     if (ctxt->debugStatus != XSLT_DEBUG_NONE)
 734         xslHandleDebugger(inst, contextNode, NULL, ctxt);
 735 #endif
 736
 737     if (comp->name == NULL) {
 738         /* TODO: fix attr acquisition wrt to the XSLT namespace */
 739         prop = xsltEvalAttrValueTemplate(ctxt, inst,
 740             (const xmlChar *) "name", XSLT_NAMESPACE);
 741         if (prop == NULL) {
 742             xsltTransformError(ctxt, NULL, inst,
 743                 "xsl:attribute: The attribute 'name' is missing.\n");
 744             goto error;
 745         }
 746         if (xmlValidateQName(prop, 0)) {
 747             xsltTransformError(ctxt, NULL, inst,
 748                 "xsl:attribute: The effective name '%s' is not a "
 749                 "valid QName.\n", prop);
 750             /* we fall through to catch any further errors, if possible */
 751         }
 752         name = xsltSplitQName(ctxt->dict, prop, &prefix);
 753         xmlFree(prop);
 754
 755         /*
 756         * Reject a prefix of "xmlns".
 757         */
 758         if ((prefix != NULL) &&
 759             (!xmlStrncasecmp(prefix, (xmlChar *) "xmlns", 5)))
 760         {
 761 #ifdef WITH_XSLT_DEBUG_PARSING
 762             xsltGenericDebug(xsltGenericDebugContext,
 763                 "xsltAttribute: xmlns prefix forbidden\n");
 764 #endif
 765             /*
 766             * SPEC XSLT 1.0:
 767             *  "It is an error if the string that results from instantiating
 768             *  the attribute value template is not a QName or is the string
 769             *  xmlns. An XSLT processor may signal the error; if it does not
 770             *  signal the error, it must recover by not adding the attribute
 771             *  to the result tree."
 772             * TODO: Decide which way to go here.
 773             */
 774             goto error;
 775         }
 776
 777     } else {
 778         /*
 779         * The "name" value was static.
 780         */
 781 #ifdef XSLT_REFACTORED
 782         prefix = comp->nsPrefix;
 783         name = comp->name;
 784 #else
 785         name = xsltSplitQName(ctxt->dict, comp->name, &prefix);
 786 #endif
 787     }
 788
 789     /*
 790     * Process namespace semantics
 791     * ---------------------------
 792     *
 793     * Evaluate the namespace name.
 794     */
 795     if (comp->has_ns) {
 796         /*
 797         * The "namespace" attribute was existent.
 798         */
 799         if (comp->ns != NULL) {
 800             /*
 801             * No AVT; just plain text for the namespace name.
 802             */
 803             if (comp->ns[0] != 0)
 804                 nsName = comp->ns;
 805         } else {
 806             xmlChar *tmpNsName;
 807             /*
 808             * Eval the AVT.
 809             */
 810             /* TODO: check attr acquisition wrt to the XSLT namespace */
 811             tmpNsName = xsltEvalAttrValueTemplate(ctxt, inst,
 812                 (const xmlChar *) "namespace", XSLT_NAMESPACE);
 813             /*
 814             * This fixes bug #302020: The AVT might also evaluate to the
 815             * empty string; this means that the empty string also indicates
 816             * "no namespace".
 817             * SPEC XSLT 1.0:
 818             *  "If the string is empty, then the expanded-name of the
 819             *  attribute has a null namespace URI."
 820             */
 821             if ((tmpNsName != NULL) && (tmpNsName[0] != 0))
 822                 nsName = xmlDictLookup(ctxt->dict, BAD_CAST tmpNsName, -1);
 823             xmlFree(tmpNsName);
 824         };
 825     } else if (prefix != NULL) {
 826         /*
 827         * SPEC XSLT 1.0:
 828         *  "If the namespace attribute is not present, then the QName is
 829         *  expanded into an expanded-name using the namespace declarations
 830         *  in effect for the xsl:attribute element, *not* including any
 831         *  default namespace declaration."
 832         */
 833         ns = xmlSearchNs(inst->doc, inst, prefix);
 834         if (ns == NULL) {
 835             /*
 836             * Note that this is treated as an error now (checked with
 837             *  Saxon, Xalan-J and MSXML).
 838             */
 839             xsltTransformError(ctxt, NULL, inst,
 840                 "xsl:attribute: The QName '%s:%s' has no "
 841                 "namespace binding in scope in the stylesheet; "
 842                 "this is an error, since the namespace was not "
 843                 "specified by the instruction itself.\n", prefix, name);
 844         } else
 845             nsName = ns->href;
 846     }
 847
 848     if (fromAttributeSet) {
 849         /*
 850         * This tries to ensure that xsl:attribute(s) coming
 851         * from an xsl:attribute-set won't override attribute of
 852         * literal result elements or of explicit xsl:attribute(s).
 853         * URGENT TODO: This might be buggy, since it will miss to
 854         *  overwrite two equal attributes both from attribute sets.
 855         */
 856         attr = xmlHasNsProp(targetElem, name, nsName);
 857         if (attr != NULL)
 858             return;
 859     }
 860
 861     /*
 862     * Find/create a matching ns-decl in the result tree.
 863     */
 864     ns = NULL;
 865
 866 #if 0
 867     if (0) {
 868         /*
 869         * OPTIMIZE TODO: How do we know if we are adding to a
 870         *  fragment or to the result tree?
 871         *
 872         * If we are adding to a result tree fragment (i.e., not to the
 873         * actual result tree), we'll don't bother searching for the
 874         * ns-decl, but just store it in the dummy-doc of the result
 875         * tree fragment.
 876         */
 877         if (nsName != NULL) {
 878             /*
 879             * TODO: Get the doc of @targetElem.
 880             */
 881             ns = xsltTreeAcquireStoredNs(some doc, nsName, prefix);
 882         }
 883     }
 884 #endif
 885
 886     if (nsName != NULL) {
 887         /*
 888         * Something about ns-prefixes:
 889         * SPEC XSLT 1.0:
 890         *  "XSLT processors may make use of the prefix of the QName specified
 891         *  in the name attribute when selecting the prefix used for outputting
 892         *  the created attribute as XML; however, they are not required to do
 893         *  so and, if the prefix is xmlns, they must not do so"
 894         */
 895         /*
 896         * xsl:attribute can produce a scenario where the prefix is NULL,
 897         * so generate a prefix.
 898         */
 899         if (prefix == NULL) {
 900             xmlChar *pref = xmlStrdup(BAD_CAST "ns_1");
 901
 902             ns = xsltGetSpecialNamespace(ctxt, inst, nsName, BAD_CAST pref,
 903                 targetElem);
 904
 905             xmlFree(pref);
 906         } else {
 907             ns = xsltGetSpecialNamespace(ctxt, inst, nsName, prefix,
 908                 targetElem);
 909         }
 910         if (ns == NULL) {
 911             xsltTransformError(ctxt, NULL, inst,
 912                 "Namespace fixup error: Failed to acquire an in-scope "
 913                 "namespace binding for the generated attribute '{%s}%s'.\n",
 914                 nsName, name);
 915             goto error;
 916         }
 917     }
 918     /*
 919     * Construction of the value
 920     * -------------------------
 921     */
 922     if (inst->children == NULL) {
 923         /*
 924         * No content.
 925         * TODO: Do we need to put the empty string in ?
 926         */
 927         attr = xmlSetNsProp(ctxt->insert, ns, name, (const xmlChar *) "");
 928     } else if ((inst->children->next == NULL) &&
 929             ((inst->children->type == XML_TEXT_NODE) ||
 930              (inst->children->type == XML_CDATA_SECTION_NODE)))
 931     {
 932         xmlNodePtr copyTxt;
 933
 934         /*
 935         * xmlSetNsProp() will take care of duplicates.
 936         */
 937         attr = xmlSetNsProp(ctxt->insert, ns, name, NULL);
 938         if (attr == NULL) /* TODO: report error ? */
 939             goto error;
 940         /*
 941         * This was taken over from xsltCopyText() (transform.c).
 942         */
 943         if (ctxt->internalized &&
 944             (ctxt->insert->doc != NULL) &&
 945             (ctxt->insert->doc->dict == ctxt->dict))
 946         {
 947             copyTxt = xmlNewText(NULL);
 948             if (copyTxt == NULL) /* TODO: report error */
 949                 goto error;
 950             /*
 951             * This is a safe scenario where we don't need to lookup
 952             * the dict.
 953             */
 954             copyTxt->content = inst->children->content;
 955             /*
 956             * Copy "disable-output-escaping" information.
 957             * TODO: Does this have any effect for attribute values
 958             *  anyway?
 959             */
 960             if (inst->children->name == xmlStringTextNoenc)
 961                 copyTxt->name = xmlStringTextNoenc;
 962         } else {
 963             /*
 964             * Copy the value.
 965             */
 966             copyTxt = xmlNewText(inst->children->content);
 967             if (copyTxt == NULL) /* TODO: report error */
 968                 goto error;
 969         }
 970         attr->children = attr->last = copyTxt;
 971         copyTxt->parent = (xmlNodePtr) attr;
 972         copyTxt->doc = attr->doc;
 973         /*
 974         * Copy "disable-output-escaping" information.
 975         * TODO: Does this have any effect for attribute values
 976         *  anyway?
 977         */
 978         if (inst->children->name == xmlStringTextNoenc)
 979             copyTxt->name = xmlStringTextNoenc;
 980
 981         /*
 982          * since we create the attribute without content IDness must be
 983          * asserted as a second step
 984          */
 985         if ((copyTxt->content != NULL) &&
 986             (xmlIsID(attr->doc, attr->parent, attr)))
 987             xmlAddID(NULL, attr->doc, copyTxt->content, attr);
 988     } else {
 989         /*
 990         * The sequence constructor might be complex, so instantiate it.
 991         */
 992         value = xsltEvalTemplateString(ctxt, contextNode, inst);
 993         if (value != NULL) {
 994             attr = xmlSetNsProp(ctxt->insert, ns, name, value);
 995             xmlFree(value);
 996         } else {
 997             /*
 998             * TODO: Do we have to add the empty string to the attr?
 999             * TODO: Does a  value of NULL indicate an
1000             *  error in xsltEvalTemplateString() ?
1001             */
1002             attr = xmlSetNsProp(ctxt->insert, ns, name,
1003                 (const xmlChar *) "");
1004         }
1005     }
1006
1007 error:
1008     return;
1009 }
1010
1011 /**
1012  * xsltAttribute:
1013  * @ctxt:  a XSLT process context
1014  * @node:  the node in the source tree.
1015  * @inst:  the xslt attribute node
1016  * @comp:  precomputed information
1017  *
1018  * Process the xslt attribute node on the source node
1019  */
1020 void
1021 xsltAttribute(xsltTransformContextPtr ctxt, xmlNodePtr node,
1022               xmlNodePtr inst, xsltStylePreCompPtr comp) {
1023     xsltAttributeInternal(ctxt, node, inst, comp, 0);
1024 }
1025
1026 /**
1027  * xsltApplyAttributeSet:
1028  * @ctxt:  the XSLT stylesheet
1029  * @node:  the node in the source tree.
1030  * @inst:  the attribute node "xsl:use-attribute-sets"
1031  * @attrSets:  the list of QNames of the attribute-sets to be applied
1032  *
1033  * Apply the xsl:use-attribute-sets.
1034  * If @attrSets is NULL, then @inst will be used to exctract this
1035  * value.
1036  * If both, @attrSets and @inst, are NULL, then this will do nothing.
1037  */
1038 void
1039 xsltApplyAttributeSet(xsltTransformContextPtr ctxt, xmlNodePtr node,
1040                       xmlNodePtr inst,
1041                       const xmlChar *attrSets)
1042 {
1043     const xmlChar *ncname = NULL;
1044     const xmlChar *prefix = NULL;
1045     const xmlChar *curstr, *endstr;
1046     xsltAttrElemPtr attrs;
1047     xsltStylesheetPtr style;
1048
1049     if (attrSets == NULL) {
1050         if (inst == NULL)
1051             return;
1052         else {
1053             /*
1054             * Extract the value from @inst.
1055             */
1056             if (inst->type == XML_ATTRIBUTE_NODE) {
1057                 if ( ((xmlAttrPtr) inst)->children != NULL)
1058                     attrSets = ((xmlAttrPtr) inst)->children->content;
1059
1060             }
1061             if (attrSets == NULL) {
1062                 /*
1063                 * TODO: Return an error?
1064                 */
1065                 return;
1066             }
1067         }
1068     }
1069     /*
1070     * Parse/apply the list of QNames.
1071     */
1072     curstr = attrSets;
1073     while (*curstr != 0) {
1074         while (IS_BLANK(*curstr))
1075             curstr++;
1076         if (*curstr == 0)
1077             break;
1078         endstr = curstr;
1079         while ((*endstr != 0) && (!IS_BLANK(*endstr)))
1080             endstr++;
1081         curstr = xmlDictLookup(ctxt->dict, curstr, endstr - curstr);
1082         if (curstr) {
1083             /*
1084             * TODO: Validate the QName.
1085             */
1086
1087 #ifdef WITH_XSLT_DEBUG_curstrUTES
1088             xsltGenericDebug(xsltGenericDebugContext,
1089                              "apply curstrute set %s\n", curstr);
1090 #endif
1091             ncname = xsltSplitQName(ctxt->dict, curstr, &prefix);
1092
1093             style = ctxt->style;
1094
1095 #ifdef WITH_DEBUGGER
1096             if ((style != NULL) &&
1097                 (style->attributeSets != NULL) &&
1098                 (ctxt->debugStatus != XSLT_DEBUG_NONE))
1099             {
1100                 attrs =
1101                     xmlHashLookup2(style->attributeSets, ncname, prefix);
1102                 if ((attrs != NULL) && (attrs->attr != NULL))
1103                     xslHandleDebugger(attrs->attr->parent, node, NULL,
1104                         ctxt);
1105             }
1106 #endif
1107             /*
1108             * Lookup the referenced curstrute-set.
1109             */
1110             while (style != NULL) {
1111                 attrs =
1112                     xmlHashLookup2(style->attributeSets, ncname, prefix);
1113                 while (attrs != NULL) {
1114                     if (attrs->attr != NULL) {
1115                         xsltAttributeInternal(ctxt, node, attrs->attr,
1116                             attrs->attr->psvi, 1);
1117                     }
1118                     attrs = attrs->next;
1119                 }
1120                 style = xsltNextImport(style);
1121             }
1122         }
1123         curstr = endstr;
1124     }
1125 }
1126
1127 /**
1128  * xsltFreeAttributeSetsHashes:
1129  * @style: an XSLT stylesheet
1130  *
1131  * Free up the memory used by attribute sets
1132  */
1133 void
1134 xsltFreeAttributeSetsHashes(xsltStylesheetPtr style) {
1135     if (style->attributeSets != NULL)
1136         xmlHashFree((xmlHashTablePtr) style->attributeSets,
1137                     (xmlHashDeallocator) xsltFreeAttrElemList);
1138     style->attributeSets = NULL;
1139 }