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