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