dll/3rdparty/libxslt/keys.c

   1 /*
   2  * keys.c: Implemetation of the keys support
   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/parserInternals.h>
  23 #include <libxml/xpathInternals.h>
  24 #include "xslt.h"
  25 #include "xsltInternals.h"
  26 #include "xsltutils.h"
  27 #include "imports.h"
  28 #include "templates.h"
  29 #include "keys.h"
  30
  31 #ifdef WITH_XSLT_DEBUG
  32 #define WITH_XSLT_DEBUG_KEYS
  33 #endif
  34
  35 static int
  36 xsltInitDocKeyTable(xsltTransformContextPtr ctxt, const xmlChar *name,
  37                     const xmlChar *nameURI);
  38
  39 /************************************************************************
  40  *                                                                      *
  41  *                      Type functions                                  *
  42  *                                                                      *
  43  ************************************************************************/
  44
  45 /**
  46  * xsltNewKeyDef:
  47  * @name:  the key name or NULL
  48  * @nameURI:  the name URI or NULL
  49  *
  50  * Create a new XSLT KeyDef
  51  *
  52  * Returns the newly allocated xsltKeyDefPtr or NULL in case of error
  53  */
  54 static xsltKeyDefPtr
  55 xsltNewKeyDef(const xmlChar *name, const xmlChar *nameURI) {
  56     xsltKeyDefPtr cur;
  57
  58     cur = (xsltKeyDefPtr) xmlMalloc(sizeof(xsltKeyDef));
  59     if (cur == NULL) {
  60         xsltTransformError(NULL, NULL, NULL,
  61                 "xsltNewKeyDef : malloc failed\n");
  62         return(NULL);
  63     }
  64     memset(cur, 0, sizeof(xsltKeyDef));
  65     if (name != NULL)
  66         cur->name = xmlStrdup(name);
  67     if (nameURI != NULL)
  68         cur->nameURI = xmlStrdup(nameURI);
  69     cur->nsList = NULL;
  70     return(cur);
  71 }
  72
  73 /**
  74  * xsltFreeKeyDef:
  75  * @keyd:  an XSLT key definition
  76  *
  77  * Free up the memory allocated by @keyd
  78  */
  79 static void
  80 xsltFreeKeyDef(xsltKeyDefPtr keyd) {
  81     if (keyd == NULL)
  82         return;
  83     if (keyd->comp != NULL)
  84         xmlXPathFreeCompExpr(keyd->comp);
  85     if (keyd->usecomp != NULL)
  86         xmlXPathFreeCompExpr(keyd->usecomp);
  87     if (keyd->name != NULL)
  88         xmlFree(keyd->name);
  89     if (keyd->nameURI != NULL)
  90         xmlFree(keyd->nameURI);
  91     if (keyd->match != NULL)
  92         xmlFree(keyd->match);
  93     if (keyd->use != NULL)
  94         xmlFree(keyd->use);
  95     if (keyd->nsList != NULL)
  96         xmlFree(keyd->nsList);
  97     memset(keyd, -1, sizeof(xsltKeyDef));
  98     xmlFree(keyd);
  99 }
 100
 101 /**
 102  * xsltFreeKeyDefList:
 103  * @keyd:  an XSLT key definition list
 104  *
 105  * Free up the memory allocated by all the elements of @keyd
 106  */
 107 static void
 108 xsltFreeKeyDefList(xsltKeyDefPtr keyd) {
 109     xsltKeyDefPtr cur;
 110
 111     while (keyd != NULL) {
 112         cur = keyd;
 113         keyd = keyd->next;
 114         xsltFreeKeyDef(cur);
 115     }
 116 }
 117
 118 /**
 119  * xsltNewKeyTable:
 120  * @name:  the key name or NULL
 121  * @nameURI:  the name URI or NULL
 122  *
 123  * Create a new XSLT KeyTable
 124  *
 125  * Returns the newly allocated xsltKeyTablePtr or NULL in case of error
 126  */
 127 static xsltKeyTablePtr
 128 xsltNewKeyTable(const xmlChar *name, const xmlChar *nameURI) {
 129     xsltKeyTablePtr cur;
 130
 131     cur = (xsltKeyTablePtr) xmlMalloc(sizeof(xsltKeyTable));
 132     if (cur == NULL) {
 133         xsltTransformError(NULL, NULL, NULL,
 134                 "xsltNewKeyTable : malloc failed\n");
 135         return(NULL);
 136     }
 137     memset(cur, 0, sizeof(xsltKeyTable));
 138     if (name != NULL)
 139         cur->name = xmlStrdup(name);
 140     if (nameURI != NULL)
 141         cur->nameURI = xmlStrdup(nameURI);
 142     cur->keys = xmlHashCreate(0);
 143     return(cur);
 144 }
 145
 146 /**
 147  * xsltFreeKeyTable:
 148  * @keyt:  an XSLT key table
 149  *
 150  * Free up the memory allocated by @keyt
 151  */
 152 static void
 153 xsltFreeKeyTable(xsltKeyTablePtr keyt) {
 154     if (keyt == NULL)
 155         return;
 156     if (keyt->name != NULL)
 157         xmlFree(keyt->name);
 158     if (keyt->nameURI != NULL)
 159         xmlFree(keyt->nameURI);
 160     if (keyt->keys != NULL)
 161         xmlHashFree(keyt->keys,
 162                     (xmlHashDeallocator) xmlXPathFreeNodeSet);
 163     memset(keyt, -1, sizeof(xsltKeyTable));
 164     xmlFree(keyt);
 165 }
 166
 167 /**
 168  * xsltFreeKeyTableList:
 169  * @keyt:  an XSLT key table list
 170  *
 171  * Free up the memory allocated by all the elements of @keyt
 172  */
 173 static void
 174 xsltFreeKeyTableList(xsltKeyTablePtr keyt) {
 175     xsltKeyTablePtr cur;
 176
 177     while (keyt != NULL) {
 178         cur = keyt;
 179         keyt = keyt->next;
 180         xsltFreeKeyTable(cur);
 181     }
 182 }
 183
 184 /************************************************************************
 185  *                                                                      *
 186  *              The interpreter for the precompiled patterns            *
 187  *                                                                      *
 188  ************************************************************************/
 189
 190
 191 /**
 192  * xsltFreeKeys:
 193  * @style: an XSLT stylesheet
 194  *
 195  * Free up the memory used by XSLT keys in a stylesheet
 196  */
 197 void
 198 xsltFreeKeys(xsltStylesheetPtr style) {
 199     if (style->keys)
 200         xsltFreeKeyDefList((xsltKeyDefPtr) style->keys);
 201 }
 202
 203 /**
 204  * skipString:
 205  * @cur: the current pointer
 206  * @end: the current offset
 207  *
 208  * skip a string delimited by " or '
 209  *
 210  * Returns the byte after the string or -1 in case of error
 211  */
 212 static int
 213 skipString(const xmlChar *cur, int end) {
 214     xmlChar limit;
 215
 216     if ((cur == NULL) || (end < 0)) return(-1);
 217     if ((cur[end] == '\'') || (cur[end] == '"')) limit = cur[end];
 218     else return(end);
 219     end++;
 220     while (cur[end] != 0) {
 221         if (cur[end] == limit)
 222             return(end + 1);
 223         end++;
 224     }
 225     return(-1);
 226 }
 227
 228 /**
 229  * skipPredicate:
 230  * @cur: the current pointer
 231  * @end: the current offset
 232  *
 233  * skip a predicate
 234  *
 235  * Returns the byte after the predicate or -1 in case of error
 236  */
 237 static int
 238 skipPredicate(const xmlChar *cur, int end) {
 239     if ((cur == NULL) || (end < 0)) return(-1);
 240     if (cur[end] != '[') return(end);
 241     end++;
 242     while (cur[end] != 0) {
 243         if ((cur[end] == '\'') || (cur[end] == '"')) {
 244             end = skipString(cur, end);
 245             if (end <= 0)
 246                 return(-1);
 247             continue;
 248         } else if (cur[end] == '[') {
 249             end = skipPredicate(cur, end);
 250             if (end <= 0)
 251                 return(-1);
 252             continue;
 253         } else if (cur[end] == ']')
 254             return(end + 1);
 255         end++;
 256     }
 257     return(-1);
 258 }
 259
 260 /**
 261  * xsltAddKey:
 262  * @style: an XSLT stylesheet
 263  * @name:  the key name or NULL
 264  * @nameURI:  the name URI or NULL
 265  * @match:  the match value
 266  * @use:  the use value
 267  * @inst: the key instruction
 268  *
 269  * add a key definition to a stylesheet
 270  *
 271  * Returns 0 in case of success, and -1 in case of failure.
 272  */
 273 int
 274 xsltAddKey(xsltStylesheetPtr style, const xmlChar *name,
 275            const xmlChar *nameURI, const xmlChar *match,
 276            const xmlChar *use, xmlNodePtr inst) {
 277     xsltKeyDefPtr key;
 278     xmlChar *pattern = NULL;
 279     int current, end, start, i = 0;
 280
 281     if ((style == NULL) || (name == NULL) || (match == NULL) || (use == NULL))
 282         return(-1);
 283
 284 #ifdef WITH_XSLT_DEBUG_KEYS
 285     xsltGenericDebug(xsltGenericDebugContext,
 286         "Add key %s, match %s, use %s\n", name, match, use);
 287 #endif
 288
 289     key = xsltNewKeyDef(name, nameURI);
 290     key->match = xmlStrdup(match);
 291     key->use = xmlStrdup(use);
 292     key->inst = inst;
 293     key->nsList = xmlGetNsList(inst->doc, inst);
 294     if (key->nsList != NULL) {
 295         while (key->nsList[i] != NULL)
 296             i++;
 297     }
 298     key->nsNr = i;
 299
 300     /*
 301      * Split the | and register it as as many keys
 302      */
 303     current = end = 0;
 304     while (match[current] != 0) {
 305         start = current;
 306         while (IS_BLANK_CH(match[current]))
 307             current++;
 308         end = current;
 309         while ((match[end] != 0) && (match[end] != '|')) {
 310             if (match[end] == '[') {
 311                 end = skipPredicate(match, end);
 312                 if (end <= 0) {
 313                     xsltTransformError(NULL, style, inst,
 314                                        "key pattern is malformed: %s",
 315                                        key->match);
 316                     if (style != NULL) style->errors++;
 317                     goto error;
 318                 }
 319             } else
 320                 end++;
 321         }
 322         if (current == end) {
 323             xsltTransformError(NULL, style, inst,
 324                                "key pattern is empty\n");
 325             if (style != NULL) style->errors++;
 326             goto error;
 327         }
 328         if (match[start] != '/') {
 329             pattern = xmlStrcat(pattern, (xmlChar *)"//");
 330             if (pattern == NULL) {
 331                 if (style != NULL) style->errors++;
 332                 goto error;
 333             }
 334         }
 335         pattern = xmlStrncat(pattern, &match[start], end - start);
 336         if (pattern == NULL) {
 337             if (style != NULL) style->errors++;
 338             goto error;
 339         }
 340
 341         if (match[end] == '|') {
 342             pattern = xmlStrcat(pattern, (xmlChar *)"|");
 343             end++;
 344         }
 345         current = end;
 346     }
 347 #ifdef WITH_XSLT_DEBUG_KEYS
 348     xsltGenericDebug(xsltGenericDebugContext,
 349         "   resulting pattern %s\n", pattern);
 350 #endif
 351     /*
 352     * XSLT-1: "It is an error for the value of either the use
 353     *  attribute or the match attribute to contain a
 354     *  VariableReference."
 355     * TODO: We should report a variable-reference at compile-time.
 356     *   Maybe a search for "$", if it occurs outside of quotation
 357     *   marks, could be sufficient.
 358     */
 359     key->comp = xsltXPathCompile(style, pattern);
 360     if (key->comp == NULL) {
 361         xsltTransformError(NULL, style, inst,
 362                 "xsl:key : XPath pattern compilation failed '%s'\n",
 363                          pattern);
 364         if (style != NULL) style->errors++;
 365     }
 366     key->usecomp = xsltXPathCompile(style, use);
 367     if (key->usecomp == NULL) {
 368         xsltTransformError(NULL, style, inst,
 369                 "xsl:key : XPath pattern compilation failed '%s'\n",
 370                          use);
 371         if (style != NULL) style->errors++;
 372     }
 373
 374     /*
 375      * Sometimes the stylesheet writer use the order to ease the
 376      * resolution of keys when they are dependant, keep the provided
 377      * order so add the new one at the end.
 378      */
 379     if (style->keys == NULL) {
 380         style->keys = key;
 381     } else {
 382         xsltKeyDefPtr prev = style->keys;
 383
 384         while (prev->next != NULL)
 385             prev = prev->next;
 386
 387         prev->next = key;
 388     }
 389     key->next = NULL;
 390
 391 error:
 392     if (pattern != NULL)
 393         xmlFree(pattern);
 394     return(0);
 395 }
 396
 397 /**
 398  * xsltGetKey:
 399  * @ctxt: an XSLT transformation context
 400  * @name:  the key name or NULL
 401  * @nameURI:  the name URI or NULL
 402  * @value:  the key value to look for
 403  *
 404  * Looks up a key of the in current source doc (the document info
 405  * on @ctxt->document). Computes the key if not already done
 406  * for the current source doc.
 407  *
 408  * Returns the nodeset resulting from the query or NULL
 409  */
 410 xmlNodeSetPtr
 411 xsltGetKey(xsltTransformContextPtr ctxt, const xmlChar *name,
 412            const xmlChar *nameURI, const xmlChar *value) {
 413     xmlNodeSetPtr ret;
 414     xsltKeyTablePtr table;
 415     int init_table = 0;
 416
 417     if ((ctxt == NULL) || (name == NULL) || (value == NULL) ||
 418         (ctxt->document == NULL))
 419         return(NULL);
 420
 421 #ifdef WITH_XSLT_DEBUG_KEYS
 422     xsltGenericDebug(xsltGenericDebugContext,
 423         "Get key %s, value %s\n", name, value);
 424 #endif
 425
 426     /*
 427      * keys are computed only on-demand on first key access for a document
 428      */
 429     if ((ctxt->document->nbKeysComputed < ctxt->nbKeys) &&
 430         (ctxt->keyInitLevel == 0)) {
 431         /*
 432          * If non-recursive behaviour, just try to initialize all keys
 433          */
 434         if (xsltInitAllDocKeys(ctxt))
 435             return(NULL);
 436     }
 437
 438 retry:
 439     table = (xsltKeyTablePtr) ctxt->document->keys;
 440     while (table != NULL) {
 441         if (((nameURI != NULL) == (table->nameURI != NULL)) &&
 442             xmlStrEqual(table->name, name) &&
 443             xmlStrEqual(table->nameURI, nameURI))
 444         {
 445             ret = (xmlNodeSetPtr)xmlHashLookup(table->keys, value);
 446             return(ret);
 447         }
 448         table = table->next;
 449     }
 450
 451     if ((ctxt->keyInitLevel != 0) && (init_table == 0)) {
 452         /*
 453          * Apparently one key is recursive and this one is needed,
 454          * initialize just it, that time and retry
 455          */
 456         xsltInitDocKeyTable(ctxt, name, nameURI);
 457         init_table = 1;
 458         goto retry;
 459     }
 460
 461     return(NULL);
 462 }
 463
 464
 465 /**
 466  * xsltInitDocKeyTable:
 467  *
 468  * INTERNAL ROUTINE ONLY
 469  *
 470  * Check if any keys on the current document need to be computed
 471  */
 472 static int
 473 xsltInitDocKeyTable(xsltTransformContextPtr ctxt, const xmlChar *name,
 474                     const xmlChar *nameURI)
 475 {
 476     xsltStylesheetPtr style;
 477     xsltKeyDefPtr keyd = NULL;
 478     int found = 0;
 479
 480 #ifdef KEY_INIT_DEBUG
 481 fprintf(stderr, "xsltInitDocKeyTable %s\n", name);
 482 #endif
 483
 484     style = ctxt->style;
 485     while (style != NULL) {
 486         keyd = (xsltKeyDefPtr) style->keys;
 487         while (keyd != NULL) {
 488             if (((keyd->nameURI != NULL) ==
 489                  (nameURI != NULL)) &&
 490                 xmlStrEqual(keyd->name, name) &&
 491                 xmlStrEqual(keyd->nameURI, nameURI))
 492             {
 493                 xsltInitCtxtKey(ctxt, ctxt->document, keyd);
 494                 if (ctxt->document->nbKeysComputed == ctxt->nbKeys)
 495                     return(0);
 496                 found = 1;
 497             }
 498             keyd = keyd->next;
 499         }
 500         style = xsltNextImport(style);
 501     }
 502     if (found == 0) {
 503 #ifdef WITH_XSLT_DEBUG_KEYS
 504         XSLT_TRACE(ctxt,XSLT_TRACE_KEYS,xsltGenericDebug(xsltGenericDebugContext,
 505              "xsltInitDocKeyTable: did not found %s\n", name));
 506 #endif
 507         xsltTransformError(ctxt, NULL, keyd? keyd->inst : NULL,
 508             "Failed to find key definition for %s\n", name);
 509         ctxt->state = XSLT_STATE_STOPPED;
 510         return(-1);
 511     }
 512 #ifdef KEY_INIT_DEBUG
 513 fprintf(stderr, "xsltInitDocKeyTable %s done\n", name);
 514 #endif
 515     return(0);
 516 }
 517
 518 /**
 519  * xsltInitAllDocKeys:
 520  * @ctxt: transformation context
 521  *
 522  * INTERNAL ROUTINE ONLY
 523  *
 524  * Check if any keys on the current document need to be computed
 525  *
 526  * Returns 0 in case of success, -1 in case of failure
 527  */
 528 int
 529 xsltInitAllDocKeys(xsltTransformContextPtr ctxt)
 530 {
 531     xsltStylesheetPtr style;
 532     xsltKeyDefPtr keyd;
 533     xsltKeyTablePtr table;
 534
 535     if (ctxt == NULL)
 536         return(-1);
 537
 538 #ifdef KEY_INIT_DEBUG
 539 fprintf(stderr, "xsltInitAllDocKeys %d %d\n",
 540         ctxt->document->nbKeysComputed, ctxt->nbKeys);
 541 #endif
 542
 543     if (ctxt->document->nbKeysComputed == ctxt->nbKeys)
 544         return(0);
 545
 546
 547     /*
 548     * TODO: This could be further optimized
 549     */
 550     style = ctxt->style;
 551     while (style) {
 552         keyd = (xsltKeyDefPtr) style->keys;
 553         while (keyd != NULL) {
 554 #ifdef KEY_INIT_DEBUG
 555 fprintf(stderr, "Init key %s\n", keyd->name);
 556 #endif
 557             /*
 558             * Check if keys with this QName have been already
 559             * computed.
 560             */
 561             table = (xsltKeyTablePtr) ctxt->document->keys;
 562             while (table) {
 563                 if (((keyd->nameURI != NULL) == (table->nameURI != NULL)) &&
 564                     xmlStrEqual(keyd->name, table->name) &&
 565                     xmlStrEqual(keyd->nameURI, table->nameURI))
 566                 {
 567                     break;
 568                 }
 569                 table = table->next;
 570             }
 571             if (table == NULL) {
 572                 /*
 573                 * Keys with this QName have not been yet computed.
 574                 */
 575                 xsltInitDocKeyTable(ctxt, keyd->name, keyd->nameURI);
 576             }
 577             keyd = keyd->next;
 578         }
 579         style = xsltNextImport(style);
 580     }
 581 #ifdef KEY_INIT_DEBUG
 582 fprintf(stderr, "xsltInitAllDocKeys: done\n");
 583 #endif
 584     return(0);
 585 }
 586
 587 /**
 588  * xsltInitCtxtKey:
 589  * @ctxt: an XSLT transformation context
 590  * @idoc:  the document information (holds key values)
 591  * @keyDef: the key definition
 592  *
 593  * Computes the key tables this key and for the current input document.
 594  *
 595  * Returns: 0 on success, -1 on error
 596  */
 597 int
 598 xsltInitCtxtKey(xsltTransformContextPtr ctxt, xsltDocumentPtr idoc,
 599                 xsltKeyDefPtr keyDef)
 600 {
 601     int i, len, k;
 602     xmlNodeSetPtr matchList = NULL, keylist;
 603     xmlXPathObjectPtr matchRes = NULL, useRes = NULL;
 604     xmlChar *str = NULL;
 605     xsltKeyTablePtr table;
 606     xmlNodePtr oldInst, cur;
 607     xmlNodePtr oldContextNode;
 608     xsltDocumentPtr oldDocInfo;
 609     int oldXPPos, oldXPSize;
 610     xmlDocPtr oldXPDoc;
 611     int oldXPNsNr;
 612     xmlNsPtr *oldXPNamespaces;
 613     xmlXPathContextPtr xpctxt;
 614
 615 #ifdef KEY_INIT_DEBUG
 616 fprintf(stderr, "xsltInitCtxtKey %s : %d\n", keyDef->name, ctxt->keyInitLevel);
 617 #endif
 618
 619     if ((keyDef->comp == NULL) || (keyDef->usecomp == NULL))
 620         return(-1);
 621
 622     /*
 623      * Detect recursive keys
 624      */
 625     if (ctxt->keyInitLevel > ctxt->nbKeys) {
 626 #ifdef WITH_XSLT_DEBUG_KEYS
 627         XSLT_TRACE(ctxt,XSLT_TRACE_KEYS,
 628                    xsltGenericDebug(xsltGenericDebugContext,
 629                        "xsltInitCtxtKey: key definition of %s is recursive\n",
 630                        keyDef->name));
 631 #endif
 632         xsltTransformError(ctxt, NULL, keyDef->inst,
 633             "Key definition for %s is recursive\n", keyDef->name);
 634         ctxt->state = XSLT_STATE_STOPPED;
 635         return(-1);
 636     }
 637     ctxt->keyInitLevel++;
 638
 639     xpctxt = ctxt->xpathCtxt;
 640     idoc->nbKeysComputed++;
 641     /*
 642     * Save context state.
 643     */
 644     oldInst = ctxt->inst;
 645     oldDocInfo = ctxt->document;
 646     oldContextNode = ctxt->node;
 647
 648     oldXPDoc = xpctxt->doc;
 649     oldXPPos = xpctxt->proximityPosition;
 650     oldXPSize = xpctxt->contextSize;
 651     oldXPNsNr = xpctxt->nsNr;
 652     oldXPNamespaces = xpctxt->namespaces;
 653
 654     /*
 655     * Set up contexts.
 656     */
 657     ctxt->document = idoc;
 658     ctxt->node = (xmlNodePtr) idoc->doc;
 659     ctxt->inst = keyDef->inst;
 660
 661     xpctxt->doc = idoc->doc;
 662     xpctxt->node = (xmlNodePtr) idoc->doc;
 663     /* TODO : clarify the use of namespaces in keys evaluation */
 664     xpctxt->namespaces = keyDef->nsList;
 665     xpctxt->nsNr = keyDef->nsNr;
 666
 667     /*
 668     * Evaluate the 'match' expression of the xsl:key.
 669     * TODO: The 'match' is a *pattern*.
 670     */
 671     matchRes = xmlXPathCompiledEval(keyDef->comp, xpctxt);
 672     if (matchRes == NULL) {
 673
 674 #ifdef WITH_XSLT_DEBUG_KEYS
 675         XSLT_TRACE(ctxt,XSLT_TRACE_KEYS,xsltGenericDebug(xsltGenericDebugContext,
 676              "xsltInitCtxtKey: %s evaluation failed\n", keyDef->match));
 677 #endif
 678         xsltTransformError(ctxt, NULL, keyDef->inst,
 679             "Failed to evaluate the 'match' expression.\n");
 680         ctxt->state = XSLT_STATE_STOPPED;
 681         goto error;
 682     } else {
 683         if (matchRes->type == XPATH_NODESET) {
 684             matchList = matchRes->nodesetval;
 685
 686 #ifdef WITH_XSLT_DEBUG_KEYS
 687             if (matchList != NULL)
 688                 XSLT_TRACE(ctxt,XSLT_TRACE_KEYS,xsltGenericDebug(xsltGenericDebugContext,
 689                      "xsltInitCtxtKey: %s evaluates to %d nodes\n",
 690                                  keyDef->match, matchList->nodeNr));
 691 #endif
 692         } else {
 693             /*
 694             * Is not a node set, but must be.
 695             */
 696 #ifdef WITH_XSLT_DEBUG_KEYS
 697             XSLT_TRACE(ctxt,XSLT_TRACE_KEYS,xsltGenericDebug(xsltGenericDebugContext,
 698                  "xsltInitCtxtKey: %s is not a node set\n", keyDef->match));
 699 #endif
 700             xsltTransformError(ctxt, NULL, keyDef->inst,
 701                 "The 'match' expression did not evaluate to a node set.\n");
 702             ctxt->state = XSLT_STATE_STOPPED;
 703             goto error;
 704         }
 705     }
 706     if ((matchList == NULL) || (matchList->nodeNr <= 0))
 707         goto exit;
 708
 709     /**
 710      * Multiple key definitions for the same name are allowed, so
 711      * we must check if the key is already present for this doc
 712      */
 713     table = (xsltKeyTablePtr) idoc->keys;
 714     while (table != NULL) {
 715         if (xmlStrEqual(table->name, keyDef->name) &&
 716             (((keyDef->nameURI == NULL) && (table->nameURI == NULL)) ||
 717              ((keyDef->nameURI != NULL) && (table->nameURI != NULL) &&
 718               (xmlStrEqual(table->nameURI, keyDef->nameURI)))))
 719             break;
 720         table = table->next;
 721     }
 722     /**
 723      * If the key was not previously defined, create it now and
 724      * chain it to the list of keys for the doc
 725      */
 726     if (table == NULL) {
 727         table = xsltNewKeyTable(keyDef->name, keyDef->nameURI);
 728         if (table == NULL)
 729             goto error;
 730         table->next = idoc->keys;
 731         idoc->keys = table;
 732     }
 733
 734     /*
 735     * SPEC XSLT 1.0 (XSLT 2.0 does not clarify the context size!)
 736     * "...the use attribute of the xsl:key element is evaluated with x as
 737     "  the current node and with a node list containing just x as the
 738     *  current node list"
 739     */
 740     xpctxt->contextSize = 1;
 741     xpctxt->proximityPosition = 1;
 742
 743     for (i = 0; i < matchList->nodeNr; i++) {
 744         cur = matchList->nodeTab[i];
 745         if (! IS_XSLT_REAL_NODE(cur))
 746             continue;
 747         xpctxt->node = cur;
 748         /*
 749         * Process the 'use' of the xsl:key.
 750         * SPEC XSLT 1.0:
 751         * "The use attribute is an expression specifying the values of
 752         *  the key; the expression is evaluated once for each node that
 753         *  matches the pattern."
 754         */
 755         if (useRes != NULL)
 756             xmlXPathFreeObject(useRes);
 757         useRes = xmlXPathCompiledEval(keyDef->usecomp, xpctxt);
 758         if (useRes == NULL) {
 759             xsltTransformError(ctxt, NULL, keyDef->inst,
 760                 "Failed to evaluate the 'use' expression.\n");
 761             ctxt->state = XSLT_STATE_STOPPED;
 762             break;
 763         }
 764         if (useRes->type == XPATH_NODESET) {
 765             if ((useRes->nodesetval != NULL) &&
 766                 (useRes->nodesetval->nodeNr != 0))
 767             {
 768                 len = useRes->nodesetval->nodeNr;
 769                 str = xmlXPathCastNodeToString(useRes->nodesetval->nodeTab[0]);
 770             } else {
 771                 continue;
 772             }
 773         } else {
 774             len = 1;
 775             if (useRes->type == XPATH_STRING) {
 776                 /*
 777                 * Consume the string value.
 778                 */
 779                 str = useRes->stringval;
 780                 useRes->stringval = NULL;
 781             } else {
 782                 str = xmlXPathCastToString(useRes);
 783             }
 784         }
 785         /*
 786         * Process all strings.
 787         */
 788         k = 0;
 789         while (1) {
 790             if (str == NULL)
 791                 goto next_string;
 792
 793 #ifdef WITH_XSLT_DEBUG_KEYS
 794             XSLT_TRACE(ctxt,XSLT_TRACE_KEYS,xsltGenericDebug(xsltGenericDebugContext,
 795                 "xsl:key : node associated to ('%s', '%s')\n", keyDef->name, str));
 796 #endif
 797
 798             keylist = xmlHashLookup(table->keys, str);
 799             if (keylist == NULL) {
 800                 keylist = xmlXPathNodeSetCreate(cur);
 801                 if (keylist == NULL)
 802                     goto error;
 803                 xmlHashAddEntry(table->keys, str, keylist);
 804             } else {
 805                 /*
 806                 * TODO: How do we know if this function failed?
 807                 */
 808                 xmlXPathNodeSetAdd(keylist, cur);
 809             }
 810             switch (cur->type) {
 811                 case XML_ELEMENT_NODE:
 812                 case XML_TEXT_NODE:
 813                 case XML_CDATA_SECTION_NODE:
 814                 case XML_PI_NODE:
 815                 case XML_COMMENT_NODE:
 816                     cur->psvi = keyDef;
 817                     break;
 818                 case XML_ATTRIBUTE_NODE:
 819                     ((xmlAttrPtr) cur)->psvi = keyDef;
 820                     break;
 821                 case XML_DOCUMENT_NODE:
 822                 case XML_HTML_DOCUMENT_NODE:
 823                     ((xmlDocPtr) cur)->psvi = keyDef;
 824                     break;
 825                 default:
 826                     break;
 827             }
 828             xmlFree(str);
 829             str = NULL;
 830
 831 next_string:
 832             k++;
 833             if (k >= len)
 834                 break;
 835             str = xmlXPathCastNodeToString(useRes->nodesetval->nodeTab[k]);
 836         }
 837     }
 838
 839 exit:
 840 error:
 841     ctxt->keyInitLevel--;
 842     /*
 843     * Restore context state.
 844     */
 845     xpctxt->doc = oldXPDoc;
 846     xpctxt->nsNr = oldXPNsNr;
 847     xpctxt->namespaces = oldXPNamespaces;
 848     xpctxt->proximityPosition = oldXPPos;
 849     xpctxt->contextSize = oldXPSize;
 850
 851     ctxt->node = oldContextNode;
 852     ctxt->document = oldDocInfo;
 853     ctxt->inst = oldInst;
 854
 855     if (str)
 856         xmlFree(str);
 857     if (useRes != NULL)
 858         xmlXPathFreeObject(useRes);
 859     if (matchRes != NULL)
 860         xmlXPathFreeObject(matchRes);
 861     return(0);
 862 }
 863
 864 /**
 865  * xsltInitCtxtKeys:
 866  * @ctxt:  an XSLT transformation context
 867  * @idoc:  a document info
 868  *
 869  * Computes all the keys tables for the current input document.
 870  * Should be done before global varibales are initialized.
 871  * NOTE: Not used anymore in the refactored code.
 872  */
 873 void
 874 xsltInitCtxtKeys(xsltTransformContextPtr ctxt, xsltDocumentPtr idoc) {
 875     xsltStylesheetPtr style;
 876     xsltKeyDefPtr keyDef;
 877
 878     if ((ctxt == NULL) || (idoc == NULL))
 879         return;
 880
 881 #ifdef KEY_INIT_DEBUG
 882 fprintf(stderr, "xsltInitCtxtKeys on document\n");
 883 #endif
 884
 885 #ifdef WITH_XSLT_DEBUG_KEYS
 886     if ((idoc->doc != NULL) && (idoc->doc->URL != NULL))
 887         XSLT_TRACE(ctxt,XSLT_TRACE_KEYS,xsltGenericDebug(xsltGenericDebugContext, "Initializing keys on %s\n",
 888                      idoc->doc->URL));
 889 #endif
 890     style = ctxt->style;
 891     while (style != NULL) {
 892         keyDef = (xsltKeyDefPtr) style->keys;
 893         while (keyDef != NULL) {
 894             xsltInitCtxtKey(ctxt, idoc, keyDef);
 895
 896             keyDef = keyDef->next;
 897         }
 898
 899         style = xsltNextImport(style);
 900     }
 901
 902 #ifdef KEY_INIT_DEBUG
 903 fprintf(stderr, "xsltInitCtxtKeys on document: done\n");
 904 #endif
 905
 906 }
 907
 908 /**
 909  * xsltFreeDocumentKeys:
 910  * @idoc: a XSLT document
 911  *
 912  * Free the keys associated to a document
 913  */
 914 void
 915 xsltFreeDocumentKeys(xsltDocumentPtr idoc) {
 916     if (idoc != NULL)
 917         xsltFreeKeyTableList(idoc->keys);
 918 }
 919