Annotation of embedaddon/libxml2/pattern.c, revision 1.1
1.1 ! misho 1: /*
! 2: * pattern.c: Implemetation of selectors for nodes
! 3: *
! 4: * Reference:
! 5: * http://www.w3.org/TR/2001/REC-xmlschema-1-20010502/
! 6: * to some extent
! 7: * http://www.w3.org/TR/1999/REC-xml-19991116
! 8: *
! 9: * See Copyright for the status of this software.
! 10: *
! 11: * daniel@veillard.com
! 12: */
! 13:
! 14: /*
! 15: * TODO:
! 16: * - compilation flags to check for specific syntaxes
! 17: * using flags of xmlPatterncompile()
! 18: * - making clear how pattern starting with / or . need to be handled,
! 19: * currently push(NULL, NULL) means a reset of the streaming context
! 20: * and indicating we are on / (the document node), probably need
! 21: * something similar for .
! 22: * - get rid of the "compile" starting with lowercase
! 23: * - DONE (2006-05-16): get rid of the Strdup/Strndup in case of dictionary
! 24: */
! 25:
! 26: #define IN_LIBXML
! 27: #include "libxml.h"
! 28:
! 29: #include <string.h>
! 30: #include <libxml/xmlmemory.h>
! 31: #include <libxml/tree.h>
! 32: #include <libxml/hash.h>
! 33: #include <libxml/dict.h>
! 34: #include <libxml/xmlerror.h>
! 35: #include <libxml/parserInternals.h>
! 36: #include <libxml/pattern.h>
! 37:
! 38: #ifdef LIBXML_PATTERN_ENABLED
! 39:
! 40: /* #define DEBUG_STREAMING */
! 41:
! 42: #define ERROR(a, b, c, d)
! 43: #define ERROR5(a, b, c, d, e)
! 44:
! 45: #define XML_STREAM_STEP_DESC 1
! 46: #define XML_STREAM_STEP_FINAL 2
! 47: #define XML_STREAM_STEP_ROOT 4
! 48: #define XML_STREAM_STEP_ATTR 8
! 49: #define XML_STREAM_STEP_NODE 16
! 50: #define XML_STREAM_STEP_IN_SET 32
! 51:
! 52: /*
! 53: * NOTE: Those private flags (XML_STREAM_xxx) are used
! 54: * in _xmlStreamCtxt->flag. They extend the public
! 55: * xmlPatternFlags, so be carefull not to interfere with the
! 56: * reserved values for xmlPatternFlags.
! 57: */
! 58: #define XML_STREAM_FINAL_IS_ANY_NODE 1<<14
! 59: #define XML_STREAM_FROM_ROOT 1<<15
! 60: #define XML_STREAM_DESC 1<<16
! 61:
! 62: /*
! 63: * XML_STREAM_ANY_NODE is used for comparison against
! 64: * xmlElementType enums, to indicate a node of any type.
! 65: */
! 66: #define XML_STREAM_ANY_NODE 100
! 67:
! 68: #define XML_PATTERN_NOTPATTERN (XML_PATTERN_XPATH | \
! 69: XML_PATTERN_XSSEL | \
! 70: XML_PATTERN_XSFIELD)
! 71:
! 72: #define XML_STREAM_XS_IDC(c) ((c)->flags & \
! 73: (XML_PATTERN_XSSEL | XML_PATTERN_XSFIELD))
! 74:
! 75: #define XML_STREAM_XS_IDC_SEL(c) ((c)->flags & XML_PATTERN_XSSEL)
! 76:
! 77: #define XML_STREAM_XS_IDC_FIELD(c) ((c)->flags & XML_PATTERN_XSFIELD)
! 78:
! 79: #define XML_PAT_COPY_NSNAME(c, r, nsname) \
! 80: if ((c)->comp->dict) \
! 81: r = (xmlChar *) xmlDictLookup((c)->comp->dict, BAD_CAST nsname, -1); \
! 82: else r = xmlStrdup(BAD_CAST nsname);
! 83:
! 84: #define XML_PAT_FREE_STRING(c, r) if ((c)->comp->dict == NULL) xmlFree(r);
! 85:
! 86: typedef struct _xmlStreamStep xmlStreamStep;
! 87: typedef xmlStreamStep *xmlStreamStepPtr;
! 88: struct _xmlStreamStep {
! 89: int flags; /* properties of that step */
! 90: const xmlChar *name; /* first string value if NULL accept all */
! 91: const xmlChar *ns; /* second string value */
! 92: int nodeType; /* type of node */
! 93: };
! 94:
! 95: typedef struct _xmlStreamComp xmlStreamComp;
! 96: typedef xmlStreamComp *xmlStreamCompPtr;
! 97: struct _xmlStreamComp {
! 98: xmlDict *dict; /* the dictionary if any */
! 99: int nbStep; /* number of steps in the automata */
! 100: int maxStep; /* allocated number of steps */
! 101: xmlStreamStepPtr steps; /* the array of steps */
! 102: int flags;
! 103: };
! 104:
! 105: struct _xmlStreamCtxt {
! 106: struct _xmlStreamCtxt *next;/* link to next sub pattern if | */
! 107: xmlStreamCompPtr comp; /* the compiled stream */
! 108: int nbState; /* number of states in the automata */
! 109: int maxState; /* allocated number of states */
! 110: int level; /* how deep are we ? */
! 111: int *states; /* the array of step indexes */
! 112: int flags; /* validation options */
! 113: int blockLevel;
! 114: };
! 115:
! 116: static void xmlFreeStreamComp(xmlStreamCompPtr comp);
! 117:
! 118: /*
! 119: * Types are private:
! 120: */
! 121:
! 122: typedef enum {
! 123: XML_OP_END=0,
! 124: XML_OP_ROOT,
! 125: XML_OP_ELEM,
! 126: XML_OP_CHILD,
! 127: XML_OP_ATTR,
! 128: XML_OP_PARENT,
! 129: XML_OP_ANCESTOR,
! 130: XML_OP_NS,
! 131: XML_OP_ALL
! 132: } xmlPatOp;
! 133:
! 134:
! 135: typedef struct _xmlStepState xmlStepState;
! 136: typedef xmlStepState *xmlStepStatePtr;
! 137: struct _xmlStepState {
! 138: int step;
! 139: xmlNodePtr node;
! 140: };
! 141:
! 142: typedef struct _xmlStepStates xmlStepStates;
! 143: typedef xmlStepStates *xmlStepStatesPtr;
! 144: struct _xmlStepStates {
! 145: int nbstates;
! 146: int maxstates;
! 147: xmlStepStatePtr states;
! 148: };
! 149:
! 150: typedef struct _xmlStepOp xmlStepOp;
! 151: typedef xmlStepOp *xmlStepOpPtr;
! 152: struct _xmlStepOp {
! 153: xmlPatOp op;
! 154: const xmlChar *value;
! 155: const xmlChar *value2; /* The namespace name */
! 156: };
! 157:
! 158: #define PAT_FROM_ROOT (1<<8)
! 159: #define PAT_FROM_CUR (1<<9)
! 160:
! 161: struct _xmlPattern {
! 162: void *data; /* the associated template */
! 163: xmlDictPtr dict; /* the optional dictionary */
! 164: struct _xmlPattern *next; /* next pattern if | is used */
! 165: const xmlChar *pattern; /* the pattern */
! 166: int flags; /* flags */
! 167: int nbStep;
! 168: int maxStep;
! 169: xmlStepOpPtr steps; /* ops for computation */
! 170: xmlStreamCompPtr stream; /* the streaming data if any */
! 171: };
! 172:
! 173: typedef struct _xmlPatParserContext xmlPatParserContext;
! 174: typedef xmlPatParserContext *xmlPatParserContextPtr;
! 175: struct _xmlPatParserContext {
! 176: const xmlChar *cur; /* the current char being parsed */
! 177: const xmlChar *base; /* the full expression */
! 178: int error; /* error code */
! 179: xmlDictPtr dict; /* the dictionary if any */
! 180: xmlPatternPtr comp; /* the result */
! 181: xmlNodePtr elem; /* the current node if any */
! 182: const xmlChar **namespaces; /* the namespaces definitions */
! 183: int nb_namespaces; /* the number of namespaces */
! 184: };
! 185:
! 186: /************************************************************************
! 187: * *
! 188: * Type functions *
! 189: * *
! 190: ************************************************************************/
! 191:
! 192: /**
! 193: * xmlNewPattern:
! 194: *
! 195: * Create a new XSLT Pattern
! 196: *
! 197: * Returns the newly allocated xmlPatternPtr or NULL in case of error
! 198: */
! 199: static xmlPatternPtr
! 200: xmlNewPattern(void) {
! 201: xmlPatternPtr cur;
! 202:
! 203: cur = (xmlPatternPtr) xmlMalloc(sizeof(xmlPattern));
! 204: if (cur == NULL) {
! 205: ERROR(NULL, NULL, NULL,
! 206: "xmlNewPattern : malloc failed\n");
! 207: return(NULL);
! 208: }
! 209: memset(cur, 0, sizeof(xmlPattern));
! 210: cur->maxStep = 10;
! 211: cur->steps = (xmlStepOpPtr) xmlMalloc(cur->maxStep * sizeof(xmlStepOp));
! 212: if (cur->steps == NULL) {
! 213: xmlFree(cur);
! 214: ERROR(NULL, NULL, NULL,
! 215: "xmlNewPattern : malloc failed\n");
! 216: return(NULL);
! 217: }
! 218: return(cur);
! 219: }
! 220:
! 221: /**
! 222: * xmlFreePattern:
! 223: * @comp: an XSLT comp
! 224: *
! 225: * Free up the memory allocated by @comp
! 226: */
! 227: void
! 228: xmlFreePattern(xmlPatternPtr comp) {
! 229: xmlStepOpPtr op;
! 230: int i;
! 231:
! 232: if (comp == NULL)
! 233: return;
! 234: if (comp->next != NULL)
! 235: xmlFreePattern(comp->next);
! 236: if (comp->stream != NULL)
! 237: xmlFreeStreamComp(comp->stream);
! 238: if (comp->pattern != NULL)
! 239: xmlFree((xmlChar *)comp->pattern);
! 240: if (comp->steps != NULL) {
! 241: if (comp->dict == NULL) {
! 242: for (i = 0;i < comp->nbStep;i++) {
! 243: op = &comp->steps[i];
! 244: if (op->value != NULL)
! 245: xmlFree((xmlChar *) op->value);
! 246: if (op->value2 != NULL)
! 247: xmlFree((xmlChar *) op->value2);
! 248: }
! 249: }
! 250: xmlFree(comp->steps);
! 251: }
! 252: if (comp->dict != NULL)
! 253: xmlDictFree(comp->dict);
! 254:
! 255: memset(comp, -1, sizeof(xmlPattern));
! 256: xmlFree(comp);
! 257: }
! 258:
! 259: /**
! 260: * xmlFreePatternList:
! 261: * @comp: an XSLT comp list
! 262: *
! 263: * Free up the memory allocated by all the elements of @comp
! 264: */
! 265: void
! 266: xmlFreePatternList(xmlPatternPtr comp) {
! 267: xmlPatternPtr cur;
! 268:
! 269: while (comp != NULL) {
! 270: cur = comp;
! 271: comp = comp->next;
! 272: cur->next = NULL;
! 273: xmlFreePattern(cur);
! 274: }
! 275: }
! 276:
! 277: /**
! 278: * xmlNewPatParserContext:
! 279: * @pattern: the pattern context
! 280: * @dict: the inherited dictionary or NULL
! 281: * @namespaces: the prefix definitions, array of [URI, prefix] terminated
! 282: * with [NULL, NULL] or NULL if no namespace is used
! 283: *
! 284: * Create a new XML pattern parser context
! 285: *
! 286: * Returns the newly allocated xmlPatParserContextPtr or NULL in case of error
! 287: */
! 288: static xmlPatParserContextPtr
! 289: xmlNewPatParserContext(const xmlChar *pattern, xmlDictPtr dict,
! 290: const xmlChar **namespaces) {
! 291: xmlPatParserContextPtr cur;
! 292:
! 293: if (pattern == NULL)
! 294: return(NULL);
! 295:
! 296: cur = (xmlPatParserContextPtr) xmlMalloc(sizeof(xmlPatParserContext));
! 297: if (cur == NULL) {
! 298: ERROR(NULL, NULL, NULL,
! 299: "xmlNewPatParserContext : malloc failed\n");
! 300: return(NULL);
! 301: }
! 302: memset(cur, 0, sizeof(xmlPatParserContext));
! 303: cur->dict = dict;
! 304: cur->cur = pattern;
! 305: cur->base = pattern;
! 306: if (namespaces != NULL) {
! 307: int i;
! 308: for (i = 0;namespaces[2 * i] != NULL;i++);
! 309: cur->nb_namespaces = i;
! 310: } else {
! 311: cur->nb_namespaces = 0;
! 312: }
! 313: cur->namespaces = namespaces;
! 314: return(cur);
! 315: }
! 316:
! 317: /**
! 318: * xmlFreePatParserContext:
! 319: * @ctxt: an XSLT parser context
! 320: *
! 321: * Free up the memory allocated by @ctxt
! 322: */
! 323: static void
! 324: xmlFreePatParserContext(xmlPatParserContextPtr ctxt) {
! 325: if (ctxt == NULL)
! 326: return;
! 327: memset(ctxt, -1, sizeof(xmlPatParserContext));
! 328: xmlFree(ctxt);
! 329: }
! 330:
! 331: /**
! 332: * xmlPatternAdd:
! 333: * @comp: the compiled match expression
! 334: * @op: an op
! 335: * @value: the first value
! 336: * @value2: the second value
! 337: *
! 338: * Add a step to an XSLT Compiled Match
! 339: *
! 340: * Returns -1 in case of failure, 0 otherwise.
! 341: */
! 342: static int
! 343: xmlPatternAdd(xmlPatParserContextPtr ctxt ATTRIBUTE_UNUSED,
! 344: xmlPatternPtr comp,
! 345: xmlPatOp op, xmlChar * value, xmlChar * value2)
! 346: {
! 347: if (comp->nbStep >= comp->maxStep) {
! 348: xmlStepOpPtr temp;
! 349: temp = (xmlStepOpPtr) xmlRealloc(comp->steps, comp->maxStep * 2 *
! 350: sizeof(xmlStepOp));
! 351: if (temp == NULL) {
! 352: ERROR(ctxt, NULL, NULL,
! 353: "xmlPatternAdd: realloc failed\n");
! 354: return (-1);
! 355: }
! 356: comp->steps = temp;
! 357: comp->maxStep *= 2;
! 358: }
! 359: comp->steps[comp->nbStep].op = op;
! 360: comp->steps[comp->nbStep].value = value;
! 361: comp->steps[comp->nbStep].value2 = value2;
! 362: comp->nbStep++;
! 363: return (0);
! 364: }
! 365:
! 366: #if 0
! 367: /**
! 368: * xsltSwapTopPattern:
! 369: * @comp: the compiled match expression
! 370: *
! 371: * reverse the two top steps.
! 372: */
! 373: static void
! 374: xsltSwapTopPattern(xmlPatternPtr comp) {
! 375: int i;
! 376: int j = comp->nbStep - 1;
! 377:
! 378: if (j > 0) {
! 379: register const xmlChar *tmp;
! 380: register xmlPatOp op;
! 381: i = j - 1;
! 382: tmp = comp->steps[i].value;
! 383: comp->steps[i].value = comp->steps[j].value;
! 384: comp->steps[j].value = tmp;
! 385: tmp = comp->steps[i].value2;
! 386: comp->steps[i].value2 = comp->steps[j].value2;
! 387: comp->steps[j].value2 = tmp;
! 388: op = comp->steps[i].op;
! 389: comp->steps[i].op = comp->steps[j].op;
! 390: comp->steps[j].op = op;
! 391: }
! 392: }
! 393: #endif
! 394:
! 395: /**
! 396: * xmlReversePattern:
! 397: * @comp: the compiled match expression
! 398: *
! 399: * reverse all the stack of expressions
! 400: *
! 401: * returns 0 in case of success and -1 in case of error.
! 402: */
! 403: static int
! 404: xmlReversePattern(xmlPatternPtr comp) {
! 405: int i, j;
! 406:
! 407: /*
! 408: * remove the leading // for //a or .//a
! 409: */
! 410: if ((comp->nbStep > 0) && (comp->steps[0].op == XML_OP_ANCESTOR)) {
! 411: for (i = 0, j = 1;j < comp->nbStep;i++,j++) {
! 412: comp->steps[i].value = comp->steps[j].value;
! 413: comp->steps[i].value2 = comp->steps[j].value2;
! 414: comp->steps[i].op = comp->steps[j].op;
! 415: }
! 416: comp->nbStep--;
! 417: }
! 418: if (comp->nbStep >= comp->maxStep) {
! 419: xmlStepOpPtr temp;
! 420: temp = (xmlStepOpPtr) xmlRealloc(comp->steps, comp->maxStep * 2 *
! 421: sizeof(xmlStepOp));
! 422: if (temp == NULL) {
! 423: ERROR(ctxt, NULL, NULL,
! 424: "xmlReversePattern: realloc failed\n");
! 425: return (-1);
! 426: }
! 427: comp->steps = temp;
! 428: comp->maxStep *= 2;
! 429: }
! 430: i = 0;
! 431: j = comp->nbStep - 1;
! 432: while (j > i) {
! 433: register const xmlChar *tmp;
! 434: register xmlPatOp op;
! 435: tmp = comp->steps[i].value;
! 436: comp->steps[i].value = comp->steps[j].value;
! 437: comp->steps[j].value = tmp;
! 438: tmp = comp->steps[i].value2;
! 439: comp->steps[i].value2 = comp->steps[j].value2;
! 440: comp->steps[j].value2 = tmp;
! 441: op = comp->steps[i].op;
! 442: comp->steps[i].op = comp->steps[j].op;
! 443: comp->steps[j].op = op;
! 444: j--;
! 445: i++;
! 446: }
! 447: comp->steps[comp->nbStep].value = NULL;
! 448: comp->steps[comp->nbStep].value2 = NULL;
! 449: comp->steps[comp->nbStep++].op = XML_OP_END;
! 450: return(0);
! 451: }
! 452:
! 453: /************************************************************************
! 454: * *
! 455: * The interpreter for the precompiled patterns *
! 456: * *
! 457: ************************************************************************/
! 458:
! 459: static int
! 460: xmlPatPushState(xmlStepStates *states, int step, xmlNodePtr node) {
! 461: if ((states->states == NULL) || (states->maxstates <= 0)) {
! 462: states->maxstates = 4;
! 463: states->nbstates = 0;
! 464: states->states = xmlMalloc(4 * sizeof(xmlStepState));
! 465: }
! 466: else if (states->maxstates <= states->nbstates) {
! 467: xmlStepState *tmp;
! 468:
! 469: tmp = (xmlStepStatePtr) xmlRealloc(states->states,
! 470: 2 * states->maxstates * sizeof(xmlStepState));
! 471: if (tmp == NULL)
! 472: return(-1);
! 473: states->states = tmp;
! 474: states->maxstates *= 2;
! 475: }
! 476: states->states[states->nbstates].step = step;
! 477: states->states[states->nbstates++].node = node;
! 478: #if 0
! 479: fprintf(stderr, "Push: %d, %s\n", step, node->name);
! 480: #endif
! 481: return(0);
! 482: }
! 483:
! 484: /**
! 485: * xmlPatMatch:
! 486: * @comp: the precompiled pattern
! 487: * @node: a node
! 488: *
! 489: * Test whether the node matches the pattern
! 490: *
! 491: * Returns 1 if it matches, 0 if it doesn't and -1 in case of failure
! 492: */
! 493: static int
! 494: xmlPatMatch(xmlPatternPtr comp, xmlNodePtr node) {
! 495: int i;
! 496: xmlStepOpPtr step;
! 497: xmlStepStates states = {0, 0, NULL}; /* // may require backtrack */
! 498:
! 499: if ((comp == NULL) || (node == NULL)) return(-1);
! 500: i = 0;
! 501: restart:
! 502: for (;i < comp->nbStep;i++) {
! 503: step = &comp->steps[i];
! 504: switch (step->op) {
! 505: case XML_OP_END:
! 506: goto found;
! 507: case XML_OP_ROOT:
! 508: if (node->type == XML_NAMESPACE_DECL)
! 509: goto rollback;
! 510: node = node->parent;
! 511: if ((node->type == XML_DOCUMENT_NODE) ||
! 512: #ifdef LIBXML_DOCB_ENABLED
! 513: (node->type == XML_DOCB_DOCUMENT_NODE) ||
! 514: #endif
! 515: (node->type == XML_HTML_DOCUMENT_NODE))
! 516: continue;
! 517: goto rollback;
! 518: case XML_OP_ELEM:
! 519: if (node->type != XML_ELEMENT_NODE)
! 520: goto rollback;
! 521: if (step->value == NULL)
! 522: continue;
! 523: if (step->value[0] != node->name[0])
! 524: goto rollback;
! 525: if (!xmlStrEqual(step->value, node->name))
! 526: goto rollback;
! 527:
! 528: /* Namespace test */
! 529: if (node->ns == NULL) {
! 530: if (step->value2 != NULL)
! 531: goto rollback;
! 532: } else if (node->ns->href != NULL) {
! 533: if (step->value2 == NULL)
! 534: goto rollback;
! 535: if (!xmlStrEqual(step->value2, node->ns->href))
! 536: goto rollback;
! 537: }
! 538: continue;
! 539: case XML_OP_CHILD: {
! 540: xmlNodePtr lst;
! 541:
! 542: if ((node->type != XML_ELEMENT_NODE) &&
! 543: (node->type != XML_DOCUMENT_NODE) &&
! 544: #ifdef LIBXML_DOCB_ENABLED
! 545: (node->type != XML_DOCB_DOCUMENT_NODE) &&
! 546: #endif
! 547: (node->type != XML_HTML_DOCUMENT_NODE))
! 548: goto rollback;
! 549:
! 550: lst = node->children;
! 551:
! 552: if (step->value != NULL) {
! 553: while (lst != NULL) {
! 554: if ((lst->type == XML_ELEMENT_NODE) &&
! 555: (step->value[0] == lst->name[0]) &&
! 556: (xmlStrEqual(step->value, lst->name)))
! 557: break;
! 558: lst = lst->next;
! 559: }
! 560: if (lst != NULL)
! 561: continue;
! 562: }
! 563: goto rollback;
! 564: }
! 565: case XML_OP_ATTR:
! 566: if (node->type != XML_ATTRIBUTE_NODE)
! 567: goto rollback;
! 568: if (step->value != NULL) {
! 569: if (step->value[0] != node->name[0])
! 570: goto rollback;
! 571: if (!xmlStrEqual(step->value, node->name))
! 572: goto rollback;
! 573: }
! 574: /* Namespace test */
! 575: if (node->ns == NULL) {
! 576: if (step->value2 != NULL)
! 577: goto rollback;
! 578: } else if (step->value2 != NULL) {
! 579: if (!xmlStrEqual(step->value2, node->ns->href))
! 580: goto rollback;
! 581: }
! 582: continue;
! 583: case XML_OP_PARENT:
! 584: if ((node->type == XML_DOCUMENT_NODE) ||
! 585: (node->type == XML_HTML_DOCUMENT_NODE) ||
! 586: #ifdef LIBXML_DOCB_ENABLED
! 587: (node->type == XML_DOCB_DOCUMENT_NODE) ||
! 588: #endif
! 589: (node->type == XML_NAMESPACE_DECL))
! 590: goto rollback;
! 591: node = node->parent;
! 592: if (node == NULL)
! 593: goto rollback;
! 594: if (step->value == NULL)
! 595: continue;
! 596: if (step->value[0] != node->name[0])
! 597: goto rollback;
! 598: if (!xmlStrEqual(step->value, node->name))
! 599: goto rollback;
! 600: /* Namespace test */
! 601: if (node->ns == NULL) {
! 602: if (step->value2 != NULL)
! 603: goto rollback;
! 604: } else if (node->ns->href != NULL) {
! 605: if (step->value2 == NULL)
! 606: goto rollback;
! 607: if (!xmlStrEqual(step->value2, node->ns->href))
! 608: goto rollback;
! 609: }
! 610: continue;
! 611: case XML_OP_ANCESTOR:
! 612: /* TODO: implement coalescing of ANCESTOR/NODE ops */
! 613: if (step->value == NULL) {
! 614: i++;
! 615: step = &comp->steps[i];
! 616: if (step->op == XML_OP_ROOT)
! 617: goto found;
! 618: if (step->op != XML_OP_ELEM)
! 619: goto rollback;
! 620: if (step->value == NULL)
! 621: return(-1);
! 622: }
! 623: if (node == NULL)
! 624: goto rollback;
! 625: if ((node->type == XML_DOCUMENT_NODE) ||
! 626: (node->type == XML_HTML_DOCUMENT_NODE) ||
! 627: #ifdef LIBXML_DOCB_ENABLED
! 628: (node->type == XML_DOCB_DOCUMENT_NODE) ||
! 629: #endif
! 630: (node->type == XML_NAMESPACE_DECL))
! 631: goto rollback;
! 632: node = node->parent;
! 633: while (node != NULL) {
! 634: if ((node->type == XML_ELEMENT_NODE) &&
! 635: (step->value[0] == node->name[0]) &&
! 636: (xmlStrEqual(step->value, node->name))) {
! 637: /* Namespace test */
! 638: if (node->ns == NULL) {
! 639: if (step->value2 == NULL)
! 640: break;
! 641: } else if (node->ns->href != NULL) {
! 642: if ((step->value2 != NULL) &&
! 643: (xmlStrEqual(step->value2, node->ns->href)))
! 644: break;
! 645: }
! 646: }
! 647: node = node->parent;
! 648: }
! 649: if (node == NULL)
! 650: goto rollback;
! 651: /*
! 652: * prepare a potential rollback from here
! 653: * for ancestors of that node.
! 654: */
! 655: if (step->op == XML_OP_ANCESTOR)
! 656: xmlPatPushState(&states, i, node);
! 657: else
! 658: xmlPatPushState(&states, i - 1, node);
! 659: continue;
! 660: case XML_OP_NS:
! 661: if (node->type != XML_ELEMENT_NODE)
! 662: goto rollback;
! 663: if (node->ns == NULL) {
! 664: if (step->value != NULL)
! 665: goto rollback;
! 666: } else if (node->ns->href != NULL) {
! 667: if (step->value == NULL)
! 668: goto rollback;
! 669: if (!xmlStrEqual(step->value, node->ns->href))
! 670: goto rollback;
! 671: }
! 672: break;
! 673: case XML_OP_ALL:
! 674: if (node->type != XML_ELEMENT_NODE)
! 675: goto rollback;
! 676: break;
! 677: }
! 678: }
! 679: found:
! 680: if (states.states != NULL) {
! 681: /* Free the rollback states */
! 682: xmlFree(states.states);
! 683: }
! 684: return(1);
! 685: rollback:
! 686: /* got an error try to rollback */
! 687: if (states.states == NULL)
! 688: return(0);
! 689: if (states.nbstates <= 0) {
! 690: xmlFree(states.states);
! 691: return(0);
! 692: }
! 693: states.nbstates--;
! 694: i = states.states[states.nbstates].step;
! 695: node = states.states[states.nbstates].node;
! 696: #if 0
! 697: fprintf(stderr, "Pop: %d, %s\n", i, node->name);
! 698: #endif
! 699: goto restart;
! 700: }
! 701:
! 702: /************************************************************************
! 703: * *
! 704: * Dedicated parser for templates *
! 705: * *
! 706: ************************************************************************/
! 707:
! 708: #define TODO \
! 709: xmlGenericError(xmlGenericErrorContext, \
! 710: "Unimplemented block at %s:%d\n", \
! 711: __FILE__, __LINE__);
! 712: #define CUR (*ctxt->cur)
! 713: #define SKIP(val) ctxt->cur += (val)
! 714: #define NXT(val) ctxt->cur[(val)]
! 715: #define PEEKPREV(val) ctxt->cur[-(val)]
! 716: #define CUR_PTR ctxt->cur
! 717:
! 718: #define SKIP_BLANKS \
! 719: while (IS_BLANK_CH(CUR)) NEXT
! 720:
! 721: #define CURRENT (*ctxt->cur)
! 722: #define NEXT ((*ctxt->cur) ? ctxt->cur++: ctxt->cur)
! 723:
! 724:
! 725: #define PUSH(op, val, val2) \
! 726: if (xmlPatternAdd(ctxt, ctxt->comp, (op), (val), (val2))) goto error;
! 727:
! 728: #define XSLT_ERROR(X) \
! 729: { xsltError(ctxt, __FILE__, __LINE__, X); \
! 730: ctxt->error = (X); return; }
! 731:
! 732: #define XSLT_ERROR0(X) \
! 733: { xsltError(ctxt, __FILE__, __LINE__, X); \
! 734: ctxt->error = (X); return(0); }
! 735:
! 736: #if 0
! 737: /**
! 738: * xmlPatScanLiteral:
! 739: * @ctxt: the XPath Parser context
! 740: *
! 741: * Parse an XPath Litteral:
! 742: *
! 743: * [29] Literal ::= '"' [^"]* '"'
! 744: * | "'" [^']* "'"
! 745: *
! 746: * Returns the Literal parsed or NULL
! 747: */
! 748:
! 749: static xmlChar *
! 750: xmlPatScanLiteral(xmlPatParserContextPtr ctxt) {
! 751: const xmlChar *q, *cur;
! 752: xmlChar *ret = NULL;
! 753: int val, len;
! 754:
! 755: SKIP_BLANKS;
! 756: if (CUR == '"') {
! 757: NEXT;
! 758: cur = q = CUR_PTR;
! 759: val = xmlStringCurrentChar(NULL, cur, &len);
! 760: while ((IS_CHAR(val)) && (val != '"')) {
! 761: cur += len;
! 762: val = xmlStringCurrentChar(NULL, cur, &len);
! 763: }
! 764: if (!IS_CHAR(val)) {
! 765: ctxt->error = 1;
! 766: return(NULL);
! 767: } else {
! 768: if (ctxt->dict)
! 769: ret = (xmlChar *) xmlDictLookup(ctxt->dict, q, cur - q);
! 770: else
! 771: ret = xmlStrndup(q, cur - q);
! 772: }
! 773: cur += len;
! 774: CUR_PTR = cur;
! 775: } else if (CUR == '\'') {
! 776: NEXT;
! 777: cur = q = CUR_PTR;
! 778: val = xmlStringCurrentChar(NULL, cur, &len);
! 779: while ((IS_CHAR(val)) && (val != '\'')) {
! 780: cur += len;
! 781: val = xmlStringCurrentChar(NULL, cur, &len);
! 782: }
! 783: if (!IS_CHAR(val)) {
! 784: ctxt->error = 1;
! 785: return(NULL);
! 786: } else {
! 787: if (ctxt->dict)
! 788: ret = (xmlChar *) xmlDictLookup(ctxt->dict, q, cur - q);
! 789: else
! 790: ret = xmlStrndup(q, cur - q);
! 791: }
! 792: cur += len;
! 793: CUR_PTR = cur;
! 794: } else {
! 795: /* XP_ERROR(XPATH_START_LITERAL_ERROR); */
! 796: ctxt->error = 1;
! 797: return(NULL);
! 798: }
! 799: return(ret);
! 800: }
! 801: #endif
! 802:
! 803: /**
! 804: * xmlPatScanName:
! 805: * @ctxt: the XPath Parser context
! 806: *
! 807: * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' |
! 808: * CombiningChar | Extender
! 809: *
! 810: * [5] Name ::= (Letter | '_' | ':') (NameChar)*
! 811: *
! 812: * [6] Names ::= Name (S Name)*
! 813: *
! 814: * Returns the Name parsed or NULL
! 815: */
! 816:
! 817: static xmlChar *
! 818: xmlPatScanName(xmlPatParserContextPtr ctxt) {
! 819: const xmlChar *q, *cur;
! 820: xmlChar *ret = NULL;
! 821: int val, len;
! 822:
! 823: SKIP_BLANKS;
! 824:
! 825: cur = q = CUR_PTR;
! 826: val = xmlStringCurrentChar(NULL, cur, &len);
! 827: if (!IS_LETTER(val) && (val != '_') && (val != ':'))
! 828: return(NULL);
! 829:
! 830: while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
! 831: (val == '.') || (val == '-') ||
! 832: (val == '_') ||
! 833: (IS_COMBINING(val)) ||
! 834: (IS_EXTENDER(val))) {
! 835: cur += len;
! 836: val = xmlStringCurrentChar(NULL, cur, &len);
! 837: }
! 838: if (ctxt->dict)
! 839: ret = (xmlChar *) xmlDictLookup(ctxt->dict, q, cur - q);
! 840: else
! 841: ret = xmlStrndup(q, cur - q);
! 842: CUR_PTR = cur;
! 843: return(ret);
! 844: }
! 845:
! 846: /**
! 847: * xmlPatScanNCName:
! 848: * @ctxt: the XPath Parser context
! 849: *
! 850: * Parses a non qualified name
! 851: *
! 852: * Returns the Name parsed or NULL
! 853: */
! 854:
! 855: static xmlChar *
! 856: xmlPatScanNCName(xmlPatParserContextPtr ctxt) {
! 857: const xmlChar *q, *cur;
! 858: xmlChar *ret = NULL;
! 859: int val, len;
! 860:
! 861: SKIP_BLANKS;
! 862:
! 863: cur = q = CUR_PTR;
! 864: val = xmlStringCurrentChar(NULL, cur, &len);
! 865: if (!IS_LETTER(val) && (val != '_'))
! 866: return(NULL);
! 867:
! 868: while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
! 869: (val == '.') || (val == '-') ||
! 870: (val == '_') ||
! 871: (IS_COMBINING(val)) ||
! 872: (IS_EXTENDER(val))) {
! 873: cur += len;
! 874: val = xmlStringCurrentChar(NULL, cur, &len);
! 875: }
! 876: if (ctxt->dict)
! 877: ret = (xmlChar *) xmlDictLookup(ctxt->dict, q, cur - q);
! 878: else
! 879: ret = xmlStrndup(q, cur - q);
! 880: CUR_PTR = cur;
! 881: return(ret);
! 882: }
! 883:
! 884: #if 0
! 885: /**
! 886: * xmlPatScanQName:
! 887: * @ctxt: the XPath Parser context
! 888: * @prefix: the place to store the prefix
! 889: *
! 890: * Parse a qualified name
! 891: *
! 892: * Returns the Name parsed or NULL
! 893: */
! 894:
! 895: static xmlChar *
! 896: xmlPatScanQName(xmlPatParserContextPtr ctxt, xmlChar **prefix) {
! 897: xmlChar *ret = NULL;
! 898:
! 899: *prefix = NULL;
! 900: ret = xmlPatScanNCName(ctxt);
! 901: if (CUR == ':') {
! 902: *prefix = ret;
! 903: NEXT;
! 904: ret = xmlPatScanNCName(ctxt);
! 905: }
! 906: return(ret);
! 907: }
! 908: #endif
! 909:
! 910: /**
! 911: * xmlCompileAttributeTest:
! 912: * @ctxt: the compilation context
! 913: *
! 914: * Compile an attribute test.
! 915: */
! 916: static void
! 917: xmlCompileAttributeTest(xmlPatParserContextPtr ctxt) {
! 918: xmlChar *token = NULL;
! 919: xmlChar *name = NULL;
! 920: xmlChar *URL = NULL;
! 921:
! 922: SKIP_BLANKS;
! 923: name = xmlPatScanNCName(ctxt);
! 924: if (name == NULL) {
! 925: if (CUR == '*') {
! 926: PUSH(XML_OP_ATTR, NULL, NULL);
! 927: NEXT;
! 928: } else {
! 929: ERROR(NULL, NULL, NULL,
! 930: "xmlCompileAttributeTest : Name expected\n");
! 931: ctxt->error = 1;
! 932: }
! 933: return;
! 934: }
! 935: if (CUR == ':') {
! 936: int i;
! 937: xmlChar *prefix = name;
! 938:
! 939: NEXT;
! 940:
! 941: if (IS_BLANK_CH(CUR)) {
! 942: ERROR5(NULL, NULL, NULL, "Invalid QName.\n", NULL);
! 943: XML_PAT_FREE_STRING(ctxt, prefix);
! 944: ctxt->error = 1;
! 945: goto error;
! 946: }
! 947: /*
! 948: * This is a namespace match
! 949: */
! 950: token = xmlPatScanName(ctxt);
! 951: if ((prefix[0] == 'x') &&
! 952: (prefix[1] == 'm') &&
! 953: (prefix[2] == 'l') &&
! 954: (prefix[3] == 0))
! 955: {
! 956: XML_PAT_COPY_NSNAME(ctxt, URL, XML_XML_NAMESPACE);
! 957: } else {
! 958: for (i = 0;i < ctxt->nb_namespaces;i++) {
! 959: if (xmlStrEqual(ctxt->namespaces[2 * i + 1], prefix)) {
! 960: XML_PAT_COPY_NSNAME(ctxt, URL, ctxt->namespaces[2 * i])
! 961: break;
! 962: }
! 963: }
! 964: if (i >= ctxt->nb_namespaces) {
! 965: ERROR5(NULL, NULL, NULL,
! 966: "xmlCompileAttributeTest : no namespace bound to prefix %s\n",
! 967: prefix);
! 968: ctxt->error = 1;
! 969: goto error;
! 970: }
! 971: }
! 972: XML_PAT_FREE_STRING(ctxt, prefix);
! 973: if (token == NULL) {
! 974: if (CUR == '*') {
! 975: NEXT;
! 976: PUSH(XML_OP_ATTR, NULL, URL);
! 977: } else {
! 978: ERROR(NULL, NULL, NULL,
! 979: "xmlCompileAttributeTest : Name expected\n");
! 980: ctxt->error = 1;
! 981: goto error;
! 982: }
! 983: } else {
! 984: PUSH(XML_OP_ATTR, token, URL);
! 985: }
! 986: } else {
! 987: PUSH(XML_OP_ATTR, name, NULL);
! 988: }
! 989: return;
! 990: error:
! 991: if (URL != NULL)
! 992: XML_PAT_FREE_STRING(ctxt, URL)
! 993: if (token != NULL)
! 994: XML_PAT_FREE_STRING(ctxt, token);
! 995: }
! 996:
! 997: /**
! 998: * xmlCompileStepPattern:
! 999: * @ctxt: the compilation context
! 1000: *
! 1001: * Compile the Step Pattern and generates a precompiled
! 1002: * form suitable for fast matching.
! 1003: *
! 1004: * [3] Step ::= '.' | NameTest
! 1005: * [4] NameTest ::= QName | '*' | NCName ':' '*'
! 1006: */
! 1007:
! 1008: static void
! 1009: xmlCompileStepPattern(xmlPatParserContextPtr ctxt) {
! 1010: xmlChar *token = NULL;
! 1011: xmlChar *name = NULL;
! 1012: xmlChar *URL = NULL;
! 1013: int hasBlanks = 0;
! 1014:
! 1015: SKIP_BLANKS;
! 1016: if (CUR == '.') {
! 1017: /*
! 1018: * Context node.
! 1019: */
! 1020: NEXT;
! 1021: PUSH(XML_OP_ELEM, NULL, NULL);
! 1022: return;
! 1023: }
! 1024: if (CUR == '@') {
! 1025: /*
! 1026: * Attribute test.
! 1027: */
! 1028: if (XML_STREAM_XS_IDC_SEL(ctxt->comp)) {
! 1029: ERROR5(NULL, NULL, NULL,
! 1030: "Unexpected attribute axis in '%s'.\n", ctxt->base);
! 1031: ctxt->error = 1;
! 1032: return;
! 1033: }
! 1034: NEXT;
! 1035: xmlCompileAttributeTest(ctxt);
! 1036: if (ctxt->error != 0)
! 1037: goto error;
! 1038: return;
! 1039: }
! 1040: name = xmlPatScanNCName(ctxt);
! 1041: if (name == NULL) {
! 1042: if (CUR == '*') {
! 1043: NEXT;
! 1044: PUSH(XML_OP_ALL, NULL, NULL);
! 1045: return;
! 1046: } else {
! 1047: ERROR(NULL, NULL, NULL,
! 1048: "xmlCompileStepPattern : Name expected\n");
! 1049: ctxt->error = 1;
! 1050: return;
! 1051: }
! 1052: }
! 1053: if (IS_BLANK_CH(CUR)) {
! 1054: hasBlanks = 1;
! 1055: SKIP_BLANKS;
! 1056: }
! 1057: if (CUR == ':') {
! 1058: NEXT;
! 1059: if (CUR != ':') {
! 1060: xmlChar *prefix = name;
! 1061: int i;
! 1062:
! 1063: if (hasBlanks || IS_BLANK_CH(CUR)) {
! 1064: ERROR5(NULL, NULL, NULL, "Invalid QName.\n", NULL);
! 1065: ctxt->error = 1;
! 1066: goto error;
! 1067: }
! 1068: /*
! 1069: * This is a namespace match
! 1070: */
! 1071: token = xmlPatScanName(ctxt);
! 1072: if ((prefix[0] == 'x') &&
! 1073: (prefix[1] == 'm') &&
! 1074: (prefix[2] == 'l') &&
! 1075: (prefix[3] == 0))
! 1076: {
! 1077: XML_PAT_COPY_NSNAME(ctxt, URL, XML_XML_NAMESPACE)
! 1078: } else {
! 1079: for (i = 0;i < ctxt->nb_namespaces;i++) {
! 1080: if (xmlStrEqual(ctxt->namespaces[2 * i + 1], prefix)) {
! 1081: XML_PAT_COPY_NSNAME(ctxt, URL, ctxt->namespaces[2 * i])
! 1082: break;
! 1083: }
! 1084: }
! 1085: if (i >= ctxt->nb_namespaces) {
! 1086: ERROR5(NULL, NULL, NULL,
! 1087: "xmlCompileStepPattern : no namespace bound to prefix %s\n",
! 1088: prefix);
! 1089: ctxt->error = 1;
! 1090: goto error;
! 1091: }
! 1092: }
! 1093: XML_PAT_FREE_STRING(ctxt, prefix);
! 1094: name = NULL;
! 1095: if (token == NULL) {
! 1096: if (CUR == '*') {
! 1097: NEXT;
! 1098: PUSH(XML_OP_NS, URL, NULL);
! 1099: } else {
! 1100: ERROR(NULL, NULL, NULL,
! 1101: "xmlCompileStepPattern : Name expected\n");
! 1102: ctxt->error = 1;
! 1103: goto error;
! 1104: }
! 1105: } else {
! 1106: PUSH(XML_OP_ELEM, token, URL);
! 1107: }
! 1108: } else {
! 1109: NEXT;
! 1110: if (xmlStrEqual(name, (const xmlChar *) "child")) {
! 1111: XML_PAT_FREE_STRING(ctxt, name);
! 1112: name = xmlPatScanName(ctxt);
! 1113: if (name == NULL) {
! 1114: if (CUR == '*') {
! 1115: NEXT;
! 1116: PUSH(XML_OP_ALL, NULL, NULL);
! 1117: return;
! 1118: } else {
! 1119: ERROR(NULL, NULL, NULL,
! 1120: "xmlCompileStepPattern : QName expected\n");
! 1121: ctxt->error = 1;
! 1122: goto error;
! 1123: }
! 1124: }
! 1125: if (CUR == ':') {
! 1126: xmlChar *prefix = name;
! 1127: int i;
! 1128:
! 1129: NEXT;
! 1130: if (IS_BLANK_CH(CUR)) {
! 1131: ERROR5(NULL, NULL, NULL, "Invalid QName.\n", NULL);
! 1132: ctxt->error = 1;
! 1133: goto error;
! 1134: }
! 1135: /*
! 1136: * This is a namespace match
! 1137: */
! 1138: token = xmlPatScanName(ctxt);
! 1139: if ((prefix[0] == 'x') &&
! 1140: (prefix[1] == 'm') &&
! 1141: (prefix[2] == 'l') &&
! 1142: (prefix[3] == 0))
! 1143: {
! 1144: XML_PAT_COPY_NSNAME(ctxt, URL, XML_XML_NAMESPACE)
! 1145: } else {
! 1146: for (i = 0;i < ctxt->nb_namespaces;i++) {
! 1147: if (xmlStrEqual(ctxt->namespaces[2 * i + 1], prefix)) {
! 1148: XML_PAT_COPY_NSNAME(ctxt, URL, ctxt->namespaces[2 * i])
! 1149: break;
! 1150: }
! 1151: }
! 1152: if (i >= ctxt->nb_namespaces) {
! 1153: ERROR5(NULL, NULL, NULL,
! 1154: "xmlCompileStepPattern : no namespace bound "
! 1155: "to prefix %s\n", prefix);
! 1156: ctxt->error = 1;
! 1157: goto error;
! 1158: }
! 1159: }
! 1160: XML_PAT_FREE_STRING(ctxt, prefix);
! 1161: name = NULL;
! 1162: if (token == NULL) {
! 1163: if (CUR == '*') {
! 1164: NEXT;
! 1165: PUSH(XML_OP_NS, URL, NULL);
! 1166: } else {
! 1167: ERROR(NULL, NULL, NULL,
! 1168: "xmlCompileStepPattern : Name expected\n");
! 1169: ctxt->error = 1;
! 1170: goto error;
! 1171: }
! 1172: } else {
! 1173: PUSH(XML_OP_CHILD, token, URL);
! 1174: }
! 1175: } else
! 1176: PUSH(XML_OP_CHILD, name, NULL);
! 1177: return;
! 1178: } else if (xmlStrEqual(name, (const xmlChar *) "attribute")) {
! 1179: XML_PAT_FREE_STRING(ctxt, name)
! 1180: name = NULL;
! 1181: if (XML_STREAM_XS_IDC_SEL(ctxt->comp)) {
! 1182: ERROR5(NULL, NULL, NULL,
! 1183: "Unexpected attribute axis in '%s'.\n", ctxt->base);
! 1184: ctxt->error = 1;
! 1185: goto error;
! 1186: }
! 1187: xmlCompileAttributeTest(ctxt);
! 1188: if (ctxt->error != 0)
! 1189: goto error;
! 1190: return;
! 1191: } else {
! 1192: ERROR5(NULL, NULL, NULL,
! 1193: "The 'element' or 'attribute' axis is expected.\n", NULL);
! 1194: ctxt->error = 1;
! 1195: goto error;
! 1196: }
! 1197: }
! 1198: } else if (CUR == '*') {
! 1199: if (name != NULL) {
! 1200: ctxt->error = 1;
! 1201: goto error;
! 1202: }
! 1203: NEXT;
! 1204: PUSH(XML_OP_ALL, token, NULL);
! 1205: } else {
! 1206: PUSH(XML_OP_ELEM, name, NULL);
! 1207: }
! 1208: return;
! 1209: error:
! 1210: if (URL != NULL)
! 1211: XML_PAT_FREE_STRING(ctxt, URL)
! 1212: if (token != NULL)
! 1213: XML_PAT_FREE_STRING(ctxt, token)
! 1214: if (name != NULL)
! 1215: XML_PAT_FREE_STRING(ctxt, name)
! 1216: }
! 1217:
! 1218: /**
! 1219: * xmlCompilePathPattern:
! 1220: * @ctxt: the compilation context
! 1221: *
! 1222: * Compile the Path Pattern and generates a precompiled
! 1223: * form suitable for fast matching.
! 1224: *
! 1225: * [5] Path ::= ('.//')? ( Step '/' )* ( Step | '@' NameTest )
! 1226: */
! 1227: static void
! 1228: xmlCompilePathPattern(xmlPatParserContextPtr ctxt) {
! 1229: SKIP_BLANKS;
! 1230: if (CUR == '/') {
! 1231: ctxt->comp->flags |= PAT_FROM_ROOT;
! 1232: } else if ((CUR == '.') || (ctxt->comp->flags & XML_PATTERN_NOTPATTERN)) {
! 1233: ctxt->comp->flags |= PAT_FROM_CUR;
! 1234: }
! 1235:
! 1236: if ((CUR == '/') && (NXT(1) == '/')) {
! 1237: PUSH(XML_OP_ANCESTOR, NULL, NULL);
! 1238: NEXT;
! 1239: NEXT;
! 1240: } else if ((CUR == '.') && (NXT(1) == '/') && (NXT(2) == '/')) {
! 1241: PUSH(XML_OP_ANCESTOR, NULL, NULL);
! 1242: NEXT;
! 1243: NEXT;
! 1244: NEXT;
! 1245: /* Check for incompleteness. */
! 1246: SKIP_BLANKS;
! 1247: if (CUR == 0) {
! 1248: ERROR5(NULL, NULL, NULL,
! 1249: "Incomplete expression '%s'.\n", ctxt->base);
! 1250: ctxt->error = 1;
! 1251: goto error;
! 1252: }
! 1253: }
! 1254: if (CUR == '@') {
! 1255: NEXT;
! 1256: xmlCompileAttributeTest(ctxt);
! 1257: SKIP_BLANKS;
! 1258: /* TODO: check for incompleteness */
! 1259: if (CUR != 0) {
! 1260: xmlCompileStepPattern(ctxt);
! 1261: if (ctxt->error != 0)
! 1262: goto error;
! 1263: }
! 1264: } else {
! 1265: if (CUR == '/') {
! 1266: PUSH(XML_OP_ROOT, NULL, NULL);
! 1267: NEXT;
! 1268: /* Check for incompleteness. */
! 1269: SKIP_BLANKS;
! 1270: if (CUR == 0) {
! 1271: ERROR5(NULL, NULL, NULL,
! 1272: "Incomplete expression '%s'.\n", ctxt->base);
! 1273: ctxt->error = 1;
! 1274: goto error;
! 1275: }
! 1276: }
! 1277: xmlCompileStepPattern(ctxt);
! 1278: if (ctxt->error != 0)
! 1279: goto error;
! 1280: SKIP_BLANKS;
! 1281: while (CUR == '/') {
! 1282: if (NXT(1) == '/') {
! 1283: PUSH(XML_OP_ANCESTOR, NULL, NULL);
! 1284: NEXT;
! 1285: NEXT;
! 1286: SKIP_BLANKS;
! 1287: xmlCompileStepPattern(ctxt);
! 1288: if (ctxt->error != 0)
! 1289: goto error;
! 1290: } else {
! 1291: PUSH(XML_OP_PARENT, NULL, NULL);
! 1292: NEXT;
! 1293: SKIP_BLANKS;
! 1294: if (CUR == 0) {
! 1295: ERROR5(NULL, NULL, NULL,
! 1296: "Incomplete expression '%s'.\n", ctxt->base);
! 1297: ctxt->error = 1;
! 1298: goto error;
! 1299: }
! 1300: xmlCompileStepPattern(ctxt);
! 1301: if (ctxt->error != 0)
! 1302: goto error;
! 1303: }
! 1304: }
! 1305: }
! 1306: if (CUR != 0) {
! 1307: ERROR5(NULL, NULL, NULL,
! 1308: "Failed to compile pattern %s\n", ctxt->base);
! 1309: ctxt->error = 1;
! 1310: }
! 1311: error:
! 1312: return;
! 1313: }
! 1314:
! 1315: /**
! 1316: * xmlCompileIDCXPathPath:
! 1317: * @ctxt: the compilation context
! 1318: *
! 1319: * Compile the Path Pattern and generates a precompiled
! 1320: * form suitable for fast matching.
! 1321: *
! 1322: * [5] Path ::= ('.//')? ( Step '/' )* ( Step | '@' NameTest )
! 1323: */
! 1324: static void
! 1325: xmlCompileIDCXPathPath(xmlPatParserContextPtr ctxt) {
! 1326: SKIP_BLANKS;
! 1327: if (CUR == '/') {
! 1328: ERROR5(NULL, NULL, NULL,
! 1329: "Unexpected selection of the document root in '%s'.\n",
! 1330: ctxt->base);
! 1331: goto error;
! 1332: }
! 1333: ctxt->comp->flags |= PAT_FROM_CUR;
! 1334:
! 1335: if (CUR == '.') {
! 1336: /* "." - "self::node()" */
! 1337: NEXT;
! 1338: SKIP_BLANKS;
! 1339: if (CUR == 0) {
! 1340: /*
! 1341: * Selection of the context node.
! 1342: */
! 1343: PUSH(XML_OP_ELEM, NULL, NULL);
! 1344: return;
! 1345: }
! 1346: if (CUR != '/') {
! 1347: /* TODO: A more meaningful error message. */
! 1348: ERROR5(NULL, NULL, NULL,
! 1349: "Unexpected token after '.' in '%s'.\n", ctxt->base);
! 1350: goto error;
! 1351: }
! 1352: /* "./" - "self::node()/" */
! 1353: NEXT;
! 1354: SKIP_BLANKS;
! 1355: if (CUR == '/') {
! 1356: if (IS_BLANK_CH(PEEKPREV(1))) {
! 1357: /*
! 1358: * Disallow "./ /"
! 1359: */
! 1360: ERROR5(NULL, NULL, NULL,
! 1361: "Unexpected '/' token in '%s'.\n", ctxt->base);
! 1362: goto error;
! 1363: }
! 1364: /* ".//" - "self:node()/descendant-or-self::node()/" */
! 1365: PUSH(XML_OP_ANCESTOR, NULL, NULL);
! 1366: NEXT;
! 1367: SKIP_BLANKS;
! 1368: }
! 1369: if (CUR == 0)
! 1370: goto error_unfinished;
! 1371: }
! 1372: /*
! 1373: * Process steps.
! 1374: */
! 1375: do {
! 1376: xmlCompileStepPattern(ctxt);
! 1377: if (ctxt->error != 0)
! 1378: goto error;
! 1379: SKIP_BLANKS;
! 1380: if (CUR != '/')
! 1381: break;
! 1382: PUSH(XML_OP_PARENT, NULL, NULL);
! 1383: NEXT;
! 1384: SKIP_BLANKS;
! 1385: if (CUR == '/') {
! 1386: /*
! 1387: * Disallow subsequent '//'.
! 1388: */
! 1389: ERROR5(NULL, NULL, NULL,
! 1390: "Unexpected subsequent '//' in '%s'.\n",
! 1391: ctxt->base);
! 1392: goto error;
! 1393: }
! 1394: if (CUR == 0)
! 1395: goto error_unfinished;
! 1396:
! 1397: } while (CUR != 0);
! 1398:
! 1399: if (CUR != 0) {
! 1400: ERROR5(NULL, NULL, NULL,
! 1401: "Failed to compile expression '%s'.\n", ctxt->base);
! 1402: ctxt->error = 1;
! 1403: }
! 1404: return;
! 1405: error:
! 1406: ctxt->error = 1;
! 1407: return;
! 1408:
! 1409: error_unfinished:
! 1410: ctxt->error = 1;
! 1411: ERROR5(NULL, NULL, NULL,
! 1412: "Unfinished expression '%s'.\n", ctxt->base);
! 1413: return;
! 1414: }
! 1415:
! 1416: /************************************************************************
! 1417: * *
! 1418: * The streaming code *
! 1419: * *
! 1420: ************************************************************************/
! 1421:
! 1422: #ifdef DEBUG_STREAMING
! 1423: static void
! 1424: xmlDebugStreamComp(xmlStreamCompPtr stream) {
! 1425: int i;
! 1426:
! 1427: if (stream == NULL) {
! 1428: printf("Stream: NULL\n");
! 1429: return;
! 1430: }
! 1431: printf("Stream: %d steps\n", stream->nbStep);
! 1432: for (i = 0;i < stream->nbStep;i++) {
! 1433: if (stream->steps[i].ns != NULL) {
! 1434: printf("{%s}", stream->steps[i].ns);
! 1435: }
! 1436: if (stream->steps[i].name == NULL) {
! 1437: printf("* ");
! 1438: } else {
! 1439: printf("%s ", stream->steps[i].name);
! 1440: }
! 1441: if (stream->steps[i].flags & XML_STREAM_STEP_ROOT)
! 1442: printf("root ");
! 1443: if (stream->steps[i].flags & XML_STREAM_STEP_DESC)
! 1444: printf("// ");
! 1445: if (stream->steps[i].flags & XML_STREAM_STEP_FINAL)
! 1446: printf("final ");
! 1447: printf("\n");
! 1448: }
! 1449: }
! 1450: static void
! 1451: xmlDebugStreamCtxt(xmlStreamCtxtPtr ctxt, int match) {
! 1452: int i;
! 1453:
! 1454: if (ctxt == NULL) {
! 1455: printf("Stream: NULL\n");
! 1456: return;
! 1457: }
! 1458: printf("Stream: level %d, %d states: ", ctxt->level, ctxt->nbState);
! 1459: if (match)
! 1460: printf("matches\n");
! 1461: else
! 1462: printf("\n");
! 1463: for (i = 0;i < ctxt->nbState;i++) {
! 1464: if (ctxt->states[2 * i] < 0)
! 1465: printf(" %d: free\n", i);
! 1466: else {
! 1467: printf(" %d: step %d, level %d", i, ctxt->states[2 * i],
! 1468: ctxt->states[(2 * i) + 1]);
! 1469: if (ctxt->comp->steps[ctxt->states[2 * i]].flags &
! 1470: XML_STREAM_STEP_DESC)
! 1471: printf(" //\n");
! 1472: else
! 1473: printf("\n");
! 1474: }
! 1475: }
! 1476: }
! 1477: #endif
! 1478: /**
! 1479: * xmlNewStreamComp:
! 1480: * @size: the number of expected steps
! 1481: *
! 1482: * build a new compiled pattern for streaming
! 1483: *
! 1484: * Returns the new structure or NULL in case of error.
! 1485: */
! 1486: static xmlStreamCompPtr
! 1487: xmlNewStreamComp(int size) {
! 1488: xmlStreamCompPtr cur;
! 1489:
! 1490: if (size < 4)
! 1491: size = 4;
! 1492:
! 1493: cur = (xmlStreamCompPtr) xmlMalloc(sizeof(xmlStreamComp));
! 1494: if (cur == NULL) {
! 1495: ERROR(NULL, NULL, NULL,
! 1496: "xmlNewStreamComp: malloc failed\n");
! 1497: return(NULL);
! 1498: }
! 1499: memset(cur, 0, sizeof(xmlStreamComp));
! 1500: cur->steps = (xmlStreamStepPtr) xmlMalloc(size * sizeof(xmlStreamStep));
! 1501: if (cur->steps == NULL) {
! 1502: xmlFree(cur);
! 1503: ERROR(NULL, NULL, NULL,
! 1504: "xmlNewStreamComp: malloc failed\n");
! 1505: return(NULL);
! 1506: }
! 1507: cur->nbStep = 0;
! 1508: cur->maxStep = size;
! 1509: return(cur);
! 1510: }
! 1511:
! 1512: /**
! 1513: * xmlFreeStreamComp:
! 1514: * @comp: the compiled pattern for streaming
! 1515: *
! 1516: * Free the compiled pattern for streaming
! 1517: */
! 1518: static void
! 1519: xmlFreeStreamComp(xmlStreamCompPtr comp) {
! 1520: if (comp != NULL) {
! 1521: if (comp->steps != NULL)
! 1522: xmlFree(comp->steps);
! 1523: if (comp->dict != NULL)
! 1524: xmlDictFree(comp->dict);
! 1525: xmlFree(comp);
! 1526: }
! 1527: }
! 1528:
! 1529: /**
! 1530: * xmlStreamCompAddStep:
! 1531: * @comp: the compiled pattern for streaming
! 1532: * @name: the first string, the name, or NULL for *
! 1533: * @ns: the second step, the namespace name
! 1534: * @flags: the flags for that step
! 1535: *
! 1536: * Add a new step to the compiled pattern
! 1537: *
! 1538: * Returns -1 in case of error or the step index if successful
! 1539: */
! 1540: static int
! 1541: xmlStreamCompAddStep(xmlStreamCompPtr comp, const xmlChar *name,
! 1542: const xmlChar *ns, int nodeType, int flags) {
! 1543: xmlStreamStepPtr cur;
! 1544:
! 1545: if (comp->nbStep >= comp->maxStep) {
! 1546: cur = (xmlStreamStepPtr) xmlRealloc(comp->steps,
! 1547: comp->maxStep * 2 * sizeof(xmlStreamStep));
! 1548: if (cur == NULL) {
! 1549: ERROR(NULL, NULL, NULL,
! 1550: "xmlNewStreamComp: malloc failed\n");
! 1551: return(-1);
! 1552: }
! 1553: comp->steps = cur;
! 1554: comp->maxStep *= 2;
! 1555: }
! 1556: cur = &comp->steps[comp->nbStep++];
! 1557: cur->flags = flags;
! 1558: cur->name = name;
! 1559: cur->ns = ns;
! 1560: cur->nodeType = nodeType;
! 1561: return(comp->nbStep - 1);
! 1562: }
! 1563:
! 1564: /**
! 1565: * xmlStreamCompile:
! 1566: * @comp: the precompiled pattern
! 1567: *
! 1568: * Tries to stream compile a pattern
! 1569: *
! 1570: * Returns -1 in case of failure and 0 in case of success.
! 1571: */
! 1572: static int
! 1573: xmlStreamCompile(xmlPatternPtr comp) {
! 1574: xmlStreamCompPtr stream;
! 1575: int i, s = 0, root = 0, flags = 0, prevs = -1;
! 1576: xmlStepOp step;
! 1577:
! 1578: if ((comp == NULL) || (comp->steps == NULL))
! 1579: return(-1);
! 1580: /*
! 1581: * special case for .
! 1582: */
! 1583: if ((comp->nbStep == 1) &&
! 1584: (comp->steps[0].op == XML_OP_ELEM) &&
! 1585: (comp->steps[0].value == NULL) &&
! 1586: (comp->steps[0].value2 == NULL)) {
! 1587: stream = xmlNewStreamComp(0);
! 1588: if (stream == NULL)
! 1589: return(-1);
! 1590: /* Note that the stream will have no steps in this case. */
! 1591: stream->flags |= XML_STREAM_FINAL_IS_ANY_NODE;
! 1592: comp->stream = stream;
! 1593: return(0);
! 1594: }
! 1595:
! 1596: stream = xmlNewStreamComp((comp->nbStep / 2) + 1);
! 1597: if (stream == NULL)
! 1598: return(-1);
! 1599: if (comp->dict != NULL) {
! 1600: stream->dict = comp->dict;
! 1601: xmlDictReference(stream->dict);
! 1602: }
! 1603:
! 1604: i = 0;
! 1605: if (comp->flags & PAT_FROM_ROOT)
! 1606: stream->flags |= XML_STREAM_FROM_ROOT;
! 1607:
! 1608: for (;i < comp->nbStep;i++) {
! 1609: step = comp->steps[i];
! 1610: switch (step.op) {
! 1611: case XML_OP_END:
! 1612: break;
! 1613: case XML_OP_ROOT:
! 1614: if (i != 0)
! 1615: goto error;
! 1616: root = 1;
! 1617: break;
! 1618: case XML_OP_NS:
! 1619: s = xmlStreamCompAddStep(stream, NULL, step.value,
! 1620: XML_ELEMENT_NODE, flags);
! 1621: if (s < 0)
! 1622: goto error;
! 1623: prevs = s;
! 1624: flags = 0;
! 1625: break;
! 1626: case XML_OP_ATTR:
! 1627: flags |= XML_STREAM_STEP_ATTR;
! 1628: prevs = -1;
! 1629: s = xmlStreamCompAddStep(stream,
! 1630: step.value, step.value2, XML_ATTRIBUTE_NODE, flags);
! 1631: flags = 0;
! 1632: if (s < 0)
! 1633: goto error;
! 1634: break;
! 1635: case XML_OP_ELEM:
! 1636: if ((step.value == NULL) && (step.value2 == NULL)) {
! 1637: /*
! 1638: * We have a "." or "self::node()" here.
! 1639: * Eliminate redundant self::node() tests like in "/./."
! 1640: * or "//./"
! 1641: * The only case we won't eliminate is "//.", i.e. if
! 1642: * self::node() is the last node test and we had
! 1643: * continuation somewhere beforehand.
! 1644: */
! 1645: if ((comp->nbStep == i + 1) &&
! 1646: (flags & XML_STREAM_STEP_DESC)) {
! 1647: /*
! 1648: * Mark the special case where the expression resolves
! 1649: * to any type of node.
! 1650: */
! 1651: if (comp->nbStep == i + 1) {
! 1652: stream->flags |= XML_STREAM_FINAL_IS_ANY_NODE;
! 1653: }
! 1654: flags |= XML_STREAM_STEP_NODE;
! 1655: s = xmlStreamCompAddStep(stream, NULL, NULL,
! 1656: XML_STREAM_ANY_NODE, flags);
! 1657: if (s < 0)
! 1658: goto error;
! 1659: flags = 0;
! 1660: /*
! 1661: * If there was a previous step, mark it to be added to
! 1662: * the result node-set; this is needed since only
! 1663: * the last step will be marked as "final" and only
! 1664: * "final" nodes are added to the resulting set.
! 1665: */
! 1666: if (prevs != -1) {
! 1667: stream->steps[prevs].flags |= XML_STREAM_STEP_IN_SET;
! 1668: prevs = -1;
! 1669: }
! 1670: break;
! 1671:
! 1672: } else {
! 1673: /* Just skip this one. */
! 1674: continue;
! 1675: }
! 1676: }
! 1677: /* An element node. */
! 1678: s = xmlStreamCompAddStep(stream, step.value, step.value2,
! 1679: XML_ELEMENT_NODE, flags);
! 1680: if (s < 0)
! 1681: goto error;
! 1682: prevs = s;
! 1683: flags = 0;
! 1684: break;
! 1685: case XML_OP_CHILD:
! 1686: /* An element node child. */
! 1687: s = xmlStreamCompAddStep(stream, step.value, step.value2,
! 1688: XML_ELEMENT_NODE, flags);
! 1689: if (s < 0)
! 1690: goto error;
! 1691: prevs = s;
! 1692: flags = 0;
! 1693: break;
! 1694: case XML_OP_ALL:
! 1695: s = xmlStreamCompAddStep(stream, NULL, NULL,
! 1696: XML_ELEMENT_NODE, flags);
! 1697: if (s < 0)
! 1698: goto error;
! 1699: prevs = s;
! 1700: flags = 0;
! 1701: break;
! 1702: case XML_OP_PARENT:
! 1703: break;
! 1704: case XML_OP_ANCESTOR:
! 1705: /* Skip redundant continuations. */
! 1706: if (flags & XML_STREAM_STEP_DESC)
! 1707: break;
! 1708: flags |= XML_STREAM_STEP_DESC;
! 1709: /*
! 1710: * Mark the expression as having "//".
! 1711: */
! 1712: if ((stream->flags & XML_STREAM_DESC) == 0)
! 1713: stream->flags |= XML_STREAM_DESC;
! 1714: break;
! 1715: }
! 1716: }
! 1717: if ((! root) && (comp->flags & XML_PATTERN_NOTPATTERN) == 0) {
! 1718: /*
! 1719: * If this should behave like a real pattern, we will mark
! 1720: * the first step as having "//", to be reentrant on every
! 1721: * tree level.
! 1722: */
! 1723: if ((stream->flags & XML_STREAM_DESC) == 0)
! 1724: stream->flags |= XML_STREAM_DESC;
! 1725:
! 1726: if (stream->nbStep > 0) {
! 1727: if ((stream->steps[0].flags & XML_STREAM_STEP_DESC) == 0)
! 1728: stream->steps[0].flags |= XML_STREAM_STEP_DESC;
! 1729: }
! 1730: }
! 1731: if (stream->nbStep <= s)
! 1732: goto error;
! 1733: stream->steps[s].flags |= XML_STREAM_STEP_FINAL;
! 1734: if (root)
! 1735: stream->steps[0].flags |= XML_STREAM_STEP_ROOT;
! 1736: #ifdef DEBUG_STREAMING
! 1737: xmlDebugStreamComp(stream);
! 1738: #endif
! 1739: comp->stream = stream;
! 1740: return(0);
! 1741: error:
! 1742: xmlFreeStreamComp(stream);
! 1743: return(0);
! 1744: }
! 1745:
! 1746: /**
! 1747: * xmlNewStreamCtxt:
! 1748: * @size: the number of expected states
! 1749: *
! 1750: * build a new stream context
! 1751: *
! 1752: * Returns the new structure or NULL in case of error.
! 1753: */
! 1754: static xmlStreamCtxtPtr
! 1755: xmlNewStreamCtxt(xmlStreamCompPtr stream) {
! 1756: xmlStreamCtxtPtr cur;
! 1757:
! 1758: cur = (xmlStreamCtxtPtr) xmlMalloc(sizeof(xmlStreamCtxt));
! 1759: if (cur == NULL) {
! 1760: ERROR(NULL, NULL, NULL,
! 1761: "xmlNewStreamCtxt: malloc failed\n");
! 1762: return(NULL);
! 1763: }
! 1764: memset(cur, 0, sizeof(xmlStreamCtxt));
! 1765: cur->states = (int *) xmlMalloc(4 * 2 * sizeof(int));
! 1766: if (cur->states == NULL) {
! 1767: xmlFree(cur);
! 1768: ERROR(NULL, NULL, NULL,
! 1769: "xmlNewStreamCtxt: malloc failed\n");
! 1770: return(NULL);
! 1771: }
! 1772: cur->nbState = 0;
! 1773: cur->maxState = 4;
! 1774: cur->level = 0;
! 1775: cur->comp = stream;
! 1776: cur->blockLevel = -1;
! 1777: return(cur);
! 1778: }
! 1779:
! 1780: /**
! 1781: * xmlFreeStreamCtxt:
! 1782: * @stream: the stream context
! 1783: *
! 1784: * Free the stream context
! 1785: */
! 1786: void
! 1787: xmlFreeStreamCtxt(xmlStreamCtxtPtr stream) {
! 1788: xmlStreamCtxtPtr next;
! 1789:
! 1790: while (stream != NULL) {
! 1791: next = stream->next;
! 1792: if (stream->states != NULL)
! 1793: xmlFree(stream->states);
! 1794: xmlFree(stream);
! 1795: stream = next;
! 1796: }
! 1797: }
! 1798:
! 1799: /**
! 1800: * xmlStreamCtxtAddState:
! 1801: * @comp: the stream context
! 1802: * @idx: the step index for that streaming state
! 1803: *
! 1804: * Add a new state to the stream context
! 1805: *
! 1806: * Returns -1 in case of error or the state index if successful
! 1807: */
! 1808: static int
! 1809: xmlStreamCtxtAddState(xmlStreamCtxtPtr comp, int idx, int level) {
! 1810: int i;
! 1811: for (i = 0;i < comp->nbState;i++) {
! 1812: if (comp->states[2 * i] < 0) {
! 1813: comp->states[2 * i] = idx;
! 1814: comp->states[2 * i + 1] = level;
! 1815: return(i);
! 1816: }
! 1817: }
! 1818: if (comp->nbState >= comp->maxState) {
! 1819: int *cur;
! 1820:
! 1821: cur = (int *) xmlRealloc(comp->states,
! 1822: comp->maxState * 4 * sizeof(int));
! 1823: if (cur == NULL) {
! 1824: ERROR(NULL, NULL, NULL,
! 1825: "xmlNewStreamCtxt: malloc failed\n");
! 1826: return(-1);
! 1827: }
! 1828: comp->states = cur;
! 1829: comp->maxState *= 2;
! 1830: }
! 1831: comp->states[2 * comp->nbState] = idx;
! 1832: comp->states[2 * comp->nbState++ + 1] = level;
! 1833: return(comp->nbState - 1);
! 1834: }
! 1835:
! 1836: /**
! 1837: * xmlStreamPushInternal:
! 1838: * @stream: the stream context
! 1839: * @name: the current name
! 1840: * @ns: the namespace name
! 1841: * @nodeType: the type of the node
! 1842: *
! 1843: * Push new data onto the stream. NOTE: if the call xmlPatterncompile()
! 1844: * indicated a dictionary, then strings for name and ns will be expected
! 1845: * to come from the dictionary.
! 1846: * Both @name and @ns being NULL means the / i.e. the root of the document.
! 1847: * This can also act as a reset.
! 1848: *
! 1849: * Returns: -1 in case of error, 1 if the current state in the stream is a
! 1850: * match and 0 otherwise.
! 1851: */
! 1852: static int
! 1853: xmlStreamPushInternal(xmlStreamCtxtPtr stream,
! 1854: const xmlChar *name, const xmlChar *ns,
! 1855: int nodeType) {
! 1856: int ret = 0, err = 0, final = 0, tmp, i, m, match, stepNr, desc;
! 1857: xmlStreamCompPtr comp;
! 1858: xmlStreamStep step;
! 1859: #ifdef DEBUG_STREAMING
! 1860: xmlStreamCtxtPtr orig = stream;
! 1861: #endif
! 1862:
! 1863: if ((stream == NULL) || (stream->nbState < 0))
! 1864: return(-1);
! 1865:
! 1866: while (stream != NULL) {
! 1867: comp = stream->comp;
! 1868:
! 1869: if ((nodeType == XML_ELEMENT_NODE) &&
! 1870: (name == NULL) && (ns == NULL)) {
! 1871: /* We have a document node here (or a reset). */
! 1872: stream->nbState = 0;
! 1873: stream->level = 0;
! 1874: stream->blockLevel = -1;
! 1875: if (comp->flags & XML_STREAM_FROM_ROOT) {
! 1876: if (comp->nbStep == 0) {
! 1877: /* TODO: We have a "/." here? */
! 1878: ret = 1;
! 1879: } else {
! 1880: if ((comp->nbStep == 1) &&
! 1881: (comp->steps[0].nodeType == XML_STREAM_ANY_NODE) &&
! 1882: (comp->steps[0].flags & XML_STREAM_STEP_DESC))
! 1883: {
! 1884: /*
! 1885: * In the case of "//." the document node will match
! 1886: * as well.
! 1887: */
! 1888: ret = 1;
! 1889: } else if (comp->steps[0].flags & XML_STREAM_STEP_ROOT) {
! 1890: /* TODO: Do we need this ? */
! 1891: tmp = xmlStreamCtxtAddState(stream, 0, 0);
! 1892: if (tmp < 0)
! 1893: err++;
! 1894: }
! 1895: }
! 1896: }
! 1897: stream = stream->next;
! 1898: continue; /* while */
! 1899: }
! 1900:
! 1901: /*
! 1902: * Fast check for ".".
! 1903: */
! 1904: if (comp->nbStep == 0) {
! 1905: /*
! 1906: * / and . are handled at the XPath node set creation
! 1907: * level by checking min depth
! 1908: */
! 1909: if (stream->flags & XML_PATTERN_XPATH) {
! 1910: stream = stream->next;
! 1911: continue; /* while */
! 1912: }
! 1913: /*
! 1914: * For non-pattern like evaluation like XML Schema IDCs
! 1915: * or traditional XPath expressions, this will match if
! 1916: * we are at the first level only, otherwise on every level.
! 1917: */
! 1918: if ((nodeType != XML_ATTRIBUTE_NODE) &&
! 1919: (((stream->flags & XML_PATTERN_NOTPATTERN) == 0) ||
! 1920: (stream->level == 0))) {
! 1921: ret = 1;
! 1922: }
! 1923: stream->level++;
! 1924: goto stream_next;
! 1925: }
! 1926: if (stream->blockLevel != -1) {
! 1927: /*
! 1928: * Skip blocked expressions.
! 1929: */
! 1930: stream->level++;
! 1931: goto stream_next;
! 1932: }
! 1933:
! 1934: if ((nodeType != XML_ELEMENT_NODE) &&
! 1935: (nodeType != XML_ATTRIBUTE_NODE) &&
! 1936: ((comp->flags & XML_STREAM_FINAL_IS_ANY_NODE) == 0)) {
! 1937: /*
! 1938: * No need to process nodes of other types if we don't
! 1939: * resolve to those types.
! 1940: * TODO: Do we need to block the context here?
! 1941: */
! 1942: stream->level++;
! 1943: goto stream_next;
! 1944: }
! 1945:
! 1946: /*
! 1947: * Check evolution of existing states
! 1948: */
! 1949: i = 0;
! 1950: m = stream->nbState;
! 1951: while (i < m) {
! 1952: if ((comp->flags & XML_STREAM_DESC) == 0) {
! 1953: /*
! 1954: * If there is no "//", then only the last
! 1955: * added state is of interest.
! 1956: */
! 1957: stepNr = stream->states[2 * (stream->nbState -1)];
! 1958: /*
! 1959: * TODO: Security check, should not happen, remove it.
! 1960: */
! 1961: if (stream->states[(2 * (stream->nbState -1)) + 1] <
! 1962: stream->level) {
! 1963: return (-1);
! 1964: }
! 1965: desc = 0;
! 1966: /* loop-stopper */
! 1967: i = m;
! 1968: } else {
! 1969: /*
! 1970: * If there are "//", then we need to process every "//"
! 1971: * occuring in the states, plus any other state for this
! 1972: * level.
! 1973: */
! 1974: stepNr = stream->states[2 * i];
! 1975:
! 1976: /* TODO: should not happen anymore: dead states */
! 1977: if (stepNr < 0)
! 1978: goto next_state;
! 1979:
! 1980: tmp = stream->states[(2 * i) + 1];
! 1981:
! 1982: /* skip new states just added */
! 1983: if (tmp > stream->level)
! 1984: goto next_state;
! 1985:
! 1986: /* skip states at ancestor levels, except if "//" */
! 1987: desc = comp->steps[stepNr].flags & XML_STREAM_STEP_DESC;
! 1988: if ((tmp < stream->level) && (!desc))
! 1989: goto next_state;
! 1990: }
! 1991: /*
! 1992: * Check for correct node-type.
! 1993: */
! 1994: step = comp->steps[stepNr];
! 1995: if (step.nodeType != nodeType) {
! 1996: if (step.nodeType == XML_ATTRIBUTE_NODE) {
! 1997: /*
! 1998: * Block this expression for deeper evaluation.
! 1999: */
! 2000: if ((comp->flags & XML_STREAM_DESC) == 0)
! 2001: stream->blockLevel = stream->level +1;
! 2002: goto next_state;
! 2003: } else if (step.nodeType != XML_STREAM_ANY_NODE)
! 2004: goto next_state;
! 2005: }
! 2006: /*
! 2007: * Compare local/namespace-name.
! 2008: */
! 2009: match = 0;
! 2010: if (step.nodeType == XML_STREAM_ANY_NODE) {
! 2011: match = 1;
! 2012: } else if (step.name == NULL) {
! 2013: if (step.ns == NULL) {
! 2014: /*
! 2015: * This lets through all elements/attributes.
! 2016: */
! 2017: match = 1;
! 2018: } else if (ns != NULL)
! 2019: match = xmlStrEqual(step.ns, ns);
! 2020: } else if (((step.ns != NULL) == (ns != NULL)) &&
! 2021: (name != NULL) &&
! 2022: (step.name[0] == name[0]) &&
! 2023: xmlStrEqual(step.name, name) &&
! 2024: ((step.ns == ns) || xmlStrEqual(step.ns, ns)))
! 2025: {
! 2026: match = 1;
! 2027: }
! 2028: #if 0
! 2029: /*
! 2030: * TODO: Pointer comparison won't work, since not guaranteed that the given
! 2031: * values are in the same dict; especially if it's the namespace name,
! 2032: * normally coming from ns->href. We need a namespace dict mechanism !
! 2033: */
! 2034: } else if (comp->dict) {
! 2035: if (step.name == NULL) {
! 2036: if (step.ns == NULL)
! 2037: match = 1;
! 2038: else
! 2039: match = (step.ns == ns);
! 2040: } else {
! 2041: match = ((step.name == name) && (step.ns == ns));
! 2042: }
! 2043: #endif /* if 0 ------------------------------------------------------- */
! 2044: if (match) {
! 2045: final = step.flags & XML_STREAM_STEP_FINAL;
! 2046: if (desc) {
! 2047: if (final) {
! 2048: ret = 1;
! 2049: } else {
! 2050: /* descending match create a new state */
! 2051: xmlStreamCtxtAddState(stream, stepNr + 1,
! 2052: stream->level + 1);
! 2053: }
! 2054: } else {
! 2055: if (final) {
! 2056: ret = 1;
! 2057: } else {
! 2058: xmlStreamCtxtAddState(stream, stepNr + 1,
! 2059: stream->level + 1);
! 2060: }
! 2061: }
! 2062: if ((ret != 1) && (step.flags & XML_STREAM_STEP_IN_SET)) {
! 2063: /*
! 2064: * Check if we have a special case like "foo/bar//.", where
! 2065: * "foo" is selected as well.
! 2066: */
! 2067: ret = 1;
! 2068: }
! 2069: }
! 2070: if (((comp->flags & XML_STREAM_DESC) == 0) &&
! 2071: ((! match) || final)) {
! 2072: /*
! 2073: * Mark this expression as blocked for any evaluation at
! 2074: * deeper levels. Note that this includes "/foo"
! 2075: * expressions if the *pattern* behaviour is used.
! 2076: */
! 2077: stream->blockLevel = stream->level +1;
! 2078: }
! 2079: next_state:
! 2080: i++;
! 2081: }
! 2082:
! 2083: stream->level++;
! 2084:
! 2085: /*
! 2086: * Re/enter the expression.
! 2087: * Don't reenter if it's an absolute expression like "/foo",
! 2088: * except "//foo".
! 2089: */
! 2090: step = comp->steps[0];
! 2091: if (step.flags & XML_STREAM_STEP_ROOT)
! 2092: goto stream_next;
! 2093:
! 2094: desc = step.flags & XML_STREAM_STEP_DESC;
! 2095: if (stream->flags & XML_PATTERN_NOTPATTERN) {
! 2096: /*
! 2097: * Re/enter the expression if it is a "descendant" one,
! 2098: * or if we are at the 1st level of evaluation.
! 2099: */
! 2100:
! 2101: if (stream->level == 1) {
! 2102: if (XML_STREAM_XS_IDC(stream)) {
! 2103: /*
! 2104: * XS-IDC: The missing "self::node()" will always
! 2105: * match the first given node.
! 2106: */
! 2107: goto stream_next;
! 2108: } else
! 2109: goto compare;
! 2110: }
! 2111: /*
! 2112: * A "//" is always reentrant.
! 2113: */
! 2114: if (desc)
! 2115: goto compare;
! 2116:
! 2117: /*
! 2118: * XS-IDC: Process the 2nd level, since the missing
! 2119: * "self::node()" is responsible for the 2nd level being
! 2120: * the real start level.
! 2121: */
! 2122: if ((stream->level == 2) && XML_STREAM_XS_IDC(stream))
! 2123: goto compare;
! 2124:
! 2125: goto stream_next;
! 2126: }
! 2127:
! 2128: compare:
! 2129: /*
! 2130: * Check expected node-type.
! 2131: */
! 2132: if (step.nodeType != nodeType) {
! 2133: if (nodeType == XML_ATTRIBUTE_NODE)
! 2134: goto stream_next;
! 2135: else if (step.nodeType != XML_STREAM_ANY_NODE)
! 2136: goto stream_next;
! 2137: }
! 2138: /*
! 2139: * Compare local/namespace-name.
! 2140: */
! 2141: match = 0;
! 2142: if (step.nodeType == XML_STREAM_ANY_NODE) {
! 2143: match = 1;
! 2144: } else if (step.name == NULL) {
! 2145: if (step.ns == NULL) {
! 2146: /*
! 2147: * This lets through all elements/attributes.
! 2148: */
! 2149: match = 1;
! 2150: } else if (ns != NULL)
! 2151: match = xmlStrEqual(step.ns, ns);
! 2152: } else if (((step.ns != NULL) == (ns != NULL)) &&
! 2153: (name != NULL) &&
! 2154: (step.name[0] == name[0]) &&
! 2155: xmlStrEqual(step.name, name) &&
! 2156: ((step.ns == ns) || xmlStrEqual(step.ns, ns)))
! 2157: {
! 2158: match = 1;
! 2159: }
! 2160: final = step.flags & XML_STREAM_STEP_FINAL;
! 2161: if (match) {
! 2162: if (final)
! 2163: ret = 1;
! 2164: else
! 2165: xmlStreamCtxtAddState(stream, 1, stream->level);
! 2166: if ((ret != 1) && (step.flags & XML_STREAM_STEP_IN_SET)) {
! 2167: /*
! 2168: * Check if we have a special case like "foo//.", where
! 2169: * "foo" is selected as well.
! 2170: */
! 2171: ret = 1;
! 2172: }
! 2173: }
! 2174: if (((comp->flags & XML_STREAM_DESC) == 0) &&
! 2175: ((! match) || final)) {
! 2176: /*
! 2177: * Mark this expression as blocked for any evaluation at
! 2178: * deeper levels.
! 2179: */
! 2180: stream->blockLevel = stream->level;
! 2181: }
! 2182:
! 2183: stream_next:
! 2184: stream = stream->next;
! 2185: } /* while stream != NULL */
! 2186:
! 2187: if (err > 0)
! 2188: ret = -1;
! 2189: #ifdef DEBUG_STREAMING
! 2190: xmlDebugStreamCtxt(orig, ret);
! 2191: #endif
! 2192: return(ret);
! 2193: }
! 2194:
! 2195: /**
! 2196: * xmlStreamPush:
! 2197: * @stream: the stream context
! 2198: * @name: the current name
! 2199: * @ns: the namespace name
! 2200: *
! 2201: * Push new data onto the stream. NOTE: if the call xmlPatterncompile()
! 2202: * indicated a dictionary, then strings for name and ns will be expected
! 2203: * to come from the dictionary.
! 2204: * Both @name and @ns being NULL means the / i.e. the root of the document.
! 2205: * This can also act as a reset.
! 2206: * Otherwise the function will act as if it has been given an element-node.
! 2207: *
! 2208: * Returns: -1 in case of error, 1 if the current state in the stream is a
! 2209: * match and 0 otherwise.
! 2210: */
! 2211: int
! 2212: xmlStreamPush(xmlStreamCtxtPtr stream,
! 2213: const xmlChar *name, const xmlChar *ns) {
! 2214: return (xmlStreamPushInternal(stream, name, ns, (int) XML_ELEMENT_NODE));
! 2215: }
! 2216:
! 2217: /**
! 2218: * xmlStreamPushNode:
! 2219: * @stream: the stream context
! 2220: * @name: the current name
! 2221: * @ns: the namespace name
! 2222: * @nodeType: the type of the node being pushed
! 2223: *
! 2224: * Push new data onto the stream. NOTE: if the call xmlPatterncompile()
! 2225: * indicated a dictionary, then strings for name and ns will be expected
! 2226: * to come from the dictionary.
! 2227: * Both @name and @ns being NULL means the / i.e. the root of the document.
! 2228: * This can also act as a reset.
! 2229: * Different from xmlStreamPush() this function can be fed with nodes of type:
! 2230: * element-, attribute-, text-, cdata-section-, comment- and
! 2231: * processing-instruction-node.
! 2232: *
! 2233: * Returns: -1 in case of error, 1 if the current state in the stream is a
! 2234: * match and 0 otherwise.
! 2235: */
! 2236: int
! 2237: xmlStreamPushNode(xmlStreamCtxtPtr stream,
! 2238: const xmlChar *name, const xmlChar *ns,
! 2239: int nodeType)
! 2240: {
! 2241: return (xmlStreamPushInternal(stream, name, ns,
! 2242: nodeType));
! 2243: }
! 2244:
! 2245: /**
! 2246: * xmlStreamPushAttr:
! 2247: * @stream: the stream context
! 2248: * @name: the current name
! 2249: * @ns: the namespace name
! 2250: *
! 2251: * Push new attribute data onto the stream. NOTE: if the call xmlPatterncompile()
! 2252: * indicated a dictionary, then strings for name and ns will be expected
! 2253: * to come from the dictionary.
! 2254: * Both @name and @ns being NULL means the / i.e. the root of the document.
! 2255: * This can also act as a reset.
! 2256: * Otherwise the function will act as if it has been given an attribute-node.
! 2257: *
! 2258: * Returns: -1 in case of error, 1 if the current state in the stream is a
! 2259: * match and 0 otherwise.
! 2260: */
! 2261: int
! 2262: xmlStreamPushAttr(xmlStreamCtxtPtr stream,
! 2263: const xmlChar *name, const xmlChar *ns) {
! 2264: return (xmlStreamPushInternal(stream, name, ns, (int) XML_ATTRIBUTE_NODE));
! 2265: }
! 2266:
! 2267: /**
! 2268: * xmlStreamPop:
! 2269: * @stream: the stream context
! 2270: *
! 2271: * push one level from the stream.
! 2272: *
! 2273: * Returns: -1 in case of error, 0 otherwise.
! 2274: */
! 2275: int
! 2276: xmlStreamPop(xmlStreamCtxtPtr stream) {
! 2277: int i, lev;
! 2278:
! 2279: if (stream == NULL)
! 2280: return(-1);
! 2281: while (stream != NULL) {
! 2282: /*
! 2283: * Reset block-level.
! 2284: */
! 2285: if (stream->blockLevel == stream->level)
! 2286: stream->blockLevel = -1;
! 2287:
! 2288: /*
! 2289: * stream->level can be zero when XML_FINAL_IS_ANY_NODE is set
! 2290: * (see the thread at
! 2291: * http://mail.gnome.org/archives/xslt/2008-July/msg00027.html)
! 2292: */
! 2293: if (stream->level)
! 2294: stream->level--;
! 2295: /*
! 2296: * Check evolution of existing states
! 2297: */
! 2298: for (i = stream->nbState -1; i >= 0; i--) {
! 2299: /* discard obsoleted states */
! 2300: lev = stream->states[(2 * i) + 1];
! 2301: if (lev > stream->level)
! 2302: stream->nbState--;
! 2303: if (lev <= stream->level)
! 2304: break;
! 2305: }
! 2306: stream = stream->next;
! 2307: }
! 2308: return(0);
! 2309: }
! 2310:
! 2311: /**
! 2312: * xmlStreamWantsAnyNode:
! 2313: * @streamCtxt: the stream context
! 2314: *
! 2315: * Query if the streaming pattern additionally needs to be fed with
! 2316: * text-, cdata-section-, comment- and processing-instruction-nodes.
! 2317: * If the result is 0 then only element-nodes and attribute-nodes
! 2318: * need to be pushed.
! 2319: *
! 2320: * Returns: 1 in case of need of nodes of the above described types,
! 2321: * 0 otherwise. -1 on API errors.
! 2322: */
! 2323: int
! 2324: xmlStreamWantsAnyNode(xmlStreamCtxtPtr streamCtxt)
! 2325: {
! 2326: if (streamCtxt == NULL)
! 2327: return(-1);
! 2328: while (streamCtxt != NULL) {
! 2329: if (streamCtxt->comp->flags & XML_STREAM_FINAL_IS_ANY_NODE)
! 2330: return(1);
! 2331: streamCtxt = streamCtxt->next;
! 2332: }
! 2333: return(0);
! 2334: }
! 2335:
! 2336: /************************************************************************
! 2337: * *
! 2338: * The public interfaces *
! 2339: * *
! 2340: ************************************************************************/
! 2341:
! 2342: /**
! 2343: * xmlPatterncompile:
! 2344: * @pattern: the pattern to compile
! 2345: * @dict: an optional dictionary for interned strings
! 2346: * @flags: compilation flags, see xmlPatternFlags
! 2347: * @namespaces: the prefix definitions, array of [URI, prefix] or NULL
! 2348: *
! 2349: * Compile a pattern.
! 2350: *
! 2351: * Returns the compiled form of the pattern or NULL in case of error
! 2352: */
! 2353: xmlPatternPtr
! 2354: xmlPatterncompile(const xmlChar *pattern, xmlDict *dict, int flags,
! 2355: const xmlChar **namespaces) {
! 2356: xmlPatternPtr ret = NULL, cur;
! 2357: xmlPatParserContextPtr ctxt = NULL;
! 2358: const xmlChar *or, *start;
! 2359: xmlChar *tmp = NULL;
! 2360: int type = 0;
! 2361: int streamable = 1;
! 2362:
! 2363: if (pattern == NULL)
! 2364: return(NULL);
! 2365:
! 2366: start = pattern;
! 2367: or = start;
! 2368: while (*or != 0) {
! 2369: tmp = NULL;
! 2370: while ((*or != 0) && (*or != '|')) or++;
! 2371: if (*or == 0)
! 2372: ctxt = xmlNewPatParserContext(start, dict, namespaces);
! 2373: else {
! 2374: tmp = xmlStrndup(start, or - start);
! 2375: if (tmp != NULL) {
! 2376: ctxt = xmlNewPatParserContext(tmp, dict, namespaces);
! 2377: }
! 2378: or++;
! 2379: }
! 2380: if (ctxt == NULL) goto error;
! 2381: cur = xmlNewPattern();
! 2382: if (cur == NULL) goto error;
! 2383: /*
! 2384: * Assign string dict.
! 2385: */
! 2386: if (dict) {
! 2387: cur->dict = dict;
! 2388: xmlDictReference(dict);
! 2389: }
! 2390: if (ret == NULL)
! 2391: ret = cur;
! 2392: else {
! 2393: cur->next = ret->next;
! 2394: ret->next = cur;
! 2395: }
! 2396: cur->flags = flags;
! 2397: ctxt->comp = cur;
! 2398:
! 2399: if (XML_STREAM_XS_IDC(cur))
! 2400: xmlCompileIDCXPathPath(ctxt);
! 2401: else
! 2402: xmlCompilePathPattern(ctxt);
! 2403: if (ctxt->error != 0)
! 2404: goto error;
! 2405: xmlFreePatParserContext(ctxt);
! 2406: ctxt = NULL;
! 2407:
! 2408:
! 2409: if (streamable) {
! 2410: if (type == 0) {
! 2411: type = cur->flags & (PAT_FROM_ROOT | PAT_FROM_CUR);
! 2412: } else if (type == PAT_FROM_ROOT) {
! 2413: if (cur->flags & PAT_FROM_CUR)
! 2414: streamable = 0;
! 2415: } else if (type == PAT_FROM_CUR) {
! 2416: if (cur->flags & PAT_FROM_ROOT)
! 2417: streamable = 0;
! 2418: }
! 2419: }
! 2420: if (streamable)
! 2421: xmlStreamCompile(cur);
! 2422: if (xmlReversePattern(cur) < 0)
! 2423: goto error;
! 2424: if (tmp != NULL) {
! 2425: xmlFree(tmp);
! 2426: tmp = NULL;
! 2427: }
! 2428: start = or;
! 2429: }
! 2430: if (streamable == 0) {
! 2431: cur = ret;
! 2432: while (cur != NULL) {
! 2433: if (cur->stream != NULL) {
! 2434: xmlFreeStreamComp(cur->stream);
! 2435: cur->stream = NULL;
! 2436: }
! 2437: cur = cur->next;
! 2438: }
! 2439: }
! 2440:
! 2441: return(ret);
! 2442: error:
! 2443: if (ctxt != NULL) xmlFreePatParserContext(ctxt);
! 2444: if (ret != NULL) xmlFreePattern(ret);
! 2445: if (tmp != NULL) xmlFree(tmp);
! 2446: return(NULL);
! 2447: }
! 2448:
! 2449: /**
! 2450: * xmlPatternMatch:
! 2451: * @comp: the precompiled pattern
! 2452: * @node: a node
! 2453: *
! 2454: * Test whether the node matches the pattern
! 2455: *
! 2456: * Returns 1 if it matches, 0 if it doesn't and -1 in case of failure
! 2457: */
! 2458: int
! 2459: xmlPatternMatch(xmlPatternPtr comp, xmlNodePtr node)
! 2460: {
! 2461: int ret = 0;
! 2462:
! 2463: if ((comp == NULL) || (node == NULL))
! 2464: return(-1);
! 2465:
! 2466: while (comp != NULL) {
! 2467: ret = xmlPatMatch(comp, node);
! 2468: if (ret != 0)
! 2469: return(ret);
! 2470: comp = comp->next;
! 2471: }
! 2472: return(ret);
! 2473: }
! 2474:
! 2475: /**
! 2476: * xmlPatternGetStreamCtxt:
! 2477: * @comp: the precompiled pattern
! 2478: *
! 2479: * Get a streaming context for that pattern
! 2480: * Use xmlFreeStreamCtxt to free the context.
! 2481: *
! 2482: * Returns a pointer to the context or NULL in case of failure
! 2483: */
! 2484: xmlStreamCtxtPtr
! 2485: xmlPatternGetStreamCtxt(xmlPatternPtr comp)
! 2486: {
! 2487: xmlStreamCtxtPtr ret = NULL, cur;
! 2488:
! 2489: if ((comp == NULL) || (comp->stream == NULL))
! 2490: return(NULL);
! 2491:
! 2492: while (comp != NULL) {
! 2493: if (comp->stream == NULL)
! 2494: goto failed;
! 2495: cur = xmlNewStreamCtxt(comp->stream);
! 2496: if (cur == NULL)
! 2497: goto failed;
! 2498: if (ret == NULL)
! 2499: ret = cur;
! 2500: else {
! 2501: cur->next = ret->next;
! 2502: ret->next = cur;
! 2503: }
! 2504: cur->flags = comp->flags;
! 2505: comp = comp->next;
! 2506: }
! 2507: return(ret);
! 2508: failed:
! 2509: xmlFreeStreamCtxt(ret);
! 2510: return(NULL);
! 2511: }
! 2512:
! 2513: /**
! 2514: * xmlPatternStreamable:
! 2515: * @comp: the precompiled pattern
! 2516: *
! 2517: * Check if the pattern is streamable i.e. xmlPatternGetStreamCtxt()
! 2518: * should work.
! 2519: *
! 2520: * Returns 1 if streamable, 0 if not and -1 in case of error.
! 2521: */
! 2522: int
! 2523: xmlPatternStreamable(xmlPatternPtr comp) {
! 2524: if (comp == NULL)
! 2525: return(-1);
! 2526: while (comp != NULL) {
! 2527: if (comp->stream == NULL)
! 2528: return(0);
! 2529: comp = comp->next;
! 2530: }
! 2531: return(1);
! 2532: }
! 2533:
! 2534: /**
! 2535: * xmlPatternMaxDepth:
! 2536: * @comp: the precompiled pattern
! 2537: *
! 2538: * Check the maximum depth reachable by a pattern
! 2539: *
! 2540: * Returns -2 if no limit (using //), otherwise the depth,
! 2541: * and -1 in case of error
! 2542: */
! 2543: int
! 2544: xmlPatternMaxDepth(xmlPatternPtr comp) {
! 2545: int ret = 0, i;
! 2546: if (comp == NULL)
! 2547: return(-1);
! 2548: while (comp != NULL) {
! 2549: if (comp->stream == NULL)
! 2550: return(-1);
! 2551: for (i = 0;i < comp->stream->nbStep;i++)
! 2552: if (comp->stream->steps[i].flags & XML_STREAM_STEP_DESC)
! 2553: return(-2);
! 2554: if (comp->stream->nbStep > ret)
! 2555: ret = comp->stream->nbStep;
! 2556: comp = comp->next;
! 2557: }
! 2558: return(ret);
! 2559: }
! 2560:
! 2561: /**
! 2562: * xmlPatternMinDepth:
! 2563: * @comp: the precompiled pattern
! 2564: *
! 2565: * Check the minimum depth reachable by a pattern, 0 mean the / or . are
! 2566: * part of the set.
! 2567: *
! 2568: * Returns -1 in case of error otherwise the depth,
! 2569: *
! 2570: */
! 2571: int
! 2572: xmlPatternMinDepth(xmlPatternPtr comp) {
! 2573: int ret = 12345678;
! 2574: if (comp == NULL)
! 2575: return(-1);
! 2576: while (comp != NULL) {
! 2577: if (comp->stream == NULL)
! 2578: return(-1);
! 2579: if (comp->stream->nbStep < ret)
! 2580: ret = comp->stream->nbStep;
! 2581: if (ret == 0)
! 2582: return(0);
! 2583: comp = comp->next;
! 2584: }
! 2585: return(ret);
! 2586: }
! 2587:
! 2588: /**
! 2589: * xmlPatternFromRoot:
! 2590: * @comp: the precompiled pattern
! 2591: *
! 2592: * Check if the pattern must be looked at from the root.
! 2593: *
! 2594: * Returns 1 if true, 0 if false and -1 in case of error
! 2595: */
! 2596: int
! 2597: xmlPatternFromRoot(xmlPatternPtr comp) {
! 2598: if (comp == NULL)
! 2599: return(-1);
! 2600: while (comp != NULL) {
! 2601: if (comp->stream == NULL)
! 2602: return(-1);
! 2603: if (comp->flags & PAT_FROM_ROOT)
! 2604: return(1);
! 2605: comp = comp->next;
! 2606: }
! 2607: return(0);
! 2608:
! 2609: }
! 2610:
! 2611: #define bottom_pattern
! 2612: #include "elfgcchack.h"
! 2613: #endif /* LIBXML_PATTERN_ENABLED */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pattern.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2