dll/3rdparty/libxslt/variables.c

   1 /*
   2  * variables.c: Implementation of the variable storage and lookup
   3  *
   4  * Reference:
   5  *   http://www.w3.org/TR/1999/REC-xslt-19991116
   6  *
   7  * See Copyright for the status of this software.
   8  *
   9  * daniel@veillard.com
  10  */
  11
  12 #define IN_LIBXSLT
  13 #include "libxslt.h"
  14
  15 #include <string.h>
  16
  17 #include <libxml/xmlmemory.h>
  18 #include <libxml/tree.h>
  19 #include <libxml/valid.h>
  20 #include <libxml/hash.h>
  21 #include <libxml/xmlerror.h>
  22 #include <libxml/xpath.h>
  23 #include <libxml/xpathInternals.h>
  24 #include <libxml/parserInternals.h>
  25 #include <libxml/dict.h>
  26 #include "xslt.h"
  27 #include "xsltInternals.h"
  28 #include "xsltutils.h"
  29 #include "variables.h"
  30 #include "transform.h"
  31 #include "imports.h"
  32 #include "preproc.h"
  33 #include "keys.h"
  34
  35 #ifdef WITH_XSLT_DEBUG
  36  #define WITH_XSLT_DEBUG_VARIABLE
  37 #endif
  38
  39 #ifdef XSLT_REFACTORED
  40 const xmlChar *xsltDocFragFake = (const xmlChar *) " fake node libxslt";
  41 #endif
  42
  43 const xmlChar *xsltComputingGlobalVarMarker =
  44  (const xmlChar *) " var/param being computed";
  45
  46 #define XSLT_VAR_GLOBAL 1<<0
  47 #define XSLT_VAR_IN_SELECT 1<<1
  48 #define XSLT_TCTXT_VARIABLE(c) ((xsltStackElemPtr) (c)->contextVariable)
  49
  50 /************************************************************************
  51  *                                                                      *
  52  *  Result Value Tree (Result Tree Fragment) interfaces                 *
  53  *                                                                      *
  54  ************************************************************************/
  55 /**
  56  * xsltCreateRVT:
  57  * @ctxt:  an XSLT transformation context
  58  *
  59  * Creates a Result Value Tree
  60  * (the XSLT 1.0 term for this is "Result Tree Fragment")
  61  *
  62  * Returns the result value tree or NULL in case of API or internal errors.
  63  */
  64 xmlDocPtr
  65 xsltCreateRVT(xsltTransformContextPtr ctxt)
  66 {
  67     xmlDocPtr container;
  68
  69     /*
  70     * Question: Why is this function public?
  71     * Answer: It is called by the EXSLT module.
  72     */
  73     if (ctxt == NULL)
  74         return(NULL);
  75
  76     /*
  77     * Reuse a RTF from the cache if available.
  78     */
  79     if (ctxt->cache->RVT) {
  80         container = ctxt->cache->RVT;
  81         ctxt->cache->RVT = (xmlDocPtr) container->next;
  82         /* clear the internal pointers */
  83         container->next = NULL;
  84         container->prev = NULL;
  85         if (ctxt->cache->nbRVT > 0)
  86             ctxt->cache->nbRVT--;
  87 #ifdef XSLT_DEBUG_PROFILE_CACHE
  88         ctxt->cache->dbgReusedRVTs++;
  89 #endif
  90         return(container);
  91     }
  92
  93     container = xmlNewDoc(NULL);
  94     if (container == NULL)
  95         return(NULL);
  96     container->dict = ctxt->dict;
  97     xmlDictReference(container->dict);
  98     XSLT_MARK_RES_TREE_FRAG(container);
  99     container->doc = container;
 100     container->parent = NULL;
 101     return(container);
 102 }
 103
 104 /**
 105  * xsltRegisterTmpRVT:
 106  * @ctxt:  an XSLT transformation context
 107  * @RVT:  a result value tree (Result Tree Fragment)
 108  *
 109  * Registers the result value tree (XSLT 1.0 term: Result Tree Fragment)
 110  * in the garbage collector.
 111  * The fragment will be freed at the exit of the currently
 112  * instantiated xsl:template.
 113  * Obsolete; this function might produce massive memory overhead,
 114  * since the fragment is only freed when the current xsl:template
 115  * exits. Use xsltRegisterLocalRVT() instead.
 116  *
 117  * Returns 0 in case of success and -1 in case of API or internal errors.
 118  */
 119 int
 120 xsltRegisterTmpRVT(xsltTransformContextPtr ctxt, xmlDocPtr RVT)
 121 {
 122     if ((ctxt == NULL) || (RVT == NULL))
 123         return(-1);
 124
 125     /*
 126     * We'll restrict the lifetime of user-created fragments
 127     * insinde an xsl:variable and xsl:param to the lifetime of the
 128     * var/param itself.
 129     */
 130     if (ctxt->contextVariable != NULL) {
 131         RVT->next = (xmlNodePtr) XSLT_TCTXT_VARIABLE(ctxt)->fragment;
 132         XSLT_TCTXT_VARIABLE(ctxt)->fragment = RVT;
 133         return(0);
 134     }
 135
 136     RVT->next = (xmlNodePtr) ctxt->tmpRVT;
 137     if (ctxt->tmpRVT != NULL)
 138         ctxt->tmpRVT->prev = (xmlNodePtr) RVT;
 139     ctxt->tmpRVT = RVT;
 140     return(0);
 141 }
 142
 143 /**
 144  * xsltRegisterLocalRVT:
 145  * @ctxt:  an XSLT transformation context
 146  * @RVT:  a result value tree (Result Tree Fragment; xmlDocPtr)
 147  *
 148  * Registers a result value tree (XSLT 1.0 term: Result Tree Fragment)
 149  * in the RVT garbage collector.
 150  * The fragment will be freed when the instruction which created the
 151  * fragment exits.
 152  *
 153  * Returns 0 in case of success and -1 in case of API or internal errors.
 154  */
 155 int
 156 xsltRegisterLocalRVT(xsltTransformContextPtr ctxt,
 157                      xmlDocPtr RVT)
 158 {
 159     if ((ctxt == NULL) || (RVT == NULL))
 160         return(-1);
 161
 162     /*
 163     * When evaluating "select" expressions of xsl:variable
 164     * and xsl:param, we need to bind newly created tree fragments
 165     * to the variable itself; otherwise the tragment will be
 166     * freed before we leave the scope of a var.
 167     */
 168     if ((ctxt->contextVariable != NULL) &&
 169         (XSLT_TCTXT_VARIABLE(ctxt)->flags & XSLT_VAR_IN_SELECT))
 170     {
 171         RVT->next = (xmlNodePtr) XSLT_TCTXT_VARIABLE(ctxt)->fragment;
 172         XSLT_TCTXT_VARIABLE(ctxt)->fragment = RVT;
 173         return(0);
 174     }
 175     /*
 176     * Store the fragment in the scope of the current instruction.
 177     * If not reference by a returning instruction (like EXSLT's function),
 178     * then this fragment will be freed, when the instruction exits.
 179     */
 180     RVT->next = (xmlNodePtr) ctxt->localRVT;
 181     if (ctxt->localRVT != NULL)
 182         ctxt->localRVT->prev = (xmlNodePtr) RVT;
 183     ctxt->localRVT = RVT;
 184     /*
 185     * We need to keep track of the first registered fragment
 186     * for extension instructions which return fragments
 187     * (e.g. EXSLT'S function), in order to let
 188     * xsltExtensionInstructionResultFinalize() clear the
 189     * preserving flag on the fragments.
 190     */
 191     if (ctxt->localRVTBase == NULL)
 192         ctxt->localRVTBase = RVT;
 193     return(0);
 194 }
 195
 196 /**
 197  * xsltExtensionInstructionResultFinalize:
 198  * @ctxt:  an XSLT transformation context
 199  *
 200  * Finalizes the data (e.g. result tree fragments) created
 201  * within a value-returning process (e.g. EXSLT's function).
 202  * Tree fragments marked as being returned by a function are
 203  * set to normal state, which means that the fragment garbage
 204  * collector will free them after the function-calling process exits.
 205  *
 206  * Returns 0 in case of success and -1 in case of API or internal errors.
 207  */
 208 int
 209 xsltExtensionInstructionResultFinalize(xsltTransformContextPtr ctxt)
 210 {
 211     xmlDocPtr cur;
 212
 213     if (ctxt == NULL)
 214         return(-1);
 215     if (ctxt->localRVTBase == NULL)
 216         return(0);
 217     /*
 218     * Enable remaining local tree fragments to be freed
 219     * by the fragment garbage collector.
 220     */
 221     cur = ctxt->localRVTBase;
 222     do {
 223         cur->psvi = NULL;
 224         cur = (xmlDocPtr) cur->next;
 225     } while (cur != NULL);
 226     return(0);
 227 }
 228
 229 /**
 230  * xsltExtensionInstructionResultRegister:
 231  * @ctxt: an XSLT transformation context
 232  * @obj: an XPath object to be inspected for result tree fragments
 233  *
 234  * Marks the result of a value-returning extension instruction
 235  * in order to avoid it being garbage collected before the
 236  * extension instruction exits.
 237  * Note that one still has to additionally register any newly created
 238  * tree fragments (via xsltCreateRVT()) with xsltRegisterLocalRVT().
 239  *
 240  * Returns 0 in case of success and -1 in case of error.
 241  */
 242 int
 243 xsltExtensionInstructionResultRegister(xsltTransformContextPtr ctxt,
 244                                        xmlXPathObjectPtr obj)
 245 {
 246     int i;
 247     xmlNodePtr cur;
 248     xmlDocPtr doc;
 249
 250     if ((ctxt == NULL) || (obj == NULL))
 251         return(-1);
 252
 253     /*
 254     * OPTIMIZE TODO: If no local variables/params and no local tree
 255     * fragments were created, then we don't need to analyse the XPath
 256     * objects for tree fragments.
 257     */
 258
 259     if ((obj->type != XPATH_NODESET) && (obj->type != XPATH_XSLT_TREE))
 260         return(0);
 261     if ((obj->nodesetval == NULL) || (obj->nodesetval->nodeNr == 0))
 262         return(0);
 263
 264     for (i = 0; i < obj->nodesetval->nodeNr; i++) {
 265         cur = obj->nodesetval->nodeTab[i];
 266         if (cur->type == XML_NAMESPACE_DECL) {
 267             /*
 268             * The XPath module sets the owner element of a ns-node on
 269             * the ns->next field.
 270             */
 271             if ((((xmlNsPtr) cur)->next != NULL) &&
 272                 (((xmlNsPtr) cur)->next->type == XML_ELEMENT_NODE))
 273             {
 274                 cur = (xmlNodePtr) ((xmlNsPtr) cur)->next;
 275                 doc = cur->doc;
 276             } else {
 277                 xsltTransformError(ctxt, NULL, ctxt->inst,
 278                     "Internal error in "
 279                     "xsltExtensionInstructionResultRegister(): "
 280                     "Cannot retrieve the doc of a namespace node.\n");
 281                 goto error;
 282             }
 283         } else {
 284             doc = cur->doc;
 285         }
 286         if (doc == NULL) {
 287             xsltTransformError(ctxt, NULL, ctxt->inst,
 288                 "Internal error in "
 289                 "xsltExtensionInstructionResultRegister(): "
 290                 "Cannot retrieve the doc of a node.\n");
 291             goto error;
 292         }
 293         if (doc->name && (doc->name[0] == ' ')) {
 294             /*
 295             * This is a result tree fragment.
 296             * We'll use the @psvi field for reference counting.
 297             * TODO: How do we know if this is a value of a
 298             *  global variable or a doc acquired via the
 299             *  document() function?
 300             */
 301             doc->psvi = (void *) ((long) 1);
 302         }
 303     }
 304
 305     return(0);
 306 error:
 307     return(-1);
 308 }
 309
 310 /**
 311  * xsltReleaseRVT:
 312  * @ctxt:  an XSLT transformation context
 313  * @RVT:  a result value tree (Result Tree Fragment)
 314  *
 315  * Either frees the RVT (which is an xmlDoc) or stores
 316  * it in the context's cache for later reuse.
 317  */
 318 void
 319 xsltReleaseRVT(xsltTransformContextPtr ctxt, xmlDocPtr RVT)
 320 {
 321     if (RVT == NULL)
 322         return;
 323
 324     if (ctxt && (ctxt->cache->nbRVT < 40)) {
 325         /*
 326         * Store the Result Tree Fragment.
 327         * Free the document info.
 328         */
 329         if (RVT->_private != NULL) {
 330             xsltFreeDocumentKeys((xsltDocumentPtr) RVT->_private);
 331             xmlFree(RVT->_private);
 332             RVT->_private = NULL;
 333         }
 334         /*
 335         * Clear the document tree.
 336         * REVISIT TODO: Do we expect ID/IDREF tables to be existent?
 337         */
 338         if (RVT->children != NULL) {
 339             xmlFreeNodeList(RVT->children);
 340             RVT->children = NULL;
 341             RVT->last = NULL;
 342         }
 343         if (RVT->ids != NULL) {
 344             xmlFreeIDTable((xmlIDTablePtr) RVT->ids);
 345             RVT->ids = NULL;
 346         }
 347         if (RVT->refs != NULL) {
 348             xmlFreeRefTable((xmlRefTablePtr) RVT->refs);
 349             RVT->refs = NULL;
 350         }
 351
 352         /*
 353         * Reset the reference counter.
 354         */
 355         RVT->psvi = 0;
 356
 357         RVT->next = (xmlNodePtr) ctxt->cache->RVT;
 358         ctxt->cache->RVT = RVT;
 359
 360         ctxt->cache->nbRVT++;
 361
 362 #ifdef XSLT_DEBUG_PROFILE_CACHE
 363         ctxt->cache->dbgCachedRVTs++;
 364 #endif
 365         return;
 366     }
 367     /*
 368     * Free it.
 369     */
 370     if (RVT->_private != NULL) {
 371         xsltFreeDocumentKeys((xsltDocumentPtr) RVT->_private);
 372         xmlFree(RVT->_private);
 373     }
 374     xmlFreeDoc(RVT);
 375 }
 376
 377 /**
 378  * xsltRegisterPersistRVT:
 379  * @ctxt:  an XSLT transformation context
 380  * @RVT:  a result value tree (Result Tree Fragment)
 381  *
 382  * Register the result value tree (XSLT 1.0 term: Result Tree Fragment)
 383  * in the fragment garbage collector.
 384  * The fragment will be freed when the transformation context is
 385  * freed.
 386  *
 387  * Returns 0 in case of success and -1 in case of error.
 388  */
 389 int
 390 xsltRegisterPersistRVT(xsltTransformContextPtr ctxt, xmlDocPtr RVT)
 391 {
 392     if ((ctxt == NULL) || (RVT == NULL)) return(-1);
 393
 394     RVT->next = (xmlNodePtr) ctxt->persistRVT;
 395     if (ctxt->persistRVT != NULL)
 396         ctxt->persistRVT->prev = (xmlNodePtr) RVT;
 397     ctxt->persistRVT = RVT;
 398     return(0);
 399 }
 400
 401 /**
 402  * xsltFreeRVTs:
 403  * @ctxt:  an XSLT transformation context
 404  *
 405  * Frees all registered result value trees (Result Tree Fragments)
 406  * of the transformation. Internal function; should not be called
 407  * by user-code.
 408  */
 409 void
 410 xsltFreeRVTs(xsltTransformContextPtr ctxt)
 411 {
 412     xmlDocPtr cur, next;
 413
 414     if (ctxt == NULL)
 415         return;
 416     /*
 417     * Local fragments.
 418     */
 419     cur = ctxt->localRVT;
 420     while (cur != NULL) {
 421         next = (xmlDocPtr) cur->next;
 422         if (cur->_private != NULL) {
 423             xsltFreeDocumentKeys(cur->_private);
 424             xmlFree(cur->_private);
 425         }
 426         xmlFreeDoc(cur);
 427         cur = next;
 428     }
 429     ctxt->localRVT = NULL;
 430     /*
 431     * User-created per-template fragments.
 432     */
 433     cur = ctxt->tmpRVT;
 434     while (cur != NULL) {
 435         next = (xmlDocPtr) cur->next;
 436         if (cur->_private != NULL) {
 437             xsltFreeDocumentKeys(cur->_private);
 438             xmlFree(cur->_private);
 439         }
 440         xmlFreeDoc(cur);
 441         cur = next;
 442     }
 443     ctxt->tmpRVT = NULL;
 444     /*
 445     * Global fragments.
 446     */
 447     cur = ctxt->persistRVT;
 448     while (cur != NULL) {
 449         next = (xmlDocPtr) cur->next;
 450         if (cur->_private != NULL) {
 451             xsltFreeDocumentKeys(cur->_private);
 452             xmlFree(cur->_private);
 453         }
 454         xmlFreeDoc(cur);
 455         cur = next;
 456     }
 457     ctxt->persistRVT = NULL;
 458 }
 459
 460 /************************************************************************
 461  *                                                                      *
 462  *                      Module interfaces                               *
 463  *                                                                      *
 464  ************************************************************************/
 465
 466 /**
 467  * xsltNewStackElem:
 468  *
 469  * Create a new XSLT ParserContext
 470  *
 471  * Returns the newly allocated xsltParserStackElem or NULL in case of error
 472  */
 473 static xsltStackElemPtr
 474 xsltNewStackElem(xsltTransformContextPtr ctxt)
 475 {
 476     xsltStackElemPtr ret;
 477     /*
 478     * Reuse a stack item from the cache if available.
 479     */
 480     if (ctxt && ctxt->cache->stackItems) {
 481         ret = ctxt->cache->stackItems;
 482         ctxt->cache->stackItems = ret->next;
 483         ret->next = NULL;
 484         ctxt->cache->nbStackItems--;
 485 #ifdef XSLT_DEBUG_PROFILE_CACHE
 486         ctxt->cache->dbgReusedVars++;
 487 #endif
 488         return(ret);
 489     }
 490     ret = (xsltStackElemPtr) xmlMalloc(sizeof(xsltStackElem));
 491     if (ret == NULL) {
 492         xsltTransformError(NULL, NULL, NULL,
 493                 "xsltNewStackElem : malloc failed\n");
 494         return(NULL);
 495     }
 496     memset(ret, 0, sizeof(xsltStackElem));
 497     ret->context = ctxt;
 498     return(ret);
 499 }
 500
 501 /**
 502  * xsltCopyStackElem:
 503  * @elem:  an XSLT stack element
 504  *
 505  * Makes a copy of the stack element
 506  *
 507  * Returns the copy of NULL
 508  */
 509 static xsltStackElemPtr
 510 xsltCopyStackElem(xsltStackElemPtr elem) {
 511     xsltStackElemPtr cur;
 512
 513     cur = (xsltStackElemPtr) xmlMalloc(sizeof(xsltStackElem));
 514     if (cur == NULL) {
 515         xsltTransformError(NULL, NULL, NULL,
 516                 "xsltCopyStackElem : malloc failed\n");
 517         return(NULL);
 518     }
 519     memset(cur, 0, sizeof(xsltStackElem));
 520     cur->context = elem->context;
 521     cur->name = elem->name;
 522     cur->nameURI = elem->nameURI;
 523     cur->select = elem->select;
 524     cur->tree = elem->tree;
 525     cur->comp = elem->comp;
 526     return(cur);
 527 }
 528
 529 /**
 530  * xsltFreeStackElem:
 531  * @elem:  an XSLT stack element
 532  *
 533  * Free up the memory allocated by @elem
 534  */
 535 static void
 536 xsltFreeStackElem(xsltStackElemPtr elem) {
 537     if (elem == NULL)
 538         return;
 539     if (elem->value != NULL)
 540         xmlXPathFreeObject(elem->value);
 541     /*
 542     * Release the list of temporary Result Tree Fragments.
 543     */
 544     if (elem->fragment) {
 545         xmlDocPtr cur;
 546
 547         while (elem->fragment != NULL) {
 548             cur = elem->fragment;
 549             elem->fragment = (xmlDocPtr) cur->next;
 550
 551             if (elem->context &&
 552                 (cur->psvi == (void *) ((long) 1)))
 553             {
 554                 /*
 555                 * This fragment is a result of an extension instruction
 556                 * (e.g. XSLT's function) and needs to be preserved until
 557                 * the instruction exits.
 558                 * Example: The fragment of the variable must not be freed
 559                 *  since it is returned by the EXSLT function:
 560                 *  <f:function name="foo">
 561                 *   <xsl:variable name="bar">
 562                 *     <bar/>
 563                 *   </xsl:variable>
 564                 *   <f:result select="$bar"/>
 565                 *  </f:function>
 566                 *
 567                 */
 568                 xsltRegisterLocalRVT(elem->context, cur);
 569             } else {
 570                 xsltReleaseRVT((xsltTransformContextPtr) elem->context,
 571                     cur);
 572             }
 573         }
 574     }
 575     /*
 576     * Cache or free the variable structure.
 577     */
 578     if (elem->context && (elem->context->cache->nbStackItems < 50)) {
 579         /*
 580         * Store the item in the cache.
 581         */
 582         xsltTransformContextPtr ctxt = elem->context;
 583         memset(elem, 0, sizeof(xsltStackElem));
 584         elem->context = ctxt;
 585         elem->next = ctxt->cache->stackItems;
 586         ctxt->cache->stackItems = elem;
 587         ctxt->cache->nbStackItems++;
 588 #ifdef XSLT_DEBUG_PROFILE_CACHE
 589         ctxt->cache->dbgCachedVars++;
 590 #endif
 591         return;
 592     }
 593     xmlFree(elem);
 594 }
 595
 596 /**
 597  * xsltFreeStackElemList:
 598  * @elem:  an XSLT stack element
 599  *
 600  * Free up the memory allocated by @elem
 601  */
 602 void
 603 xsltFreeStackElemList(xsltStackElemPtr elem) {
 604     xsltStackElemPtr next;
 605
 606     while (elem != NULL) {
 607         next = elem->next;
 608         xsltFreeStackElem(elem);
 609         elem = next;
 610     }
 611 }
 612
 613 /**
 614  * xsltStackLookup:
 615  * @ctxt:  an XSLT transformation context
 616  * @name:  the local part of the name
 617  * @nameURI:  the URI part of the name
 618  *
 619  * Locate an element in the stack based on its name.
 620  */
 621 #if 0 /* TODO: Those seem to have been used for debugging. */
 622 static int stack_addr = 0;
 623 static int stack_cmp = 0;
 624 #endif
 625
 626 static xsltStackElemPtr
 627 xsltStackLookup(xsltTransformContextPtr ctxt, const xmlChar *name,
 628                 const xmlChar *nameURI) {
 629     int i;
 630     xsltStackElemPtr cur;
 631
 632     if ((ctxt == NULL) || (name == NULL) || (ctxt->varsNr == 0))
 633         return(NULL);
 634
 635     /*
 636      * Do the lookup from the top of the stack, but
 637      * don't use params being computed in a call-param
 638      * First lookup expects the variable name and URI to
 639      * come from the disctionnary and hence pointer comparison.
 640      */
 641     for (i = ctxt->varsNr; i > ctxt->varsBase; i--) {
 642         cur = ctxt->varsTab[i-1];
 643         while (cur != NULL) {
 644             if ((cur->name == name) && (cur->nameURI == nameURI)) {
 645 #if 0
 646                 stack_addr++;
 647 #endif
 648                 return(cur);
 649             }
 650             cur = cur->next;
 651         }
 652     }
 653
 654     /*
 655      * Redo the lookup with interned string compares
 656      * to avoid string compares.
 657      */
 658     name = xmlDictLookup(ctxt->dict, name, -1);
 659     if (nameURI != NULL)
 660         nameURI = xmlDictLookup(ctxt->dict, nameURI, -1);
 661
 662     for (i = ctxt->varsNr; i > ctxt->varsBase; i--) {
 663         cur = ctxt->varsTab[i-1];
 664         while (cur != NULL) {
 665             if ((cur->name == name) && (cur->nameURI == nameURI)) {
 666 #if 0
 667                 stack_cmp++;
 668 #endif
 669                 return(cur);
 670             }
 671             cur = cur->next;
 672         }
 673     }
 674
 675     return(NULL);
 676 }
 677
 678 /**
 679  * xsltCheckStackElem:
 680  * @ctxt:  xn XSLT transformation context
 681  * @name:  the variable name
 682  * @nameURI:  the variable namespace URI
 683  *
 684  * Checks whether a variable or param is already defined.
 685  *
 686  * URGENT TODO: Checks for redefinition of vars/params should be
 687  *  done only at compilation time.
 688  *
 689  * Returns 1 if variable is present, 2 if param is present, 3 if this
 690  *         is an inherited param, 0 if not found, -1 in case of failure.
 691  */
 692 static int
 693 xsltCheckStackElem(xsltTransformContextPtr ctxt, const xmlChar *name,
 694                    const xmlChar *nameURI) {
 695     xsltStackElemPtr cur;
 696
 697     if ((ctxt == NULL) || (name == NULL))
 698         return(-1);
 699
 700     cur = xsltStackLookup(ctxt, name, nameURI);
 701     if (cur == NULL)
 702         return(0);
 703     if (cur->comp != NULL) {
 704         if (cur->comp->type == XSLT_FUNC_WITHPARAM)
 705             return(3);
 706         else if (cur->comp->type == XSLT_FUNC_PARAM)
 707             return(2);
 708     }
 709
 710     return(1);
 711 }
 712
 713 /**
 714  * xsltAddStackElem:
 715  * @ctxt:  xn XSLT transformation context
 716  * @elem:  a stack element
 717  *
 718  * Push an element (or list) onto the stack.
 719  * In case of a list, each member will be pushed into
 720  * a seperate slot; i.e. there's always 1 stack entry for
 721  * 1 stack element.
 722  *
 723  * Returns 0 in case of success, -1 in case of failure.
 724  */
 725 static int
 726 xsltAddStackElem(xsltTransformContextPtr ctxt, xsltStackElemPtr elem)
 727 {
 728     if ((ctxt == NULL) || (elem == NULL))
 729         return(-1);
 730
 731     do {
 732         if (ctxt->varsMax == 0) {
 733             ctxt->varsMax = 10;
 734             ctxt->varsTab =
 735                 (xsltStackElemPtr *) xmlMalloc(ctxt->varsMax *
 736                 sizeof(ctxt->varsTab[0]));
 737             if (ctxt->varsTab == NULL) {
 738                 xmlGenericError(xmlGenericErrorContext, "malloc failed !\n");
 739                 return (-1);
 740             }
 741         }
 742         if (ctxt->varsNr >= ctxt->varsMax) {
 743             ctxt->varsMax *= 2;
 744             ctxt->varsTab =
 745                 (xsltStackElemPtr *) xmlRealloc(ctxt->varsTab,
 746                 ctxt->varsMax *
 747                 sizeof(ctxt->varsTab[0]));
 748             if (ctxt->varsTab == NULL) {
 749                 xmlGenericError(xmlGenericErrorContext, "realloc failed !\n");
 750                 return (-1);
 751             }
 752         }
 753         ctxt->varsTab[ctxt->varsNr++] = elem;
 754         ctxt->vars = elem;
 755
 756         elem = elem->next;
 757     } while (elem != NULL);
 758
 759     return(0);
 760 }
 761
 762 /**
 763  * xsltAddStackElemList:
 764  * @ctxt:  xn XSLT transformation context
 765  * @elems:  a stack element list
 766  *
 767  * Push an element list onto the stack.
 768  *
 769  * Returns 0 in case of success, -1 in case of failure.
 770  */
 771 int
 772 xsltAddStackElemList(xsltTransformContextPtr ctxt, xsltStackElemPtr elems)
 773 {
 774     return(xsltAddStackElem(ctxt, elems));
 775 }
 776
 777 /************************************************************************
 778  *                                                                      *
 779  *                      Module interfaces                               *
 780  *                                                                      *
 781  ************************************************************************/
 782
 783 /**
 784  * xsltEvalVariable:
 785  * @ctxt:  the XSLT transformation context
 786  * @variable:  the variable or parameter item
 787  * @comp: the compiled XSLT instruction
 788  *
 789  * Evaluate a variable value.
 790  *
 791  * Returns the XPath Object value or NULL in case of error
 792  */
 793 static xmlXPathObjectPtr
 794 xsltEvalVariable(xsltTransformContextPtr ctxt, xsltStackElemPtr variable,
 795                  xsltStylePreCompPtr castedComp)
 796 {
 797 #ifdef XSLT_REFACTORED
 798     xsltStyleItemVariablePtr comp =
 799         (xsltStyleItemVariablePtr) castedComp;
 800 #else
 801     xsltStylePreCompPtr comp = castedComp;
 802 #endif
 803     xmlXPathObjectPtr result = NULL;
 804     xmlNodePtr oldInst;
 805
 806     if ((ctxt == NULL) || (variable == NULL))
 807         return(NULL);
 808
 809     /*
 810     * A variable or parameter are evaluated on demand; thus the
 811     * context (of XSLT and XPath) need to be temporarily adjusted and
 812     * restored on exit.
 813     */
 814     oldInst = ctxt->inst;
 815
 816 #ifdef WITH_XSLT_DEBUG_VARIABLE
 817     XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
 818         "Evaluating variable '%s'\n", variable->name));
 819 #endif
 820     if (variable->select != NULL) {
 821         xmlXPathCompExprPtr xpExpr = NULL;
 822         xmlDocPtr oldXPDoc;
 823         xmlNodePtr oldXPContextNode;
 824         int oldXPProximityPosition, oldXPContextSize, oldXPNsNr;
 825         xmlNsPtr *oldXPNamespaces;
 826         xmlXPathContextPtr xpctxt = ctxt->xpathCtxt;
 827         xsltStackElemPtr oldVar = ctxt->contextVariable;
 828
 829         if ((comp != NULL) && (comp->comp != NULL)) {
 830             xpExpr = comp->comp;
 831         } else {
 832             xpExpr = xmlXPathCompile(variable->select);
 833         }
 834         if (xpExpr == NULL)
 835             return(NULL);
 836         /*
 837         * Save context states.
 838         */
 839         oldXPDoc = xpctxt->doc;
 840         oldXPContextNode = xpctxt->node;
 841         oldXPProximityPosition = xpctxt->proximityPosition;
 842         oldXPContextSize = xpctxt->contextSize;
 843         oldXPNamespaces = xpctxt->namespaces;
 844         oldXPNsNr = xpctxt->nsNr;
 845
 846         xpctxt->node = ctxt->node;
 847         /*
 848         * OPTIMIZE TODO: Lame try to set the context doc.
 849         *   Get rid of this somehow in xpath.c.
 850         */
 851         if ((ctxt->node->type != XML_NAMESPACE_DECL) &&
 852             ctxt->node->doc)
 853             xpctxt->doc = ctxt->node->doc;
 854         /*
 855         * BUG TODO: The proximity position and the context size will
 856         *  potentially be wrong.
 857         *  Example:
 858         *  <xsl:template select="foo">
 859         *    <xsl:variable name="pos" select="position()"/>
 860         *    <xsl:for-each select="bar">
 861         *      <xsl:value-of select="$pos"/>
 862         *    </xsl:for-each>
 863         *  </xsl:template>
 864         *  Here the proximity position and context size are changed
 865         *  to the context of <xsl:for-each select="bar">, but
 866         *  the variable needs to be evaluated in the context of
 867         *  <xsl:template select="foo">.
 868         */
 869         if (comp != NULL) {
 870
 871 #ifdef XSLT_REFACTORED
 872             if (comp->inScopeNs != NULL) {
 873                 xpctxt->namespaces = comp->inScopeNs->list;
 874                 xpctxt->nsNr = comp->inScopeNs->xpathNumber;
 875             } else {
 876                 xpctxt->namespaces = NULL;
 877                 xpctxt->nsNr = 0;
 878             }
 879 #else
 880             xpctxt->namespaces = comp->nsList;
 881             xpctxt->nsNr = comp->nsNr;
 882 #endif
 883         } else {
 884             xpctxt->namespaces = NULL;
 885             xpctxt->nsNr = 0;
 886         }
 887
 888         /*
 889         * We need to mark that we are "selecting" a var's value;
 890         * if any tree fragments are created inside the expression,
 891         * then those need to be stored inside the variable; otherwise
 892         * we'll eventually free still referenced fragments, before
 893         * we leave the scope of the variable.
 894         */
 895         ctxt->contextVariable = variable;
 896         variable->flags |= XSLT_VAR_IN_SELECT;
 897
 898         result = xmlXPathCompiledEval(xpExpr, xpctxt);
 899
 900         variable->flags ^= XSLT_VAR_IN_SELECT;
 901         /*
 902         * Restore Context states.
 903         */
 904         ctxt->contextVariable = oldVar;
 905
 906         xpctxt->doc = oldXPDoc;
 907         xpctxt->node = oldXPContextNode;
 908         xpctxt->contextSize = oldXPContextSize;
 909         xpctxt->proximityPosition = oldXPProximityPosition;
 910         xpctxt->namespaces = oldXPNamespaces;
 911         xpctxt->nsNr = oldXPNsNr;
 912
 913         if ((comp == NULL) || (comp->comp == NULL))
 914             xmlXPathFreeCompExpr(xpExpr);
 915         if (result == NULL) {
 916             xsltTransformError(ctxt, NULL,
 917                 (comp != NULL) ? comp->inst : NULL,
 918                 "Failed to evaluate the expression of variable '%s'.\n",
 919                 variable->name);
 920             ctxt->state = XSLT_STATE_STOPPED;
 921
 922 #ifdef WITH_XSLT_DEBUG_VARIABLE
 923 #ifdef LIBXML_DEBUG_ENABLED
 924         } else {
 925             if ((xsltGenericDebugContext == stdout) ||
 926                 (xsltGenericDebugContext == stderr))
 927                 xmlXPathDebugDumpObject((FILE *)xsltGenericDebugContext,
 928                                         result, 0);
 929 #endif
 930 #endif
 931         }
 932     } else {
 933         if (variable->tree == NULL) {
 934             result = xmlXPathNewCString("");
 935         } else {
 936             if (variable->tree) {
 937                 xmlDocPtr container;
 938                 xmlNodePtr oldInsert;
 939                 xmlDocPtr  oldOutput;
 940                 xsltStackElemPtr oldVar = ctxt->contextVariable;
 941
 942                 /*
 943                 * Generate a result tree fragment.
 944                 */
 945                 container = xsltCreateRVT(ctxt);
 946                 if (container == NULL)
 947                     goto error;
 948                 /*
 949                 * NOTE: Local Result Tree Fragments of params/variables
 950                 * are not registered globally anymore; the life-time
 951                 * is not directly dependant of the param/variable itself.
 952                 *
 953                 * OLD: xsltRegisterTmpRVT(ctxt, container);
 954                 */
 955                 /*
 956                 * Attach the Result Tree Fragment to the variable;
 957                 * when the variable is freed, it will also free
 958                 * the Result Tree Fragment.
 959                 */
 960                 variable->fragment = container;
 961
 962                 oldOutput = ctxt->output;
 963                 oldInsert = ctxt->insert;
 964
 965                 ctxt->output = container;
 966                 ctxt->insert = (xmlNodePtr) container;
 967                 ctxt->contextVariable = variable;
 968                 /*
 969                 * Process the sequence constructor (variable->tree).
 970                 * The resulting tree will be held by @container.
 971                 */
 972                 xsltApplyOneTemplate(ctxt, ctxt->node, variable->tree,
 973                     NULL, NULL);
 974
 975                 ctxt->contextVariable = oldVar;
 976                 ctxt->insert = oldInsert;
 977                 ctxt->output = oldOutput;
 978
 979                 result = xmlXPathNewValueTree((xmlNodePtr) container);
 980             }
 981             if (result == NULL) {
 982                 result = xmlXPathNewCString("");
 983             } else {
 984                 /*
 985                 * Freeing is not handled there anymore.
 986                 * QUESTION TODO: What does the above comment mean?
 987                 */
 988                 result->boolval = 0;
 989             }
 990 #ifdef WITH_XSLT_DEBUG_VARIABLE
 991 #ifdef LIBXML_DEBUG_ENABLED
 992
 993             if ((xsltGenericDebugContext == stdout) ||
 994                 (xsltGenericDebugContext == stderr))
 995                 xmlXPathDebugDumpObject((FILE *)xsltGenericDebugContext,
 996                                         result, 0);
 997 #endif
 998 #endif
 999         }
1000     }
1001
1002 error:
1003     ctxt->inst = oldInst;
1004     return(result);
1005 }
1006
1007 /**
1008  * xsltEvalGlobalVariable:
1009  * @elem:  the variable or parameter
1010  * @ctxt:  the XSLT transformation context
1011  *
1012  * Evaluates a the value of a global xsl:variable or
1013  * xsl:param declaration.
1014  *
1015  * Returns the XPath Object value or NULL in case of error
1016  */
1017 static xmlXPathObjectPtr
1018 xsltEvalGlobalVariable(xsltStackElemPtr elem, xsltTransformContextPtr ctxt)
1019 {
1020     xmlXPathObjectPtr result = NULL;
1021     xmlNodePtr oldInst;
1022     const xmlChar* oldVarName;
1023
1024 #ifdef XSLT_REFACTORED
1025     xsltStyleBasicItemVariablePtr comp;
1026 #else
1027     xsltStylePreCompPtr comp;
1028 #endif
1029
1030     if ((ctxt == NULL) || (elem == NULL))
1031         return(NULL);
1032     if (elem->computed)
1033         return(elem->value);
1034
1035
1036 #ifdef WITH_XSLT_DEBUG_VARIABLE
1037     XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
1038         "Evaluating global variable %s\n", elem->name));
1039 #endif
1040
1041 #ifdef WITH_DEBUGGER
1042     if ((ctxt->debugStatus != XSLT_DEBUG_NONE) &&
1043         elem->comp && elem->comp->inst)
1044         xslHandleDebugger(elem->comp->inst, NULL, NULL, ctxt);
1045 #endif
1046
1047     oldInst = ctxt->inst;
1048     comp = elem->comp;
1049     oldVarName = elem->name;
1050     elem->name = xsltComputingGlobalVarMarker;
1051     /*
1052     * OPTIMIZE TODO: We should consider instantiating global vars/params
1053     *  on-demand. The vars/params don't need to be evaluated if never
1054     *  called; and in the case of global params, if values for such params
1055     *  are provided by the user.
1056     */
1057     if (elem->select != NULL) {
1058         xmlXPathCompExprPtr xpExpr = NULL;
1059         xmlDocPtr oldXPDoc;
1060         xmlNodePtr oldXPContextNode;
1061         int oldXPProximityPosition, oldXPContextSize, oldXPNsNr;
1062         xmlNsPtr *oldXPNamespaces;
1063         xmlXPathContextPtr xpctxt = ctxt->xpathCtxt;
1064
1065         if ((comp != NULL) && (comp->comp != NULL)) {
1066             xpExpr = comp->comp;
1067         } else {
1068             xpExpr = xmlXPathCompile(elem->select);
1069         }
1070         if (xpExpr == NULL)
1071             goto error;
1072
1073
1074         if (comp != NULL)
1075             ctxt->inst = comp->inst;
1076         else
1077             ctxt->inst = NULL;
1078         /*
1079         * SPEC XSLT 1.0:
1080         * "At top-level, the expression or template specifying the
1081         *  variable value is evaluated with the same context as that used
1082         *  to process the root node of the source document: the current
1083         *  node is the root node of the source document and the current
1084         *  node list is a list containing just the root node of the source
1085         *  document."
1086         */
1087         /*
1088         * Save context states.
1089         */
1090         oldXPDoc = xpctxt->doc;
1091         oldXPContextNode = xpctxt->node;
1092         oldXPProximityPosition = xpctxt->proximityPosition;
1093         oldXPContextSize = xpctxt->contextSize;
1094         oldXPNamespaces = xpctxt->namespaces;
1095         oldXPNsNr = xpctxt->nsNr;
1096
1097         xpctxt->node = ctxt->initialContextNode;
1098         xpctxt->doc = ctxt->initialContextDoc;
1099         xpctxt->contextSize = 1;
1100         xpctxt->proximityPosition = 1;
1101
1102         if (comp != NULL) {
1103
1104 #ifdef XSLT_REFACTORED
1105             if (comp->inScopeNs != NULL) {
1106                 xpctxt->namespaces = comp->inScopeNs->list;
1107                 xpctxt->nsNr = comp->inScopeNs->xpathNumber;
1108             } else {
1109                 xpctxt->namespaces = NULL;
1110                 xpctxt->nsNr = 0;
1111             }
1112 #else
1113             xpctxt->namespaces = comp->nsList;
1114             xpctxt->nsNr = comp->nsNr;
1115 #endif
1116         } else {
1117             xpctxt->namespaces = NULL;
1118             xpctxt->nsNr = 0;
1119         }
1120
1121         result = xmlXPathCompiledEval(xpExpr, xpctxt);
1122
1123         /*
1124         * Restore Context states.
1125         */
1126         xpctxt->doc = oldXPDoc;
1127         xpctxt->node = oldXPContextNode;
1128         xpctxt->contextSize = oldXPContextSize;
1129         xpctxt->proximityPosition = oldXPProximityPosition;
1130         xpctxt->namespaces = oldXPNamespaces;
1131         xpctxt->nsNr = oldXPNsNr;
1132
1133         if ((comp == NULL) || (comp->comp == NULL))
1134             xmlXPathFreeCompExpr(xpExpr);
1135         if (result == NULL) {
1136             if (comp == NULL)
1137                 xsltTransformError(ctxt, NULL, NULL,
1138                     "Evaluating global variable %s failed\n", elem->name);
1139             else
1140                 xsltTransformError(ctxt, NULL, comp->inst,
1141                     "Evaluating global variable %s failed\n", elem->name);
1142             ctxt->state = XSLT_STATE_STOPPED;
1143 #ifdef WITH_XSLT_DEBUG_VARIABLE
1144 #ifdef LIBXML_DEBUG_ENABLED
1145         } else {
1146             if ((xsltGenericDebugContext == stdout) ||
1147                 (xsltGenericDebugContext == stderr))
1148                 xmlXPathDebugDumpObject((FILE *)xsltGenericDebugContext,
1149                                         result, 0);
1150 #endif
1151 #endif
1152         }
1153     } else {
1154         if (elem->tree == NULL) {
1155             result = xmlXPathNewCString("");
1156         } else {
1157             xmlDocPtr container;
1158             xmlNodePtr oldInsert;
1159             xmlDocPtr  oldOutput, oldXPDoc;
1160             /*
1161             * Generate a result tree fragment.
1162             */
1163             container = xsltCreateRVT(ctxt);
1164             if (container == NULL)
1165                 goto error;
1166             /*
1167             * Let the lifetime of the tree fragment be handled by
1168             * the Libxslt's garbage collector.
1169             */
1170             xsltRegisterPersistRVT(ctxt, container);
1171
1172             oldOutput = ctxt->output;
1173             oldInsert = ctxt->insert;
1174
1175             oldXPDoc = ctxt->xpathCtxt->doc;
1176
1177             ctxt->output = container;
1178             ctxt->insert = (xmlNodePtr) container;
1179
1180             ctxt->xpathCtxt->doc = ctxt->initialContextDoc;
1181             /*
1182             * Process the sequence constructor.
1183             */
1184             xsltApplyOneTemplate(ctxt, ctxt->node, elem->tree, NULL, NULL);
1185
1186             ctxt->xpathCtxt->doc = oldXPDoc;
1187
1188             ctxt->insert = oldInsert;
1189             ctxt->output = oldOutput;
1190
1191             result = xmlXPathNewValueTree((xmlNodePtr) container);
1192             if (result == NULL) {
1193                 result = xmlXPathNewCString("");
1194             } else {
1195                 result->boolval = 0; /* Freeing is not handled there anymore */
1196             }
1197 #ifdef WITH_XSLT_DEBUG_VARIABLE
1198 #ifdef LIBXML_DEBUG_ENABLED
1199             if ((xsltGenericDebugContext == stdout) ||
1200                 (xsltGenericDebugContext == stderr))
1201                 xmlXPathDebugDumpObject((FILE *)xsltGenericDebugContext,
1202                                         result, 0);
1203 #endif
1204 #endif
1205         }
1206     }
1207
1208 error:
1209     elem->name = oldVarName;
1210     ctxt->inst = oldInst;
1211     if (result != NULL) {
1212         elem->value = result;
1213         elem->computed = 1;
1214     }
1215     return(result);
1216 }
1217
1218 /**
1219  * xsltEvalGlobalVariables:
1220  * @ctxt:  the XSLT transformation context
1221  *
1222  * Evaluates all global variables and parameters of a stylesheet.
1223  * For internal use only. This is called at start of a transformation.
1224  *
1225  * Returns 0 in case of success, -1 in case of error
1226  */
1227 int
1228 xsltEvalGlobalVariables(xsltTransformContextPtr ctxt) {
1229     xsltStackElemPtr elem;
1230     xsltStylesheetPtr style;
1231
1232     if ((ctxt == NULL) || (ctxt->document == NULL))
1233         return(-1);
1234
1235 #ifdef WITH_XSLT_DEBUG_VARIABLE
1236     XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
1237         "Registering global variables\n"));
1238 #endif
1239     /*
1240      * Walk the list from the stylesheets and populate the hash table
1241      */
1242     style = ctxt->style;
1243     while (style != NULL) {
1244         elem = style->variables;
1245
1246 #ifdef WITH_XSLT_DEBUG_VARIABLE
1247         if ((style->doc != NULL) && (style->doc->URL != NULL)) {
1248             XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
1249                              "Registering global variables from %s\n",
1250                              style->doc->URL));
1251         }
1252 #endif
1253
1254         while (elem != NULL) {
1255             xsltStackElemPtr def;
1256
1257             /*
1258              * Global variables are stored in the variables pool.
1259              */
1260             def = (xsltStackElemPtr)
1261                     xmlHashLookup2(ctxt->globalVars,
1262                                  elem->name, elem->nameURI);
1263             if (def == NULL) {
1264
1265                 def = xsltCopyStackElem(elem);
1266                 xmlHashAddEntry2(ctxt->globalVars,
1267                                  elem->name, elem->nameURI, def);
1268             } else if ((elem->comp != NULL) &&
1269                        (elem->comp->type == XSLT_FUNC_VARIABLE)) {
1270                 /*
1271                  * Redefinition of variables from a different stylesheet
1272                  * should not generate a message.
1273                  */
1274                 if ((elem->comp->inst != NULL) &&
1275                     (def->comp != NULL) && (def->comp->inst != NULL) &&
1276                     (elem->comp->inst->doc == def->comp->inst->doc))
1277                 {
1278                     xsltTransformError(ctxt, style, elem->comp->inst,
1279                         "Global variable %s already defined\n", elem->name);
1280                     if (style != NULL) style->errors++;
1281                 }
1282             }
1283             elem = elem->next;
1284         }
1285
1286         style = xsltNextImport(style);
1287     }
1288
1289     /*
1290      * This part does the actual evaluation
1291      */
1292     xmlHashScan(ctxt->globalVars,
1293                 (xmlHashScanner) xsltEvalGlobalVariable, ctxt);
1294
1295     return(0);
1296 }
1297
1298 /**
1299  * xsltRegisterGlobalVariable:
1300  * @style:  the XSLT transformation context
1301  * @name:  the variable name
1302  * @ns_uri:  the variable namespace URI
1303  * @sel:  the expression which need to be evaluated to generate a value
1304  * @tree:  the subtree if sel is NULL
1305  * @comp:  the precompiled value
1306  * @value:  the string value if available
1307  *
1308  * Register a new variable value. If @value is NULL it unregisters
1309  * the variable
1310  *
1311  * Returns 0 in case of success, -1 in case of error
1312  */
1313 static int
1314 xsltRegisterGlobalVariable(xsltStylesheetPtr style, const xmlChar *name,
1315                      const xmlChar *ns_uri, const xmlChar *sel,
1316                      xmlNodePtr tree, xsltStylePreCompPtr comp,
1317                      const xmlChar *value) {
1318     xsltStackElemPtr elem, tmp;
1319     if (style == NULL)
1320         return(-1);
1321     if (name == NULL)
1322         return(-1);
1323     if (comp == NULL)
1324         return(-1);
1325
1326 #ifdef WITH_XSLT_DEBUG_VARIABLE
1327     if (comp->type == XSLT_FUNC_PARAM)
1328         xsltGenericDebug(xsltGenericDebugContext,
1329                          "Defining global param %s\n", name);
1330     else
1331         xsltGenericDebug(xsltGenericDebugContext,
1332                          "Defining global variable %s\n", name);
1333 #endif
1334
1335     elem = xsltNewStackElem(NULL);
1336     if (elem == NULL)
1337         return(-1);
1338     elem->comp = comp;
1339     elem->name = xmlDictLookup(style->dict, name, -1);
1340     elem->select = xmlDictLookup(style->dict, sel, -1);
1341     if (ns_uri)
1342         elem->nameURI = xmlDictLookup(style->dict, ns_uri, -1);
1343     elem->tree = tree;
1344     tmp = style->variables;
1345     if (tmp == NULL) {
1346         elem->next = NULL;
1347         style->variables = elem;
1348     } else {
1349         while (tmp != NULL) {
1350             if ((elem->comp->type == XSLT_FUNC_VARIABLE) &&
1351                 (tmp->comp->type == XSLT_FUNC_VARIABLE) &&
1352                 (xmlStrEqual(elem->name, tmp->name)) &&
1353                 ((elem->nameURI == tmp->nameURI) ||
1354                  (xmlStrEqual(elem->nameURI, tmp->nameURI))))
1355             {
1356                 xsltTransformError(NULL, style, comp->inst,
1357                 "redefinition of global variable %s\n", elem->name);
1358                 style->errors++;
1359             }
1360             if (tmp->next == NULL)
1361                 break;
1362             tmp = tmp->next;
1363         }
1364         elem->next = NULL;
1365         tmp->next = elem;
1366     }
1367     if (value != NULL) {
1368         elem->computed = 1;
1369         elem->value = xmlXPathNewString(value);
1370     }
1371     return(0);
1372 }
1373
1374 /**
1375  * xsltProcessUserParamInternal
1376  *
1377  * @ctxt:  the XSLT transformation context
1378  * @name:  a null terminated parameter name
1379  * @value: a null terminated value (may be an XPath expression)
1380  * @eval:  0 to treat the value literally, else evaluate as XPath expression
1381  *
1382  * If @eval is 0 then @value is treated literally and is stored in the global
1383  * parameter/variable table without any change.
1384  *
1385  * Uf @eval is 1 then @value is treated as an XPath expression and is
1386  * evaluated.  In this case, if you want to pass a string which will be
1387  * interpreted literally then it must be enclosed in single or double quotes.
1388  * If the string contains single quotes (double quotes) then it cannot be
1389  * enclosed single quotes (double quotes).  If the string which you want to
1390  * be treated literally contains both single and double quotes (e.g. Meet
1391  * at Joe's for "Twelfth Night" at 7 o'clock) then there is no suitable
1392  * quoting character.  You cannot use &apos; or &quot; inside the string
1393  * because the replacement of character entities with their equivalents is
1394  * done at a different stage of processing.  The solution is to call
1395  * xsltQuoteUserParams or xsltQuoteOneUserParam.
1396  *
1397  * This needs to be done on parsed stylesheets before starting to apply
1398  * transformations.  Normally this will be called (directly or indirectly)
1399  * only from xsltEvalUserParams, xsltEvalOneUserParam, xsltQuoteUserParams,
1400  * or xsltQuoteOneUserParam.
1401  *
1402  * Returns 0 in case of success, -1 in case of error
1403  */
1404
1405 static
1406 int
1407 xsltProcessUserParamInternal(xsltTransformContextPtr ctxt,
1408                              const xmlChar * name,
1409                              const xmlChar * value,
1410                              int eval) {
1411
1412     xsltStylesheetPtr style;
1413     const xmlChar *prefix;
1414     const xmlChar *href;
1415     xmlXPathCompExprPtr xpExpr;
1416     xmlXPathObjectPtr result;
1417
1418     xsltStackElemPtr elem;
1419     int res;
1420     void *res_ptr;
1421
1422     if (ctxt == NULL)
1423         return(-1);
1424     if (name == NULL)
1425         return(0);
1426     if (value == NULL)
1427         return(0);
1428
1429     style = ctxt->style;
1430
1431 #ifdef WITH_XSLT_DEBUG_VARIABLE
1432     XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
1433             "Evaluating user parameter %s=%s\n", name, value));
1434 #endif
1435
1436     /*
1437      * Name lookup
1438      */
1439
1440     name = xsltSplitQName(ctxt->dict, name, &prefix);
1441     href = NULL;
1442     if (prefix != NULL) {
1443         xmlNsPtr ns;
1444
1445         ns = xmlSearchNs(style->doc, xmlDocGetRootElement(style->doc),
1446                          prefix);
1447         if (ns == NULL) {
1448             xsltTransformError(ctxt, style, NULL,
1449             "user param : no namespace bound to prefix %s\n", prefix);
1450             href = NULL;
1451         } else {
1452             href = ns->href;
1453         }
1454     }
1455
1456     if (name == NULL)
1457         return (-1);
1458
1459     res_ptr = xmlHashLookup2(ctxt->globalVars, name, href);
1460     if (res_ptr != 0) {
1461         xsltTransformError(ctxt, style, NULL,
1462             "Global parameter %s already defined\n", name);
1463     }
1464     if (ctxt->globalVars == NULL)
1465         ctxt->globalVars = xmlHashCreate(20);
1466
1467     /*
1468      * do not overwrite variables with parameters from the command line
1469      */
1470     while (style != NULL) {
1471         elem = ctxt->style->variables;
1472         while (elem != NULL) {
1473             if ((elem->comp != NULL) &&
1474                 (elem->comp->type == XSLT_FUNC_VARIABLE) &&
1475                 (xmlStrEqual(elem->name, name)) &&
1476                 (xmlStrEqual(elem->nameURI, href))) {
1477                 return(0);
1478             }
1479             elem = elem->next;
1480         }
1481         style = xsltNextImport(style);
1482     }
1483     style = ctxt->style;
1484     elem = NULL;
1485
1486     /*
1487      * Do the evaluation if @eval is non-zero.
1488      */
1489
1490     result = NULL;
1491     if (eval != 0) {
1492         xpExpr = xmlXPathCompile(value);
1493         if (xpExpr != NULL) {
1494             xmlDocPtr oldXPDoc;
1495             xmlNodePtr oldXPContextNode;
1496             int oldXPProximityPosition, oldXPContextSize, oldXPNsNr;
1497             xmlNsPtr *oldXPNamespaces;
1498             xmlXPathContextPtr xpctxt = ctxt->xpathCtxt;
1499
1500             /*
1501             * Save context states.
1502             */
1503             oldXPDoc = xpctxt->doc;
1504             oldXPContextNode = xpctxt->node;
1505             oldXPProximityPosition = xpctxt->proximityPosition;
1506             oldXPContextSize = xpctxt->contextSize;
1507             oldXPNamespaces = xpctxt->namespaces;
1508             oldXPNsNr = xpctxt->nsNr;
1509
1510             /*
1511             * SPEC XSLT 1.0:
1512             * "At top-level, the expression or template specifying the
1513             *  variable value is evaluated with the same context as that used
1514             *  to process the root node of the source document: the current
1515             *  node is the root node of the source document and the current
1516             *  node list is a list containing just the root node of the source
1517             *  document."
1518             */
1519             xpctxt->doc = ctxt->initialContextDoc;
1520             xpctxt->node = ctxt->initialContextNode;
1521             xpctxt->contextSize = 1;
1522             xpctxt->proximityPosition = 1;
1523             /*
1524             * There is really no in scope namespace for parameters on the
1525             * command line.
1526             */
1527             xpctxt->namespaces = NULL;
1528             xpctxt->nsNr = 0;
1529
1530             result = xmlXPathCompiledEval(xpExpr, xpctxt);
1531
1532             /*
1533             * Restore Context states.
1534             */
1535             xpctxt->doc = oldXPDoc;
1536             xpctxt->node = oldXPContextNode;
1537             xpctxt->contextSize = oldXPContextSize;
1538             xpctxt->proximityPosition = oldXPProximityPosition;
1539             xpctxt->namespaces = oldXPNamespaces;
1540             xpctxt->nsNr = oldXPNsNr;
1541
1542             xmlXPathFreeCompExpr(xpExpr);
1543         }
1544         if (result == NULL) {
1545             xsltTransformError(ctxt, style, NULL,
1546                 "Evaluating user parameter %s failed\n", name);
1547             ctxt->state = XSLT_STATE_STOPPED;
1548             return(-1);
1549         }
1550     }
1551
1552     /*
1553      * If @eval is 0 then @value is to be taken literally and result is NULL
1554      *
1555      * If @eval is not 0, then @value is an XPath expression and has been
1556      * successfully evaluated and result contains the resulting value and
1557      * is not NULL.
1558      *
1559      * Now create an xsltStackElemPtr for insertion into the context's
1560      * global variable/parameter hash table.
1561      */
1562
1563 #ifdef WITH_XSLT_DEBUG_VARIABLE
1564 #ifdef LIBXML_DEBUG_ENABLED
1565     if ((xsltGenericDebugContext == stdout) ||
1566         (xsltGenericDebugContext == stderr))
1567             xmlXPathDebugDumpObject((FILE *)xsltGenericDebugContext,
1568                                     result, 0);
1569 #endif
1570 #endif
1571
1572     elem = xsltNewStackElem(NULL);
1573     if (elem != NULL) {
1574         elem->name = name;
1575         elem->select = xmlDictLookup(ctxt->dict, value, -1);
1576         if (href != NULL)
1577             elem->nameURI = xmlDictLookup(ctxt->dict, href, -1);
1578         elem->tree = NULL;
1579         elem->computed = 1;
1580         if (eval == 0) {
1581             elem->value = xmlXPathNewString(value);
1582         }
1583         else {
1584             elem->value = result;
1585         }
1586     }
1587
1588     /*
1589      * Global parameters are stored in the XPath context variables pool.
1590      */
1591
1592     res = xmlHashAddEntry2(ctxt->globalVars, name, href, elem);
1593     if (res != 0) {
1594         xsltFreeStackElem(elem);
1595         xsltTransformError(ctxt, style, NULL,
1596             "Global parameter %s already defined\n", name);
1597     }
1598     return(0);
1599 }
1600
1601 /**
1602  * xsltEvalUserParams:
1603  *
1604  * @ctxt:  the XSLT transformation context
1605  * @params:  a NULL terminated array of parameters name/value tuples
1606  *
1607  * Evaluate the global variables of a stylesheet. This needs to be
1608  * done on parsed stylesheets before starting to apply transformations.
1609  * Each of the parameters is evaluated as an XPath expression and stored
1610  * in the global variables/parameter hash table.  If you want your
1611  * parameter used literally, use xsltQuoteUserParams.
1612  *
1613  * Returns 0 in case of success, -1 in case of error
1614  */
1615
1616 int
1617 xsltEvalUserParams(xsltTransformContextPtr ctxt, const char **params) {
1618     int indx = 0;
1619     const xmlChar *name;
1620     const xmlChar *value;
1621
1622     if (params == NULL)
1623         return(0);
1624     while (params[indx] != NULL) {
1625         name = (const xmlChar *) params[indx++];
1626         value = (const xmlChar *) params[indx++];
1627         if (xsltEvalOneUserParam(ctxt, name, value) != 0)
1628             return(-1);
1629     }
1630     return 0;
1631 }
1632
1633 /**
1634  * xsltQuoteUserParams:
1635  *
1636  * @ctxt:  the XSLT transformation context
1637  * @params:  a NULL terminated arry of parameters names/values tuples
1638  *
1639  * Similar to xsltEvalUserParams, but the values are treated literally and
1640  * are * *not* evaluated as XPath expressions. This should be done on parsed
1641  * stylesheets before starting to apply transformations.
1642  *
1643  * Returns 0 in case of success, -1 in case of error.
1644  */
1645
1646 int
1647 xsltQuoteUserParams(xsltTransformContextPtr ctxt, const char **params) {
1648     int indx = 0;
1649     const xmlChar *name;
1650     const xmlChar *value;
1651
1652     if (params == NULL)
1653         return(0);
1654     while (params[indx] != NULL) {
1655         name = (const xmlChar *) params[indx++];
1656         value = (const xmlChar *) params[indx++];
1657         if (xsltQuoteOneUserParam(ctxt, name, value) != 0)
1658             return(-1);
1659     }
1660     return 0;
1661 }
1662
1663 /**
1664  * xsltEvalOneUserParam:
1665  * @ctxt:  the XSLT transformation context
1666  * @name:  a null terminated string giving the name of the parameter
1667  * @value:  a null terminated string giving the XPath expression to be evaluated
1668  *
1669  * This is normally called from xsltEvalUserParams to process a single
1670  * parameter from a list of parameters.  The @value is evaluated as an
1671  * XPath expression and the result is stored in the context's global
1672  * variable/parameter hash table.
1673  *
1674  * To have a parameter treated literally (not as an XPath expression)
1675  * use xsltQuoteUserParams (or xsltQuoteOneUserParam).  For more
1676  * details see description of xsltProcessOneUserParamInternal.
1677  *
1678  * Returns 0 in case of success, -1 in case of error.
1679  */
1680
1681 int
1682 xsltEvalOneUserParam(xsltTransformContextPtr ctxt,
1683                      const xmlChar * name,
1684                      const xmlChar * value) {
1685     return xsltProcessUserParamInternal(ctxt, name, value,
1686                                         1 /* xpath eval ? */);
1687 }
1688
1689 /**
1690  * xsltQuoteOneUserParam:
1691  * @ctxt:  the XSLT transformation context
1692  * @name:  a null terminated string giving the name of the parameter
1693  * @value:  a null terminated string giving the parameter value
1694  *
1695  * This is normally called from xsltQuoteUserParams to process a single
1696  * parameter from a list of parameters.  The @value is stored in the
1697  * context's global variable/parameter hash table.
1698  *
1699  * Returns 0 in case of success, -1 in case of error.
1700  */
1701
1702 int
1703 xsltQuoteOneUserParam(xsltTransformContextPtr ctxt,
1704                          const xmlChar * name,
1705                          const xmlChar * value) {
1706     return xsltProcessUserParamInternal(ctxt, name, value,
1707                                         0 /* xpath eval ? */);
1708 }
1709
1710 /**
1711  * xsltBuildVariable:
1712  * @ctxt:  the XSLT transformation context
1713  * @comp:  the precompiled form
1714  * @tree:  the tree if select is NULL
1715  *
1716  * Computes a new variable value.
1717  *
1718  * Returns the xsltStackElemPtr or NULL in case of error
1719  */
1720 static xsltStackElemPtr
1721 xsltBuildVariable(xsltTransformContextPtr ctxt,
1722                   xsltStylePreCompPtr castedComp,
1723                   xmlNodePtr tree)
1724 {
1725 #ifdef XSLT_REFACTORED
1726     xsltStyleBasicItemVariablePtr comp =
1727         (xsltStyleBasicItemVariablePtr) castedComp;
1728 #else
1729     xsltStylePreCompPtr comp = castedComp;
1730 #endif
1731     xsltStackElemPtr elem;
1732
1733 #ifdef WITH_XSLT_DEBUG_VARIABLE
1734     XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
1735                      "Building variable %s", comp->name));
1736     if (comp->select != NULL)
1737         XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
1738                          " select %s", comp->select));
1739     XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext, "\n"));
1740 #endif
1741
1742     elem = xsltNewStackElem(ctxt);
1743     if (elem == NULL)
1744         return(NULL);
1745     elem->comp = (xsltStylePreCompPtr) comp;
1746     elem->name = comp->name;
1747     elem->select = comp->select;
1748     elem->nameURI = comp->ns;
1749     elem->tree = tree;
1750     elem->value = xsltEvalVariable(ctxt, elem,
1751         (xsltStylePreCompPtr) comp);
1752     if (elem->value != NULL)
1753         elem->computed = 1;
1754     return(elem);
1755 }
1756
1757 /**
1758  * xsltRegisterVariable:
1759  * @ctxt:  the XSLT transformation context
1760  * @comp: the compiled XSLT-variable (or param) instruction
1761  * @tree:  the tree if select is NULL
1762  * @isParam:  indicates if this is a parameter
1763  *
1764  * Computes and registers a new variable.
1765  *
1766  * Returns 0 in case of success, -1 in case of error
1767  */
1768 static int
1769 xsltRegisterVariable(xsltTransformContextPtr ctxt,
1770                      xsltStylePreCompPtr castedComp,
1771                      xmlNodePtr tree, int isParam)
1772 {
1773 #ifdef XSLT_REFACTORED
1774     xsltStyleBasicItemVariablePtr comp =
1775         (xsltStyleBasicItemVariablePtr) castedComp;
1776 #else
1777     xsltStylePreCompPtr comp = castedComp;
1778     int present;
1779 #endif
1780     xsltStackElemPtr variable;
1781
1782 #ifdef XSLT_REFACTORED
1783     /*
1784     * REFACTORED NOTE: Redefinitions of vars/params are checked
1785     *  at compilation time in the refactored code.
1786     * xsl:with-param parameters are checked in xsltApplyXSLTTemplate().
1787     */
1788 #else
1789     present = xsltCheckStackElem(ctxt, comp->name, comp->ns);
1790     if (isParam == 0) {
1791         if ((present != 0) && (present != 3)) {
1792             /* TODO: report QName. */
1793             xsltTransformError(ctxt, NULL, comp->inst,
1794                 "XSLT-variable: Redefinition of variable '%s'.\n", comp->name);
1795             return(0);
1796         }
1797     } else if (present != 0) {
1798         if ((present == 1) || (present == 2)) {
1799             /* TODO: report QName. */
1800             xsltTransformError(ctxt, NULL, comp->inst,
1801                 "XSLT-param: Redefinition of parameter '%s'.\n", comp->name);
1802             return(0);
1803         }
1804 #ifdef WITH_XSLT_DEBUG_VARIABLE
1805         XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
1806                  "param %s defined by caller\n", comp->name));
1807 #endif
1808         return(0);
1809     }
1810 #endif /* else of XSLT_REFACTORED */
1811
1812     variable = xsltBuildVariable(ctxt, (xsltStylePreCompPtr) comp, tree);
1813     xsltAddStackElem(ctxt, variable);
1814     return(0);
1815 }
1816
1817 /**
1818  * xsltGlobalVariableLookup:
1819  * @ctxt:  the XSLT transformation context
1820  * @name:  the variable name
1821  * @ns_uri:  the variable namespace URI
1822  *
1823  * Search in the Variable array of the context for the given
1824  * variable value.
1825  *
1826  * Returns the value or NULL if not found
1827  */
1828 static xmlXPathObjectPtr
1829 xsltGlobalVariableLookup(xsltTransformContextPtr ctxt, const xmlChar *name,
1830                          const xmlChar *ns_uri) {
1831     xsltStackElemPtr elem;
1832     xmlXPathObjectPtr ret = NULL;
1833
1834     /*
1835      * Lookup the global variables in XPath global variable hash table
1836      */
1837     if ((ctxt->xpathCtxt == NULL) || (ctxt->globalVars == NULL))
1838         return(NULL);
1839     elem = (xsltStackElemPtr)
1840             xmlHashLookup2(ctxt->globalVars, name, ns_uri);
1841     if (elem == NULL) {
1842 #ifdef WITH_XSLT_DEBUG_VARIABLE
1843         XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
1844                          "global variable not found %s\n", name));
1845 #endif
1846         return(NULL);
1847     }
1848     /*
1849     * URGENT TODO: Move the detection of recursive definitions
1850     * to compile-time.
1851     */
1852     if (elem->computed == 0) {
1853         if (elem->name == xsltComputingGlobalVarMarker) {
1854             xsltTransformError(ctxt, NULL, elem->comp->inst,
1855                 "Recursive definition of %s\n", name);
1856             return(NULL);
1857         }
1858         ret = xsltEvalGlobalVariable(elem, ctxt);
1859     } else
1860         ret = elem->value;
1861     return(xmlXPathObjectCopy(ret));
1862 }
1863
1864 /**
1865  * xsltVariableLookup:
1866  * @ctxt:  the XSLT transformation context
1867  * @name:  the variable name
1868  * @ns_uri:  the variable namespace URI
1869  *
1870  * Search in the Variable array of the context for the given
1871  * variable value.
1872  *
1873  * Returns the value or NULL if not found
1874  */
1875 xmlXPathObjectPtr
1876 xsltVariableLookup(xsltTransformContextPtr ctxt, const xmlChar *name,
1877                    const xmlChar *ns_uri) {
1878     xsltStackElemPtr elem;
1879
1880     if (ctxt == NULL)
1881         return(NULL);
1882
1883     elem = xsltStackLookup(ctxt, name, ns_uri);
1884     if (elem == NULL) {
1885         return(xsltGlobalVariableLookup(ctxt, name, ns_uri));
1886     }
1887     if (elem->computed == 0) {
1888 #ifdef WITH_XSLT_DEBUG_VARIABLE
1889         XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
1890                          "uncomputed variable %s\n", name));
1891 #endif
1892         elem->value = xsltEvalVariable(ctxt, elem, NULL);
1893         elem->computed = 1;
1894     }
1895     if (elem->value != NULL)
1896         return(xmlXPathObjectCopy(elem->value));
1897 #ifdef WITH_XSLT_DEBUG_VARIABLE
1898     XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
1899                      "variable not found %s\n", name));
1900 #endif
1901     return(NULL);
1902 }
1903
1904 /**
1905  * xsltParseStylesheetCallerParam:
1906  * @ctxt:  the XSLT transformation context
1907  * @inst:  the xsl:with-param instruction element
1908  *
1909  * Processes an xsl:with-param instruction at transformation time.
1910  * The value is compute, but not recorded.
1911  * NOTE that this is also called with an *xsl:param* element
1912  * from exsltFuncFunctionFunction().
1913  *
1914  * Returns the new xsltStackElemPtr or NULL
1915  */
1916
1917 xsltStackElemPtr
1918 xsltParseStylesheetCallerParam(xsltTransformContextPtr ctxt, xmlNodePtr inst)
1919 {
1920 #ifdef XSLT_REFACTORED
1921     xsltStyleBasicItemVariablePtr comp;
1922 #else
1923     xsltStylePreCompPtr comp;
1924 #endif
1925     xmlNodePtr tree = NULL; /* The first child node of the instruction or
1926                                the instruction itself. */
1927     xsltStackElemPtr param = NULL;
1928
1929     if ((ctxt == NULL) || (inst == NULL))
1930         return(NULL);
1931
1932 #ifdef XSLT_REFACTORED
1933     comp = (xsltStyleBasicItemVariablePtr) inst->psvi;
1934 #else
1935     comp = (xsltStylePreCompPtr) inst->psvi;
1936 #endif
1937
1938     if (comp == NULL) {
1939         xsltTransformError(ctxt, NULL, inst,
1940             "Internal error in xsltParseStylesheetCallerParam(): "
1941             "The XSLT 'with-param' instruction was not compiled.\n");
1942         return(NULL);
1943     }
1944     if (comp->name == NULL) {
1945         xsltTransformError(ctxt, NULL, inst,
1946             "Internal error in xsltParseStylesheetCallerParam(): "
1947             "XSLT 'with-param': The attribute 'name' was not compiled.\n");
1948         return(NULL);
1949     }
1950
1951 #ifdef WITH_XSLT_DEBUG_VARIABLE
1952     XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
1953             "Handling xsl:with-param %s\n", comp->name));
1954 #endif
1955
1956     if (comp->select == NULL) {
1957         tree = inst->children;
1958     } else {
1959 #ifdef WITH_XSLT_DEBUG_VARIABLE
1960         XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
1961             "        select %s\n", comp->select));
1962 #endif
1963         tree = inst;
1964     }
1965
1966     param = xsltBuildVariable(ctxt, (xsltStylePreCompPtr) comp, tree);
1967
1968     return(param);
1969 }
1970
1971 /**
1972  * xsltParseGlobalVariable:
1973  * @style:  the XSLT stylesheet
1974  * @cur:  the "variable" element
1975  *
1976  * Parses a global XSLT 'variable' declaration at compilation time
1977  * and registers it
1978  */
1979 void
1980 xsltParseGlobalVariable(xsltStylesheetPtr style, xmlNodePtr cur)
1981 {
1982 #ifdef XSLT_REFACTORED
1983     xsltStyleItemVariablePtr comp;
1984 #else
1985     xsltStylePreCompPtr comp;
1986 #endif
1987
1988     if ((cur == NULL) || (style == NULL))
1989         return;
1990
1991 #ifdef XSLT_REFACTORED
1992     /*
1993     * Note that xsltStylePreCompute() will be called from
1994     * xslt.c only.
1995     */
1996     comp = (xsltStyleItemVariablePtr) cur->psvi;
1997 #else
1998     xsltStylePreCompute(style, cur);
1999     comp = (xsltStylePreCompPtr) cur->psvi;
2000 #endif
2001     if (comp == NULL) {
2002         xsltTransformError(NULL, style, cur,
2003              "xsl:variable : compilation failed\n");
2004         return;
2005     }
2006
2007     if (comp->name == NULL) {
2008         xsltTransformError(NULL, style, cur,
2009             "xsl:variable : missing name attribute\n");
2010         return;
2011     }
2012
2013     /*
2014     * Parse the content (a sequence constructor) of xsl:variable.
2015     */
2016     if (cur->children != NULL) {
2017 #ifdef XSLT_REFACTORED
2018         xsltParseSequenceConstructor(XSLT_CCTXT(style), cur->children);
2019 #else
2020         xsltParseTemplateContent(style, cur);
2021 #endif
2022     }
2023 #ifdef WITH_XSLT_DEBUG_VARIABLE
2024     xsltGenericDebug(xsltGenericDebugContext,
2025         "Registering global variable %s\n", comp->name);
2026 #endif
2027
2028     xsltRegisterGlobalVariable(style, comp->name, comp->ns,
2029         comp->select, cur->children, (xsltStylePreCompPtr) comp,
2030         NULL);
2031 }
2032
2033 /**
2034  * xsltParseGlobalParam:
2035  * @style:  the XSLT stylesheet
2036  * @cur:  the "param" element
2037  *
2038  * parse an XSLT transformation param declaration and record
2039  * its value.
2040  */
2041
2042 void
2043 xsltParseGlobalParam(xsltStylesheetPtr style, xmlNodePtr cur) {
2044 #ifdef XSLT_REFACTORED
2045     xsltStyleItemParamPtr comp;
2046 #else
2047     xsltStylePreCompPtr comp;
2048 #endif
2049
2050     if ((cur == NULL) || (style == NULL))
2051         return;
2052
2053 #ifdef XSLT_REFACTORED
2054     /*
2055     * Note that xsltStylePreCompute() will be called from
2056     * xslt.c only.
2057     */
2058     comp = (xsltStyleItemParamPtr) cur->psvi;
2059 #else
2060     xsltStylePreCompute(style, cur);
2061     comp = (xsltStylePreCompPtr) cur->psvi;
2062 #endif
2063     if (comp == NULL) {
2064         xsltTransformError(NULL, style, cur,
2065              "xsl:param : compilation failed\n");
2066         return;
2067     }
2068
2069     if (comp->name == NULL) {
2070         xsltTransformError(NULL, style, cur,
2071             "xsl:param : missing name attribute\n");
2072         return;
2073     }
2074
2075     /*
2076     * Parse the content (a sequence constructor) of xsl:param.
2077     */
2078     if (cur->children != NULL) {
2079 #ifdef XSLT_REFACTORED
2080         xsltParseSequenceConstructor(XSLT_CCTXT(style), cur->children);
2081 #else
2082         xsltParseTemplateContent(style, cur);
2083 #endif
2084     }
2085
2086 #ifdef WITH_XSLT_DEBUG_VARIABLE
2087     xsltGenericDebug(xsltGenericDebugContext,
2088         "Registering global param %s\n", comp->name);
2089 #endif
2090
2091     xsltRegisterGlobalVariable(style, comp->name, comp->ns,
2092         comp->select, cur->children, (xsltStylePreCompPtr) comp,
2093         NULL);
2094 }
2095
2096 /**
2097  * xsltParseStylesheetVariable:
2098  * @ctxt:  the XSLT transformation context
2099  * @inst:  the xsl:variable instruction element
2100  *
2101  * Registers a local XSLT 'variable' instruction at transformation time
2102  * and evaluates its value.
2103  */
2104 void
2105 xsltParseStylesheetVariable(xsltTransformContextPtr ctxt, xmlNodePtr inst)
2106 {
2107 #ifdef XSLT_REFACTORED
2108     xsltStyleItemVariablePtr comp;
2109 #else
2110     xsltStylePreCompPtr comp;
2111 #endif
2112
2113     if ((inst == NULL) || (ctxt == NULL))
2114         return;
2115
2116     comp = inst->psvi;
2117     if (comp == NULL) {
2118         xsltTransformError(ctxt, NULL, inst,
2119             "Internal error in xsltParseStylesheetVariable(): "
2120             "The XSLT 'variable' instruction was not compiled.\n");
2121         return;
2122     }
2123     if (comp->name == NULL) {
2124         xsltTransformError(ctxt, NULL, inst,
2125             "Internal error in xsltParseStylesheetVariable(): "
2126             "The attribute 'name' was not compiled.\n");
2127         return;
2128     }
2129
2130 #ifdef WITH_XSLT_DEBUG_VARIABLE
2131     XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
2132         "Registering variable '%s'\n", comp->name));
2133 #endif
2134
2135     xsltRegisterVariable(ctxt, (xsltStylePreCompPtr) comp, inst->children, 0);
2136 }
2137
2138 /**
2139  * xsltParseStylesheetParam:
2140  * @ctxt:  the XSLT transformation context
2141  * @cur:  the XSLT 'param' element
2142  *
2143  * Registers a local XSLT 'param' declaration at transformation time and
2144  * evaluates its value.
2145  */
2146 void
2147 xsltParseStylesheetParam(xsltTransformContextPtr ctxt, xmlNodePtr cur)
2148 {
2149 #ifdef XSLT_REFACTORED
2150     xsltStyleItemParamPtr comp;
2151 #else
2152     xsltStylePreCompPtr comp;
2153 #endif
2154
2155     if ((cur == NULL) || (ctxt == NULL))
2156         return;
2157
2158     comp = cur->psvi;
2159     if ((comp == NULL) || (comp->name == NULL)) {
2160         xsltTransformError(ctxt, NULL, cur,
2161             "Internal error in xsltParseStylesheetParam(): "
2162             "The XSLT 'param' declaration was not compiled correctly.\n");
2163         return;
2164     }
2165
2166 #ifdef WITH_XSLT_DEBUG_VARIABLE
2167     XSLT_TRACE(ctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
2168         "Registering param %s\n", comp->name));
2169 #endif
2170
2171     xsltRegisterVariable(ctxt, (xsltStylePreCompPtr) comp, cur->children, 1);
2172 }
2173
2174 /**
2175  * xsltFreeGlobalVariables:
2176  * @ctxt:  the XSLT transformation context
2177  *
2178  * Free up the data associated to the global variables
2179  * its value.
2180  */
2181
2182 void
2183 xsltFreeGlobalVariables(xsltTransformContextPtr ctxt) {
2184     xmlHashFree(ctxt->globalVars, (xmlHashDeallocator) xsltFreeStackElem);
2185 }
2186
2187 /**
2188  * xsltXPathVariableLookup:
2189  * @ctxt:  a void * but the the XSLT transformation context actually
2190  * @name:  the variable name
2191  * @ns_uri:  the variable namespace URI
2192  *
2193  * This is the entry point when a varibale is needed by the XPath
2194  * interpretor.
2195  *
2196  * Returns the value or NULL if not found
2197  */
2198 xmlXPathObjectPtr
2199 xsltXPathVariableLookup(void *ctxt, const xmlChar *name,
2200                         const xmlChar *ns_uri) {
2201     xsltTransformContextPtr tctxt;
2202     xmlXPathObjectPtr valueObj = NULL;
2203
2204     if ((ctxt == NULL) || (name == NULL))
2205         return(NULL);
2206
2207 #ifdef WITH_XSLT_DEBUG_VARIABLE
2208     XSLT_TRACE(((xsltTransformContextPtr)ctxt),XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
2209             "Lookup variable '%s'\n", name));
2210 #endif
2211
2212     tctxt = (xsltTransformContextPtr) ctxt;
2213     /*
2214     * Local variables/params ---------------------------------------------
2215     *
2216     * Do the lookup from the top of the stack, but
2217     * don't use params being computed in a call-param
2218     * First lookup expects the variable name and URI to
2219     * come from the disctionnary and hence pointer comparison.
2220     */
2221     if (tctxt->varsNr != 0) {
2222         int i;
2223         xsltStackElemPtr variable = NULL, cur;
2224
2225         for (i = tctxt->varsNr; i > tctxt->varsBase; i--) {
2226             cur = tctxt->varsTab[i-1];
2227             if ((cur->name == name) && (cur->nameURI == ns_uri)) {
2228 #if 0
2229                 stack_addr++;
2230 #endif
2231                 variable = cur;
2232                 goto local_variable_found;
2233             }
2234             cur = cur->next;
2235         }
2236         /*
2237         * Redo the lookup with interned strings to avoid string comparison.
2238         *
2239         * OPTIMIZE TODO: The problem here is, that if we request a
2240         *  global variable, then this will be also executed.
2241         */
2242         {
2243             const xmlChar *tmpName = name, *tmpNsName = ns_uri;
2244
2245             name = xmlDictLookup(tctxt->dict, name, -1);
2246             if (ns_uri)
2247                 ns_uri = xmlDictLookup(tctxt->dict, ns_uri, -1);
2248             if ((tmpName != name) || (tmpNsName != ns_uri)) {
2249                 for (i = tctxt->varsNr; i > tctxt->varsBase; i--) {
2250                     cur = tctxt->varsTab[i-1];
2251                     if ((cur->name == name) && (cur->nameURI == ns_uri)) {
2252 #if 0
2253                         stack_cmp++;
2254 #endif
2255                         variable = cur;
2256                         goto local_variable_found;
2257                     }
2258                 }
2259             }
2260         }
2261
2262 local_variable_found:
2263
2264         if (variable) {
2265             if (variable->computed == 0) {
2266
2267 #ifdef WITH_XSLT_DEBUG_VARIABLE
2268                 XSLT_TRACE(tctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
2269                     "uncomputed variable '%s'\n", name));
2270 #endif
2271                 variable->value = xsltEvalVariable(tctxt, variable, NULL);
2272                 variable->computed = 1;
2273             }
2274             if (variable->value != NULL) {
2275                 valueObj = xmlXPathObjectCopy(variable->value);
2276             }
2277             return(valueObj);
2278         }
2279     }
2280     /*
2281     * Global variables/params --------------------------------------------
2282     */
2283     if (tctxt->globalVars) {
2284         valueObj = xsltGlobalVariableLookup(tctxt, name, ns_uri);
2285     }
2286
2287     if (valueObj == NULL) {
2288
2289 #ifdef WITH_XSLT_DEBUG_VARIABLE
2290     XSLT_TRACE(tctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
2291                      "variable not found '%s'\n", name));
2292 #endif
2293
2294         if (ns_uri) {
2295             xsltTransformError(tctxt, NULL, tctxt->inst,
2296                 "Variable '{%s}%s' has not been declared.\n", ns_uri, name);
2297         } else {
2298             xsltTransformError(tctxt, NULL, tctxt->inst,
2299                 "Variable '%s' has not been declared.\n", name);
2300         }
2301     } else {
2302
2303 #ifdef WITH_XSLT_DEBUG_VARIABLE
2304         XSLT_TRACE(tctxt,XSLT_TRACE_VARIABLES,xsltGenericDebug(xsltGenericDebugContext,
2305             "found variable '%s'\n", name));
2306 #endif
2307     }
2308
2309     return(valueObj);
2310 }
2311
2312