1 /* 2 * pattern.c: Implemetation of the template match compilation 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 (at) veillard.com 10 */ 11 12 /* 13 * TODO: handle pathological cases like *[*[@a="b"]] 14 * TODO: detect [number] at compilation, optimize accordingly 15 */ 16 17 #define IN_LIBXSLT 18 #include "libxslt.h" 19 20 #include <string.h> 21 22 #include <libxml/xmlmemory.h> 23 #include <libxml/tree.h> 24 #include <libxml/valid.h> 25 #include <libxml/hash.h> 26 #include <libxml/xmlerror.h> 27 #include <libxml/parserInternals.h> 28 #include "xslt.h" 29 #include "xsltInternals.h" 30 #include "xsltutils.h" 31 #include "imports.h" 32 #include "templates.h" 33 #include "keys.h" 34 #include "pattern.h" 35 #include "documents.h" 36 37 #ifdef WITH_XSLT_DEBUG 38 #define WITH_XSLT_DEBUG_PATTERN 39 #endif 40 41 /* 42 * Types are private: 43 */ 44 45 typedef enum { 46 XSLT_OP_END=0, 47 XSLT_OP_ROOT, 48 XSLT_OP_ELEM, 49 XSLT_OP_ATTR, 50 XSLT_OP_PARENT, 51 XSLT_OP_ANCESTOR, 52 XSLT_OP_ID, 53 XSLT_OP_KEY, 54 XSLT_OP_NS, 55 XSLT_OP_ALL, 56 XSLT_OP_PI, 57 XSLT_OP_COMMENT, 58 XSLT_OP_TEXT, 59 XSLT_OP_NODE, 60 XSLT_OP_PREDICATE 61 } xsltOp; 62 63 typedef enum { 64 AXIS_CHILD=1, 65 AXIS_ATTRIBUTE 66 } xsltAxis; 67 68 typedef struct _xsltStepState xsltStepState; 69 typedef xsltStepState *xsltStepStatePtr; 70 struct _xsltStepState { 71 int step; 72 xmlNodePtr node; 73 }; 74 75 typedef struct _xsltStepStates xsltStepStates; 76 typedef xsltStepStates *xsltStepStatesPtr; 77 struct _xsltStepStates { 78 int nbstates; 79 int maxstates; 80 xsltStepStatePtr states; 81 }; 82 83 typedef struct _xsltStepOp xsltStepOp; 84 typedef xsltStepOp *xsltStepOpPtr; 85 struct _xsltStepOp { 86 xsltOp op; 87 xmlChar *value; 88 xmlChar *value2; 89 xmlChar *value3; 90 xmlXPathCompExprPtr comp; 91 /* 92 * Optimisations for count 93 */ 94 int previousExtra; 95 int indexExtra; 96 int lenExtra; 97 }; 98 99 struct _xsltCompMatch { 100 struct _xsltCompMatch *next; /* siblings in the name hash */ 101 float priority; /* the priority */ 102 const xmlChar *pattern; /* the pattern */ 103 const xmlChar *mode; /* the mode */ 104 const xmlChar *modeURI; /* the mode URI */ 105 xsltTemplatePtr template; /* the associated template */ 106 107 int direct; 108 /* TODO fix the statically allocated size steps[] */ 109 int nbStep; 110 int maxStep; 111 xmlNsPtr *nsList; /* the namespaces in scope */ 112 int nsNr; /* the number of namespaces in scope */ 113 xsltStepOpPtr steps; /* ops for computation */ 114 }; 115 116 typedef struct _xsltParserContext xsltParserContext; 117 typedef xsltParserContext *xsltParserContextPtr; 118 struct _xsltParserContext { 119 xsltStylesheetPtr style; /* the stylesheet */ 120 xsltTransformContextPtr ctxt; /* the transformation or NULL */ 121 const xmlChar *cur; /* the current char being parsed */ 122 const xmlChar *base; /* the full expression */ 123 xmlDocPtr doc; /* the source document */ 124 xmlNodePtr elem; /* the source element */ 125 int error; /* error code */ 126 xsltCompMatchPtr comp; /* the result */ 127 }; 128 129 /************************************************************************ 130 * * 131 * Type functions * 132 * * 133 ************************************************************************/ 134 135 /** 136 * xsltNewCompMatch: 137 * 138 * Create a new XSLT CompMatch 139 * 140 * Returns the newly allocated xsltCompMatchPtr or NULL in case of error 141 */ 142 static xsltCompMatchPtr 143 xsltNewCompMatch(void) { 144 xsltCompMatchPtr cur; 145 146 cur = (xsltCompMatchPtr) xmlMalloc(sizeof(xsltCompMatch)); 147 if (cur == NULL) { 148 xsltTransformError(NULL, NULL, NULL, 149 "xsltNewCompMatch : out of memory error\n"); 150 return(NULL); 151 } 152 memset(cur, 0, sizeof(xsltCompMatch)); 153 cur->maxStep = 10; 154 cur->nbStep = 0; 155 cur-> steps = (xsltStepOpPtr) xmlMalloc(sizeof(xsltStepOp) * 156 cur->maxStep); 157 if (cur->steps == NULL) { 158 xsltTransformError(NULL, NULL, NULL, 159 "xsltNewCompMatch : out of memory error\n"); 160 xmlFree(cur); 161 return(NULL); 162 } 163 cur->nsNr = 0; 164 cur->nsList = NULL; 165 cur->direct = 0; 166 return(cur); 167 } 168 169 /** 170 * xsltFreeCompMatch: 171 * @comp: an XSLT comp 172 * 173 * Free up the memory allocated by @comp 174 */ 175 static void 176 xsltFreeCompMatch(xsltCompMatchPtr comp) { 177 xsltStepOpPtr op; 178 int i; 179 180 if (comp == NULL) 181 return; 182 if (comp->pattern != NULL) 183 xmlFree((xmlChar *)comp->pattern); 184 if (comp->nsList != NULL) 185 xmlFree(comp->nsList); 186 for (i = 0;i < comp->nbStep;i++) { 187 op = &comp->steps[i]; 188 if (op->value != NULL) 189 xmlFree(op->value); 190 if (op->value2 != NULL) 191 xmlFree(op->value2); 192 if (op->value3 != NULL) 193 xmlFree(op->value3); 194 if (op->comp != NULL) 195 xmlXPathFreeCompExpr(op->comp); 196 } 197 xmlFree(comp->steps); 198 memset(comp, -1, sizeof(xsltCompMatch)); 199 xmlFree(comp); 200 } 201 202 /** 203 * xsltFreeCompMatchList: 204 * @comp: an XSLT comp list 205 * 206 * Free up the memory allocated by all the elements of @comp 207 */ 208 void 209 xsltFreeCompMatchList(xsltCompMatchPtr comp) { 210 xsltCompMatchPtr cur; 211 212 while (comp != NULL) { 213 cur = comp; 214 comp = comp->next; 215 xsltFreeCompMatch(cur); 216 } 217 } 218 219 /** 220 * xsltNormalizeCompSteps: 221 * @payload: pointer to template hash table entry 222 * @data: pointer to the stylesheet 223 * @name: template match name 224 * 225 * This is a hashtable scanner function to normalize the compiled 226 * steps of an imported stylesheet. 227 */ 228 void xsltNormalizeCompSteps(void *payload, 229 void *data, const xmlChar *name ATTRIBUTE_UNUSED) { 230 xsltCompMatchPtr comp = payload; 231 xsltStylesheetPtr style = data; 232 int ix; 233 234 for (ix = 0; ix < comp->nbStep; ix++) { 235 comp->steps[ix].previousExtra += style->extrasNr; 236 comp->steps[ix].indexExtra += style->extrasNr; 237 comp->steps[ix].lenExtra += style->extrasNr; 238 } 239 } 240 241 /** 242 * xsltNewParserContext: 243 * @style: the stylesheet 244 * @ctxt: the transformation context, if done at run-time 245 * 246 * Create a new XSLT ParserContext 247 * 248 * Returns the newly allocated xsltParserContextPtr or NULL in case of error 249 */ 250 static xsltParserContextPtr 251 xsltNewParserContext(xsltStylesheetPtr style, xsltTransformContextPtr ctxt) { 252 xsltParserContextPtr cur; 253 254 cur = (xsltParserContextPtr) xmlMalloc(sizeof(xsltParserContext)); 255 if (cur == NULL) { 256 xsltTransformError(NULL, NULL, NULL, 257 "xsltNewParserContext : malloc failed\n"); 258 return(NULL); 259 } 260 memset(cur, 0, sizeof(xsltParserContext)); 261 cur->style = style; 262 cur->ctxt = ctxt; 263 return(cur); 264 } 265 266 /** 267 * xsltFreeParserContext: 268 * @ctxt: an XSLT parser context 269 * 270 * Free up the memory allocated by @ctxt 271 */ 272 static void 273 xsltFreeParserContext(xsltParserContextPtr ctxt) { 274 if (ctxt == NULL) 275 return; 276 memset(ctxt, -1, sizeof(xsltParserContext)); 277 xmlFree(ctxt); 278 } 279 280 /** 281 * xsltCompMatchAdd: 282 * @comp: the compiled match expression 283 * @op: an op 284 * @value: the first value 285 * @value2: the second value 286 * @novar: flag to set XML_XPATH_NOVAR 287 * 288 * Add an step to an XSLT Compiled Match 289 * 290 * Returns -1 in case of failure, 0 otherwise. 291 */ 292 static int 293 xsltCompMatchAdd(xsltParserContextPtr ctxt, xsltCompMatchPtr comp, 294 xsltOp op, xmlChar * value, xmlChar * value2, int novar) 295 { 296 if (comp->nbStep >= comp->maxStep) { 297 xsltStepOpPtr tmp; 298 299 tmp = (xsltStepOpPtr) xmlRealloc(comp->steps, comp->maxStep * 2 * 300 sizeof(xsltStepOp)); 301 if (tmp == NULL) { 302 xsltGenericError(xsltGenericErrorContext, 303 "xsltCompMatchAdd: memory re-allocation failure.\n"); 304 if (ctxt->style != NULL) 305 ctxt->style->errors++; 306 return (-1); 307 } 308 comp->maxStep *= 2; 309 comp->steps = tmp; 310 } 311 comp->steps[comp->nbStep].op = op; 312 comp->steps[comp->nbStep].value = value; 313 comp->steps[comp->nbStep].value2 = value2; 314 comp->steps[comp->nbStep].value3 = NULL; 315 comp->steps[comp->nbStep].comp = NULL; 316 if (ctxt->ctxt != NULL) { 317 comp->steps[comp->nbStep].previousExtra = 318 xsltAllocateExtraCtxt(ctxt->ctxt); 319 comp->steps[comp->nbStep].indexExtra = 320 xsltAllocateExtraCtxt(ctxt->ctxt); 321 comp->steps[comp->nbStep].lenExtra = 322 xsltAllocateExtraCtxt(ctxt->ctxt); 323 } else { 324 comp->steps[comp->nbStep].previousExtra = 325 xsltAllocateExtra(ctxt->style); 326 comp->steps[comp->nbStep].indexExtra = 327 xsltAllocateExtra(ctxt->style); 328 comp->steps[comp->nbStep].lenExtra = 329 xsltAllocateExtra(ctxt->style); 330 } 331 if (op == XSLT_OP_PREDICATE) { 332 xmlXPathContextPtr xctxt; 333 334 if (ctxt->style != NULL) 335 xctxt = xmlXPathNewContext(ctxt->style->doc); 336 else 337 xctxt = xmlXPathNewContext(NULL); 338 #ifdef XML_XPATH_NOVAR 339 if (novar != 0) 340 xctxt->flags = XML_XPATH_NOVAR; 341 #endif 342 if (ctxt->style != NULL) 343 xctxt->dict = ctxt->style->dict; 344 comp->steps[comp->nbStep].comp = xmlXPathCtxtCompile(xctxt, value); 345 xmlXPathFreeContext(xctxt); 346 if (comp->steps[comp->nbStep].comp == NULL) { 347 xsltTransformError(NULL, ctxt->style, ctxt->elem, 348 "Failed to compile predicate\n"); 349 if (ctxt->style != NULL) 350 ctxt->style->errors++; 351 } 352 } 353 comp->nbStep++; 354 return (0); 355 } 356 357 /** 358 * xsltSwapTopCompMatch: 359 * @comp: the compiled match expression 360 * 361 * reverse the two top steps. 362 */ 363 static void 364 xsltSwapTopCompMatch(xsltCompMatchPtr comp) { 365 int i; 366 int j = comp->nbStep - 1; 367 368 if (j > 0) { 369 register xmlChar *tmp; 370 register xsltOp op; 371 register xmlXPathCompExprPtr expr; 372 register int t; 373 i = j - 1; 374 tmp = comp->steps[i].value; 375 comp->steps[i].value = comp->steps[j].value; 376 comp->steps[j].value = tmp; 377 tmp = comp->steps[i].value2; 378 comp->steps[i].value2 = comp->steps[j].value2; 379 comp->steps[j].value2 = tmp; 380 tmp = comp->steps[i].value3; 381 comp->steps[i].value3 = comp->steps[j].value3; 382 comp->steps[j].value3 = tmp; 383 op = comp->steps[i].op; 384 comp->steps[i].op = comp->steps[j].op; 385 comp->steps[j].op = op; 386 expr = comp->steps[i].comp; 387 comp->steps[i].comp = comp->steps[j].comp; 388 comp->steps[j].comp = expr; 389 t = comp->steps[i].previousExtra; 390 comp->steps[i].previousExtra = comp->steps[j].previousExtra; 391 comp->steps[j].previousExtra = t; 392 t = comp->steps[i].indexExtra; 393 comp->steps[i].indexExtra = comp->steps[j].indexExtra; 394 comp->steps[j].indexExtra = t; 395 t = comp->steps[i].lenExtra; 396 comp->steps[i].lenExtra = comp->steps[j].lenExtra; 397 comp->steps[j].lenExtra = t; 398 } 399 } 400 401 /** 402 * xsltReverseCompMatch: 403 * @ctxt: the parser context 404 * @comp: the compiled match expression 405 * 406 * reverse all the stack of expressions 407 */ 408 static void 409 xsltReverseCompMatch(xsltParserContextPtr ctxt, xsltCompMatchPtr comp) { 410 int i = 0; 411 int j = comp->nbStep - 1; 412 413 while (j > i) { 414 register xmlChar *tmp; 415 register xsltOp op; 416 register xmlXPathCompExprPtr expr; 417 register int t; 418 419 tmp = comp->steps[i].value; 420 comp->steps[i].value = comp->steps[j].value; 421 comp->steps[j].value = tmp; 422 tmp = comp->steps[i].value2; 423 comp->steps[i].value2 = comp->steps[j].value2; 424 comp->steps[j].value2 = tmp; 425 tmp = comp->steps[i].value3; 426 comp->steps[i].value3 = comp->steps[j].value3; 427 comp->steps[j].value3 = tmp; 428 op = comp->steps[i].op; 429 comp->steps[i].op = comp->steps[j].op; 430 comp->steps[j].op = op; 431 expr = comp->steps[i].comp; 432 comp->steps[i].comp = comp->steps[j].comp; 433 comp->steps[j].comp = expr; 434 t = comp->steps[i].previousExtra; 435 comp->steps[i].previousExtra = comp->steps[j].previousExtra; 436 comp->steps[j].previousExtra = t; 437 t = comp->steps[i].indexExtra; 438 comp->steps[i].indexExtra = comp->steps[j].indexExtra; 439 comp->steps[j].indexExtra = t; 440 t = comp->steps[i].lenExtra; 441 comp->steps[i].lenExtra = comp->steps[j].lenExtra; 442 comp->steps[j].lenExtra = t; 443 j--; 444 i++; 445 } 446 xsltCompMatchAdd(ctxt, comp, XSLT_OP_END, NULL, NULL, 0); 447 448 /* 449 * detect consecutive XSLT_OP_PREDICATE indicating a direct 450 * matching should be done. 451 */ 452 for (i = 0;i < comp->nbStep - 1;i++) { 453 if ((comp->steps[i].op == XSLT_OP_PREDICATE) && 454 (comp->steps[i + 1].op == XSLT_OP_PREDICATE)) { 455 456 comp->direct = 1; 457 if (comp->pattern[0] != '/') { 458 xmlChar *query; 459 460 query = xmlStrdup((const xmlChar *)"//"); 461 query = xmlStrcat(query, comp->pattern); 462 463 xmlFree((xmlChar *) comp->pattern); 464 comp->pattern = query; 465 } 466 break; 467 } 468 } 469 } 470 471 /************************************************************************ 472 * * 473 * The interpreter for the precompiled patterns * 474 * * 475 ************************************************************************/ 476 477 static int 478 xsltPatPushState(xsltTransformContextPtr ctxt, xsltStepStates *states, 479 int step, xmlNodePtr node) { 480 if ((states->states == NULL) || (states->maxstates <= 0)) { 481 states->maxstates = 4; 482 states->nbstates = 0; 483 states->states = xmlMalloc(4 * sizeof(xsltStepState)); 484 } 485 else if (states->maxstates <= states->nbstates) { 486 xsltStepState *tmp; 487 488 tmp = (xsltStepStatePtr) xmlRealloc(states->states, 489 2 * states->maxstates * sizeof(xsltStepState)); 490 if (tmp == NULL) { 491 xsltGenericError(xsltGenericErrorContext, 492 "xsltPatPushState: memory re-allocation failure.\n"); 493 ctxt->state = XSLT_STATE_STOPPED; 494 return(-1); 495 } 496 states->states = tmp; 497 states->maxstates *= 2; 498 } 499 states->states[states->nbstates].step = step; 500 states->states[states->nbstates++].node = node; 501 #if 0 502 fprintf(stderr, "Push: %d, %s\n", step, node->name); 503 #endif 504 return(0); 505 } 506 507 /** 508 * xsltTestCompMatchDirect: 509 * @ctxt: a XSLT process context 510 * @comp: the precompiled pattern 511 * @node: a node 512 * @nsList: the namespaces in scope 513 * @nsNr: the number of namespaces in scope 514 * 515 * Test whether the node matches the pattern, do a direct evalutation 516 * and not a step by step evaluation. 517 * 518 * Returns 1 if it matches, 0 if it doesn't and -1 in case of failure 519 */ 520 static int 521 xsltTestCompMatchDirect(xsltTransformContextPtr ctxt, xsltCompMatchPtr comp, 522 xmlNodePtr node, xmlNsPtr *nsList, int nsNr) { 523 xsltStepOpPtr sel = NULL; 524 xmlDocPtr prevdoc; 525 xmlDocPtr doc; 526 xmlXPathObjectPtr list; 527 int ix, j; 528 int nocache = 0; 529 int isRVT; 530 531 doc = node->doc; 532 if (XSLT_IS_RES_TREE_FRAG(doc)) 533 isRVT = 1; 534 else 535 isRVT = 0; 536 sel = &comp->steps[0]; /* store extra in first step arbitrarily */ 537 538 prevdoc = (xmlDocPtr) 539 XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr); 540 ix = XSLT_RUNTIME_EXTRA(ctxt, sel->indexExtra, ival); 541 list = (xmlXPathObjectPtr) 542 XSLT_RUNTIME_EXTRA_LST(ctxt, sel->lenExtra); 543 544 if ((list == NULL) || (prevdoc != doc)) { 545 xmlXPathObjectPtr newlist; 546 xmlNodePtr parent = node->parent; 547 xmlDocPtr olddoc; 548 xmlNodePtr oldnode; 549 int oldNsNr; 550 xmlNsPtr *oldNamespaces; 551 552 oldnode = ctxt->xpathCtxt->node; 553 olddoc = ctxt->xpathCtxt->doc; 554 oldNsNr = ctxt->xpathCtxt->nsNr; 555 oldNamespaces = ctxt->xpathCtxt->namespaces; 556 ctxt->xpathCtxt->node = node; 557 ctxt->xpathCtxt->doc = doc; 558 ctxt->xpathCtxt->namespaces = nsList; 559 ctxt->xpathCtxt->nsNr = nsNr; 560 newlist = xmlXPathEval(comp->pattern, ctxt->xpathCtxt); 561 ctxt->xpathCtxt->node = oldnode; 562 ctxt->xpathCtxt->doc = olddoc; 563 ctxt->xpathCtxt->namespaces = oldNamespaces; 564 ctxt->xpathCtxt->nsNr = oldNsNr; 565 if (newlist == NULL) 566 return(-1); 567 if (newlist->type != XPATH_NODESET) { 568 xmlXPathFreeObject(newlist); 569 return(-1); 570 } 571 ix = 0; 572 573 if ((parent == NULL) || (node->doc == NULL) || isRVT) 574 nocache = 1; 575 576 if (nocache == 0) { 577 if (list != NULL) 578 xmlXPathFreeObject(list); 579 list = newlist; 580 581 XSLT_RUNTIME_EXTRA_LST(ctxt, sel->lenExtra) = 582 (void *) list; 583 XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr) = 584 (void *) doc; 585 XSLT_RUNTIME_EXTRA(ctxt, sel->indexExtra, ival) = 586 0; 587 XSLT_RUNTIME_EXTRA_FREE(ctxt, sel->lenExtra) = 588 (xmlFreeFunc) xmlXPathFreeObject; 589 } else 590 list = newlist; 591 } 592 if ((list->nodesetval == NULL) || 593 (list->nodesetval->nodeNr <= 0)) { 594 if (nocache == 1) 595 xmlXPathFreeObject(list); 596 return(0); 597 } 598 /* TODO: store the index and use it for the scan */ 599 if (ix == 0) { 600 for (j = 0;j < list->nodesetval->nodeNr;j++) { 601 if (list->nodesetval->nodeTab[j] == node) { 602 if (nocache == 1) 603 xmlXPathFreeObject(list); 604 return(1); 605 } 606 } 607 } else { 608 } 609 if (nocache == 1) 610 xmlXPathFreeObject(list); 611 return(0); 612 } 613 614 /** 615 * xsltTestCompMatch: 616 * @ctxt: a XSLT process context 617 * @comp: the precompiled pattern 618 * @node: a node 619 * @mode: the mode name or NULL 620 * @modeURI: the mode URI or NULL 621 * 622 * Test whether the node matches the pattern 623 * 624 * Returns 1 if it matches, 0 if it doesn't and -1 in case of failure 625 */ 626 static int 627 xsltTestCompMatch(xsltTransformContextPtr ctxt, xsltCompMatchPtr comp, 628 xmlNodePtr node, const xmlChar *mode, 629 const xmlChar *modeURI) { 630 int i; 631 xsltStepOpPtr step, sel = NULL; 632 xsltStepStates states = {0, 0, NULL}; /* // may require backtrack */ 633 634 if ((comp == NULL) || (node == NULL) || (ctxt == NULL)) { 635 xsltTransformError(ctxt, NULL, node, 636 "xsltTestCompMatch: null arg\n"); 637 return(-1); 638 } 639 if (mode != NULL) { 640 if (comp->mode == NULL) 641 return(0); 642 /* 643 * both mode strings must be interned on the stylesheet dictionary 644 */ 645 if (comp->mode != mode) 646 return(0); 647 } else { 648 if (comp->mode != NULL) 649 return(0); 650 } 651 if (modeURI != NULL) { 652 if (comp->modeURI == NULL) 653 return(0); 654 /* 655 * both modeURI strings must be interned on the stylesheet dictionary 656 */ 657 if (comp->modeURI != modeURI) 658 return(0); 659 } else { 660 if (comp->modeURI != NULL) 661 return(0); 662 } 663 664 i = 0; 665 restart: 666 for (;i < comp->nbStep;i++) { 667 step = &comp->steps[i]; 668 if (step->op != XSLT_OP_PREDICATE) 669 sel = step; 670 switch (step->op) { 671 case XSLT_OP_END: 672 goto found; 673 case XSLT_OP_ROOT: 674 if ((node->type == XML_DOCUMENT_NODE) || 675 #ifdef LIBXML_DOCB_ENABLED 676 (node->type == XML_DOCB_DOCUMENT_NODE) || 677 #endif 678 (node->type == XML_HTML_DOCUMENT_NODE)) 679 continue; 680 if ((node->type == XML_ELEMENT_NODE) && (node->name[0] == ' ')) 681 continue; 682 goto rollback; 683 case XSLT_OP_ELEM: 684 if (node->type != XML_ELEMENT_NODE) 685 goto rollback; 686 if (step->value == NULL) 687 continue; 688 if (step->value[0] != node->name[0]) 689 goto rollback; 690 if (!xmlStrEqual(step->value, node->name)) 691 goto rollback; 692 693 /* Namespace test */ 694 if (node->ns == NULL) { 695 if (step->value2 != NULL) 696 goto rollback; 697 } else if (node->ns->href != NULL) { 698 if (step->value2 == NULL) 699 goto rollback; 700 if (!xmlStrEqual(step->value2, node->ns->href)) 701 goto rollback; 702 } 703 continue; 704 case XSLT_OP_ATTR: 705 if (node->type != XML_ATTRIBUTE_NODE) 706 goto rollback; 707 if (step->value != NULL) { 708 if (step->value[0] != node->name[0]) 709 goto rollback; 710 if (!xmlStrEqual(step->value, node->name)) 711 goto rollback; 712 } 713 /* Namespace test */ 714 if (node->ns == NULL) { 715 if (step->value2 != NULL) 716 goto rollback; 717 } else if (step->value2 != NULL) { 718 if (!xmlStrEqual(step->value2, node->ns->href)) 719 goto rollback; 720 } 721 continue; 722 case XSLT_OP_PARENT: 723 if ((node->type == XML_DOCUMENT_NODE) || 724 (node->type == XML_HTML_DOCUMENT_NODE) || 725 #ifdef LIBXML_DOCB_ENABLED 726 (node->type == XML_DOCB_DOCUMENT_NODE) || 727 #endif 728 (node->type == XML_NAMESPACE_DECL)) 729 goto rollback; 730 node = node->parent; 731 if (node == NULL) 732 goto rollback; 733 if (step->value == NULL) 734 continue; 735 if (step->value[0] != node->name[0]) 736 goto rollback; 737 if (!xmlStrEqual(step->value, node->name)) 738 goto rollback; 739 /* Namespace test */ 740 if (node->ns == NULL) { 741 if (step->value2 != NULL) 742 goto rollback; 743 } else if (node->ns->href != NULL) { 744 if (step->value2 == NULL) 745 goto rollback; 746 if (!xmlStrEqual(step->value2, node->ns->href)) 747 goto rollback; 748 } 749 continue; 750 case XSLT_OP_ANCESTOR: 751 /* TODO: implement coalescing of ANCESTOR/NODE ops */ 752 if (step->value == NULL) { 753 step = &comp->steps[i+1]; 754 if (step->op == XSLT_OP_ROOT) 755 goto found; 756 /* added NS, ID and KEY as a result of bug 168208 */ 757 if ((step->op != XSLT_OP_ELEM) && 758 (step->op != XSLT_OP_ALL) && 759 (step->op != XSLT_OP_NS) && 760 (step->op != XSLT_OP_ID) && 761 (step->op != XSLT_OP_KEY)) 762 goto rollback; 763 } 764 if (node == NULL) 765 goto rollback; 766 if ((node->type == XML_DOCUMENT_NODE) || 767 (node->type == XML_HTML_DOCUMENT_NODE) || 768 #ifdef LIBXML_DOCB_ENABLED 769 (node->type == XML_DOCB_DOCUMENT_NODE) || 770 #endif 771 (node->type == XML_NAMESPACE_DECL)) 772 goto rollback; 773 node = node->parent; 774 if ((step->op != XSLT_OP_ELEM) && step->op != XSLT_OP_ALL) { 775 xsltPatPushState(ctxt, &states, i, node); 776 continue; 777 } 778 i++; 779 if (step->value == NULL) { 780 xsltPatPushState(ctxt, &states, i - 1, node); 781 continue; 782 } 783 while (node != NULL) { 784 if ((node->type == XML_ELEMENT_NODE) && 785 (step->value[0] == node->name[0]) && 786 (xmlStrEqual(step->value, node->name))) { 787 /* Namespace test */ 788 if (node->ns == NULL) { 789 if (step->value2 == NULL) 790 break; 791 } else if (node->ns->href != NULL) { 792 if ((step->value2 != NULL) && 793 (xmlStrEqual(step->value2, node->ns->href))) 794 break; 795 } 796 } 797 node = node->parent; 798 } 799 if (node == NULL) 800 goto rollback; 801 xsltPatPushState(ctxt, &states, i - 1, node); 802 continue; 803 case XSLT_OP_ID: { 804 /* TODO Handle IDs decently, must be done differently */ 805 xmlAttrPtr id; 806 807 if (node->type != XML_ELEMENT_NODE) 808 goto rollback; 809 810 id = xmlGetID(node->doc, step->value); 811 if ((id == NULL) || (id->parent != node)) 812 goto rollback; 813 break; 814 } 815 case XSLT_OP_KEY: { 816 xmlNodeSetPtr list; 817 int indx; 818 819 list = xsltGetKey(ctxt, step->value, 820 step->value3, step->value2); 821 if (list == NULL) 822 goto rollback; 823 for (indx = 0;indx < list->nodeNr;indx++) 824 if (list->nodeTab[indx] == node) 825 break; 826 if (indx >= list->nodeNr) 827 goto rollback; 828 break; 829 } 830 case XSLT_OP_NS: 831 if (node->type != XML_ELEMENT_NODE) 832 goto rollback; 833 if (node->ns == NULL) { 834 if (step->value != NULL) 835 goto rollback; 836 } else if (node->ns->href != NULL) { 837 if (step->value == NULL) 838 goto rollback; 839 if (!xmlStrEqual(step->value, node->ns->href)) 840 goto rollback; 841 } 842 break; 843 case XSLT_OP_ALL: 844 if (node->type != XML_ELEMENT_NODE) 845 goto rollback; 846 break; 847 case XSLT_OP_PREDICATE: { 848 xmlNodePtr oldNode; 849 xmlDocPtr doc; 850 int oldCS, oldCP; 851 int pos = 0, len = 0; 852 int isRVT; 853 854 /* 855 * when there is cascading XSLT_OP_PREDICATE, then use a 856 * direct computation approach. It's not done directly 857 * at the beginning of the routine to filter out as much 858 * as possible this costly computation. 859 */ 860 if (comp->direct) { 861 if (states.states != NULL) { 862 /* Free the rollback states */ 863 xmlFree(states.states); 864 } 865 return(xsltTestCompMatchDirect(ctxt, comp, node, 866 comp->nsList, comp->nsNr)); 867 } 868 869 doc = node->doc; 870 if (XSLT_IS_RES_TREE_FRAG(doc)) 871 isRVT = 1; 872 else 873 isRVT = 0; 874 875 /* 876 * Depending on the last selection, one may need to 877 * recompute contextSize and proximityPosition. 878 */ 879 oldCS = ctxt->xpathCtxt->contextSize; 880 oldCP = ctxt->xpathCtxt->proximityPosition; 881 if ((sel != NULL) && 882 (sel->op == XSLT_OP_ELEM) && 883 (sel->value != NULL) && 884 (node->type == XML_ELEMENT_NODE) && 885 (node->parent != NULL)) { 886 xmlNodePtr previous; 887 int ix, nocache = 0; 888 889 previous = (xmlNodePtr) 890 XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr); 891 ix = XSLT_RUNTIME_EXTRA(ctxt, sel->indexExtra, ival); 892 if ((previous != NULL) && 893 (previous->parent == node->parent)) { 894 /* 895 * just walk back to adjust the index 896 */ 897 int indx = 0; 898 xmlNodePtr sibling = node; 899 900 while (sibling != NULL) { 901 if (sibling == previous) 902 break; 903 if ((previous->type == XML_ELEMENT_NODE) && 904 (previous->name != NULL) && 905 (sibling->name != NULL) && 906 (previous->name[0] == sibling->name[0]) && 907 (xmlStrEqual(previous->name, sibling->name))) 908 { 909 if ((sel->value2 == NULL) || 910 ((sibling->ns != NULL) && 911 (xmlStrEqual(sel->value2, 912 sibling->ns->href)))) 913 indx++; 914 } 915 sibling = sibling->prev; 916 } 917 if (sibling == NULL) { 918 /* hum going backward in document order ... */ 919 indx = 0; 920 sibling = node; 921 while (sibling != NULL) { 922 if (sibling == previous) 923 break; 924 if ((previous->type == XML_ELEMENT_NODE) && 925 (previous->name != NULL) && 926 (sibling->name != NULL) && 927 (previous->name[0] == sibling->name[0]) && 928 (xmlStrEqual(previous->name, sibling->name))) 929 { 930 if ((sel->value2 == NULL) || 931 ((sibling->ns != NULL) && 932 (xmlStrEqual(sel->value2, 933 sibling->ns->href)))) 934 { 935 indx--; 936 } 937 } 938 sibling = sibling->next; 939 } 940 } 941 if (sibling != NULL) { 942 pos = ix + indx; 943 /* 944 * If the node is in a Value Tree we need to 945 * save len, but cannot cache the node! 946 * (bugs 153137 and 158840) 947 */ 948 if (node->doc != NULL) { 949 len = XSLT_RUNTIME_EXTRA(ctxt, 950 sel->lenExtra, ival); 951 if (!isRVT) { 952 XSLT_RUNTIME_EXTRA(ctxt, 953 sel->previousExtra, ptr) = node; 954 XSLT_RUNTIME_EXTRA(ctxt, 955 sel->indexExtra, ival) = pos; 956 } 957 } 958 ix = pos; 959 } else 960 pos = 0; 961 } else { 962 /* 963 * recompute the index 964 */ 965 xmlNodePtr parent = node->parent; 966 xmlNodePtr siblings = NULL; 967 968 if (parent) siblings = parent->children; 969 970 while (siblings != NULL) { 971 if (siblings->type == XML_ELEMENT_NODE) { 972 if (siblings == node) { 973 len++; 974 pos = len; 975 } else if ((node->name != NULL) && 976 (siblings->name != NULL) && 977 (node->name[0] == siblings->name[0]) && 978 (xmlStrEqual(node->name, siblings->name))) { 979 if ((sel->value2 == NULL) || 980 ((siblings->ns != NULL) && 981 (xmlStrEqual(sel->value2, 982 siblings->ns->href)))) 983 len++; 984 } 985 } 986 siblings = siblings->next; 987 } 988 if ((parent == NULL) || (node->doc == NULL)) 989 nocache = 1; 990 else { 991 while (parent->parent != NULL) 992 parent = parent->parent; 993 if (((parent->type != XML_DOCUMENT_NODE) && 994 (parent->type != XML_HTML_DOCUMENT_NODE)) || 995 (parent != (xmlNodePtr) node->doc)) 996 nocache = 1; 997 } 998 } 999 if (pos != 0) { 1000 ctxt->xpathCtxt->contextSize = len; 1001 ctxt->xpathCtxt->proximityPosition = pos; 1002 /* 1003 * If the node is in a Value Tree we cannot 1004 * cache it ! 1005 */ 1006 if ((!isRVT) && (node->doc != NULL) && 1007 (nocache == 0)) { 1008 XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr) = 1009 node; 1010 XSLT_RUNTIME_EXTRA(ctxt, sel->indexExtra, ival) = 1011 pos; 1012 XSLT_RUNTIME_EXTRA(ctxt, sel->lenExtra, ival) = 1013 len; 1014 } 1015 } 1016 } else if ((sel != NULL) && (sel->op == XSLT_OP_ALL) && 1017 (node->type == XML_ELEMENT_NODE)) { 1018 xmlNodePtr previous; 1019 int ix, nocache = 0; 1020 1021 previous = (xmlNodePtr) 1022 XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr); 1023 ix = XSLT_RUNTIME_EXTRA(ctxt, sel->indexExtra, ival); 1024 if ((previous != NULL) && 1025 (previous->parent == node->parent)) { 1026 /* 1027 * just walk back to adjust the index 1028 */ 1029 int indx = 0; 1030 xmlNodePtr sibling = node; 1031 1032 while (sibling != NULL) { 1033 if (sibling == previous) 1034 break; 1035 if (sibling->type == XML_ELEMENT_NODE) 1036 indx++; 1037 sibling = sibling->prev; 1038 } 1039 if (sibling == NULL) { 1040 /* hum going backward in document order ... */ 1041 indx = 0; 1042 sibling = node; 1043 while (sibling != NULL) { 1044 if (sibling == previous) 1045 break; 1046 if (sibling->type == XML_ELEMENT_NODE) 1047 indx--; 1048 sibling = sibling->next; 1049 } 1050 } 1051 if (sibling != NULL) { 1052 pos = ix + indx; 1053 /* 1054 * If the node is in a Value Tree we cannot 1055 * cache it ! 1056 */ 1057 if ((node->doc != NULL) && !isRVT) { 1058 len = XSLT_RUNTIME_EXTRA(ctxt, 1059 sel->lenExtra, ival); 1060 XSLT_RUNTIME_EXTRA(ctxt, 1061 sel->previousExtra, ptr) = node; 1062 XSLT_RUNTIME_EXTRA(ctxt, 1063 sel->indexExtra, ival) = pos; 1064 } 1065 } else 1066 pos = 0; 1067 } else { 1068 /* 1069 * recompute the index 1070 */ 1071 xmlNodePtr parent = node->parent; 1072 xmlNodePtr siblings = NULL; 1073 1074 if (parent) siblings = parent->children; 1075 1076 while (siblings != NULL) { 1077 if (siblings->type == XML_ELEMENT_NODE) { 1078 len++; 1079 if (siblings == node) { 1080 pos = len; 1081 } 1082 } 1083 siblings = siblings->next; 1084 } 1085 if ((parent == NULL) || (node->doc == NULL)) 1086 nocache = 1; 1087 else { 1088 while (parent->parent != NULL) 1089 parent = parent->parent; 1090 if (((parent->type != XML_DOCUMENT_NODE) && 1091 (parent->type != XML_HTML_DOCUMENT_NODE)) || 1092 (parent != (xmlNodePtr) node->doc)) 1093 nocache = 1; 1094 } 1095 } 1096 if (pos != 0) { 1097 ctxt->xpathCtxt->contextSize = len; 1098 ctxt->xpathCtxt->proximityPosition = pos; 1099 /* 1100 * If the node is in a Value Tree we cannot 1101 * cache it ! 1102 */ 1103 if ((node->doc != NULL) && (nocache == 0) && !isRVT) { 1104 XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr) = 1105 node; 1106 XSLT_RUNTIME_EXTRA(ctxt, sel->indexExtra, ival) = 1107 pos; 1108 XSLT_RUNTIME_EXTRA(ctxt, sel->lenExtra, ival) = 1109 len; 1110 } 1111 } 1112 } 1113 oldNode = ctxt->node; 1114 ctxt->node = node; 1115 1116 if (step->value == NULL) 1117 goto wrong_index; 1118 if (step->comp == NULL) 1119 goto wrong_index; 1120 1121 if (!xsltEvalXPathPredicate(ctxt, step->comp, comp->nsList, 1122 comp->nsNr)) 1123 goto wrong_index; 1124 1125 if (pos != 0) { 1126 ctxt->xpathCtxt->contextSize = oldCS; 1127 ctxt->xpathCtxt->proximityPosition = oldCP; 1128 } 1129 ctxt->node = oldNode; 1130 break; 1131 wrong_index: 1132 if (pos != 0) { 1133 ctxt->xpathCtxt->contextSize = oldCS; 1134 ctxt->xpathCtxt->proximityPosition = oldCP; 1135 } 1136 ctxt->node = oldNode; 1137 goto rollback; 1138 } 1139 case XSLT_OP_PI: 1140 if (node->type != XML_PI_NODE) 1141 goto rollback; 1142 if (step->value != NULL) { 1143 if (!xmlStrEqual(step->value, node->name)) 1144 goto rollback; 1145 } 1146 break; 1147 case XSLT_OP_COMMENT: 1148 if (node->type != XML_COMMENT_NODE) 1149 goto rollback; 1150 break; 1151 case XSLT_OP_TEXT: 1152 if ((node->type != XML_TEXT_NODE) && 1153 (node->type != XML_CDATA_SECTION_NODE)) 1154 goto rollback; 1155 break; 1156 case XSLT_OP_NODE: 1157 switch (node->type) { 1158 case XML_ELEMENT_NODE: 1159 case XML_CDATA_SECTION_NODE: 1160 case XML_PI_NODE: 1161 case XML_COMMENT_NODE: 1162 case XML_TEXT_NODE: 1163 break; 1164 default: 1165 goto rollback; 1166 } 1167 break; 1168 } 1169 } 1170 found: 1171 if (states.states != NULL) { 1172 /* Free the rollback states */ 1173 xmlFree(states.states); 1174 } 1175 return(1); 1176 rollback: 1177 /* got an error try to rollback */ 1178 if (states.states == NULL) 1179 return(0); 1180 if (states.nbstates <= 0) { 1181 xmlFree(states.states); 1182 return(0); 1183 } 1184 states.nbstates--; 1185 i = states.states[states.nbstates].step; 1186 node = states.states[states.nbstates].node; 1187 #if 0 1188 fprintf(stderr, "Pop: %d, %s\n", i, node->name); 1189 #endif 1190 goto restart; 1191 } 1192 1193 /** 1194 * xsltTestCompMatchList: 1195 * @ctxt: a XSLT process context 1196 * @node: a node 1197 * @comp: the precompiled pattern list 1198 * 1199 * Test whether the node matches one of the patterns in the list 1200 * 1201 * Returns 1 if it matches, 0 if it doesn't and -1 in case of failure 1202 */ 1203 int 1204 xsltTestCompMatchList(xsltTransformContextPtr ctxt, xmlNodePtr node, 1205 xsltCompMatchPtr comp) { 1206 int ret; 1207 1208 if ((ctxt == NULL) || (node == NULL)) 1209 return(-1); 1210 while (comp != NULL) { 1211 ret = xsltTestCompMatch(ctxt, comp, node, NULL, NULL); 1212 if (ret == 1) 1213 return(1); 1214 comp = comp->next; 1215 } 1216 return(0); 1217 } 1218 1219 /************************************************************************ 1220 * * 1221 * Dedicated parser for templates * 1222 * * 1223 ************************************************************************/ 1224 1225 #define CUR (*ctxt->cur) 1226 #define SKIP(val) ctxt->cur += (val) 1227 #define NXT(val) ctxt->cur[(val)] 1228 #define CUR_PTR ctxt->cur 1229 1230 #define SKIP_BLANKS \ 1231 while (IS_BLANK_CH(CUR)) NEXT 1232 1233 #define CURRENT (*ctxt->cur) 1234 #define NEXT ((*ctxt->cur) ? ctxt->cur++: ctxt->cur) 1235 1236 1237 #define PUSH(op, val, val2, novar) \ 1238 if (xsltCompMatchAdd(ctxt, ctxt->comp, (op), (val), (val2), (novar))) goto error; 1239 1240 #define SWAP() \ 1241 xsltSwapTopCompMatch(ctxt->comp); 1242 1243 #define XSLT_ERROR(X) \ 1244 { xsltError(ctxt, __FILE__, __LINE__, X); \ 1245 ctxt->error = (X); return; } 1246 1247 #define XSLT_ERROR0(X) \ 1248 { xsltError(ctxt, __FILE__, __LINE__, X); \ 1249 ctxt->error = (X); return(0); } 1250 1251 /** 1252 * xsltScanLiteral: 1253 * @ctxt: the XPath Parser context 1254 * 1255 * Parse an XPath Litteral: 1256 * 1257 * [29] Literal ::= '"' [^"]* '"' 1258 * | "'" [^']* "'" 1259 * 1260 * Returns the Literal parsed or NULL 1261 */ 1262 1263 static xmlChar * 1264 xsltScanLiteral(xsltParserContextPtr ctxt) { 1265 const xmlChar *q, *cur; 1266 xmlChar *ret = NULL; 1267 int val, len; 1268 1269 SKIP_BLANKS; 1270 if (CUR == '"') { 1271 NEXT; 1272 cur = q = CUR_PTR; 1273 val = xmlStringCurrentChar(NULL, cur, &len); 1274 while ((IS_CHAR(val)) && (val != '"')) { 1275 cur += len; 1276 val = xmlStringCurrentChar(NULL, cur, &len); 1277 } 1278 if (!IS_CHAR(val)) { 1279 ctxt->error = 1; 1280 return(NULL); 1281 } else { 1282 ret = xmlStrndup(q, cur - q); 1283 } 1284 cur += len; 1285 CUR_PTR = cur; 1286 } else if (CUR == '\'') { 1287 NEXT; 1288 cur = q = CUR_PTR; 1289 val = xmlStringCurrentChar(NULL, cur, &len); 1290 while ((IS_CHAR(val)) && (val != '\'')) { 1291 cur += len; 1292 val = xmlStringCurrentChar(NULL, cur, &len); 1293 } 1294 if (!IS_CHAR(val)) { 1295 ctxt->error = 1; 1296 return(NULL); 1297 } else { 1298 ret = xmlStrndup(q, cur - q); 1299 } 1300 cur += len; 1301 CUR_PTR = cur; 1302 } else { 1303 /* XP_ERROR(XPATH_START_LITERAL_ERROR); */ 1304 ctxt->error = 1; 1305 return(NULL); 1306 } 1307 return(ret); 1308 } 1309 1310 /** 1311 * xsltScanNCName: 1312 * @ctxt: the XPath Parser context 1313 * 1314 * Parses a non qualified name 1315 * 1316 * Returns the Name parsed or NULL 1317 */ 1318 1319 static xmlChar * 1320 xsltScanNCName(xsltParserContextPtr ctxt) { 1321 const xmlChar *q, *cur; 1322 xmlChar *ret = NULL; 1323 int val, len; 1324 1325 SKIP_BLANKS; 1326 1327 cur = q = CUR_PTR; 1328 val = xmlStringCurrentChar(NULL, cur, &len); 1329 if (!IS_LETTER(val) && (val != '_')) 1330 return(NULL); 1331 1332 while ((IS_LETTER(val)) || (IS_DIGIT(val)) || 1333 (val == '.') || (val == '-') || 1334 (val == '_') || 1335 (IS_COMBINING(val)) || 1336 (IS_EXTENDER(val))) { 1337 cur += len; 1338 val = xmlStringCurrentChar(NULL, cur, &len); 1339 } 1340 ret = xmlStrndup(q, cur - q); 1341 CUR_PTR = cur; 1342 return(ret); 1343 } 1344 1345 /* 1346 * xsltCompileIdKeyPattern: 1347 * @ctxt: the compilation context 1348 * @name: a preparsed name 1349 * @aid: whether id/key are allowed there 1350 * @novar: flag to prohibit xslt var 1351 * 1352 * Compile the XSLT LocationIdKeyPattern 1353 * [3] IdKeyPattern ::= 'id' '(' Literal ')' 1354 * | 'key' '(' Literal ',' Literal ')' 1355 * 1356 * also handle NodeType and PI from: 1357 * 1358 * [7] NodeTest ::= NameTest 1359 * | NodeType '(' ')' 1360 * | 'processing-instruction' '(' Literal ')' 1361 */ 1362 static void 1363 xsltCompileIdKeyPattern(xsltParserContextPtr ctxt, xmlChar *name, 1364 int aid, int novar, xsltAxis axis) { 1365 xmlChar *lit = NULL; 1366 xmlChar *lit2 = NULL; 1367 1368 if (CUR != '(') { 1369 xsltTransformError(NULL, NULL, NULL, 1370 "xsltCompileIdKeyPattern : ( expected\n"); 1371 ctxt->error = 1; 1372 return; 1373 } 1374 if ((aid) && (xmlStrEqual(name, (const xmlChar *)"id"))) { 1375 if (axis != 0) { 1376 xsltTransformError(NULL, NULL, NULL, 1377 "xsltCompileIdKeyPattern : NodeTest expected\n"); 1378 ctxt->error = 1; 1379 return; 1380 } 1381 NEXT; 1382 SKIP_BLANKS; 1383 lit = xsltScanLiteral(ctxt); 1384 if (ctxt->error) 1385 return; 1386 SKIP_BLANKS; 1387 if (CUR != ')') { 1388 xsltTransformError(NULL, NULL, NULL, 1389 "xsltCompileIdKeyPattern : ) expected\n"); 1390 ctxt->error = 1; 1391 return; 1392 } 1393 NEXT; 1394 PUSH(XSLT_OP_ID, lit, NULL, novar); 1395 } else if ((aid) && (xmlStrEqual(name, (const xmlChar *)"key"))) { 1396 if (axis != 0) { 1397 xsltTransformError(NULL, NULL, NULL, 1398 "xsltCompileIdKeyPattern : NodeTest expected\n"); 1399 ctxt->error = 1; 1400 return; 1401 } 1402 NEXT; 1403 SKIP_BLANKS; 1404 lit = xsltScanLiteral(ctxt); 1405 if (ctxt->error) 1406 return; 1407 SKIP_BLANKS; 1408 if (CUR != ',') { 1409 xsltTransformError(NULL, NULL, NULL, 1410 "xsltCompileIdKeyPattern : , expected\n"); 1411 ctxt->error = 1; 1412 return; 1413 } 1414 NEXT; 1415 SKIP_BLANKS; 1416 lit2 = xsltScanLiteral(ctxt); 1417 if (ctxt->error) 1418 return; 1419 SKIP_BLANKS; 1420 if (CUR != ')') { 1421 xsltTransformError(NULL, NULL, NULL, 1422 "xsltCompileIdKeyPattern : ) expected\n"); 1423 ctxt->error = 1; 1424 return; 1425 } 1426 NEXT; 1427 /* URGENT TODO: support namespace in keys */ 1428 PUSH(XSLT_OP_KEY, lit, lit2, novar); 1429 } else if (xmlStrEqual(name, (const xmlChar *)"processing-instruction")) { 1430 NEXT; 1431 SKIP_BLANKS; 1432 if (CUR != ')') { 1433 lit = xsltScanLiteral(ctxt); 1434 if (ctxt->error) 1435 return; 1436 SKIP_BLANKS; 1437 if (CUR != ')') { 1438 xsltTransformError(NULL, NULL, NULL, 1439 "xsltCompileIdKeyPattern : ) expected\n"); 1440 ctxt->error = 1; 1441 return; 1442 } 1443 } 1444 NEXT; 1445 PUSH(XSLT_OP_PI, lit, NULL, novar); 1446 } else if (xmlStrEqual(name, (const xmlChar *)"text")) { 1447 NEXT; 1448 SKIP_BLANKS; 1449 if (CUR != ')') { 1450 xsltTransformError(NULL, NULL, NULL, 1451 "xsltCompileIdKeyPattern : ) expected\n"); 1452 ctxt->error = 1; 1453 return; 1454 } 1455 NEXT; 1456 PUSH(XSLT_OP_TEXT, NULL, NULL, novar); 1457 } else if (xmlStrEqual(name, (const xmlChar *)"comment")) { 1458 NEXT; 1459 SKIP_BLANKS; 1460 if (CUR != ')') { 1461 xsltTransformError(NULL, NULL, NULL, 1462 "xsltCompileIdKeyPattern : ) expected\n"); 1463 ctxt->error = 1; 1464 return; 1465 } 1466 NEXT; 1467 PUSH(XSLT_OP_COMMENT, NULL, NULL, novar); 1468 } else if (xmlStrEqual(name, (const xmlChar *)"node")) { 1469 NEXT; 1470 SKIP_BLANKS; 1471 if (CUR != ')') { 1472 xsltTransformError(NULL, NULL, NULL, 1473 "xsltCompileIdKeyPattern : ) expected\n"); 1474 ctxt->error = 1; 1475 return; 1476 } 1477 NEXT; 1478 if (axis == AXIS_ATTRIBUTE) { 1479 PUSH(XSLT_OP_ATTR, NULL, NULL, novar); 1480 } 1481 else { 1482 PUSH(XSLT_OP_NODE, NULL, NULL, novar); 1483 } 1484 } else if (aid) { 1485 xsltTransformError(NULL, NULL, NULL, 1486 "xsltCompileIdKeyPattern : expecting 'key' or 'id' or node type\n"); 1487 ctxt->error = 1; 1488 return; 1489 } else { 1490 xsltTransformError(NULL, NULL, NULL, 1491 "xsltCompileIdKeyPattern : node type\n"); 1492 ctxt->error = 1; 1493 return; 1494 } 1495 error: 1496 if (name != NULL) 1497 xmlFree(name); 1498 } 1499 1500 /** 1501 * xsltCompileStepPattern: 1502 * @ctxt: the compilation context 1503 * @token: a posible precompiled name 1504 * @novar: flag to prohibit xslt variables from pattern 1505 * 1506 * Compile the XSLT StepPattern and generates a precompiled 1507 * form suitable for fast matching. 1508 * 1509 * [5] StepPattern ::= ChildOrAttributeAxisSpecifier NodeTest Predicate* 1510 * [6] ChildOrAttributeAxisSpecifier ::= AbbreviatedAxisSpecifier 1511 * | ('child' | 'attribute') '::' 1512 * from XPath 1513 * [7] NodeTest ::= NameTest 1514 * | NodeType '(' ')' 1515 * | 'processing-instruction' '(' Literal ')' 1516 * [8] Predicate ::= '[' PredicateExpr ']' 1517 * [9] PredicateExpr ::= Expr 1518 * [13] AbbreviatedAxisSpecifier ::= '@'? 1519 * [37] NameTest ::= '*' | NCName ':' '*' | QName 1520 */ 1521 1522 static void 1523 xsltCompileStepPattern(xsltParserContextPtr ctxt, xmlChar *token, int novar) { 1524 xmlChar *name = NULL; 1525 const xmlChar *URI = NULL; 1526 xmlChar *URL = NULL; 1527 int level; 1528 xsltAxis axis = 0; 1529 1530 SKIP_BLANKS; 1531 if ((token == NULL) && (CUR == '@')) { 1532 NEXT; 1533 axis = AXIS_ATTRIBUTE; 1534 } 1535 parse_node_test: 1536 if (token == NULL) 1537 token = xsltScanNCName(ctxt); 1538 if (token == NULL) { 1539 if (CUR == '*') { 1540 NEXT; 1541 if (axis == AXIS_ATTRIBUTE) { 1542 PUSH(XSLT_OP_ATTR, NULL, NULL, novar); 1543 } 1544 else { 1545 PUSH(XSLT_OP_ALL, NULL, NULL, novar); 1546 } 1547 goto parse_predicate; 1548 } else { 1549 xsltTransformError(NULL, NULL, NULL, 1550 "xsltCompileStepPattern : Name expected\n"); 1551 ctxt->error = 1; 1552 goto error; 1553 } 1554 } 1555 1556 1557 SKIP_BLANKS; 1558 if (CUR == '(') { 1559 xsltCompileIdKeyPattern(ctxt, token, 0, novar, axis); 1560 if (ctxt->error) 1561 goto error; 1562 } else if (CUR == ':') { 1563 NEXT; 1564 if (CUR != ':') { 1565 xmlChar *prefix = token; 1566 xmlNsPtr ns; 1567 1568 /* 1569 * This is a namespace match 1570 */ 1571 token = xsltScanNCName(ctxt); 1572 ns = xmlSearchNs(ctxt->doc, ctxt->elem, prefix); 1573 if (ns == NULL) { 1574 xsltTransformError(NULL, NULL, NULL, 1575 "xsltCompileStepPattern : no namespace bound to prefix %s\n", 1576 prefix); 1577 xmlFree(prefix); 1578 ctxt->error = 1; 1579 goto error; 1580 } else { 1581 URL = xmlStrdup(ns->href); 1582 } 1583 xmlFree(prefix); 1584 if (token == NULL) { 1585 if (CUR == '*') { 1586 NEXT; 1587 if (axis == AXIS_ATTRIBUTE) { 1588 PUSH(XSLT_OP_ATTR, NULL, URL, novar); 1589 } 1590 else { 1591 PUSH(XSLT_OP_NS, URL, NULL, novar); 1592 } 1593 } else { 1594 xsltTransformError(NULL, NULL, NULL, 1595 "xsltCompileStepPattern : Name expected\n"); 1596 ctxt->error = 1; 1597 goto error; 1598 } 1599 } else { 1600 if (axis == AXIS_ATTRIBUTE) { 1601 PUSH(XSLT_OP_ATTR, token, URL, novar); 1602 } 1603 else { 1604 PUSH(XSLT_OP_ELEM, token, URL, novar); 1605 } 1606 } 1607 } else { 1608 if (axis != 0) { 1609 xsltTransformError(NULL, NULL, NULL, 1610 "xsltCompileStepPattern : NodeTest expected\n"); 1611 ctxt->error = 1; 1612 goto error; 1613 } 1614 NEXT; 1615 if (xmlStrEqual(token, (const xmlChar *) "child")) { 1616 axis = AXIS_CHILD; 1617 } else if (xmlStrEqual(token, (const xmlChar *) "attribute")) { 1618 axis = AXIS_ATTRIBUTE; 1619 } else { 1620 xsltTransformError(NULL, NULL, NULL, 1621 "xsltCompileStepPattern : 'child' or 'attribute' expected\n"); 1622 ctxt->error = 1; 1623 goto error; 1624 } 1625 xmlFree(token); 1626 SKIP_BLANKS; 1627 token = xsltScanNCName(ctxt); 1628 goto parse_node_test; 1629 } 1630 } else { 1631 URI = xsltGetQNameURI(ctxt->elem, &token); 1632 if (token == NULL) { 1633 ctxt->error = 1; 1634 goto error; 1635 } 1636 if (URI != NULL) 1637 URL = xmlStrdup(URI); 1638 if (axis == AXIS_ATTRIBUTE) { 1639 PUSH(XSLT_OP_ATTR, token, URL, novar); 1640 } 1641 else { 1642 PUSH(XSLT_OP_ELEM, token, URL, novar); 1643 } 1644 } 1645 parse_predicate: 1646 SKIP_BLANKS; 1647 level = 0; 1648 while (CUR == '[') { 1649 const xmlChar *q; 1650 xmlChar *ret = NULL; 1651 1652 level++; 1653 NEXT; 1654 q = CUR_PTR; 1655 while (CUR != 0) { 1656 /* Skip over nested predicates */ 1657 if (CUR == '[') 1658 level++; 1659 else if (CUR == ']') { 1660 level--; 1661 if (level == 0) 1662 break; 1663 } else if (CUR == '"') { 1664 NEXT; 1665 while ((CUR != 0) && (CUR != '"')) 1666 NEXT; 1667 } else if (CUR == '\'') { 1668 NEXT; 1669 while ((CUR != 0) && (CUR != '\'')) 1670 NEXT; 1671 } 1672 NEXT; 1673 } 1674 if (CUR == 0) { 1675 xsltTransformError(NULL, NULL, NULL, 1676 "xsltCompileStepPattern : ']' expected\n"); 1677 ctxt->error = 1; 1678 return; 1679 } 1680 ret = xmlStrndup(q, CUR_PTR - q); 1681 PUSH(XSLT_OP_PREDICATE, ret, NULL, novar); 1682 /* push the predicate lower than local test */ 1683 SWAP(); 1684 NEXT; 1685 SKIP_BLANKS; 1686 } 1687 return; 1688 error: 1689 if (token != NULL) 1690 xmlFree(token); 1691 if (name != NULL) 1692 xmlFree(name); 1693 } 1694 1695 /** 1696 * xsltCompileRelativePathPattern: 1697 * @comp: the compilation context 1698 * @token: a posible precompiled name 1699 * @novar: flag to prohibit xslt variables 1700 * 1701 * Compile the XSLT RelativePathPattern and generates a precompiled 1702 * form suitable for fast matching. 1703 * 1704 * [4] RelativePathPattern ::= StepPattern 1705 * | RelativePathPattern '/' StepPattern 1706 * | RelativePathPattern '//' StepPattern 1707 */ 1708 static void 1709 xsltCompileRelativePathPattern(xsltParserContextPtr ctxt, xmlChar *token, int novar) { 1710 xsltCompileStepPattern(ctxt, token, novar); 1711 if (ctxt->error) 1712 goto error; 1713 SKIP_BLANKS; 1714 while ((CUR != 0) && (CUR != '|')) { 1715 if ((CUR == '/') && (NXT(1) == '/')) { 1716 PUSH(XSLT_OP_ANCESTOR, NULL, NULL, novar); 1717 NEXT; 1718 NEXT; 1719 SKIP_BLANKS; 1720 xsltCompileStepPattern(ctxt, NULL, novar); 1721 } else if (CUR == '/') { 1722 PUSH(XSLT_OP_PARENT, NULL, NULL, novar); 1723 NEXT; 1724 SKIP_BLANKS; 1725 if ((CUR != 0) && (CUR != '|')) { 1726 xsltCompileRelativePathPattern(ctxt, NULL, novar); 1727 } 1728 } else { 1729 ctxt->error = 1; 1730 } 1731 if (ctxt->error) 1732 goto error; 1733 SKIP_BLANKS; 1734 } 1735 error: 1736 return; 1737 } 1738 1739 /** 1740 * xsltCompileLocationPathPattern: 1741 * @ctxt: the compilation context 1742 * @novar: flag to prohibit xslt variables 1743 * 1744 * Compile the XSLT LocationPathPattern and generates a precompiled 1745 * form suitable for fast matching. 1746 * 1747 * [2] LocationPathPattern ::= '/' RelativePathPattern? 1748 * | IdKeyPattern (('/' | '//') RelativePathPattern)? 1749 * | '//'? RelativePathPattern 1750 */ 1751 static void 1752 xsltCompileLocationPathPattern(xsltParserContextPtr ctxt, int novar) { 1753 SKIP_BLANKS; 1754 if ((CUR == '/') && (NXT(1) == '/')) { 1755 /* 1756 * since we reverse the query 1757 * a leading // can be safely ignored 1758 */ 1759 NEXT; 1760 NEXT; 1761 ctxt->comp->priority = 0.5; /* '//' means not 0 priority */ 1762 xsltCompileRelativePathPattern(ctxt, NULL, novar); 1763 } else if (CUR == '/') { 1764 /* 1765 * We need to find root as the parent 1766 */ 1767 NEXT; 1768 SKIP_BLANKS; 1769 PUSH(XSLT_OP_ROOT, NULL, NULL, novar); 1770 if ((CUR != 0) && (CUR != '|')) { 1771 PUSH(XSLT_OP_PARENT, NULL, NULL, novar); 1772 xsltCompileRelativePathPattern(ctxt, NULL, novar); 1773 } 1774 } else if (CUR == '*') { 1775 xsltCompileRelativePathPattern(ctxt, NULL, novar); 1776 } else if (CUR == '@') { 1777 xsltCompileRelativePathPattern(ctxt, NULL, novar); 1778 } else { 1779 xmlChar *name; 1780 name = xsltScanNCName(ctxt); 1781 if (name == NULL) { 1782 xsltTransformError(NULL, NULL, NULL, 1783 "xsltCompileLocationPathPattern : Name expected\n"); 1784 ctxt->error = 1; 1785 return; 1786 } 1787 SKIP_BLANKS; 1788 if ((CUR == '(') && !xmlXPathIsNodeType(name)) { 1789 xsltCompileIdKeyPattern(ctxt, name, 1, novar, 0); 1790 if ((CUR == '/') && (NXT(1) == '/')) { 1791 PUSH(XSLT_OP_ANCESTOR, NULL, NULL, novar); 1792 NEXT; 1793 NEXT; 1794 SKIP_BLANKS; 1795 xsltCompileRelativePathPattern(ctxt, NULL, novar); 1796 } else if (CUR == '/') { 1797 PUSH(XSLT_OP_PARENT, NULL, NULL, novar); 1798 NEXT; 1799 SKIP_BLANKS; 1800 xsltCompileRelativePathPattern(ctxt, NULL, novar); 1801 } 1802 return; 1803 } 1804 xsltCompileRelativePathPattern(ctxt, name, novar); 1805 } 1806 error: 1807 return; 1808 } 1809 1810 /** 1811 * xsltCompilePatternInternal: 1812 * @pattern: an XSLT pattern 1813 * @doc: the containing document 1814 * @node: the containing element 1815 * @style: the stylesheet 1816 * @runtime: the transformation context, if done at run-time 1817 * @novar: flag to prohibit xslt variables 1818 * 1819 * Compile the XSLT pattern and generates a list of precompiled form suitable 1820 * for fast matching. 1821 * 1822 * [1] Pattern ::= LocationPathPattern | Pattern '|' LocationPathPattern 1823 * 1824 * Returns the generated pattern list or NULL in case of failure 1825 */ 1826 1827 static xsltCompMatchPtr 1828 xsltCompilePatternInternal(const xmlChar *pattern, xmlDocPtr doc, 1829 xmlNodePtr node, xsltStylesheetPtr style, 1830 xsltTransformContextPtr runtime, int novar) { 1831 xsltParserContextPtr ctxt = NULL; 1832 xsltCompMatchPtr element, first = NULL, previous = NULL; 1833 int current, start, end, level, j; 1834 1835 if (pattern == NULL) { 1836 xsltTransformError(NULL, NULL, node, 1837 "xsltCompilePattern : NULL pattern\n"); 1838 return(NULL); 1839 } 1840 1841 ctxt = xsltNewParserContext(style, runtime); 1842 if (ctxt == NULL) 1843 return(NULL); 1844 ctxt->doc = doc; 1845 ctxt->elem = node; 1846 current = end = 0; 1847 while (pattern[current] != 0) { 1848 start = current; 1849 while (IS_BLANK_CH(pattern[current])) 1850 current++; 1851 end = current; 1852 level = 0; 1853 while ((pattern[end] != 0) && ((pattern[end] != '|') || (level != 0))) { 1854 if (pattern[end] == '[') 1855 level++; 1856 else if (pattern[end] == ']') 1857 level--; 1858 else if (pattern[end] == '\'') { 1859 end++; 1860 while ((pattern[end] != 0) && (pattern[end] != '\'')) 1861 end++; 1862 } else if (pattern[end] == '"') { 1863 end++; 1864 while ((pattern[end] != 0) && (pattern[end] != '"')) 1865 end++; 1866 } 1867 end++; 1868 } 1869 if (current == end) { 1870 xsltTransformError(NULL, NULL, node, 1871 "xsltCompilePattern : NULL pattern\n"); 1872 goto error; 1873 } 1874 element = xsltNewCompMatch(); 1875 if (element == NULL) { 1876 goto error; 1877 } 1878 if (first == NULL) 1879 first = element; 1880 else if (previous != NULL) 1881 previous->next = element; 1882 previous = element; 1883 1884 ctxt->comp = element; 1885 ctxt->base = xmlStrndup(&pattern[start], end - start); 1886 if (ctxt->base == NULL) 1887 goto error; 1888 ctxt->cur = &(ctxt->base)[current - start]; 1889 element->pattern = ctxt->base; 1890 element->nsList = xmlGetNsList(doc, node); 1891 j = 0; 1892 if (element->nsList != NULL) { 1893 while (element->nsList[j] != NULL) 1894 j++; 1895 } 1896 element->nsNr = j; 1897 1898 1899 #ifdef WITH_XSLT_DEBUG_PATTERN 1900 xsltGenericDebug(xsltGenericDebugContext, 1901 "xsltCompilePattern : parsing '%s'\n", 1902 element->pattern); 1903 #endif 1904 /* 1905 Preset default priority to be zero. 1906 This may be changed by xsltCompileLocationPathPattern. 1907 */ 1908 element->priority = 0; 1909 xsltCompileLocationPathPattern(ctxt, novar); 1910 if (ctxt->error) { 1911 xsltTransformError(NULL, style, node, 1912 "xsltCompilePattern : failed to compile '%s'\n", 1913 element->pattern); 1914 if (style != NULL) style->errors++; 1915 goto error; 1916 } 1917 1918 /* 1919 * Reverse for faster interpretation. 1920 */ 1921 xsltReverseCompMatch(ctxt, element); 1922 1923 /* 1924 * Set-up the priority 1925 */ 1926 if (element->priority == 0) { /* if not yet determined */ 1927 if (((element->steps[0].op == XSLT_OP_ELEM) || 1928 (element->steps[0].op == XSLT_OP_ATTR) || 1929 (element->steps[0].op == XSLT_OP_PI)) && 1930 (element->steps[0].value != NULL) && 1931 (element->steps[1].op == XSLT_OP_END)) { 1932 ; /* previously preset */ 1933 } else if ((element->steps[0].op == XSLT_OP_ATTR) && 1934 (element->steps[0].value2 != NULL) && 1935 (element->steps[1].op == XSLT_OP_END)) { 1936 element->priority = -0.25; 1937 } else if ((element->steps[0].op == XSLT_OP_NS) && 1938 (element->steps[0].value != NULL) && 1939 (element->steps[1].op == XSLT_OP_END)) { 1940 element->priority = -0.25; 1941 } else if ((element->steps[0].op == XSLT_OP_ATTR) && 1942 (element->steps[0].value == NULL) && 1943 (element->steps[0].value2 == NULL) && 1944 (element->steps[1].op == XSLT_OP_END)) { 1945 element->priority = -0.5; 1946 } else if (((element->steps[0].op == XSLT_OP_PI) || 1947 (element->steps[0].op == XSLT_OP_TEXT) || 1948 (element->steps[0].op == XSLT_OP_ALL) || 1949 (element->steps[0].op == XSLT_OP_NODE) || 1950 (element->steps[0].op == XSLT_OP_COMMENT)) && 1951 (element->steps[1].op == XSLT_OP_END)) { 1952 element->priority = -0.5; 1953 } else { 1954 element->priority = 0.5; 1955 } 1956 } 1957 #ifdef WITH_XSLT_DEBUG_PATTERN 1958 xsltGenericDebug(xsltGenericDebugContext, 1959 "xsltCompilePattern : parsed %s, default priority %f\n", 1960 element->pattern, element->priority); 1961 #endif 1962 if (pattern[end] == '|') 1963 end++; 1964 current = end; 1965 } 1966 if (end == 0) { 1967 xsltTransformError(NULL, style, node, 1968 "xsltCompilePattern : NULL pattern\n"); 1969 if (style != NULL) style->errors++; 1970 goto error; 1971 } 1972 1973 xsltFreeParserContext(ctxt); 1974 return(first); 1975 1976 error: 1977 if (ctxt != NULL) 1978 xsltFreeParserContext(ctxt); 1979 if (first != NULL) 1980 xsltFreeCompMatchList(first); 1981 return(NULL); 1982 } 1983 1984 /** 1985 * xsltCompilePattern: 1986 * @pattern: an XSLT pattern 1987 * @doc: the containing document 1988 * @node: the containing element 1989 * @style: the stylesheet 1990 * @runtime: the transformation context, if done at run-time 1991 * 1992 * Compile the XSLT pattern and generates a list of precompiled form suitable 1993 * for fast matching. 1994 * 1995 * [1] Pattern ::= LocationPathPattern | Pattern '|' LocationPathPattern 1996 * 1997 * Returns the generated pattern list or NULL in case of failure 1998 */ 1999 2000 xsltCompMatchPtr 2001 xsltCompilePattern(const xmlChar *pattern, xmlDocPtr doc, 2002 xmlNodePtr node, xsltStylesheetPtr style, 2003 xsltTransformContextPtr runtime) { 2004 return (xsltCompilePatternInternal(pattern, doc, node, style, runtime, 0)); 2005 } 2006 2007 /************************************************************************ 2008 * * 2009 * Module interfaces * 2010 * * 2011 ************************************************************************/ 2012 2013 /** 2014 * xsltAddTemplate: 2015 * @style: an XSLT stylesheet 2016 * @cur: an XSLT template 2017 * @mode: the mode name or NULL 2018 * @modeURI: the mode URI or NULL 2019 * 2020 * Register the XSLT pattern associated to @cur 2021 * 2022 * Returns -1 in case of error, 0 otherwise 2023 */ 2024 int 2025 xsltAddTemplate(xsltStylesheetPtr style, xsltTemplatePtr cur, 2026 const xmlChar *mode, const xmlChar *modeURI) { 2027 xsltCompMatchPtr pat, list, next; 2028 /* 2029 * 'top' will point to style->xxxMatch ptr - declaring as 'void' 2030 * avoids gcc 'type-punned pointer' warning. 2031 */ 2032 void **top = NULL; 2033 const xmlChar *name = NULL; 2034 float priority; /* the priority */ 2035 2036 if ((style == NULL) || (cur == NULL) || (cur->match == NULL)) 2037 return(-1); 2038 2039 priority = cur->priority; 2040 pat = xsltCompilePatternInternal(cur->match, style->doc, cur->elem, 2041 style, NULL, 1); 2042 if (pat == NULL) 2043 return(-1); 2044 while (pat) { 2045 next = pat->next; 2046 pat->next = NULL; 2047 name = NULL; 2048 2049 pat->template = cur; 2050 if (mode != NULL) 2051 pat->mode = xmlDictLookup(style->dict, mode, -1); 2052 if (modeURI != NULL) 2053 pat->modeURI = xmlDictLookup(style->dict, modeURI, -1); 2054 if (priority != XSLT_PAT_NO_PRIORITY) 2055 pat->priority = priority; 2056 2057 /* 2058 * insert it in the hash table list corresponding to its lookup name 2059 */ 2060 switch (pat->steps[0].op) { 2061 case XSLT_OP_ATTR: 2062 if (pat->steps[0].value != NULL) 2063 name = pat->steps[0].value; 2064 else 2065 top = &(style->attrMatch); 2066 break; 2067 case XSLT_OP_PARENT: 2068 case XSLT_OP_ANCESTOR: 2069 top = &(style->elemMatch); 2070 break; 2071 case XSLT_OP_ROOT: 2072 top = &(style->rootMatch); 2073 break; 2074 case XSLT_OP_KEY: 2075 top = &(style->keyMatch); 2076 break; 2077 case XSLT_OP_ID: 2078 /* TODO optimize ID !!! */ 2079 case XSLT_OP_NS: 2080 case XSLT_OP_ALL: 2081 top = &(style->elemMatch); 2082 break; 2083 case XSLT_OP_END: 2084 case XSLT_OP_PREDICATE: 2085 xsltTransformError(NULL, style, NULL, 2086 "xsltAddTemplate: invalid compiled pattern\n"); 2087 xsltFreeCompMatch(pat); 2088 return(-1); 2089 /* 2090 * TODO: some flags at the top level about type based patterns 2091 * would be faster than inclusion in the hash table. 2092 */ 2093 case XSLT_OP_PI: 2094 if (pat->steps[0].value != NULL) 2095 name = pat->steps[0].value; 2096 else 2097 top = &(style->piMatch); 2098 break; 2099 case XSLT_OP_COMMENT: 2100 top = &(style->commentMatch); 2101 break; 2102 case XSLT_OP_TEXT: 2103 top = &(style->textMatch); 2104 break; 2105 case XSLT_OP_ELEM: 2106 case XSLT_OP_NODE: 2107 if (pat->steps[0].value != NULL) 2108 name = pat->steps[0].value; 2109 else 2110 top = &(style->elemMatch); 2111 break; 2112 } 2113 if (name != NULL) { 2114 if (style->templatesHash == NULL) { 2115 style->templatesHash = xmlHashCreate(1024); 2116 if (style->templatesHash == NULL) { 2117 xsltFreeCompMatch(pat); 2118 return(-1); 2119 } 2120 xmlHashAddEntry3(style->templatesHash, name, mode, modeURI, pat); 2121 } else { 2122 list = (xsltCompMatchPtr) xmlHashLookup3(style->templatesHash, 2123 name, mode, modeURI); 2124 if (list == NULL) { 2125 xmlHashAddEntry3(style->templatesHash, name, 2126 mode, modeURI, pat); 2127 } else { 2128 /* 2129 * Note '<=' since one must choose among the matching 2130 * template rules that are left, the one that occurs 2131 * last in the stylesheet 2132 */ 2133 if (list->priority <= pat->priority) { 2134 pat->next = list; 2135 xmlHashUpdateEntry3(style->templatesHash, name, 2136 mode, modeURI, pat, NULL); 2137 } else { 2138 while (list->next != NULL) { 2139 if (list->next->priority <= pat->priority) 2140 break; 2141 list = list->next; 2142 } 2143 pat->next = list->next; 2144 list->next = pat; 2145 } 2146 } 2147 } 2148 } else if (top != NULL) { 2149 list = *top; 2150 if (list == NULL) { 2151 *top = pat; 2152 pat->next = NULL; 2153 } else if (list->priority <= pat->priority) { 2154 pat->next = list; 2155 *top = pat; 2156 } else { 2157 while (list->next != NULL) { 2158 if (list->next->priority <= pat->priority) 2159 break; 2160 list = list->next; 2161 } 2162 pat->next = list->next; 2163 list->next = pat; 2164 } 2165 } else { 2166 xsltTransformError(NULL, style, NULL, 2167 "xsltAddTemplate: invalid compiled pattern\n"); 2168 xsltFreeCompMatch(pat); 2169 return(-1); 2170 } 2171 #ifdef WITH_XSLT_DEBUG_PATTERN 2172 if (mode) 2173 xsltGenericDebug(xsltGenericDebugContext, 2174 "added pattern : '%s' mode '%s' priority %f\n", 2175 pat->pattern, pat->mode, pat->priority); 2176 else 2177 xsltGenericDebug(xsltGenericDebugContext, 2178 "added pattern : '%s' priority %f\n", 2179 pat->pattern, pat->priority); 2180 #endif 2181 2182 pat = next; 2183 } 2184 return(0); 2185 } 2186 2187 static int 2188 xsltComputeAllKeys(xsltTransformContextPtr ctxt, xmlNodePtr contextNode) 2189 { 2190 if ((ctxt == NULL) || (contextNode == NULL)) { 2191 xsltTransformError(ctxt, NULL, ctxt->inst, 2192 "Internal error in xsltComputeAllKeys(): " 2193 "Bad arguments.\n"); 2194 return(-1); 2195 } 2196 2197 if (ctxt->document == NULL) { 2198 /* 2199 * The document info will only be NULL if we have a RTF. 2200 */ 2201 if (contextNode->doc->_private != NULL) 2202 goto doc_info_mismatch; 2203 /* 2204 * On-demand creation of the document info (needed for keys). 2205 */ 2206 ctxt->document = xsltNewDocument(ctxt, contextNode->doc); 2207 if (ctxt->document == NULL) 2208 return(-1); 2209 } 2210 return xsltInitAllDocKeys(ctxt); 2211 2212 doc_info_mismatch: 2213 xsltTransformError(ctxt, NULL, ctxt->inst, 2214 "Internal error in xsltComputeAllKeys(): " 2215 "The context's document info doesn't match the " 2216 "document info of the current result tree.\n"); 2217 ctxt->state = XSLT_STATE_STOPPED; 2218 return(-1); 2219 } 2220 2221 /** 2222 * xsltGetTemplate: 2223 * @ctxt: a XSLT process context 2224 * @node: the node being processed 2225 * @style: the current style 2226 * 2227 * Finds the template applying to this node, if @style is non-NULL 2228 * it means one needs to look for the next imported template in scope. 2229 * 2230 * Returns the xsltTemplatePtr or NULL if not found 2231 */ 2232 xsltTemplatePtr 2233 xsltGetTemplate(xsltTransformContextPtr ctxt, xmlNodePtr node, 2234 xsltStylesheetPtr style) 2235 { 2236 xsltStylesheetPtr curstyle; 2237 xsltTemplatePtr ret = NULL; 2238 const xmlChar *name = NULL; 2239 xsltCompMatchPtr list = NULL; 2240 float priority; 2241 int keyed = 0; 2242 2243 if ((ctxt == NULL) || (node == NULL)) 2244 return(NULL); 2245 2246 if (style == NULL) { 2247 curstyle = ctxt->style; 2248 } else { 2249 curstyle = xsltNextImport(style); 2250 } 2251 2252 while ((curstyle != NULL) && (curstyle != style)) { 2253 priority = XSLT_PAT_NO_PRIORITY; 2254 /* TODO : handle IDs/keys here ! */ 2255 if (curstyle->templatesHash != NULL) { 2256 /* 2257 * Use the top name as selector 2258 */ 2259 switch (node->type) { 2260 case XML_ELEMENT_NODE: 2261 if (node->name[0] == ' ') 2262 break; 2263 case XML_ATTRIBUTE_NODE: 2264 case XML_PI_NODE: 2265 name = node->name; 2266 break; 2267 case XML_DOCUMENT_NODE: 2268 case XML_HTML_DOCUMENT_NODE: 2269 case XML_TEXT_NODE: 2270 case XML_CDATA_SECTION_NODE: 2271 case XML_COMMENT_NODE: 2272 case XML_ENTITY_REF_NODE: 2273 case XML_ENTITY_NODE: 2274 case XML_DOCUMENT_TYPE_NODE: 2275 case XML_DOCUMENT_FRAG_NODE: 2276 case XML_NOTATION_NODE: 2277 case XML_DTD_NODE: 2278 case XML_ELEMENT_DECL: 2279 case XML_ATTRIBUTE_DECL: 2280 case XML_ENTITY_DECL: 2281 case XML_NAMESPACE_DECL: 2282 case XML_XINCLUDE_START: 2283 case XML_XINCLUDE_END: 2284 break; 2285 default: 2286 return(NULL); 2287 2288 } 2289 } 2290 if (name != NULL) { 2291 /* 2292 * find the list of applicable expressions based on the name 2293 */ 2294 list = (xsltCompMatchPtr) xmlHashLookup3(curstyle->templatesHash, 2295 name, ctxt->mode, ctxt->modeURI); 2296 } else 2297 list = NULL; 2298 while (list != NULL) { 2299 if (xsltTestCompMatch(ctxt, list, node, 2300 ctxt->mode, ctxt->modeURI)) { 2301 ret = list->template; 2302 priority = list->priority; 2303 break; 2304 } 2305 list = list->next; 2306 } 2307 list = NULL; 2308 2309 /* 2310 * find alternate generic matches 2311 */ 2312 switch (node->type) { 2313 case XML_ELEMENT_NODE: 2314 if (node->name[0] == ' ') 2315 list = curstyle->rootMatch; 2316 else 2317 list = curstyle->elemMatch; 2318 if (node->psvi != NULL) keyed = 1; 2319 break; 2320 case XML_ATTRIBUTE_NODE: { 2321 xmlAttrPtr attr; 2322 2323 list = curstyle->attrMatch; 2324 attr = (xmlAttrPtr) node; 2325 if (attr->psvi != NULL) keyed = 1; 2326 break; 2327 } 2328 case XML_PI_NODE: 2329 list = curstyle->piMatch; 2330 if (node->psvi != NULL) keyed = 1; 2331 break; 2332 case XML_DOCUMENT_NODE: 2333 case XML_HTML_DOCUMENT_NODE: { 2334 xmlDocPtr doc; 2335 2336 list = curstyle->rootMatch; 2337 doc = (xmlDocPtr) node; 2338 if (doc->psvi != NULL) keyed = 1; 2339 break; 2340 } 2341 case XML_TEXT_NODE: 2342 case XML_CDATA_SECTION_NODE: 2343 list = curstyle->textMatch; 2344 if (node->psvi != NULL) keyed = 1; 2345 break; 2346 case XML_COMMENT_NODE: 2347 list = curstyle->commentMatch; 2348 if (node->psvi != NULL) keyed = 1; 2349 break; 2350 case XML_ENTITY_REF_NODE: 2351 case XML_ENTITY_NODE: 2352 case XML_DOCUMENT_TYPE_NODE: 2353 case XML_DOCUMENT_FRAG_NODE: 2354 case XML_NOTATION_NODE: 2355 case XML_DTD_NODE: 2356 case XML_ELEMENT_DECL: 2357 case XML_ATTRIBUTE_DECL: 2358 case XML_ENTITY_DECL: 2359 case XML_NAMESPACE_DECL: 2360 case XML_XINCLUDE_START: 2361 case XML_XINCLUDE_END: 2362 break; 2363 default: 2364 break; 2365 } 2366 while ((list != NULL) && 2367 ((ret == NULL) || (list->priority > priority))) { 2368 if (xsltTestCompMatch(ctxt, list, node, 2369 ctxt->mode, ctxt->modeURI)) { 2370 ret = list->template; 2371 priority = list->priority; 2372 break; 2373 } 2374 list = list->next; 2375 } 2376 /* 2377 * Some of the tests for elements can also apply to documents 2378 */ 2379 if ((node->type == XML_DOCUMENT_NODE) || 2380 (node->type == XML_HTML_DOCUMENT_NODE) || 2381 (node->type == XML_TEXT_NODE)) { 2382 list = curstyle->elemMatch; 2383 while ((list != NULL) && 2384 ((ret == NULL) || (list->priority > priority))) { 2385 if (xsltTestCompMatch(ctxt, list, node, 2386 ctxt->mode, ctxt->modeURI)) { 2387 ret = list->template; 2388 priority = list->priority; 2389 break; 2390 } 2391 list = list->next; 2392 } 2393 } else if ((node->type == XML_PI_NODE) || 2394 (node->type == XML_COMMENT_NODE)) { 2395 list = curstyle->elemMatch; 2396 while ((list != NULL) && 2397 ((ret == NULL) || (list->priority > priority))) { 2398 if (xsltTestCompMatch(ctxt, list, node, 2399 ctxt->mode, ctxt->modeURI)) { 2400 ret = list->template; 2401 priority = list->priority; 2402 break; 2403 } 2404 list = list->next; 2405 } 2406 } 2407 2408 keyed_match: 2409 if (keyed) { 2410 list = curstyle->keyMatch; 2411 while ((list != NULL) && 2412 ((ret == NULL) || (list->priority > priority))) { 2413 if (xsltTestCompMatch(ctxt, list, node, 2414 ctxt->mode, ctxt->modeURI)) { 2415 ret = list->template; 2416 priority = list->priority; 2417 break; 2418 } 2419 list = list->next; 2420 } 2421 } 2422 else if (ctxt->hasTemplKeyPatterns && 2423 ((ctxt->document == NULL) || 2424 (ctxt->document->nbKeysComputed < ctxt->nbKeys))) 2425 { 2426 /* 2427 * Compute all remaining keys for this document. 2428 * 2429 * REVISIT TODO: I think this could be further optimized. 2430 */ 2431 if (xsltComputeAllKeys(ctxt, node) == -1) 2432 goto error; 2433 2434 switch (node->type) { 2435 case XML_ELEMENT_NODE: 2436 if (node->psvi != NULL) keyed = 1; 2437 break; 2438 case XML_ATTRIBUTE_NODE: 2439 if (((xmlAttrPtr) node)->psvi != NULL) keyed = 1; 2440 break; 2441 case XML_TEXT_NODE: 2442 case XML_CDATA_SECTION_NODE: 2443 case XML_COMMENT_NODE: 2444 case XML_PI_NODE: 2445 if (node->psvi != NULL) keyed = 1; 2446 break; 2447 case XML_DOCUMENT_NODE: 2448 case XML_HTML_DOCUMENT_NODE: 2449 if (((xmlDocPtr) node)->psvi != NULL) keyed = 1; 2450 break; 2451 default: 2452 break; 2453 } 2454 if (keyed) 2455 goto keyed_match; 2456 } 2457 if (ret != NULL) 2458 return(ret); 2459 2460 /* 2461 * Cycle on next curstylesheet import. 2462 */ 2463 curstyle = xsltNextImport(curstyle); 2464 } 2465 2466 error: 2467 return(NULL); 2468 } 2469 2470 /** 2471 * xsltCleanupTemplates: 2472 * @style: an XSLT stylesheet 2473 * 2474 * Cleanup the state of the templates used by the stylesheet and 2475 * the ones it imports. 2476 */ 2477 void 2478 xsltCleanupTemplates(xsltStylesheetPtr style ATTRIBUTE_UNUSED) { 2479 } 2480 2481 /** 2482 * xsltFreeTemplateHashes: 2483 * @style: an XSLT stylesheet 2484 * 2485 * Free up the memory used by xsltAddTemplate/xsltGetTemplate mechanism 2486 */ 2487 void 2488 xsltFreeTemplateHashes(xsltStylesheetPtr style) { 2489 if (style->templatesHash != NULL) 2490 xmlHashFree((xmlHashTablePtr) style->templatesHash, 2491 (xmlHashDeallocator) xsltFreeCompMatchList); 2492 if (style->rootMatch != NULL) 2493 xsltFreeCompMatchList(style->rootMatch); 2494 if (style->keyMatch != NULL) 2495 xsltFreeCompMatchList(style->keyMatch); 2496 if (style->elemMatch != NULL) 2497 xsltFreeCompMatchList(style->elemMatch); 2498 if (style->attrMatch != NULL) 2499 xsltFreeCompMatchList(style->attrMatch); 2500 if (style->parentMatch != NULL) 2501 xsltFreeCompMatchList(style->parentMatch); 2502 if (style->textMatch != NULL) 2503 xsltFreeCompMatchList(style->textMatch); 2504 if (style->piMatch != NULL) 2505 xsltFreeCompMatchList(style->piMatch); 2506 if (style->commentMatch != NULL) 2507 xsltFreeCompMatchList(style->commentMatch); 2508 } 2509 2510
