libs/xslt/libxslt/preproc.c

   1 /*
   2  * preproc.c: Preprocessing of style operations
   3  *
   4  * References:
   5  *   http://www.w3.org/TR/1999/REC-xslt-19991116
   6  *
   7  *   Michael Kay "XSLT Programmer's Reference" pp 637-643
   8  *   Writing Multiple Output Files
   9  *
  10  *   XSLT-1.1 Working Draft
  11  *   http://www.w3.org/TR/xslt11#multiple-output
  12  *
  13  * See Copyright for the status of this software.
  14  *
  15  * daniel@veillard.com
  16  */
  17
  18 #define IN_LIBXSLT
  19 #include "libxslt.h"
  20
  21 #include <string.h>
  22
  23 #include <libxml/xmlmemory.h>
  24 #include <libxml/parser.h>
  25 #include <libxml/tree.h>
  26 #include <libxml/valid.h>
  27 #include <libxml/hash.h>
  28 #include <libxml/uri.h>
  29 #include <libxml/encoding.h>
  30 #include <libxml/xmlerror.h>
  31 #include "xslt.h"
  32 #include "xsltutils.h"
  33 #include "xsltInternals.h"
  34 #include "transform.h"
  35 #include "templates.h"
  36 #include "variables.h"
  37 #include "numbersInternals.h"
  38 #include "preproc.h"
  39 #include "extra.h"
  40 #include "imports.h"
  41 #include "extensions.h"
  42 #include "pattern.h"
  43
  44 #ifdef WITH_XSLT_DEBUG
  45 #define WITH_XSLT_DEBUG_PREPROC
  46 #endif
  47
  48 const xmlChar *xsltExtMarker = (const xmlChar *) "Extension Element";
  49
  50 /************************************************************************
  51  *                                                                      *
  52  *                      Grammar checks                                  *
  53  *                                                                      *
  54  ************************************************************************/
  55
  56 #ifdef XSLT_REFACTORED
  57     /*
  58     * Grammar checks are now performed in xslt.c.
  59     */
  60 #else
  61 /**
  62  * xsltCheckTopLevelElement:
  63  * @style: the XSLT stylesheet
  64  * @inst: the XSLT instruction
  65  * @err: raise an error or not
  66  *
  67  * Check that the instruction is instanciated as a top level element.
  68  *
  69  * Returns -1 in case of error, 0 if failed and 1 in case of success
  70  */
  71 static int
  72 xsltCheckTopLevelElement(xsltStylesheetPtr style, xmlNodePtr inst, int err) {
  73     xmlNodePtr parent;
  74     if ((style == NULL) || (inst == NULL) || (inst->ns == NULL))
  75         return(-1);
  76
  77     parent = inst->parent;
  78     if (parent == NULL) {
  79         if (err) {
  80             xsltTransformError(NULL, style, inst,
  81                     "internal problem: element has no parent\n");
  82             style->errors++;
  83         }
  84         return(0);
  85     }
  86     if ((parent->ns == NULL) || (parent->type != XML_ELEMENT_NODE) ||
  87         ((parent->ns != inst->ns) &&
  88          (!xmlStrEqual(parent->ns->href, inst->ns->href))) ||
  89         ((!xmlStrEqual(parent->name, BAD_CAST "stylesheet")) &&
  90          (!xmlStrEqual(parent->name, BAD_CAST "transform")))) {
  91         if (err) {
  92             xsltTransformError(NULL, style, inst,
  93                     "element %s only allowed as child of stylesheet\n",
  94                                inst->name);
  95             style->errors++;
  96         }
  97         return(0);
  98     }
  99     return(1);
 100 }
 101
 102 /**
 103  * xsltCheckInstructionElement:
 104  * @style: the XSLT stylesheet
 105  * @inst: the XSLT instruction
 106  *
 107  * Check that the instruction is instanciated as an instruction element.
 108  */
 109 static void
 110 xsltCheckInstructionElement(xsltStylesheetPtr style, xmlNodePtr inst) {
 111     xmlNodePtr parent;
 112     int has_ext;
 113
 114     if ((style == NULL) || (inst == NULL) || (inst->ns == NULL) ||
 115         (style->literal_result))
 116         return;
 117
 118     has_ext = (style->extInfos != NULL);
 119
 120     parent = inst->parent;
 121     if (parent == NULL) {
 122         xsltTransformError(NULL, style, inst,
 123                 "internal problem: element has no parent\n");
 124         style->errors++;
 125         return;
 126     }
 127     while ((parent != NULL) && (parent->type != XML_DOCUMENT_NODE)) {
 128         if (((parent->ns == inst->ns) ||
 129              ((parent->ns != NULL) &&
 130               (xmlStrEqual(parent->ns->href, inst->ns->href)))) &&
 131             ((xmlStrEqual(parent->name, BAD_CAST "template")) ||
 132              (xmlStrEqual(parent->name, BAD_CAST "param")) ||
 133              (xmlStrEqual(parent->name, BAD_CAST "attribute")) ||
 134              (xmlStrEqual(parent->name, BAD_CAST "variable")))) {
 135             return;
 136         }
 137
 138         /*
 139          * if we are within an extension element all bets are off
 140          * about the semantic there e.g. xsl:param within func:function
 141          */
 142         if ((has_ext) && (parent->ns != NULL) &&
 143             (xmlHashLookup(style->extInfos, parent->ns->href) != NULL))
 144             return;
 145
 146         parent = parent->parent;
 147     }
 148     xsltTransformError(NULL, style, inst,
 149             "element %s only allowed within a template, variable or param\n",
 150                            inst->name);
 151     style->errors++;
 152 }
 153
 154 /**
 155  * xsltCheckParentElement:
 156  * @style: the XSLT stylesheet
 157  * @inst: the XSLT instruction
 158  * @allow1: allowed parent1
 159  * @allow2: allowed parent2
 160  *
 161  * Check that the instruction is instanciated as the childre of one of the
 162  * possible parents.
 163  */
 164 static void
 165 xsltCheckParentElement(xsltStylesheetPtr style, xmlNodePtr inst,
 166                        const xmlChar *allow1, const xmlChar *allow2) {
 167     xmlNodePtr parent;
 168
 169     if ((style == NULL) || (inst == NULL) || (inst->ns == NULL) ||
 170         (style->literal_result))
 171         return;
 172
 173     parent = inst->parent;
 174     if (parent == NULL) {
 175         xsltTransformError(NULL, style, inst,
 176                 "internal problem: element has no parent\n");
 177         style->errors++;
 178         return;
 179     }
 180     if (((parent->ns == inst->ns) ||
 181          ((parent->ns != NULL) &&
 182           (xmlStrEqual(parent->ns->href, inst->ns->href)))) &&
 183         ((xmlStrEqual(parent->name, allow1)) ||
 184          (xmlStrEqual(parent->name, allow2)))) {
 185         return;
 186     }
 187
 188     if (style->extInfos != NULL) {
 189         while ((parent != NULL) && (parent->type != XML_DOCUMENT_NODE)) {
 190             /*
 191              * if we are within an extension element all bets are off
 192              * about the semantic there e.g. xsl:param within func:function
 193              */
 194             if ((parent->ns != NULL) &&
 195                 (xmlHashLookup(style->extInfos, parent->ns->href) != NULL))
 196                 return;
 197
 198             parent = parent->parent;
 199         }
 200     }
 201     xsltTransformError(NULL, style, inst,
 202                        "element %s is not allowed within that context\n",
 203                        inst->name);
 204     style->errors++;
 205 }
 206 #endif
 207
 208 /************************************************************************
 209  *                                                                      *
 210  *                      handling of precomputed data                    *
 211  *                                                                      *
 212  ************************************************************************/
 213
 214 /**
 215  * xsltNewStylePreComp:
 216  * @style:  the XSLT stylesheet
 217  * @type:  the construct type
 218  *
 219  * Create a new XSLT Style precomputed block
 220  *
 221  * Returns the newly allocated specialized structure
 222  *         or NULL in case of error
 223  */
 224 static xsltStylePreCompPtr
 225 xsltNewStylePreComp(xsltStylesheetPtr style, xsltStyleType type) {
 226     xsltStylePreCompPtr cur;
 227 #ifdef XSLT_REFACTORED
 228     size_t size;
 229 #endif
 230
 231     if (style == NULL)
 232         return(NULL);
 233
 234 #ifdef XSLT_REFACTORED
 235     /*
 236     * URGENT TODO: Use specialized factory functions in order
 237     *   to avoid this ugliness.
 238     */
 239     switch (type) {
 240         case XSLT_FUNC_COPY:
 241             size = sizeof(xsltStyleItemCopy); break;
 242         case XSLT_FUNC_SORT:
 243             size = sizeof(xsltStyleItemSort); break;
 244         case XSLT_FUNC_TEXT:
 245             size = sizeof(xsltStyleItemText); break;
 246         case XSLT_FUNC_ELEMENT:
 247             size = sizeof(xsltStyleItemElement); break;
 248         case XSLT_FUNC_ATTRIBUTE:
 249             size = sizeof(xsltStyleItemAttribute); break;
 250         case XSLT_FUNC_COMMENT:
 251             size = sizeof(xsltStyleItemComment); break;
 252         case XSLT_FUNC_PI:
 253             size = sizeof(xsltStyleItemPI); break;
 254         case XSLT_FUNC_COPYOF:
 255             size = sizeof(xsltStyleItemCopyOf); break;
 256         case XSLT_FUNC_VALUEOF:
 257             size = sizeof(xsltStyleItemValueOf); break;;
 258         case XSLT_FUNC_NUMBER:
 259             size = sizeof(xsltStyleItemNumber); break;
 260         case XSLT_FUNC_APPLYIMPORTS:
 261             size = sizeof(xsltStyleItemApplyImports); break;
 262         case XSLT_FUNC_CALLTEMPLATE:
 263             size = sizeof(xsltStyleItemCallTemplate); break;
 264         case XSLT_FUNC_APPLYTEMPLATES:
 265             size = sizeof(xsltStyleItemApplyTemplates); break;
 266         case XSLT_FUNC_CHOOSE:
 267             size = sizeof(xsltStyleItemChoose); break;
 268         case XSLT_FUNC_IF:
 269             size = sizeof(xsltStyleItemIf); break;
 270         case XSLT_FUNC_FOREACH:
 271             size = sizeof(xsltStyleItemForEach); break;
 272         case XSLT_FUNC_DOCUMENT:
 273             size = sizeof(xsltStyleItemDocument); break;
 274         case XSLT_FUNC_WITHPARAM:
 275             size = sizeof(xsltStyleItemWithParam); break;
 276         case XSLT_FUNC_PARAM:
 277             size = sizeof(xsltStyleItemParam); break;
 278         case XSLT_FUNC_VARIABLE:
 279             size = sizeof(xsltStyleItemVariable); break;
 280         case XSLT_FUNC_WHEN:
 281             size = sizeof(xsltStyleItemWhen); break;
 282         case XSLT_FUNC_OTHERWISE:
 283             size = sizeof(xsltStyleItemOtherwise); break;
 284         default:
 285             xsltTransformError(NULL, style, NULL,
 286                     "xsltNewStylePreComp : invalid type %d\n", type);
 287             style->errors++;
 288             return(NULL);
 289     }
 290     /*
 291     * Create the structure.
 292     */
 293     cur = (xsltStylePreCompPtr) xmlMalloc(size);
 294     if (cur == NULL) {
 295         xsltTransformError(NULL, style, NULL,
 296                 "xsltNewStylePreComp : malloc failed\n");
 297         style->errors++;
 298         return(NULL);
 299     }
 300     memset(cur, 0, size);
 301
 302 #else /* XSLT_REFACTORED */
 303     /*
 304     * Old behaviour.
 305     */
 306     cur = (xsltStylePreCompPtr) xmlMalloc(sizeof(xsltStylePreComp));
 307     if (cur == NULL) {
 308         xsltTransformError(NULL, style, NULL,
 309                 "xsltNewStylePreComp : malloc failed\n");
 310         style->errors++;
 311         return(NULL);
 312     }
 313     memset(cur, 0, sizeof(xsltStylePreComp));
 314 #endif /* XSLT_REFACTORED */
 315
 316     /*
 317     * URGENT TODO: Better to move this to spezialized factory functions.
 318     */
 319     cur->type = type;
 320     switch (cur->type) {
 321         case XSLT_FUNC_COPY:
 322             cur->func = xsltCopy;break;
 323         case XSLT_FUNC_SORT:
 324             cur->func = xsltSort;break;
 325         case XSLT_FUNC_TEXT:
 326             cur->func = xsltText;break;
 327         case XSLT_FUNC_ELEMENT:
 328             cur->func = xsltElement;break;
 329         case XSLT_FUNC_ATTRIBUTE:
 330             cur->func = xsltAttribute;break;
 331         case XSLT_FUNC_COMMENT:
 332             cur->func = xsltComment;break;
 333         case XSLT_FUNC_PI:
 334             cur->func = xsltProcessingInstruction;
 335             break;
 336         case XSLT_FUNC_COPYOF:
 337             cur->func = xsltCopyOf;break;
 338         case XSLT_FUNC_VALUEOF:
 339             cur->func = xsltValueOf;break;
 340         case XSLT_FUNC_NUMBER:
 341             cur->func = xsltNumber;break;
 342         case XSLT_FUNC_APPLYIMPORTS:
 343             cur->func = xsltApplyImports;break;
 344         case XSLT_FUNC_CALLTEMPLATE:
 345             cur->func = xsltCallTemplate;break;
 346         case XSLT_FUNC_APPLYTEMPLATES:
 347             cur->func = xsltApplyTemplates;break;
 348         case XSLT_FUNC_CHOOSE:
 349             cur->func = xsltChoose;break;
 350         case XSLT_FUNC_IF:
 351             cur->func = xsltIf;break;
 352         case XSLT_FUNC_FOREACH:
 353             cur->func = xsltForEach;break;
 354         case XSLT_FUNC_DOCUMENT:
 355             cur->func = xsltDocumentElem;break;
 356         case XSLT_FUNC_WITHPARAM:
 357         case XSLT_FUNC_PARAM:
 358         case XSLT_FUNC_VARIABLE:
 359         case XSLT_FUNC_WHEN:
 360             break;
 361         default:
 362         if (cur->func == NULL) {
 363             xsltTransformError(NULL, style, NULL,
 364                     "xsltNewStylePreComp : no function for type %d\n", type);
 365             style->errors++;
 366         }
 367     }
 368     cur->next = style->preComps;
 369     style->preComps = (xsltElemPreCompPtr) cur;
 370
 371     return(cur);
 372 }
 373
 374 /**
 375  * xsltFreeStylePreComp:
 376  * @comp:  an XSLT Style precomputed block
 377  *
 378  * Free up the memory allocated by @comp
 379  */
 380 static void
 381 xsltFreeStylePreComp(xsltStylePreCompPtr comp) {
 382     if (comp == NULL)
 383         return;
 384 #ifdef XSLT_REFACTORED
 385     /*
 386     * URGENT TODO: Implement destructors.
 387     */
 388     switch (comp->type) {
 389         case XSLT_FUNC_LITERAL_RESULT_ELEMENT:
 390             break;
 391         case XSLT_FUNC_COPY:
 392             break;
 393         case XSLT_FUNC_SORT: {
 394                 xsltStyleItemSortPtr item = (xsltStyleItemSortPtr) comp;
 395                 if (item->locale != (xsltLocale)0)
 396                     xsltFreeLocale(item->locale);
 397                 if (item->comp != NULL)
 398                     xmlXPathFreeCompExpr(item->comp);
 399             }
 400             break;
 401         case XSLT_FUNC_TEXT:
 402             break;
 403         case XSLT_FUNC_ELEMENT:
 404             break;
 405         case XSLT_FUNC_ATTRIBUTE:
 406             break;
 407         case XSLT_FUNC_COMMENT:
 408             break;
 409         case XSLT_FUNC_PI:
 410             break;
 411         case XSLT_FUNC_COPYOF: {
 412                 xsltStyleItemCopyOfPtr item = (xsltStyleItemCopyOfPtr) comp;
 413                 if (item->comp != NULL)
 414                     xmlXPathFreeCompExpr(item->comp);
 415             }
 416             break;
 417         case XSLT_FUNC_VALUEOF: {
 418                 xsltStyleItemValueOfPtr item = (xsltStyleItemValueOfPtr) comp;
 419                 if (item->comp != NULL)
 420                     xmlXPathFreeCompExpr(item->comp);
 421             }
 422             break;
 423         case XSLT_FUNC_NUMBER: {
 424                 xsltStyleItemNumberPtr item = (xsltStyleItemNumberPtr) comp;
 425                 if (item->numdata.countPat != NULL)
 426                     xsltFreeCompMatchList(item->numdata.countPat);
 427                 if (item->numdata.fromPat != NULL)
 428                     xsltFreeCompMatchList(item->numdata.fromPat);
 429             }
 430             break;
 431         case XSLT_FUNC_APPLYIMPORTS:
 432             break;
 433         case XSLT_FUNC_CALLTEMPLATE:
 434             break;
 435         case XSLT_FUNC_APPLYTEMPLATES: {
 436                 xsltStyleItemApplyTemplatesPtr item =
 437                     (xsltStyleItemApplyTemplatesPtr) comp;
 438                 if (item->comp != NULL)
 439                     xmlXPathFreeCompExpr(item->comp);
 440             }
 441             break;
 442         case XSLT_FUNC_CHOOSE:
 443             break;
 444         case XSLT_FUNC_IF: {
 445                 xsltStyleItemIfPtr item = (xsltStyleItemIfPtr) comp;
 446                 if (item->comp != NULL)
 447                     xmlXPathFreeCompExpr(item->comp);
 448             }
 449             break;
 450         case XSLT_FUNC_FOREACH: {
 451                 xsltStyleItemForEachPtr item =
 452                     (xsltStyleItemForEachPtr) comp;
 453                 if (item->comp != NULL)
 454                     xmlXPathFreeCompExpr(item->comp);
 455             }
 456             break;
 457         case XSLT_FUNC_DOCUMENT:
 458             break;
 459         case XSLT_FUNC_WITHPARAM: {
 460                 xsltStyleItemWithParamPtr item =
 461                     (xsltStyleItemWithParamPtr) comp;
 462                 if (item->comp != NULL)
 463                     xmlXPathFreeCompExpr(item->comp);
 464             }
 465             break;
 466         case XSLT_FUNC_PARAM: {
 467                 xsltStyleItemParamPtr item =
 468                     (xsltStyleItemParamPtr) comp;
 469                 if (item->comp != NULL)
 470                     xmlXPathFreeCompExpr(item->comp);
 471             }
 472             break;
 473         case XSLT_FUNC_VARIABLE: {
 474                 xsltStyleItemVariablePtr item =
 475                     (xsltStyleItemVariablePtr) comp;
 476                 if (item->comp != NULL)
 477                     xmlXPathFreeCompExpr(item->comp);
 478             }
 479             break;
 480         case XSLT_FUNC_WHEN: {
 481                 xsltStyleItemWhenPtr item =
 482                     (xsltStyleItemWhenPtr) comp;
 483                 if (item->comp != NULL)
 484                     xmlXPathFreeCompExpr(item->comp);
 485             }
 486             break;
 487         case XSLT_FUNC_OTHERWISE:
 488         case XSLT_FUNC_FALLBACK:
 489         case XSLT_FUNC_MESSAGE:
 490         case XSLT_FUNC_INCLUDE:
 491         case XSLT_FUNC_ATTRSET:
 492
 493             break;
 494         default:
 495             /* TODO: Raise error. */
 496             break;
 497     }
 498 #else
 499     if (comp->locale != (xsltLocale)0)
 500         xsltFreeLocale(comp->locale);
 501     if (comp->comp != NULL)
 502         xmlXPathFreeCompExpr(comp->comp);
 503     if (comp->numdata.countPat != NULL)
 504         xsltFreeCompMatchList(comp->numdata.countPat);
 505     if (comp->numdata.fromPat != NULL)
 506         xsltFreeCompMatchList(comp->numdata.fromPat);
 507     if (comp->nsList != NULL)
 508         xmlFree(comp->nsList);
 509 #endif
 510
 511     xmlFree(comp);
 512 }
 513
 514
 515 /************************************************************************
 516  *                                                                      *
 517  *                  XSLT-1.1 extensions                                 *
 518  *                                                                      *
 519  ************************************************************************/
 520
 521 /**
 522  * xsltDocumentComp:
 523  * @style:  the XSLT stylesheet
 524  * @inst:  the instruction in the stylesheet
 525  * @function:  unused
 526  *
 527  * Pre process an XSLT-1.1 document element
 528  *
 529  * Returns a precompiled data structure for the element
 530  */
 531 xsltElemPreCompPtr
 532 xsltDocumentComp(xsltStylesheetPtr style, xmlNodePtr inst,
 533                  xsltTransformFunction function ATTRIBUTE_UNUSED) {
 534 #ifdef XSLT_REFACTORED
 535     xsltStyleItemDocumentPtr comp;
 536 #else
 537     xsltStylePreCompPtr comp;
 538 #endif
 539     const xmlChar *filename = NULL;
 540
 541     /*
 542     * As of 2006-03-30, this function is currently defined in Libxslt
 543     * to be used for:
 544     * (in libxslt/extra.c)
 545     * "output" in XSLT_SAXON_NAMESPACE
 546     * "write" XSLT_XALAN_NAMESPACE
 547     * "document" XSLT_XT_NAMESPACE
 548     * "document" XSLT_NAMESPACE (from the abandoned old working
 549     *                            draft of XSLT 1.1)
 550     * (in libexslt/common.c)
 551     * "document" in EXSLT_COMMON_NAMESPACE
 552     */
 553 #ifdef XSLT_REFACTORED
 554     comp = (xsltStyleItemDocumentPtr)
 555         xsltNewStylePreComp(style, XSLT_FUNC_DOCUMENT);
 556 #else
 557     comp = xsltNewStylePreComp(style, XSLT_FUNC_DOCUMENT);
 558 #endif
 559
 560     if (comp == NULL)
 561         return (NULL);
 562     comp->inst = inst;
 563     comp->ver11 = 0;
 564
 565     if (xmlStrEqual(inst->name, (const xmlChar *) "output")) {
 566 #ifdef WITH_XSLT_DEBUG_EXTRA
 567         xsltGenericDebug(xsltGenericDebugContext,
 568             "Found saxon:output extension\n");
 569 #endif
 570         /*
 571         * The element "output" is in the namespace XSLT_SAXON_NAMESPACE
 572         *   (http://icl.com/saxon)
 573         * The @file is in no namespace; it is an AVT.
 574         *   (http://www.computerwizards.com/saxon/doc/extensions.html#saxon:output)
 575         *
 576         * TODO: Do we need not to check the namespace here?
 577         */
 578         filename = xsltEvalStaticAttrValueTemplate(style, inst,
 579                          (const xmlChar *)"file",
 580                          NULL, &comp->has_filename);
 581     } else if (xmlStrEqual(inst->name, (const xmlChar *) "write")) {
 582 #ifdef WITH_XSLT_DEBUG_EXTRA
 583         xsltGenericDebug(xsltGenericDebugContext,
 584             "Found xalan:write extension\n");
 585 #endif
 586         /* the filename need to be interpreted */
 587         /*
 588         * TODO: Is "filename need to be interpreted" meant to be a todo?
 589         *   Where will be the filename of xalan:write be processed?
 590         *
 591         * TODO: Do we need not to check the namespace here?
 592         *   The extension ns is "http://xml.apache.org/xalan/redirect".
 593         *   See http://xml.apache.org/xalan-j/extensionslib.html.
 594         */
 595     } else if (xmlStrEqual(inst->name, (const xmlChar *) "document")) {
 596         if (inst->ns != NULL) {
 597             if (xmlStrEqual(inst->ns->href, XSLT_NAMESPACE)) {
 598                 /*
 599                 * Mark the instruction as being of
 600                 * XSLT version 1.1 (abandoned).
 601                 */
 602                 comp->ver11 = 1;
 603 #ifdef WITH_XSLT_DEBUG_EXTRA
 604                 xsltGenericDebug(xsltGenericDebugContext,
 605                     "Found xslt11:document construct\n");
 606 #endif
 607             } else {
 608                 if (xmlStrEqual(inst->ns->href,
 609                     (const xmlChar *)"http://exslt.org/common")) {
 610                     /* EXSLT. */
 611 #ifdef WITH_XSLT_DEBUG_EXTRA
 612                     xsltGenericDebug(xsltGenericDebugContext,
 613                         "Found exslt:document extension\n");
 614 #endif
 615                 } else if (xmlStrEqual(inst->ns->href, XSLT_XT_NAMESPACE)) {
 616                     /* James Clark's XT. */
 617 #ifdef WITH_XSLT_DEBUG_EXTRA
 618                     xsltGenericDebug(xsltGenericDebugContext,
 619                         "Found xt:document extension\n");
 620 #endif
 621                 }
 622             }
 623         }
 624         /*
 625         * The element "document" is used in conjunction with the
 626         * following namespaces:
 627         *
 628         * 1) XSLT_NAMESPACE (http://www.w3.org/1999/XSL/Transform version 1.1)
 629         *    <!ELEMENT xsl:document %template;>
 630         *    <!ATTLIST xsl:document
 631         *       href %avt; #REQUIRED
 632         *    @href is an AVT
 633         *    IMPORTANT: xsl:document was in the abandoned XSLT 1.1 draft,
 634         *    it was removed and isn't available in XSLT 1.1 anymore.
 635         *    In XSLT 2.0 it was renamed to xsl:result-document.
 636         *
 637         *   All other attributes are identical to the attributes
 638         *   on xsl:output
 639         *
 640         * 2) EXSLT_COMMON_NAMESPACE (http://exslt.org/common)
 641         *    <exsl:document
 642         *       href = { uri-reference }
 643         *    TODO: is @href is an AVT?
 644         *
 645         * 3) XSLT_XT_NAMESPACE (http://www.jclark.com/xt)
 646         *     Example: <xt:document method="xml" href="myFile.xml">
 647         *    TODO: is @href is an AVT?
 648         *
 649         * In all cases @href is in no namespace.
 650         */
 651         filename = xsltEvalStaticAttrValueTemplate(style, inst,
 652             (const xmlChar *)"href", NULL, &comp->has_filename);
 653     }
 654     if (!comp->has_filename) {
 655         goto error;
 656     }
 657     comp->filename = filename;
 658
 659 error:
 660     return ((xsltElemPreCompPtr) comp);
 661 }
 662
 663 /************************************************************************
 664  *                                                                      *
 665  *              Most of the XSLT-1.0 transformations                    *
 666  *                                                                      *
 667  ************************************************************************/
 668
 669 /**
 670  * xsltSortComp:
 671  * @style:  the XSLT stylesheet
 672  * @inst:  the xslt sort node
 673  *
 674  * Process the xslt sort node on the source node
 675  */
 676 static void
 677 xsltSortComp(xsltStylesheetPtr style, xmlNodePtr inst) {
 678 #ifdef XSLT_REFACTORED
 679     xsltStyleItemSortPtr comp;
 680 #else
 681     xsltStylePreCompPtr comp;
 682 #endif
 683     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
 684         return;
 685
 686 #ifdef XSLT_REFACTORED
 687     comp = (xsltStyleItemSortPtr) xsltNewStylePreComp(style, XSLT_FUNC_SORT);
 688 #else
 689     comp = xsltNewStylePreComp(style, XSLT_FUNC_SORT);
 690 #endif
 691
 692     if (comp == NULL)
 693         return;
 694     inst->psvi = comp;
 695     comp->inst = inst;
 696
 697     comp->stype = xsltEvalStaticAttrValueTemplate(style, inst,
 698                          (const xmlChar *)"data-type",
 699                          NULL, &comp->has_stype);
 700     if (comp->stype != NULL) {
 701         if (xmlStrEqual(comp->stype, (const xmlChar *) "text"))
 702             comp->number = 0;
 703         else if (xmlStrEqual(comp->stype, (const xmlChar *) "number"))
 704             comp->number = 1;
 705         else {
 706             xsltTransformError(NULL, style, inst,
 707                  "xsltSortComp: no support for data-type = %s\n", comp->stype);
 708             comp->number = 0; /* use default */
 709             if (style != NULL) style->warnings++;
 710         }
 711     }
 712     comp->order = xsltEvalStaticAttrValueTemplate(style, inst,
 713                               (const xmlChar *)"order",
 714                               NULL, &comp->has_order);
 715     if (comp->order != NULL) {
 716         if (xmlStrEqual(comp->order, (const xmlChar *) "ascending"))
 717             comp->descending = 0;
 718         else if (xmlStrEqual(comp->order, (const xmlChar *) "descending"))
 719             comp->descending = 1;
 720         else {
 721             xsltTransformError(NULL, style, inst,
 722                  "xsltSortComp: invalid value %s for order\n", comp->order);
 723             comp->descending = 0; /* use default */
 724             if (style != NULL) style->warnings++;
 725         }
 726     }
 727     comp->case_order = xsltEvalStaticAttrValueTemplate(style, inst,
 728                               (const xmlChar *)"case-order",
 729                               NULL, &comp->has_use);
 730     if (comp->case_order != NULL) {
 731         if (xmlStrEqual(comp->case_order, (const xmlChar *) "upper-first"))
 732             comp->lower_first = 0;
 733         else if (xmlStrEqual(comp->case_order, (const xmlChar *) "lower-first"))
 734             comp->lower_first = 1;
 735         else {
 736             xsltTransformError(NULL, style, inst,
 737                  "xsltSortComp: invalid value %s for order\n", comp->order);
 738             comp->lower_first = 0; /* use default */
 739             if (style != NULL) style->warnings++;
 740         }
 741     }
 742
 743     comp->lang = xsltEvalStaticAttrValueTemplate(style, inst,
 744                                  (const xmlChar *)"lang",
 745                                  NULL, &comp->has_lang);
 746     if (comp->lang != NULL) {
 747         comp->locale = xsltNewLocale(comp->lang);
 748     }
 749     else {
 750         comp->locale = (xsltLocale)0;
 751     }
 752
 753     comp->select = xsltGetCNsProp(style, inst,(const xmlChar *)"select", XSLT_NAMESPACE);
 754     if (comp->select == NULL) {
 755         /*
 756          * The default value of the select attribute is ., which will
 757          * cause the string-value of the current node to be used as
 758          * the sort key.
 759          */
 760         comp->select = xmlDictLookup(style->dict, BAD_CAST ".", 1);
 761     }
 762     comp->comp = xsltXPathCompile(style, comp->select);
 763     if (comp->comp == NULL) {
 764         xsltTransformError(NULL, style, inst,
 765              "xsltSortComp: could not compile select expression '%s'\n",
 766                          comp->select);
 767         if (style != NULL) style->errors++;
 768     }
 769     if (inst->children != NULL) {
 770         xsltTransformError(NULL, style, inst,
 771         "xsl:sort : is not empty\n");
 772         if (style != NULL) style->errors++;
 773     }
 774 }
 775
 776 /**
 777  * xsltCopyComp:
 778  * @style:  the XSLT stylesheet
 779  * @inst:  the xslt copy node
 780  *
 781  * Process the xslt copy node on the source node
 782  */
 783 static void
 784 xsltCopyComp(xsltStylesheetPtr style, xmlNodePtr inst) {
 785 #ifdef XSLT_REFACTORED
 786     xsltStyleItemCopyPtr comp;
 787 #else
 788     xsltStylePreCompPtr comp;
 789 #endif
 790
 791     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
 792         return;
 793 #ifdef XSLT_REFACTORED
 794     comp = (xsltStyleItemCopyPtr) xsltNewStylePreComp(style, XSLT_FUNC_COPY);
 795 #else
 796     comp = xsltNewStylePreComp(style, XSLT_FUNC_COPY);
 797 #endif
 798
 799     if (comp == NULL)
 800         return;
 801     inst->psvi = comp;
 802     comp->inst = inst;
 803
 804
 805     comp->use = xsltGetCNsProp(style, inst, (const xmlChar *)"use-attribute-sets",
 806                                     XSLT_NAMESPACE);
 807     if (comp->use == NULL)
 808         comp->has_use = 0;
 809     else
 810         comp->has_use = 1;
 811 }
 812
 813 #ifdef XSLT_REFACTORED
 814     /* Enable if ever needed for xsl:text. */
 815 #else
 816 /**
 817  * xsltTextComp:
 818  * @style: an XSLT compiled stylesheet
 819  * @inst:  the xslt text node
 820  *
 821  * TODO: This function is obsolete, since xsl:text won't
 822  *  be compiled, but removed from the tree.
 823  *
 824  * Process the xslt text node on the source node
 825  */
 826 static void
 827 xsltTextComp(xsltStylesheetPtr style, xmlNodePtr inst) {
 828 #ifdef XSLT_REFACTORED
 829     xsltStyleItemTextPtr comp;
 830 #else
 831     xsltStylePreCompPtr comp;
 832 #endif
 833     const xmlChar *prop;
 834
 835     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
 836         return;
 837
 838 #ifdef XSLT_REFACTORED
 839     comp = (xsltStyleItemTextPtr) xsltNewStylePreComp(style, XSLT_FUNC_TEXT);
 840 #else
 841     comp = xsltNewStylePreComp(style, XSLT_FUNC_TEXT);
 842 #endif
 843     if (comp == NULL)
 844         return;
 845     inst->psvi = comp;
 846     comp->inst = inst;
 847     comp->noescape = 0;
 848
 849     prop = xsltGetCNsProp(style, inst,
 850             (const xmlChar *)"disable-output-escaping",
 851                         XSLT_NAMESPACE);
 852     if (prop != NULL) {
 853         if (xmlStrEqual(prop, (const xmlChar *)"yes")) {
 854             comp->noescape = 1;
 855         } else if (!xmlStrEqual(prop,
 856             (const xmlChar *)"no")){
 857             xsltTransformError(NULL, style, inst,
 858                 "xsl:text: disable-output-escaping allows only yes or no\n");
 859             if (style != NULL) style->warnings++;
 860         }
 861     }
 862 }
 863 #endif /* else of XSLT_REFACTORED */
 864
 865 /**
 866  * xsltElementComp:
 867  * @style: an XSLT compiled stylesheet
 868  * @inst:  the xslt element node
 869  *
 870  * Process the xslt element node on the source node
 871  */
 872 static void
 873 xsltElementComp(xsltStylesheetPtr style, xmlNodePtr inst) {
 874 #ifdef XSLT_REFACTORED
 875     xsltStyleItemElementPtr comp;
 876 #else
 877     xsltStylePreCompPtr comp;
 878 #endif
 879
 880     /*
 881     * <xsl:element
 882     *   name = { qname }
 883     *   namespace = { uri-reference }
 884     *   use-attribute-sets = qnames>
 885     *   <!-- Content: template -->
 886     * </xsl:element>
 887     */
 888     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
 889         return;
 890
 891 #ifdef XSLT_REFACTORED
 892     comp = (xsltStyleItemElementPtr) xsltNewStylePreComp(style, XSLT_FUNC_ELEMENT);
 893 #else
 894     comp = xsltNewStylePreComp(style, XSLT_FUNC_ELEMENT);
 895 #endif
 896
 897     if (comp == NULL)
 898         return;
 899     inst->psvi = comp;
 900     comp->inst = inst;
 901
 902     /*
 903     * Attribute "name".
 904     */
 905     /*
 906     * TODO: Precompile the AVT. See bug #344894.
 907     */
 908     comp->name = xsltEvalStaticAttrValueTemplate(style, inst,
 909         (const xmlChar *)"name", NULL, &comp->has_name);
 910     if (! comp->has_name) {
 911         xsltTransformError(NULL, style, inst,
 912             "xsl:element: The attribute 'name' is missing.\n");
 913         style->errors++;
 914         goto error;
 915     }
 916     /*
 917     * Attribute "namespace".
 918     */
 919     /*
 920     * TODO: Precompile the AVT. See bug #344894.
 921     */
 922     comp->ns = xsltEvalStaticAttrValueTemplate(style, inst,
 923         (const xmlChar *)"namespace", NULL, &comp->has_ns);
 924
 925     if (comp->name != NULL) {
 926         if (xmlValidateQName(comp->name, 0)) {
 927             xsltTransformError(NULL, style, inst,
 928                 "xsl:element: The value '%s' of the attribute 'name' is "
 929                 "not a valid QName.\n", comp->name);
 930             style->errors++;
 931         } else {
 932             const xmlChar *prefix = NULL, *name;
 933
 934             name = xsltSplitQName(style->dict, comp->name, &prefix);
 935             if (comp->has_ns == 0) {
 936                 xmlNsPtr ns;
 937
 938                 /*
 939                 * SPEC XSLT 1.0:
 940                 *  "If the namespace attribute is not present, then the QName is
 941                 *  expanded into an expanded-name using the namespace declarations
 942                 *  in effect for the xsl:element element, including any default
 943                 *  namespace declaration.
 944                 */
 945                 ns = xmlSearchNs(inst->doc, inst, prefix);
 946                 if (ns != NULL) {
 947                     comp->ns = xmlDictLookup(style->dict, ns->href, -1);
 948                     comp->has_ns = 1;
 949 #ifdef XSLT_REFACTORED
 950                     comp->nsPrefix = prefix;
 951                     comp->name = name;
 952 #else
 953                     (void)name; /* Suppress unused variable warning. */
 954 #endif
 955                 } else if (prefix != NULL) {
 956                     xsltTransformError(NULL, style, inst,
 957                         "xsl:element: The prefixed QName '%s' "
 958                         "has no namespace binding in scope in the "
 959                         "stylesheet; this is an error, since the namespace was "
 960                         "not specified by the instruction itself.\n", comp->name);
 961                     style->errors++;
 962                 }
 963             }
 964             if ((prefix != NULL) &&
 965                 (!xmlStrncasecmp(prefix, (xmlChar *)"xml", 3)))
 966             {
 967                 /*
 968                 * Mark is to be skipped.
 969                 */
 970                 comp->has_name = 0;
 971             }
 972         }
 973     }
 974     /*
 975     * Attribute "use-attribute-sets",
 976     */
 977     comp->use = xsltEvalStaticAttrValueTemplate(style, inst,
 978                        (const xmlChar *)"use-attribute-sets",
 979                        NULL, &comp->has_use);
 980
 981 error:
 982     return;
 983 }
 984
 985 /**
 986  * xsltAttributeComp:
 987  * @style: an XSLT compiled stylesheet
 988  * @inst:  the xslt attribute node
 989  *
 990  * Process the xslt attribute node on the source node
 991  */
 992 static void
 993 xsltAttributeComp(xsltStylesheetPtr style, xmlNodePtr inst) {
 994 #ifdef XSLT_REFACTORED
 995     xsltStyleItemAttributePtr comp;
 996 #else
 997     xsltStylePreCompPtr comp;
 998 #endif
 999
1000     /*
1001     * <xsl:attribute
1002     *   name = { qname }
1003     *   namespace = { uri-reference }>
1004     *   <!-- Content: template -->
1005     * </xsl:attribute>
1006     */
1007     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1008         return;
1009
1010 #ifdef XSLT_REFACTORED
1011     comp = (xsltStyleItemAttributePtr) xsltNewStylePreComp(style,
1012         XSLT_FUNC_ATTRIBUTE);
1013 #else
1014     comp = xsltNewStylePreComp(style, XSLT_FUNC_ATTRIBUTE);
1015 #endif
1016
1017     if (comp == NULL)
1018         return;
1019     inst->psvi = comp;
1020     comp->inst = inst;
1021
1022     /*
1023     * Attribute "name".
1024     */
1025     /*
1026     * TODO: Precompile the AVT. See bug #344894.
1027     */
1028     comp->name = xsltEvalStaticAttrValueTemplate(style, inst,
1029                                  (const xmlChar *)"name",
1030                                  NULL, &comp->has_name);
1031     if (! comp->has_name) {
1032         xsltTransformError(NULL, style, inst,
1033             "XSLT-attribute: The attribute 'name' is missing.\n");
1034         style->errors++;
1035         return;
1036     }
1037     /*
1038     * Attribute "namespace".
1039     */
1040     /*
1041     * TODO: Precompile the AVT. See bug #344894.
1042     */
1043     comp->ns = xsltEvalStaticAttrValueTemplate(style, inst,
1044         (const xmlChar *)"namespace",
1045         NULL, &comp->has_ns);
1046
1047     if (comp->name != NULL) {
1048         if (xmlValidateQName(comp->name, 0)) {
1049             xsltTransformError(NULL, style, inst,
1050                 "xsl:attribute: The value '%s' of the attribute 'name' is "
1051                 "not a valid QName.\n", comp->name);
1052             style->errors++;
1053         } else if (xmlStrEqual(comp->name, BAD_CAST "xmlns")) {
1054             xsltTransformError(NULL, style, inst,
1055                 "xsl:attribute: The attribute name 'xmlns' is not allowed.\n");
1056             style->errors++;
1057         } else {
1058             const xmlChar *prefix = NULL, *name;
1059
1060             name = xsltSplitQName(style->dict, comp->name, &prefix);
1061             if (prefix != NULL) {
1062                 if (comp->has_ns == 0) {
1063                     xmlNsPtr ns;
1064
1065                     /*
1066                     * SPEC XSLT 1.0:
1067                     *  "If the namespace attribute is not present, then the
1068                     *  QName is expanded into an expanded-name using the
1069                     *  namespace declarations in effect for the xsl:element
1070                     *  element, including any default namespace declaration.
1071                     */
1072                     ns = xmlSearchNs(inst->doc, inst, prefix);
1073                     if (ns != NULL) {
1074                         comp->ns = xmlDictLookup(style->dict, ns->href, -1);
1075                         comp->has_ns = 1;
1076 #ifdef XSLT_REFACTORED
1077                         comp->nsPrefix = prefix;
1078                         comp->name = name;
1079 #else
1080                         (void)name; /* Suppress unused variable warning. */
1081 #endif
1082                     } else {
1083                         xsltTransformError(NULL, style, inst,
1084                             "xsl:attribute: The prefixed QName '%s' "
1085                             "has no namespace binding in scope in the "
1086                             "stylesheet; this is an error, since the "
1087                             "namespace was not specified by the instruction "
1088                             "itself.\n", comp->name);
1089                         style->errors++;
1090                     }
1091                 }
1092             }
1093         }
1094     }
1095 }
1096
1097 /**
1098  * xsltCommentComp:
1099  * @style: an XSLT compiled stylesheet
1100  * @inst:  the xslt comment node
1101  *
1102  * Process the xslt comment node on the source node
1103  */
1104 static void
1105 xsltCommentComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1106 #ifdef XSLT_REFACTORED
1107     xsltStyleItemCommentPtr comp;
1108 #else
1109     xsltStylePreCompPtr comp;
1110 #endif
1111
1112     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1113         return;
1114
1115 #ifdef XSLT_REFACTORED
1116     comp = (xsltStyleItemCommentPtr) xsltNewStylePreComp(style, XSLT_FUNC_COMMENT);
1117 #else
1118     comp = xsltNewStylePreComp(style, XSLT_FUNC_COMMENT);
1119 #endif
1120
1121     if (comp == NULL)
1122         return;
1123     inst->psvi = comp;
1124     comp->inst = inst;
1125 }
1126
1127 /**
1128  * xsltProcessingInstructionComp:
1129  * @style: an XSLT compiled stylesheet
1130  * @inst:  the xslt processing-instruction node
1131  *
1132  * Process the xslt processing-instruction node on the source node
1133  */
1134 static void
1135 xsltProcessingInstructionComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1136 #ifdef XSLT_REFACTORED
1137     xsltStyleItemPIPtr comp;
1138 #else
1139     xsltStylePreCompPtr comp;
1140 #endif
1141
1142     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1143         return;
1144
1145 #ifdef XSLT_REFACTORED
1146     comp = (xsltStyleItemPIPtr) xsltNewStylePreComp(style, XSLT_FUNC_PI);
1147 #else
1148     comp = xsltNewStylePreComp(style, XSLT_FUNC_PI);
1149 #endif
1150
1151     if (comp == NULL)
1152         return;
1153     inst->psvi = comp;
1154     comp->inst = inst;
1155
1156     comp->name = xsltEvalStaticAttrValueTemplate(style, inst,
1157                                  (const xmlChar *)"name",
1158                                  XSLT_NAMESPACE, &comp->has_name);
1159 }
1160
1161 /**
1162  * xsltCopyOfComp:
1163  * @style: an XSLT compiled stylesheet
1164  * @inst:  the xslt copy-of node
1165  *
1166  * Process the xslt copy-of node on the source node
1167  */
1168 static void
1169 xsltCopyOfComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1170 #ifdef XSLT_REFACTORED
1171     xsltStyleItemCopyOfPtr comp;
1172 #else
1173     xsltStylePreCompPtr comp;
1174 #endif
1175
1176     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1177         return;
1178
1179 #ifdef XSLT_REFACTORED
1180     comp = (xsltStyleItemCopyOfPtr) xsltNewStylePreComp(style, XSLT_FUNC_COPYOF);
1181 #else
1182     comp = xsltNewStylePreComp(style, XSLT_FUNC_COPYOF);
1183 #endif
1184
1185     if (comp == NULL)
1186         return;
1187     inst->psvi = comp;
1188     comp->inst = inst;
1189
1190     comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
1191                                 XSLT_NAMESPACE);
1192     if (comp->select == NULL) {
1193         xsltTransformError(NULL, style, inst,
1194              "xsl:copy-of : select is missing\n");
1195         if (style != NULL) style->errors++;
1196         return;
1197     }
1198     comp->comp = xsltXPathCompile(style, comp->select);
1199     if (comp->comp == NULL) {
1200         xsltTransformError(NULL, style, inst,
1201              "xsl:copy-of : could not compile select expression '%s'\n",
1202                          comp->select);
1203         if (style != NULL) style->errors++;
1204     }
1205 }
1206
1207 /**
1208  * xsltValueOfComp:
1209  * @style: an XSLT compiled stylesheet
1210  * @inst:  the xslt value-of node
1211  *
1212  * Process the xslt value-of node on the source node
1213  */
1214 static void
1215 xsltValueOfComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1216 #ifdef XSLT_REFACTORED
1217     xsltStyleItemValueOfPtr comp;
1218 #else
1219     xsltStylePreCompPtr comp;
1220 #endif
1221     const xmlChar *prop;
1222
1223     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1224         return;
1225
1226 #ifdef XSLT_REFACTORED
1227     comp = (xsltStyleItemValueOfPtr) xsltNewStylePreComp(style, XSLT_FUNC_VALUEOF);
1228 #else
1229     comp = xsltNewStylePreComp(style, XSLT_FUNC_VALUEOF);
1230 #endif
1231
1232     if (comp == NULL)
1233         return;
1234     inst->psvi = comp;
1235     comp->inst = inst;
1236
1237     prop = xsltGetCNsProp(style, inst,
1238             (const xmlChar *)"disable-output-escaping",
1239                         XSLT_NAMESPACE);
1240     if (prop != NULL) {
1241         if (xmlStrEqual(prop, (const xmlChar *)"yes")) {
1242             comp->noescape = 1;
1243         } else if (!xmlStrEqual(prop,
1244                                 (const xmlChar *)"no")){
1245             xsltTransformError(NULL, style, inst,
1246 "xsl:value-of : disable-output-escaping allows only yes or no\n");
1247             if (style != NULL) style->warnings++;
1248         }
1249     }
1250     comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
1251                                 XSLT_NAMESPACE);
1252     if (comp->select == NULL) {
1253         xsltTransformError(NULL, style, inst,
1254              "xsl:value-of : select is missing\n");
1255         if (style != NULL) style->errors++;
1256         return;
1257     }
1258     comp->comp = xsltXPathCompile(style, comp->select);
1259     if (comp->comp == NULL) {
1260         xsltTransformError(NULL, style, inst,
1261              "xsl:value-of : could not compile select expression '%s'\n",
1262                          comp->select);
1263         if (style != NULL) style->errors++;
1264     }
1265 }
1266
1267 static void
1268 xsltGetQNameProperty(xsltStylesheetPtr style, xmlNodePtr inst,
1269                      const xmlChar *propName,
1270                      int mandatory,
1271                      int *hasProp, const xmlChar **nsName,
1272                      const xmlChar** localName)
1273 {
1274     const xmlChar *prop;
1275
1276     if (nsName)
1277         *nsName = NULL;
1278     if (localName)
1279         *localName = NULL;
1280     if (hasProp)
1281         *hasProp = 0;
1282
1283     prop = xsltGetCNsProp(style, inst, propName, XSLT_NAMESPACE);
1284     if (prop == NULL) {
1285         if (mandatory) {
1286             xsltTransformError(NULL, style, inst,
1287                 "The attribute '%s' is missing.\n", propName);
1288             style->errors++;
1289             return;
1290         }
1291     } else {
1292         const xmlChar *URI;
1293
1294         if (xmlValidateQName(prop, 0)) {
1295             xsltTransformError(NULL, style, inst,
1296                 "The value '%s' of the attribute "
1297                 "'%s' is not a valid QName.\n", prop, propName);
1298             style->errors++;
1299             return;
1300         } else {
1301             /*
1302             * @prop will be in the string dict afterwards, @URI not.
1303             */
1304             URI = xsltGetQNameURI2(style, inst, &prop);
1305             if (prop == NULL) {
1306                 style->errors++;
1307             } else {
1308                 if (localName)
1309                     *localName = prop;
1310                 if (hasProp)
1311                     *hasProp = 1;
1312                 if (URI != NULL) {
1313                     /*
1314                     * Fixes bug #308441: Put the ns-name in the dict
1315                     * in order to pointer compare names during XPath's
1316                     * variable lookup.
1317                     */
1318                     if (nsName)
1319                         *nsName = xmlDictLookup(style->dict, URI, -1);
1320                     /* comp->has_ns = 1; */
1321                 }
1322             }
1323         }
1324     }
1325     return;
1326 }
1327
1328 /**
1329  * xsltWithParamComp:
1330  * @style: an XSLT compiled stylesheet
1331  * @inst:  the xslt with-param node
1332  *
1333  * Process the xslt with-param node on the source node
1334  * Allowed parents: xsl:call-template, xsl:apply-templates.
1335  * <xsl:with-param
1336  *  name = qname
1337  *  select = expression>
1338  *  <!-- Content: template -->
1339  * </xsl:with-param>
1340  */
1341 static void
1342 xsltWithParamComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1343 #ifdef XSLT_REFACTORED
1344     xsltStyleItemWithParamPtr comp;
1345 #else
1346     xsltStylePreCompPtr comp;
1347 #endif
1348
1349     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1350         return;
1351
1352 #ifdef XSLT_REFACTORED
1353     comp = (xsltStyleItemWithParamPtr) xsltNewStylePreComp(style, XSLT_FUNC_WITHPARAM);
1354 #else
1355     comp = xsltNewStylePreComp(style, XSLT_FUNC_WITHPARAM);
1356 #endif
1357
1358     if (comp == NULL)
1359         return;
1360     inst->psvi = comp;
1361     comp->inst = inst;
1362
1363     /*
1364     * Attribute "name".
1365     */
1366     xsltGetQNameProperty(style, inst, BAD_CAST "name",
1367         1, &(comp->has_name), &(comp->ns), &(comp->name));
1368     if (comp->ns)
1369         comp->has_ns = 1;
1370     /*
1371     * Attribute "select".
1372     */
1373     comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
1374                                 XSLT_NAMESPACE);
1375     if (comp->select != NULL) {
1376         comp->comp = xsltXPathCompile(style, comp->select);
1377         if (comp->comp == NULL) {
1378             xsltTransformError(NULL, style, inst,
1379                  "XSLT-with-param: Failed to compile select "
1380                  "expression '%s'\n", comp->select);
1381             style->errors++;
1382         }
1383         if (inst->children != NULL) {
1384             xsltTransformError(NULL, style, inst,
1385                 "XSLT-with-param: The content should be empty since "
1386                 "the attribute select is present.\n");
1387             style->warnings++;
1388         }
1389     }
1390 }
1391
1392 /**
1393  * xsltNumberComp:
1394  * @style: an XSLT compiled stylesheet
1395  * @cur:   the xslt number node
1396  *
1397  * Process the xslt number node on the source node
1398  */
1399 static void
1400 xsltNumberComp(xsltStylesheetPtr style, xmlNodePtr cur) {
1401 #ifdef XSLT_REFACTORED
1402     xsltStyleItemNumberPtr comp;
1403 #else
1404     xsltStylePreCompPtr comp;
1405 #endif
1406     const xmlChar *prop;
1407
1408     if ((style == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE))
1409         return;
1410
1411 #ifdef XSLT_REFACTORED
1412     comp = (xsltStyleItemNumberPtr) xsltNewStylePreComp(style, XSLT_FUNC_NUMBER);
1413 #else
1414     comp = xsltNewStylePreComp(style, XSLT_FUNC_NUMBER);
1415 #endif
1416
1417     if (comp == NULL)
1418         return;
1419     cur->psvi = comp;
1420
1421     comp->numdata.doc = cur->doc;
1422     comp->numdata.node = cur;
1423     comp->numdata.value = xsltGetCNsProp(style, cur, (const xmlChar *)"value",
1424                                         XSLT_NAMESPACE);
1425
1426     prop = xsltEvalStaticAttrValueTemplate(style, cur,
1427                          (const xmlChar *)"format",
1428                          XSLT_NAMESPACE, &comp->numdata.has_format);
1429     if (comp->numdata.has_format == 0) {
1430         comp->numdata.format = xmlDictLookup(style->dict, BAD_CAST "" , 0);
1431     } else {
1432         comp->numdata.format = prop;
1433     }
1434
1435     comp->numdata.count = xsltGetCNsProp(style, cur, (const xmlChar *)"count",
1436                                          XSLT_NAMESPACE);
1437     comp->numdata.from = xsltGetCNsProp(style, cur, (const xmlChar *)"from",
1438                                         XSLT_NAMESPACE);
1439
1440     prop = xsltGetCNsProp(style, cur, (const xmlChar *)"count", XSLT_NAMESPACE);
1441     if (prop != NULL) {
1442         comp->numdata.countPat = xsltCompilePattern(prop, cur->doc, cur, style,
1443                                                     NULL);
1444     }
1445
1446     prop = xsltGetCNsProp(style, cur, (const xmlChar *)"from", XSLT_NAMESPACE);
1447     if (prop != NULL) {
1448         comp->numdata.fromPat = xsltCompilePattern(prop, cur->doc, cur, style,
1449                                                    NULL);
1450     }
1451
1452     prop = xsltGetCNsProp(style, cur, (const xmlChar *)"level", XSLT_NAMESPACE);
1453     if (prop != NULL) {
1454         if (xmlStrEqual(prop, BAD_CAST("single")) ||
1455             xmlStrEqual(prop, BAD_CAST("multiple")) ||
1456             xmlStrEqual(prop, BAD_CAST("any"))) {
1457             comp->numdata.level = prop;
1458         } else {
1459             xsltTransformError(NULL, style, cur,
1460                          "xsl:number : invalid value %s for level\n", prop);
1461             if (style != NULL) style->warnings++;
1462         }
1463     }
1464
1465     prop = xsltGetCNsProp(style, cur, (const xmlChar *)"lang", XSLT_NAMESPACE);
1466     if (prop != NULL) {
1467             xsltTransformError(NULL, style, cur,
1468                  "xsl:number : lang attribute not implemented\n");
1469         XSLT_TODO; /* xsl:number lang attribute */
1470     }
1471
1472     prop = xsltGetCNsProp(style, cur, (const xmlChar *)"letter-value", XSLT_NAMESPACE);
1473     if (prop != NULL) {
1474         if (xmlStrEqual(prop, BAD_CAST("alphabetic"))) {
1475             xsltTransformError(NULL, style, cur,
1476                  "xsl:number : letter-value 'alphabetic' not implemented\n");
1477             if (style != NULL) style->warnings++;
1478             XSLT_TODO; /* xsl:number letter-value attribute alphabetic */
1479         } else if (xmlStrEqual(prop, BAD_CAST("traditional"))) {
1480             xsltTransformError(NULL, style, cur,
1481                  "xsl:number : letter-value 'traditional' not implemented\n");
1482             if (style != NULL) style->warnings++;
1483             XSLT_TODO; /* xsl:number letter-value attribute traditional */
1484         } else {
1485             xsltTransformError(NULL, style, cur,
1486                      "xsl:number : invalid value %s for letter-value\n", prop);
1487             if (style != NULL) style->warnings++;
1488         }
1489     }
1490
1491     prop = xsltGetCNsProp(style, cur, (const xmlChar *)"grouping-separator",
1492                         XSLT_NAMESPACE);
1493     if (prop != NULL) {
1494         comp->numdata.groupingCharacterLen = xmlStrlen(prop);
1495         comp->numdata.groupingCharacter =
1496             xsltGetUTF8Char(prop, &(comp->numdata.groupingCharacterLen));
1497     }
1498
1499     prop = xsltGetCNsProp(style, cur, (const xmlChar *)"grouping-size", XSLT_NAMESPACE);
1500     if (prop != NULL) {
1501         sscanf((char *)prop, "%d", &comp->numdata.digitsPerGroup);
1502     } else {
1503         comp->numdata.groupingCharacter = 0;
1504     }
1505
1506     /* Set default values */
1507     if (comp->numdata.value == NULL) {
1508         if (comp->numdata.level == NULL) {
1509             comp->numdata.level = xmlDictLookup(style->dict,
1510                                                 BAD_CAST"single", 6);
1511         }
1512     }
1513
1514 }
1515
1516 /**
1517  * xsltApplyImportsComp:
1518  * @style: an XSLT compiled stylesheet
1519  * @inst:  the xslt apply-imports node
1520  *
1521  * Process the xslt apply-imports node on the source node
1522  */
1523 static void
1524 xsltApplyImportsComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1525 #ifdef XSLT_REFACTORED
1526     xsltStyleItemApplyImportsPtr comp;
1527 #else
1528     xsltStylePreCompPtr comp;
1529 #endif
1530
1531     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1532         return;
1533
1534 #ifdef XSLT_REFACTORED
1535     comp = (xsltStyleItemApplyImportsPtr) xsltNewStylePreComp(style, XSLT_FUNC_APPLYIMPORTS);
1536 #else
1537     comp = xsltNewStylePreComp(style, XSLT_FUNC_APPLYIMPORTS);
1538 #endif
1539
1540     if (comp == NULL)
1541         return;
1542     inst->psvi = comp;
1543     comp->inst = inst;
1544 }
1545
1546 /**
1547  * xsltCallTemplateComp:
1548  * @style: an XSLT compiled stylesheet
1549  * @inst:  the xslt call-template node
1550  *
1551  * Process the xslt call-template node on the source node
1552  */
1553 static void
1554 xsltCallTemplateComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1555 #ifdef XSLT_REFACTORED
1556     xsltStyleItemCallTemplatePtr comp;
1557 #else
1558     xsltStylePreCompPtr comp;
1559 #endif
1560
1561     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1562         return;
1563
1564 #ifdef XSLT_REFACTORED
1565     comp = (xsltStyleItemCallTemplatePtr)
1566         xsltNewStylePreComp(style, XSLT_FUNC_CALLTEMPLATE);
1567 #else
1568     comp = xsltNewStylePreComp(style, XSLT_FUNC_CALLTEMPLATE);
1569 #endif
1570
1571     if (comp == NULL)
1572         return;
1573     inst->psvi = comp;
1574     comp->inst = inst;
1575
1576     /*
1577      * Attribute "name".
1578      */
1579     xsltGetQNameProperty(style, inst, BAD_CAST "name",
1580         1, &(comp->has_name), &(comp->ns), &(comp->name));
1581     if (comp->ns)
1582         comp->has_ns = 1;
1583 }
1584
1585 /**
1586  * xsltApplyTemplatesComp:
1587  * @style: an XSLT compiled stylesheet
1588  * @inst:  the apply-templates node
1589  *
1590  * Process the apply-templates node on the source node
1591  */
1592 static void
1593 xsltApplyTemplatesComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1594 #ifdef XSLT_REFACTORED
1595     xsltStyleItemApplyTemplatesPtr comp;
1596 #else
1597     xsltStylePreCompPtr comp;
1598 #endif
1599
1600     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1601         return;
1602
1603 #ifdef XSLT_REFACTORED
1604     comp = (xsltStyleItemApplyTemplatesPtr)
1605         xsltNewStylePreComp(style, XSLT_FUNC_APPLYTEMPLATES);
1606 #else
1607     comp = xsltNewStylePreComp(style, XSLT_FUNC_APPLYTEMPLATES);
1608 #endif
1609
1610     if (comp == NULL)
1611         return;
1612     inst->psvi = comp;
1613     comp->inst = inst;
1614
1615     /*
1616      * Attribute "mode".
1617      */
1618     xsltGetQNameProperty(style, inst, BAD_CAST "mode",
1619         0, NULL, &(comp->modeURI), &(comp->mode));
1620     /*
1621     * Attribute "select".
1622     */
1623     comp->select = xsltGetCNsProp(style, inst, BAD_CAST "select",
1624         XSLT_NAMESPACE);
1625     if (comp->select != NULL) {
1626         comp->comp = xsltXPathCompile(style, comp->select);
1627         if (comp->comp == NULL) {
1628             xsltTransformError(NULL, style, inst,
1629                 "XSLT-apply-templates: could not compile select "
1630                 "expression '%s'\n", comp->select);
1631              style->errors++;
1632         }
1633     }
1634     /* TODO: handle (or skip) the xsl:sort and xsl:with-param */
1635 }
1636
1637 /**
1638  * xsltChooseComp:
1639  * @style: an XSLT compiled stylesheet
1640  * @inst:  the xslt choose node
1641  *
1642  * Process the xslt choose node on the source node
1643  */
1644 static void
1645 xsltChooseComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1646 #ifdef XSLT_REFACTORED
1647     xsltStyleItemChoosePtr comp;
1648 #else
1649     xsltStylePreCompPtr comp;
1650 #endif
1651
1652     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1653         return;
1654
1655 #ifdef XSLT_REFACTORED
1656     comp = (xsltStyleItemChoosePtr)
1657         xsltNewStylePreComp(style, XSLT_FUNC_CHOOSE);
1658 #else
1659     comp = xsltNewStylePreComp(style, XSLT_FUNC_CHOOSE);
1660 #endif
1661
1662     if (comp == NULL)
1663         return;
1664     inst->psvi = comp;
1665     comp->inst = inst;
1666 }
1667
1668 /**
1669  * xsltIfComp:
1670  * @style: an XSLT compiled stylesheet
1671  * @inst:  the xslt if node
1672  *
1673  * Process the xslt if node on the source node
1674  */
1675 static void
1676 xsltIfComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1677 #ifdef XSLT_REFACTORED
1678     xsltStyleItemIfPtr comp;
1679 #else
1680     xsltStylePreCompPtr comp;
1681 #endif
1682
1683     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1684         return;
1685
1686 #ifdef XSLT_REFACTORED
1687     comp = (xsltStyleItemIfPtr)
1688         xsltNewStylePreComp(style, XSLT_FUNC_IF);
1689 #else
1690     comp = xsltNewStylePreComp(style, XSLT_FUNC_IF);
1691 #endif
1692
1693     if (comp == NULL)
1694         return;
1695     inst->psvi = comp;
1696     comp->inst = inst;
1697
1698     comp->test = xsltGetCNsProp(style, inst, (const xmlChar *)"test", XSLT_NAMESPACE);
1699     if (comp->test == NULL) {
1700         xsltTransformError(NULL, style, inst,
1701              "xsl:if : test is not defined\n");
1702         if (style != NULL) style->errors++;
1703         return;
1704     }
1705     comp->comp = xsltXPathCompile(style, comp->test);
1706     if (comp->comp == NULL) {
1707         xsltTransformError(NULL, style, inst,
1708              "xsl:if : could not compile test expression '%s'\n",
1709                          comp->test);
1710         if (style != NULL) style->errors++;
1711     }
1712 }
1713
1714 /**
1715  * xsltWhenComp:
1716  * @style: an XSLT compiled stylesheet
1717  * @inst:  the xslt if node
1718  *
1719  * Process the xslt if node on the source node
1720  */
1721 static void
1722 xsltWhenComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1723 #ifdef XSLT_REFACTORED
1724     xsltStyleItemWhenPtr comp;
1725 #else
1726     xsltStylePreCompPtr comp;
1727 #endif
1728
1729     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1730         return;
1731
1732 #ifdef XSLT_REFACTORED
1733     comp = (xsltStyleItemWhenPtr)
1734         xsltNewStylePreComp(style, XSLT_FUNC_WHEN);
1735 #else
1736     comp = xsltNewStylePreComp(style, XSLT_FUNC_WHEN);
1737 #endif
1738
1739     if (comp == NULL)
1740         return;
1741     inst->psvi = comp;
1742     comp->inst = inst;
1743
1744     comp->test = xsltGetCNsProp(style, inst, (const xmlChar *)"test", XSLT_NAMESPACE);
1745     if (comp->test == NULL) {
1746         xsltTransformError(NULL, style, inst,
1747              "xsl:when : test is not defined\n");
1748         if (style != NULL) style->errors++;
1749         return;
1750     }
1751     comp->comp = xsltXPathCompile(style, comp->test);
1752     if (comp->comp == NULL) {
1753         xsltTransformError(NULL, style, inst,
1754              "xsl:when : could not compile test expression '%s'\n",
1755                          comp->test);
1756         if (style != NULL) style->errors++;
1757     }
1758 }
1759
1760 /**
1761  * xsltForEachComp:
1762  * @style: an XSLT compiled stylesheet
1763  * @inst:  the xslt for-each node
1764  *
1765  * Process the xslt for-each node on the source node
1766  */
1767 static void
1768 xsltForEachComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1769 #ifdef XSLT_REFACTORED
1770     xsltStyleItemForEachPtr comp;
1771 #else
1772     xsltStylePreCompPtr comp;
1773 #endif
1774
1775     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1776         return;
1777
1778 #ifdef XSLT_REFACTORED
1779     comp = (xsltStyleItemForEachPtr)
1780         xsltNewStylePreComp(style, XSLT_FUNC_FOREACH);
1781 #else
1782     comp = xsltNewStylePreComp(style, XSLT_FUNC_FOREACH);
1783 #endif
1784
1785     if (comp == NULL)
1786         return;
1787     inst->psvi = comp;
1788     comp->inst = inst;
1789
1790     comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
1791                                 XSLT_NAMESPACE);
1792     if (comp->select == NULL) {
1793         xsltTransformError(NULL, style, inst,
1794                 "xsl:for-each : select is missing\n");
1795         if (style != NULL) style->errors++;
1796     } else {
1797         comp->comp = xsltXPathCompile(style, comp->select);
1798         if (comp->comp == NULL) {
1799             xsltTransformError(NULL, style, inst,
1800      "xsl:for-each : could not compile select expression '%s'\n",
1801                              comp->select);
1802             if (style != NULL) style->errors++;
1803         }
1804     }
1805     /* TODO: handle and skip the xsl:sort */
1806 }
1807
1808 /**
1809  * xsltVariableComp:
1810  * @style: an XSLT compiled stylesheet
1811  * @inst:  the xslt variable node
1812  *
1813  * Process the xslt variable node on the source node
1814  */
1815 static void
1816 xsltVariableComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1817 #ifdef XSLT_REFACTORED
1818     xsltStyleItemVariablePtr comp;
1819 #else
1820     xsltStylePreCompPtr comp;
1821 #endif
1822
1823     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1824         return;
1825
1826 #ifdef XSLT_REFACTORED
1827     comp = (xsltStyleItemVariablePtr)
1828         xsltNewStylePreComp(style, XSLT_FUNC_VARIABLE);
1829 #else
1830     comp = xsltNewStylePreComp(style, XSLT_FUNC_VARIABLE);
1831 #endif
1832
1833     if (comp == NULL)
1834         return;
1835
1836     inst->psvi = comp;
1837     comp->inst = inst;
1838     /*
1839      * The full template resolution can be done statically
1840      */
1841
1842     /*
1843     * Attribute "name".
1844     */
1845     xsltGetQNameProperty(style, inst, BAD_CAST "name",
1846         1, &(comp->has_name), &(comp->ns), &(comp->name));
1847     if (comp->ns)
1848         comp->has_ns = 1;
1849     /*
1850     * Attribute "select".
1851     */
1852     comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
1853                                 XSLT_NAMESPACE);
1854     if (comp->select != NULL) {
1855 #ifndef XSLT_REFACTORED
1856         xmlNodePtr cur;
1857 #endif
1858         comp->comp = xsltXPathCompile(style, comp->select);
1859         if (comp->comp == NULL) {
1860             xsltTransformError(NULL, style, inst,
1861                 "XSLT-variable: Failed to compile the XPath expression '%s'.\n",
1862                 comp->select);
1863             style->errors++;
1864         }
1865 #ifdef XSLT_REFACTORED
1866         if (inst->children != NULL) {
1867             xsltTransformError(NULL, style, inst,
1868                 "XSLT-variable: There must be no child nodes, since the "
1869                 "attribute 'select' was specified.\n");
1870             style->errors++;
1871         }
1872 #else
1873         for (cur = inst->children; cur != NULL; cur = cur->next) {
1874             if (cur->type != XML_COMMENT_NODE &&
1875                 (cur->type != XML_TEXT_NODE || !xsltIsBlank(cur->content)))
1876             {
1877                 xsltTransformError(NULL, style, inst,
1878                     "XSLT-variable: There must be no child nodes, since the "
1879                     "attribute 'select' was specified.\n");
1880                 style->errors++;
1881             }
1882         }
1883 #endif
1884     }
1885 }
1886
1887 /**
1888  * xsltParamComp:
1889  * @style: an XSLT compiled stylesheet
1890  * @inst:  the xslt param node
1891  *
1892  * Process the xslt param node on the source node
1893  */
1894 static void
1895 xsltParamComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1896 #ifdef XSLT_REFACTORED
1897     xsltStyleItemParamPtr comp;
1898 #else
1899     xsltStylePreCompPtr comp;
1900 #endif
1901
1902     if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1903         return;
1904
1905 #ifdef XSLT_REFACTORED
1906     comp = (xsltStyleItemParamPtr)
1907         xsltNewStylePreComp(style, XSLT_FUNC_PARAM);
1908 #else
1909     comp = xsltNewStylePreComp(style, XSLT_FUNC_PARAM);
1910 #endif
1911
1912     if (comp == NULL)
1913         return;
1914     inst->psvi = comp;
1915     comp->inst = inst;
1916
1917     /*
1918      * Attribute "name".
1919      */
1920     xsltGetQNameProperty(style, inst, BAD_CAST "name",
1921         1, &(comp->has_name), &(comp->ns), &(comp->name));
1922     if (comp->ns)
1923         comp->has_ns = 1;
1924     /*
1925     * Attribute "select".
1926     */
1927     comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
1928                                 XSLT_NAMESPACE);
1929     if (comp->select != NULL) {
1930         comp->comp = xsltXPathCompile(style, comp->select);
1931         if (comp->comp == NULL) {
1932             xsltTransformError(NULL, style, inst,
1933                 "XSLT-param: could not compile select expression '%s'.\n",
1934                 comp->select);
1935             style->errors++;
1936         }
1937         if (inst->children != NULL) {
1938             xsltTransformError(NULL, style, inst,
1939                 "XSLT-param: The content should be empty since the "
1940                 "attribute 'select' is present.\n");
1941             style->warnings++;
1942         }
1943     }
1944 }
1945
1946 /************************************************************************
1947  *                                                                      *
1948  *                  Generic interface                                   *
1949  *                                                                      *
1950  ************************************************************************/
1951
1952 /**
1953  * xsltFreeStylePreComps:
1954  * @style:  an XSLT transformation context
1955  *
1956  * Free up the memory allocated by all precomputed blocks
1957  */
1958 void
1959 xsltFreeStylePreComps(xsltStylesheetPtr style) {
1960     xsltElemPreCompPtr cur, next;
1961
1962     if (style == NULL)
1963         return;
1964
1965     cur = style->preComps;
1966     while (cur != NULL) {
1967         next = cur->next;
1968         if (cur->type == XSLT_FUNC_EXTENSION)
1969             cur->free(cur);
1970         else
1971             xsltFreeStylePreComp((xsltStylePreCompPtr) cur);
1972         cur = next;
1973     }
1974 }
1975
1976 #ifdef XSLT_REFACTORED
1977
1978 /**
1979  * xsltStylePreCompute:
1980  * @style:  the XSLT stylesheet
1981  * @node:  the element in the XSLT namespace
1982  *
1983  * Precompute an XSLT element.
1984  * This expects the type of the element to be already
1985  * set in style->compCtxt->inode->type;
1986  */
1987 void
1988 xsltStylePreCompute(xsltStylesheetPtr style, xmlNodePtr node) {
1989     /*
1990     * The xsltXSLTElemMarker marker was set beforehand by
1991     *  the parsing mechanism for all elements in the XSLT namespace.
1992     */
1993     if (style == NULL) {
1994         if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
1995             node->psvi = NULL;
1996         return;
1997     }
1998     if (node == NULL)
1999         return;
2000     if (! IS_XSLT_ELEM_FAST(node))
2001         return;
2002
2003     node->psvi = NULL;
2004     if (XSLT_CCTXT(style)->inode->type != 0) {
2005         switch (XSLT_CCTXT(style)->inode->type) {
2006             case XSLT_FUNC_APPLYTEMPLATES:
2007                 xsltApplyTemplatesComp(style, node);
2008                 break;
2009             case XSLT_FUNC_WITHPARAM:
2010                 xsltWithParamComp(style, node);
2011                 break;
2012             case XSLT_FUNC_VALUEOF:
2013                 xsltValueOfComp(style, node);
2014                 break;
2015             case XSLT_FUNC_COPY:
2016                 xsltCopyComp(style, node);
2017                 break;
2018             case XSLT_FUNC_COPYOF:
2019                 xsltCopyOfComp(style, node);
2020                 break;
2021             case XSLT_FUNC_IF:
2022                 xsltIfComp(style, node);
2023                 break;
2024             case XSLT_FUNC_CHOOSE:
2025                 xsltChooseComp(style, node);
2026                 break;
2027             case XSLT_FUNC_WHEN:
2028                 xsltWhenComp(style, node);
2029                 break;
2030             case XSLT_FUNC_OTHERWISE:
2031                 /* NOP yet */
2032                 return;
2033             case XSLT_FUNC_FOREACH:
2034                 xsltForEachComp(style, node);
2035                 break;
2036             case XSLT_FUNC_APPLYIMPORTS:
2037                 xsltApplyImportsComp(style, node);
2038                 break;
2039             case XSLT_FUNC_ATTRIBUTE:
2040                 xsltAttributeComp(style, node);
2041                 break;
2042             case XSLT_FUNC_ELEMENT:
2043                 xsltElementComp(style, node);
2044                 break;
2045             case XSLT_FUNC_SORT:
2046                 xsltSortComp(style, node);
2047                 break;
2048             case XSLT_FUNC_COMMENT:
2049                 xsltCommentComp(style, node);
2050                 break;
2051             case XSLT_FUNC_NUMBER:
2052                 xsltNumberComp(style, node);
2053                 break;
2054             case XSLT_FUNC_PI:
2055                 xsltProcessingInstructionComp(style, node);
2056                 break;
2057             case XSLT_FUNC_CALLTEMPLATE:
2058                 xsltCallTemplateComp(style, node);
2059                 break;
2060             case XSLT_FUNC_PARAM:
2061                 xsltParamComp(style, node);
2062                 break;
2063             case XSLT_FUNC_VARIABLE:
2064                 xsltVariableComp(style, node);
2065                 break;
2066             case XSLT_FUNC_FALLBACK:
2067                 /* NOP yet */
2068                 return;
2069             case XSLT_FUNC_DOCUMENT:
2070                 /* The extra one */
2071                 node->psvi = (void *) xsltDocumentComp(style, node,
2072                     xsltDocumentElem);
2073                 break;
2074             case XSLT_FUNC_MESSAGE:
2075                 /* NOP yet */
2076                 return;
2077             default:
2078                 /*
2079                 * NOTE that xsl:text, xsl:template, xsl:stylesheet,
2080                 *  xsl:transform, xsl:import, xsl:include are not expected
2081                 *  to be handed over to this function.
2082                 */
2083                 xsltTransformError(NULL, style, node,
2084                     "Internal error: (xsltStylePreCompute) cannot handle "
2085                     "the XSLT element '%s'.\n", node->name);
2086                 style->errors++;
2087                 return;
2088         }
2089     } else {
2090         /*
2091         * Fallback to string comparison.
2092         */
2093         if (IS_XSLT_NAME(node, "apply-templates")) {
2094             xsltApplyTemplatesComp(style, node);
2095         } else if (IS_XSLT_NAME(node, "with-param")) {
2096             xsltWithParamComp(style, node);
2097         } else if (IS_XSLT_NAME(node, "value-of")) {
2098             xsltValueOfComp(style, node);
2099         } else if (IS_XSLT_NAME(node, "copy")) {
2100             xsltCopyComp(style, node);
2101         } else if (IS_XSLT_NAME(node, "copy-of")) {
2102             xsltCopyOfComp(style, node);
2103         } else if (IS_XSLT_NAME(node, "if")) {
2104             xsltIfComp(style, node);
2105         } else if (IS_XSLT_NAME(node, "choose")) {
2106             xsltChooseComp(style, node);
2107         } else if (IS_XSLT_NAME(node, "when")) {
2108             xsltWhenComp(style, node);
2109         } else if (IS_XSLT_NAME(node, "otherwise")) {
2110             /* NOP yet */
2111             return;
2112         } else if (IS_XSLT_NAME(node, "for-each")) {
2113             xsltForEachComp(style, node);
2114         } else if (IS_XSLT_NAME(node, "apply-imports")) {
2115             xsltApplyImportsComp(style, node);
2116         } else if (IS_XSLT_NAME(node, "attribute")) {
2117             xsltAttributeComp(style, node);
2118         } else if (IS_XSLT_NAME(node, "element")) {
2119             xsltElementComp(style, node);
2120         } else if (IS_XSLT_NAME(node, "sort")) {
2121             xsltSortComp(style, node);
2122         } else if (IS_XSLT_NAME(node, "comment")) {
2123             xsltCommentComp(style, node);
2124         } else if (IS_XSLT_NAME(node, "number")) {
2125             xsltNumberComp(style, node);
2126         } else if (IS_XSLT_NAME(node, "processing-instruction")) {
2127             xsltProcessingInstructionComp(style, node);
2128         } else if (IS_XSLT_NAME(node, "call-template")) {
2129             xsltCallTemplateComp(style, node);
2130         } else if (IS_XSLT_NAME(node, "param")) {
2131             xsltParamComp(style, node);
2132         } else if (IS_XSLT_NAME(node, "variable")) {
2133             xsltVariableComp(style, node);
2134         } else if (IS_XSLT_NAME(node, "fallback")) {
2135             /* NOP yet */
2136             return;
2137         } else if (IS_XSLT_NAME(node, "document")) {
2138             /* The extra one */
2139             node->psvi = (void *) xsltDocumentComp(style, node,
2140                 xsltDocumentElem);
2141         } else if (IS_XSLT_NAME(node, "output")) {
2142             /* Top-level */
2143             return;
2144         } else if (IS_XSLT_NAME(node, "preserve-space")) {
2145             /* Top-level */
2146             return;
2147         } else if (IS_XSLT_NAME(node, "strip-space")) {
2148             /* Top-level */
2149             return;
2150         } else if (IS_XSLT_NAME(node, "key")) {
2151             /* Top-level */
2152             return;
2153         } else if (IS_XSLT_NAME(node, "message")) {
2154             return;
2155         } else if (IS_XSLT_NAME(node, "attribute-set")) {
2156             /* Top-level */
2157             return;
2158         } else if (IS_XSLT_NAME(node, "namespace-alias")) {
2159             /* Top-level */
2160             return;
2161         } else if (IS_XSLT_NAME(node, "decimal-format")) {
2162             /* Top-level */
2163             return;
2164         } else if (IS_XSLT_NAME(node, "include")) {
2165             /* Top-level */
2166         } else {
2167             /*
2168             * NOTE that xsl:text, xsl:template, xsl:stylesheet,
2169             *  xsl:transform, xsl:import, xsl:include are not expected
2170             *  to be handed over to this function.
2171             */
2172             xsltTransformError(NULL, style, node,
2173                 "Internal error: (xsltStylePreCompute) cannot handle "
2174                 "the XSLT element '%s'.\n", node->name);
2175                 style->errors++;
2176             return;
2177         }
2178     }
2179     /*
2180     * Assign the current list of in-scope namespaces to the
2181     * item. This is needed for XPath expressions.
2182     */
2183     if (node->psvi != NULL) {
2184         ((xsltStylePreCompPtr) node->psvi)->inScopeNs =
2185             XSLT_CCTXT(style)->inode->inScopeNs;
2186     }
2187 }
2188
2189 #else
2190
2191 /**
2192  * xsltStylePreCompute:
2193  * @style:  the XSLT stylesheet
2194  * @inst:  the instruction in the stylesheet
2195  *
2196  * Precompute an XSLT stylesheet element
2197  */
2198 void
2199 xsltStylePreCompute(xsltStylesheetPtr style, xmlNodePtr inst) {
2200     /*
2201     * URGENT TODO: Normally inst->psvi Should never be reserved here,
2202     *   BUT: since if we include the same stylesheet from
2203     *   multiple imports, then the stylesheet will be parsed
2204     *   again. We simply must not try to compute the stylesheet again.
2205     * TODO: Get to the point where we don't need to query the
2206     *   namespace- and local-name of the node, but can evaluate this
2207     *   using cctxt->style->inode->category;
2208     */
2209     if ((inst == NULL) || (inst->type != XML_ELEMENT_NODE) ||
2210         (inst->psvi != NULL))
2211         return;
2212
2213     if (IS_XSLT_ELEM(inst)) {
2214         xsltStylePreCompPtr cur;
2215
2216         if (IS_XSLT_NAME(inst, "apply-templates")) {
2217             xsltCheckInstructionElement(style, inst);
2218             xsltApplyTemplatesComp(style, inst);
2219         } else if (IS_XSLT_NAME(inst, "with-param")) {
2220             xsltCheckParentElement(style, inst, BAD_CAST "apply-templates",
2221                                    BAD_CAST "call-template");
2222             xsltWithParamComp(style, inst);
2223         } else if (IS_XSLT_NAME(inst, "value-of")) {
2224             xsltCheckInstructionElement(style, inst);
2225             xsltValueOfComp(style, inst);
2226         } else if (IS_XSLT_NAME(inst, "copy")) {
2227             xsltCheckInstructionElement(style, inst);
2228             xsltCopyComp(style, inst);
2229         } else if (IS_XSLT_NAME(inst, "copy-of")) {
2230             xsltCheckInstructionElement(style, inst);
2231             xsltCopyOfComp(style, inst);
2232         } else if (IS_XSLT_NAME(inst, "if")) {
2233             xsltCheckInstructionElement(style, inst);
2234             xsltIfComp(style, inst);
2235         } else if (IS_XSLT_NAME(inst, "when")) {
2236             xsltCheckParentElement(style, inst, BAD_CAST "choose", NULL);
2237             xsltWhenComp(style, inst);
2238         } else if (IS_XSLT_NAME(inst, "choose")) {
2239             xsltCheckInstructionElement(style, inst);
2240             xsltChooseComp(style, inst);
2241         } else if (IS_XSLT_NAME(inst, "for-each")) {
2242             xsltCheckInstructionElement(style, inst);
2243             xsltForEachComp(style, inst);
2244         } else if (IS_XSLT_NAME(inst, "apply-imports")) {
2245             xsltCheckInstructionElement(style, inst);
2246             xsltApplyImportsComp(style, inst);
2247         } else if (IS_XSLT_NAME(inst, "attribute")) {
2248             xmlNodePtr parent = inst->parent;
2249
2250             if ((parent == NULL) ||
2251                 (parent->type != XML_ELEMENT_NODE) || (parent->ns == NULL) ||
2252                 ((parent->ns != inst->ns) &&
2253                  (!xmlStrEqual(parent->ns->href, inst->ns->href))) ||
2254                 (!xmlStrEqual(parent->name, BAD_CAST "attribute-set"))) {
2255                 xsltCheckInstructionElement(style, inst);
2256             }
2257             xsltAttributeComp(style, inst);
2258         } else if (IS_XSLT_NAME(inst, "element")) {
2259             xsltCheckInstructionElement(style, inst);
2260             xsltElementComp(style, inst);
2261         } else if (IS_XSLT_NAME(inst, "text")) {
2262             xsltCheckInstructionElement(style, inst);
2263             xsltTextComp(style, inst);
2264         } else if (IS_XSLT_NAME(inst, "sort")) {
2265             xsltCheckParentElement(style, inst, BAD_CAST "apply-templates",
2266                                    BAD_CAST "for-each");
2267             xsltSortComp(style, inst);
2268         } else if (IS_XSLT_NAME(inst, "comment")) {
2269             xsltCheckInstructionElement(style, inst);
2270             xsltCommentComp(style, inst);
2271         } else if (IS_XSLT_NAME(inst, "number")) {
2272             xsltCheckInstructionElement(style, inst);
2273             xsltNumberComp(style, inst);
2274         } else if (IS_XSLT_NAME(inst, "processing-instruction")) {
2275             xsltCheckInstructionElement(style, inst);
2276             xsltProcessingInstructionComp(style, inst);
2277         } else if (IS_XSLT_NAME(inst, "call-template")) {
2278             xsltCheckInstructionElement(style, inst);
2279             xsltCallTemplateComp(style, inst);
2280         } else if (IS_XSLT_NAME(inst, "param")) {
2281             if (xsltCheckTopLevelElement(style, inst, 0) == 0)
2282                 xsltCheckInstructionElement(style, inst);
2283             xsltParamComp(style, inst);
2284         } else if (IS_XSLT_NAME(inst, "variable")) {
2285             if (xsltCheckTopLevelElement(style, inst, 0) == 0)
2286                 xsltCheckInstructionElement(style, inst);
2287             xsltVariableComp(style, inst);
2288         } else if (IS_XSLT_NAME(inst, "otherwise")) {
2289             xsltCheckParentElement(style, inst, BAD_CAST "choose", NULL);
2290             xsltCheckInstructionElement(style, inst);
2291             return;
2292         } else if (IS_XSLT_NAME(inst, "template")) {
2293             xsltCheckTopLevelElement(style, inst, 1);
2294             return;
2295         } else if (IS_XSLT_NAME(inst, "output")) {
2296             xsltCheckTopLevelElement(style, inst, 1);
2297             return;
2298         } else if (IS_XSLT_NAME(inst, "preserve-space")) {
2299             xsltCheckTopLevelElement(style, inst, 1);
2300             return;
2301         } else if (IS_XSLT_NAME(inst, "strip-space")) {
2302             xsltCheckTopLevelElement(style, inst, 1);
2303             return;
2304         } else if ((IS_XSLT_NAME(inst, "stylesheet")) ||
2305                    (IS_XSLT_NAME(inst, "transform"))) {
2306             xmlNodePtr parent = inst->parent;
2307
2308             if ((parent == NULL) || (parent->type != XML_DOCUMENT_NODE)) {
2309                 xsltTransformError(NULL, style, inst,
2310                     "element %s only allowed only as root element\n",
2311                                    inst->name);
2312                 style->errors++;
2313             }
2314             return;
2315         } else if (IS_XSLT_NAME(inst, "key")) {
2316             xsltCheckTopLevelElement(style, inst, 1);
2317             return;
2318         } else if (IS_XSLT_NAME(inst, "message")) {
2319             xsltCheckInstructionElement(style, inst);
2320             return;
2321         } else if (IS_XSLT_NAME(inst, "attribute-set")) {
2322             xsltCheckTopLevelElement(style, inst, 1);
2323             return;
2324         } else if (IS_XSLT_NAME(inst, "namespace-alias")) {
2325             xsltCheckTopLevelElement(style, inst, 1);
2326             return;
2327         } else if (IS_XSLT_NAME(inst, "include")) {
2328             xsltCheckTopLevelElement(style, inst, 1);
2329             return;
2330         } else if (IS_XSLT_NAME(inst, "import")) {
2331             xsltCheckTopLevelElement(style, inst, 1);
2332             return;
2333         } else if (IS_XSLT_NAME(inst, "decimal-format")) {
2334             xsltCheckTopLevelElement(style, inst, 1);
2335             return;
2336         } else if (IS_XSLT_NAME(inst, "fallback")) {
2337             xsltCheckInstructionElement(style, inst);
2338             return;
2339         } else if (IS_XSLT_NAME(inst, "document")) {
2340             xsltCheckInstructionElement(style, inst);
2341             inst->psvi = (void *) xsltDocumentComp(style, inst,
2342                                 xsltDocumentElem);
2343         } else if ((style == NULL) || (style->forwards_compatible == 0)) {
2344             xsltTransformError(NULL, style, inst,
2345                  "xsltStylePreCompute: unknown xsl:%s\n", inst->name);
2346             if (style != NULL) style->warnings++;
2347         }
2348
2349         cur = (xsltStylePreCompPtr) inst->psvi;
2350         /*
2351         * A ns-list is build for every XSLT item in the
2352         * node-tree. This is needed for XPath expressions.
2353         */
2354         if (cur != NULL) {
2355             int i = 0;
2356
2357             cur->nsList = xmlGetNsList(inst->doc, inst);
2358             if (cur->nsList != NULL) {
2359                 while (cur->nsList[i] != NULL)
2360                     i++;
2361             }
2362             cur->nsNr = i;
2363         }
2364     } else {
2365         inst->psvi =
2366             (void *) xsltPreComputeExtModuleElement(style, inst);
2367
2368         /*
2369          * Unknown element, maybe registered at the context
2370          * level. Mark it for later recognition.
2371          */
2372         if (inst->psvi == NULL)
2373             inst->psvi = (void *) xsltExtMarker;
2374     }
2375 }
2376 #endif /* XSLT_REFACTORED */