Annotation of embedaddon/libxml2/xmlregexp.c, revision 1.1.1.1
1.1 misho 1: /*
2: * regexp.c: generic and extensible Regular Expression engine
3: *
4: * Basically designed with the purpose of compiling regexps for
5: * the variety of validation/shemas mechanisms now available in
6: * XML related specifications these include:
7: * - XML-1.0 DTD validation
8: * - XML Schemas structure part 1
9: * - XML Schemas Datatypes part 2 especially Appendix F
10: * - RELAX-NG/TREX i.e. the counter proposal
11: *
12: * See Copyright for the status of this software.
13: *
14: * Daniel Veillard <veillard@redhat.com>
15: */
16:
17: #define IN_LIBXML
18: #include "libxml.h"
19:
20: #ifdef LIBXML_REGEXP_ENABLED
21:
22: /* #define DEBUG_ERR */
23:
24: #include <stdio.h>
25: #include <string.h>
26: #ifdef HAVE_LIMITS_H
27: #include <limits.h>
28: #endif
29:
30: #include <libxml/tree.h>
31: #include <libxml/parserInternals.h>
32: #include <libxml/xmlregexp.h>
33: #include <libxml/xmlautomata.h>
34: #include <libxml/xmlunicode.h>
35:
36: #ifndef INT_MAX
37: #define INT_MAX 123456789 /* easy to flag and big enough for our needs */
38: #endif
39:
40: /* #define DEBUG_REGEXP_GRAPH */
41: /* #define DEBUG_REGEXP_EXEC */
42: /* #define DEBUG_PUSH */
43: /* #define DEBUG_COMPACTION */
44:
45: #define MAX_PUSH 10000000
46:
47: #define ERROR(str) \
48: ctxt->error = XML_REGEXP_COMPILE_ERROR; \
49: xmlRegexpErrCompile(ctxt, str);
50: #define NEXT ctxt->cur++
51: #define CUR (*(ctxt->cur))
52: #define NXT(index) (ctxt->cur[index])
53:
54: #define CUR_SCHAR(s, l) xmlStringCurrentChar(NULL, s, &l)
55: #define NEXTL(l) ctxt->cur += l;
56: #define XML_REG_STRING_SEPARATOR '|'
57: /*
58: * Need PREV to check on a '-' within a Character Group. May only be used
59: * when it's guaranteed that cur is not at the beginning of ctxt->string!
60: */
61: #define PREV (ctxt->cur[-1])
62:
63: /**
64: * TODO:
65: *
66: * macro to flag unimplemented blocks
67: */
68: #define TODO \
69: xmlGenericError(xmlGenericErrorContext, \
70: "Unimplemented block at %s:%d\n", \
71: __FILE__, __LINE__);
72:
73: /************************************************************************
74: * *
75: * Datatypes and structures *
76: * *
77: ************************************************************************/
78:
79: /*
80: * Note: the order of the enums below is significant, do not shuffle
81: */
82: typedef enum {
83: XML_REGEXP_EPSILON = 1,
84: XML_REGEXP_CHARVAL,
85: XML_REGEXP_RANGES,
86: XML_REGEXP_SUBREG, /* used for () sub regexps */
87: XML_REGEXP_STRING,
88: XML_REGEXP_ANYCHAR, /* . */
89: XML_REGEXP_ANYSPACE, /* \s */
90: XML_REGEXP_NOTSPACE, /* \S */
91: XML_REGEXP_INITNAME, /* \l */
92: XML_REGEXP_NOTINITNAME, /* \L */
93: XML_REGEXP_NAMECHAR, /* \c */
94: XML_REGEXP_NOTNAMECHAR, /* \C */
95: XML_REGEXP_DECIMAL, /* \d */
96: XML_REGEXP_NOTDECIMAL, /* \D */
97: XML_REGEXP_REALCHAR, /* \w */
98: XML_REGEXP_NOTREALCHAR, /* \W */
99: XML_REGEXP_LETTER = 100,
100: XML_REGEXP_LETTER_UPPERCASE,
101: XML_REGEXP_LETTER_LOWERCASE,
102: XML_REGEXP_LETTER_TITLECASE,
103: XML_REGEXP_LETTER_MODIFIER,
104: XML_REGEXP_LETTER_OTHERS,
105: XML_REGEXP_MARK,
106: XML_REGEXP_MARK_NONSPACING,
107: XML_REGEXP_MARK_SPACECOMBINING,
108: XML_REGEXP_MARK_ENCLOSING,
109: XML_REGEXP_NUMBER,
110: XML_REGEXP_NUMBER_DECIMAL,
111: XML_REGEXP_NUMBER_LETTER,
112: XML_REGEXP_NUMBER_OTHERS,
113: XML_REGEXP_PUNCT,
114: XML_REGEXP_PUNCT_CONNECTOR,
115: XML_REGEXP_PUNCT_DASH,
116: XML_REGEXP_PUNCT_OPEN,
117: XML_REGEXP_PUNCT_CLOSE,
118: XML_REGEXP_PUNCT_INITQUOTE,
119: XML_REGEXP_PUNCT_FINQUOTE,
120: XML_REGEXP_PUNCT_OTHERS,
121: XML_REGEXP_SEPAR,
122: XML_REGEXP_SEPAR_SPACE,
123: XML_REGEXP_SEPAR_LINE,
124: XML_REGEXP_SEPAR_PARA,
125: XML_REGEXP_SYMBOL,
126: XML_REGEXP_SYMBOL_MATH,
127: XML_REGEXP_SYMBOL_CURRENCY,
128: XML_REGEXP_SYMBOL_MODIFIER,
129: XML_REGEXP_SYMBOL_OTHERS,
130: XML_REGEXP_OTHER,
131: XML_REGEXP_OTHER_CONTROL,
132: XML_REGEXP_OTHER_FORMAT,
133: XML_REGEXP_OTHER_PRIVATE,
134: XML_REGEXP_OTHER_NA,
135: XML_REGEXP_BLOCK_NAME
136: } xmlRegAtomType;
137:
138: typedef enum {
139: XML_REGEXP_QUANT_EPSILON = 1,
140: XML_REGEXP_QUANT_ONCE,
141: XML_REGEXP_QUANT_OPT,
142: XML_REGEXP_QUANT_MULT,
143: XML_REGEXP_QUANT_PLUS,
144: XML_REGEXP_QUANT_ONCEONLY,
145: XML_REGEXP_QUANT_ALL,
146: XML_REGEXP_QUANT_RANGE
147: } xmlRegQuantType;
148:
149: typedef enum {
150: XML_REGEXP_START_STATE = 1,
151: XML_REGEXP_FINAL_STATE,
152: XML_REGEXP_TRANS_STATE,
153: XML_REGEXP_SINK_STATE,
154: XML_REGEXP_UNREACH_STATE
155: } xmlRegStateType;
156:
157: typedef enum {
158: XML_REGEXP_MARK_NORMAL = 0,
159: XML_REGEXP_MARK_START,
160: XML_REGEXP_MARK_VISITED
161: } xmlRegMarkedType;
162:
163: typedef struct _xmlRegRange xmlRegRange;
164: typedef xmlRegRange *xmlRegRangePtr;
165:
166: struct _xmlRegRange {
167: int neg; /* 0 normal, 1 not, 2 exclude */
168: xmlRegAtomType type;
169: int start;
170: int end;
171: xmlChar *blockName;
172: };
173:
174: typedef struct _xmlRegAtom xmlRegAtom;
175: typedef xmlRegAtom *xmlRegAtomPtr;
176:
177: typedef struct _xmlAutomataState xmlRegState;
178: typedef xmlRegState *xmlRegStatePtr;
179:
180: struct _xmlRegAtom {
181: int no;
182: xmlRegAtomType type;
183: xmlRegQuantType quant;
184: int min;
185: int max;
186:
187: void *valuep;
188: void *valuep2;
189: int neg;
190: int codepoint;
191: xmlRegStatePtr start;
192: xmlRegStatePtr start0;
193: xmlRegStatePtr stop;
194: int maxRanges;
195: int nbRanges;
196: xmlRegRangePtr *ranges;
197: void *data;
198: };
199:
200: typedef struct _xmlRegCounter xmlRegCounter;
201: typedef xmlRegCounter *xmlRegCounterPtr;
202:
203: struct _xmlRegCounter {
204: int min;
205: int max;
206: };
207:
208: typedef struct _xmlRegTrans xmlRegTrans;
209: typedef xmlRegTrans *xmlRegTransPtr;
210:
211: struct _xmlRegTrans {
212: xmlRegAtomPtr atom;
213: int to;
214: int counter;
215: int count;
216: int nd;
217: };
218:
219: struct _xmlAutomataState {
220: xmlRegStateType type;
221: xmlRegMarkedType mark;
222: xmlRegMarkedType reached;
223: int no;
224: int maxTrans;
225: int nbTrans;
226: xmlRegTrans *trans;
227: /* knowing states ponting to us can speed things up */
228: int maxTransTo;
229: int nbTransTo;
230: int *transTo;
231: };
232:
233: typedef struct _xmlAutomata xmlRegParserCtxt;
234: typedef xmlRegParserCtxt *xmlRegParserCtxtPtr;
235:
236: #define AM_AUTOMATA_RNG 1
237:
238: struct _xmlAutomata {
239: xmlChar *string;
240: xmlChar *cur;
241:
242: int error;
243: int neg;
244:
245: xmlRegStatePtr start;
246: xmlRegStatePtr end;
247: xmlRegStatePtr state;
248:
249: xmlRegAtomPtr atom;
250:
251: int maxAtoms;
252: int nbAtoms;
253: xmlRegAtomPtr *atoms;
254:
255: int maxStates;
256: int nbStates;
257: xmlRegStatePtr *states;
258:
259: int maxCounters;
260: int nbCounters;
261: xmlRegCounter *counters;
262:
263: int determinist;
264: int negs;
265: int flags;
266: };
267:
268: struct _xmlRegexp {
269: xmlChar *string;
270: int nbStates;
271: xmlRegStatePtr *states;
272: int nbAtoms;
273: xmlRegAtomPtr *atoms;
274: int nbCounters;
275: xmlRegCounter *counters;
276: int determinist;
277: int flags;
278: /*
279: * That's the compact form for determinists automatas
280: */
281: int nbstates;
282: int *compact;
283: void **transdata;
284: int nbstrings;
285: xmlChar **stringMap;
286: };
287:
288: typedef struct _xmlRegExecRollback xmlRegExecRollback;
289: typedef xmlRegExecRollback *xmlRegExecRollbackPtr;
290:
291: struct _xmlRegExecRollback {
292: xmlRegStatePtr state;/* the current state */
293: int index; /* the index in the input stack */
294: int nextbranch; /* the next transition to explore in that state */
295: int *counts; /* save the automata state if it has some */
296: };
297:
298: typedef struct _xmlRegInputToken xmlRegInputToken;
299: typedef xmlRegInputToken *xmlRegInputTokenPtr;
300:
301: struct _xmlRegInputToken {
302: xmlChar *value;
303: void *data;
304: };
305:
306: struct _xmlRegExecCtxt {
307: int status; /* execution status != 0 indicate an error */
308: int determinist; /* did we find an indeterministic behaviour */
309: xmlRegexpPtr comp; /* the compiled regexp */
310: xmlRegExecCallbacks callback;
311: void *data;
312:
313: xmlRegStatePtr state;/* the current state */
314: int transno; /* the current transition on that state */
315: int transcount; /* the number of chars in char counted transitions */
316:
317: /*
318: * A stack of rollback states
319: */
320: int maxRollbacks;
321: int nbRollbacks;
322: xmlRegExecRollback *rollbacks;
323:
324: /*
325: * The state of the automata if any
326: */
327: int *counts;
328:
329: /*
330: * The input stack
331: */
332: int inputStackMax;
333: int inputStackNr;
334: int index;
335: int *charStack;
336: const xmlChar *inputString; /* when operating on characters */
337: xmlRegInputTokenPtr inputStack;/* when operating on strings */
338:
339: /*
340: * error handling
341: */
342: int errStateNo; /* the error state number */
343: xmlRegStatePtr errState; /* the error state */
344: xmlChar *errString; /* the string raising the error */
345: int *errCounts; /* counters at the error state */
346: int nbPush;
347: };
348:
349: #define REGEXP_ALL_COUNTER 0x123456
350: #define REGEXP_ALL_LAX_COUNTER 0x123457
351:
352: static void xmlFAParseRegExp(xmlRegParserCtxtPtr ctxt, int top);
353: static void xmlRegFreeState(xmlRegStatePtr state);
354: static void xmlRegFreeAtom(xmlRegAtomPtr atom);
355: static int xmlRegStrEqualWildcard(const xmlChar *expStr, const xmlChar *valStr);
356: static int xmlRegCheckCharacter(xmlRegAtomPtr atom, int codepoint);
357: static int xmlRegCheckCharacterRange(xmlRegAtomType type, int codepoint,
358: int neg, int start, int end, const xmlChar *blockName);
359:
360: void xmlAutomataSetFlags(xmlAutomataPtr am, int flags);
361:
362: /************************************************************************
363: * *
364: * Regexp memory error handler *
365: * *
366: ************************************************************************/
367: /**
368: * xmlRegexpErrMemory:
369: * @extra: extra information
370: *
371: * Handle an out of memory condition
372: */
373: static void
374: xmlRegexpErrMemory(xmlRegParserCtxtPtr ctxt, const char *extra)
375: {
376: const char *regexp = NULL;
377: if (ctxt != NULL) {
378: regexp = (const char *) ctxt->string;
379: ctxt->error = XML_ERR_NO_MEMORY;
380: }
381: __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
382: XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
383: regexp, NULL, 0, 0,
384: "Memory allocation failed : %s\n", extra);
385: }
386:
387: /**
388: * xmlRegexpErrCompile:
389: * @extra: extra information
390: *
391: * Handle a compilation failure
392: */
393: static void
394: xmlRegexpErrCompile(xmlRegParserCtxtPtr ctxt, const char *extra)
395: {
396: const char *regexp = NULL;
397: int idx = 0;
398:
399: if (ctxt != NULL) {
400: regexp = (const char *) ctxt->string;
401: idx = ctxt->cur - ctxt->string;
402: ctxt->error = XML_REGEXP_COMPILE_ERROR;
403: }
404: __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
405: XML_REGEXP_COMPILE_ERROR, XML_ERR_FATAL, NULL, 0, extra,
406: regexp, NULL, idx, 0,
407: "failed to compile: %s\n", extra);
408: }
409:
410: /************************************************************************
411: * *
412: * Allocation/Deallocation *
413: * *
414: ************************************************************************/
415:
416: static int xmlFAComputesDeterminism(xmlRegParserCtxtPtr ctxt);
417: /**
418: * xmlRegEpxFromParse:
419: * @ctxt: the parser context used to build it
420: *
421: * Allocate a new regexp and fill it with the result from the parser
422: *
423: * Returns the new regexp or NULL in case of error
424: */
425: static xmlRegexpPtr
426: xmlRegEpxFromParse(xmlRegParserCtxtPtr ctxt) {
427: xmlRegexpPtr ret;
428:
429: ret = (xmlRegexpPtr) xmlMalloc(sizeof(xmlRegexp));
430: if (ret == NULL) {
431: xmlRegexpErrMemory(ctxt, "compiling regexp");
432: return(NULL);
433: }
434: memset(ret, 0, sizeof(xmlRegexp));
435: ret->string = ctxt->string;
436: ret->nbStates = ctxt->nbStates;
437: ret->states = ctxt->states;
438: ret->nbAtoms = ctxt->nbAtoms;
439: ret->atoms = ctxt->atoms;
440: ret->nbCounters = ctxt->nbCounters;
441: ret->counters = ctxt->counters;
442: ret->determinist = ctxt->determinist;
443: ret->flags = ctxt->flags;
444: if (ret->determinist == -1) {
445: xmlRegexpIsDeterminist(ret);
446: }
447:
448: if ((ret->determinist != 0) &&
449: (ret->nbCounters == 0) &&
450: (ctxt->negs == 0) &&
451: (ret->atoms != NULL) &&
452: (ret->atoms[0] != NULL) &&
453: (ret->atoms[0]->type == XML_REGEXP_STRING)) {
454: int i, j, nbstates = 0, nbatoms = 0;
455: int *stateRemap;
456: int *stringRemap;
457: int *transitions;
458: void **transdata;
459: xmlChar **stringMap;
460: xmlChar *value;
461:
462: /*
463: * Switch to a compact representation
464: * 1/ counting the effective number of states left
465: * 2/ counting the unique number of atoms, and check that
466: * they are all of the string type
467: * 3/ build a table state x atom for the transitions
468: */
469:
470: stateRemap = xmlMalloc(ret->nbStates * sizeof(int));
471: if (stateRemap == NULL) {
472: xmlRegexpErrMemory(ctxt, "compiling regexp");
473: xmlFree(ret);
474: return(NULL);
475: }
476: for (i = 0;i < ret->nbStates;i++) {
477: if (ret->states[i] != NULL) {
478: stateRemap[i] = nbstates;
479: nbstates++;
480: } else {
481: stateRemap[i] = -1;
482: }
483: }
484: #ifdef DEBUG_COMPACTION
485: printf("Final: %d states\n", nbstates);
486: #endif
487: stringMap = xmlMalloc(ret->nbAtoms * sizeof(char *));
488: if (stringMap == NULL) {
489: xmlRegexpErrMemory(ctxt, "compiling regexp");
490: xmlFree(stateRemap);
491: xmlFree(ret);
492: return(NULL);
493: }
494: stringRemap = xmlMalloc(ret->nbAtoms * sizeof(int));
495: if (stringRemap == NULL) {
496: xmlRegexpErrMemory(ctxt, "compiling regexp");
497: xmlFree(stringMap);
498: xmlFree(stateRemap);
499: xmlFree(ret);
500: return(NULL);
501: }
502: for (i = 0;i < ret->nbAtoms;i++) {
503: if ((ret->atoms[i]->type == XML_REGEXP_STRING) &&
504: (ret->atoms[i]->quant == XML_REGEXP_QUANT_ONCE)) {
505: value = ret->atoms[i]->valuep;
506: for (j = 0;j < nbatoms;j++) {
507: if (xmlStrEqual(stringMap[j], value)) {
508: stringRemap[i] = j;
509: break;
510: }
511: }
512: if (j >= nbatoms) {
513: stringRemap[i] = nbatoms;
514: stringMap[nbatoms] = xmlStrdup(value);
515: if (stringMap[nbatoms] == NULL) {
516: for (i = 0;i < nbatoms;i++)
517: xmlFree(stringMap[i]);
518: xmlFree(stringRemap);
519: xmlFree(stringMap);
520: xmlFree(stateRemap);
521: xmlFree(ret);
522: return(NULL);
523: }
524: nbatoms++;
525: }
526: } else {
527: xmlFree(stateRemap);
528: xmlFree(stringRemap);
529: for (i = 0;i < nbatoms;i++)
530: xmlFree(stringMap[i]);
531: xmlFree(stringMap);
532: xmlFree(ret);
533: return(NULL);
534: }
535: }
536: #ifdef DEBUG_COMPACTION
537: printf("Final: %d atoms\n", nbatoms);
538: #endif
539: transitions = (int *) xmlMalloc((nbstates + 1) *
540: (nbatoms + 1) * sizeof(int));
541: if (transitions == NULL) {
542: xmlFree(stateRemap);
543: xmlFree(stringRemap);
544: xmlFree(stringMap);
545: xmlFree(ret);
546: return(NULL);
547: }
548: memset(transitions, 0, (nbstates + 1) * (nbatoms + 1) * sizeof(int));
549:
550: /*
551: * Allocate the transition table. The first entry for each
552: * state corresponds to the state type.
553: */
554: transdata = NULL;
555:
556: for (i = 0;i < ret->nbStates;i++) {
557: int stateno, atomno, targetno, prev;
558: xmlRegStatePtr state;
559: xmlRegTransPtr trans;
560:
561: stateno = stateRemap[i];
562: if (stateno == -1)
563: continue;
564: state = ret->states[i];
565:
566: transitions[stateno * (nbatoms + 1)] = state->type;
567:
568: for (j = 0;j < state->nbTrans;j++) {
569: trans = &(state->trans[j]);
570: if ((trans->to == -1) || (trans->atom == NULL))
571: continue;
572: atomno = stringRemap[trans->atom->no];
573: if ((trans->atom->data != NULL) && (transdata == NULL)) {
574: transdata = (void **) xmlMalloc(nbstates * nbatoms *
575: sizeof(void *));
576: if (transdata != NULL)
577: memset(transdata, 0,
578: nbstates * nbatoms * sizeof(void *));
579: else {
580: xmlRegexpErrMemory(ctxt, "compiling regexp");
581: break;
582: }
583: }
584: targetno = stateRemap[trans->to];
585: /*
586: * if the same atom can generate transitions to 2 different
587: * states then it means the automata is not determinist and
588: * the compact form can't be used !
589: */
590: prev = transitions[stateno * (nbatoms + 1) + atomno + 1];
591: if (prev != 0) {
592: if (prev != targetno + 1) {
593: ret->determinist = 0;
594: #ifdef DEBUG_COMPACTION
595: printf("Indet: state %d trans %d, atom %d to %d : %d to %d\n",
596: i, j, trans->atom->no, trans->to, atomno, targetno);
597: printf(" previous to is %d\n", prev);
598: #endif
599: if (transdata != NULL)
600: xmlFree(transdata);
601: xmlFree(transitions);
602: xmlFree(stateRemap);
603: xmlFree(stringRemap);
604: for (i = 0;i < nbatoms;i++)
605: xmlFree(stringMap[i]);
606: xmlFree(stringMap);
607: goto not_determ;
608: }
609: } else {
610: #if 0
611: printf("State %d trans %d: atom %d to %d : %d to %d\n",
612: i, j, trans->atom->no, trans->to, atomno, targetno);
613: #endif
614: transitions[stateno * (nbatoms + 1) + atomno + 1] =
615: targetno + 1; /* to avoid 0 */
616: if (transdata != NULL)
617: transdata[stateno * nbatoms + atomno] =
618: trans->atom->data;
619: }
620: }
621: }
622: ret->determinist = 1;
623: #ifdef DEBUG_COMPACTION
624: /*
625: * Debug
626: */
627: for (i = 0;i < nbstates;i++) {
628: for (j = 0;j < nbatoms + 1;j++) {
629: printf("%02d ", transitions[i * (nbatoms + 1) + j]);
630: }
631: printf("\n");
632: }
633: printf("\n");
634: #endif
635: /*
636: * Cleanup of the old data
637: */
638: if (ret->states != NULL) {
639: for (i = 0;i < ret->nbStates;i++)
640: xmlRegFreeState(ret->states[i]);
641: xmlFree(ret->states);
642: }
643: ret->states = NULL;
644: ret->nbStates = 0;
645: if (ret->atoms != NULL) {
646: for (i = 0;i < ret->nbAtoms;i++)
647: xmlRegFreeAtom(ret->atoms[i]);
648: xmlFree(ret->atoms);
649: }
650: ret->atoms = NULL;
651: ret->nbAtoms = 0;
652:
653: ret->compact = transitions;
654: ret->transdata = transdata;
655: ret->stringMap = stringMap;
656: ret->nbstrings = nbatoms;
657: ret->nbstates = nbstates;
658: xmlFree(stateRemap);
659: xmlFree(stringRemap);
660: }
661: not_determ:
662: ctxt->string = NULL;
663: ctxt->nbStates = 0;
664: ctxt->states = NULL;
665: ctxt->nbAtoms = 0;
666: ctxt->atoms = NULL;
667: ctxt->nbCounters = 0;
668: ctxt->counters = NULL;
669: return(ret);
670: }
671:
672: /**
673: * xmlRegNewParserCtxt:
674: * @string: the string to parse
675: *
676: * Allocate a new regexp parser context
677: *
678: * Returns the new context or NULL in case of error
679: */
680: static xmlRegParserCtxtPtr
681: xmlRegNewParserCtxt(const xmlChar *string) {
682: xmlRegParserCtxtPtr ret;
683:
684: ret = (xmlRegParserCtxtPtr) xmlMalloc(sizeof(xmlRegParserCtxt));
685: if (ret == NULL)
686: return(NULL);
687: memset(ret, 0, sizeof(xmlRegParserCtxt));
688: if (string != NULL)
689: ret->string = xmlStrdup(string);
690: ret->cur = ret->string;
691: ret->neg = 0;
692: ret->negs = 0;
693: ret->error = 0;
694: ret->determinist = -1;
695: return(ret);
696: }
697:
698: /**
699: * xmlRegNewRange:
700: * @ctxt: the regexp parser context
701: * @neg: is that negative
702: * @type: the type of range
703: * @start: the start codepoint
704: * @end: the end codepoint
705: *
706: * Allocate a new regexp range
707: *
708: * Returns the new range or NULL in case of error
709: */
710: static xmlRegRangePtr
711: xmlRegNewRange(xmlRegParserCtxtPtr ctxt,
712: int neg, xmlRegAtomType type, int start, int end) {
713: xmlRegRangePtr ret;
714:
715: ret = (xmlRegRangePtr) xmlMalloc(sizeof(xmlRegRange));
716: if (ret == NULL) {
717: xmlRegexpErrMemory(ctxt, "allocating range");
718: return(NULL);
719: }
720: ret->neg = neg;
721: ret->type = type;
722: ret->start = start;
723: ret->end = end;
724: return(ret);
725: }
726:
727: /**
728: * xmlRegFreeRange:
729: * @range: the regexp range
730: *
731: * Free a regexp range
732: */
733: static void
734: xmlRegFreeRange(xmlRegRangePtr range) {
735: if (range == NULL)
736: return;
737:
738: if (range->blockName != NULL)
739: xmlFree(range->blockName);
740: xmlFree(range);
741: }
742:
743: /**
744: * xmlRegCopyRange:
745: * @range: the regexp range
746: *
747: * Copy a regexp range
748: *
749: * Returns the new copy or NULL in case of error.
750: */
751: static xmlRegRangePtr
752: xmlRegCopyRange(xmlRegParserCtxtPtr ctxt, xmlRegRangePtr range) {
753: xmlRegRangePtr ret;
754:
755: if (range == NULL)
756: return(NULL);
757:
758: ret = xmlRegNewRange(ctxt, range->neg, range->type, range->start,
759: range->end);
760: if (ret == NULL)
761: return(NULL);
762: if (range->blockName != NULL) {
763: ret->blockName = xmlStrdup(range->blockName);
764: if (ret->blockName == NULL) {
765: xmlRegexpErrMemory(ctxt, "allocating range");
766: xmlRegFreeRange(ret);
767: return(NULL);
768: }
769: }
770: return(ret);
771: }
772:
773: /**
774: * xmlRegNewAtom:
775: * @ctxt: the regexp parser context
776: * @type: the type of atom
777: *
778: * Allocate a new atom
779: *
780: * Returns the new atom or NULL in case of error
781: */
782: static xmlRegAtomPtr
783: xmlRegNewAtom(xmlRegParserCtxtPtr ctxt, xmlRegAtomType type) {
784: xmlRegAtomPtr ret;
785:
786: ret = (xmlRegAtomPtr) xmlMalloc(sizeof(xmlRegAtom));
787: if (ret == NULL) {
788: xmlRegexpErrMemory(ctxt, "allocating atom");
789: return(NULL);
790: }
791: memset(ret, 0, sizeof(xmlRegAtom));
792: ret->type = type;
793: ret->quant = XML_REGEXP_QUANT_ONCE;
794: ret->min = 0;
795: ret->max = 0;
796: return(ret);
797: }
798:
799: /**
800: * xmlRegFreeAtom:
801: * @atom: the regexp atom
802: *
803: * Free a regexp atom
804: */
805: static void
806: xmlRegFreeAtom(xmlRegAtomPtr atom) {
807: int i;
808:
809: if (atom == NULL)
810: return;
811:
812: for (i = 0;i < atom->nbRanges;i++)
813: xmlRegFreeRange(atom->ranges[i]);
814: if (atom->ranges != NULL)
815: xmlFree(atom->ranges);
816: if ((atom->type == XML_REGEXP_STRING) && (atom->valuep != NULL))
817: xmlFree(atom->valuep);
818: if ((atom->type == XML_REGEXP_STRING) && (atom->valuep2 != NULL))
819: xmlFree(atom->valuep2);
820: if ((atom->type == XML_REGEXP_BLOCK_NAME) && (atom->valuep != NULL))
821: xmlFree(atom->valuep);
822: xmlFree(atom);
823: }
824:
825: /**
826: * xmlRegCopyAtom:
827: * @ctxt: the regexp parser context
828: * @atom: the oiginal atom
829: *
830: * Allocate a new regexp range
831: *
832: * Returns the new atom or NULL in case of error
833: */
834: static xmlRegAtomPtr
835: xmlRegCopyAtom(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom) {
836: xmlRegAtomPtr ret;
837:
838: ret = (xmlRegAtomPtr) xmlMalloc(sizeof(xmlRegAtom));
839: if (ret == NULL) {
840: xmlRegexpErrMemory(ctxt, "copying atom");
841: return(NULL);
842: }
843: memset(ret, 0, sizeof(xmlRegAtom));
844: ret->type = atom->type;
845: ret->quant = atom->quant;
846: ret->min = atom->min;
847: ret->max = atom->max;
848: if (atom->nbRanges > 0) {
849: int i;
850:
851: ret->ranges = (xmlRegRangePtr *) xmlMalloc(sizeof(xmlRegRangePtr) *
852: atom->nbRanges);
853: if (ret->ranges == NULL) {
854: xmlRegexpErrMemory(ctxt, "copying atom");
855: goto error;
856: }
857: for (i = 0;i < atom->nbRanges;i++) {
858: ret->ranges[i] = xmlRegCopyRange(ctxt, atom->ranges[i]);
859: if (ret->ranges[i] == NULL)
860: goto error;
861: ret->nbRanges = i + 1;
862: }
863: }
864: return(ret);
865:
866: error:
867: xmlRegFreeAtom(ret);
868: return(NULL);
869: }
870:
871: static xmlRegStatePtr
872: xmlRegNewState(xmlRegParserCtxtPtr ctxt) {
873: xmlRegStatePtr ret;
874:
875: ret = (xmlRegStatePtr) xmlMalloc(sizeof(xmlRegState));
876: if (ret == NULL) {
877: xmlRegexpErrMemory(ctxt, "allocating state");
878: return(NULL);
879: }
880: memset(ret, 0, sizeof(xmlRegState));
881: ret->type = XML_REGEXP_TRANS_STATE;
882: ret->mark = XML_REGEXP_MARK_NORMAL;
883: return(ret);
884: }
885:
886: /**
887: * xmlRegFreeState:
888: * @state: the regexp state
889: *
890: * Free a regexp state
891: */
892: static void
893: xmlRegFreeState(xmlRegStatePtr state) {
894: if (state == NULL)
895: return;
896:
897: if (state->trans != NULL)
898: xmlFree(state->trans);
899: if (state->transTo != NULL)
900: xmlFree(state->transTo);
901: xmlFree(state);
902: }
903:
904: /**
905: * xmlRegFreeParserCtxt:
906: * @ctxt: the regexp parser context
907: *
908: * Free a regexp parser context
909: */
910: static void
911: xmlRegFreeParserCtxt(xmlRegParserCtxtPtr ctxt) {
912: int i;
913: if (ctxt == NULL)
914: return;
915:
916: if (ctxt->string != NULL)
917: xmlFree(ctxt->string);
918: if (ctxt->states != NULL) {
919: for (i = 0;i < ctxt->nbStates;i++)
920: xmlRegFreeState(ctxt->states[i]);
921: xmlFree(ctxt->states);
922: }
923: if (ctxt->atoms != NULL) {
924: for (i = 0;i < ctxt->nbAtoms;i++)
925: xmlRegFreeAtom(ctxt->atoms[i]);
926: xmlFree(ctxt->atoms);
927: }
928: if (ctxt->counters != NULL)
929: xmlFree(ctxt->counters);
930: xmlFree(ctxt);
931: }
932:
933: /************************************************************************
934: * *
935: * Display of Data structures *
936: * *
937: ************************************************************************/
938:
939: static void
940: xmlRegPrintAtomType(FILE *output, xmlRegAtomType type) {
941: switch (type) {
942: case XML_REGEXP_EPSILON:
943: fprintf(output, "epsilon "); break;
944: case XML_REGEXP_CHARVAL:
945: fprintf(output, "charval "); break;
946: case XML_REGEXP_RANGES:
947: fprintf(output, "ranges "); break;
948: case XML_REGEXP_SUBREG:
949: fprintf(output, "subexpr "); break;
950: case XML_REGEXP_STRING:
951: fprintf(output, "string "); break;
952: case XML_REGEXP_ANYCHAR:
953: fprintf(output, "anychar "); break;
954: case XML_REGEXP_ANYSPACE:
955: fprintf(output, "anyspace "); break;
956: case XML_REGEXP_NOTSPACE:
957: fprintf(output, "notspace "); break;
958: case XML_REGEXP_INITNAME:
959: fprintf(output, "initname "); break;
960: case XML_REGEXP_NOTINITNAME:
961: fprintf(output, "notinitname "); break;
962: case XML_REGEXP_NAMECHAR:
963: fprintf(output, "namechar "); break;
964: case XML_REGEXP_NOTNAMECHAR:
965: fprintf(output, "notnamechar "); break;
966: case XML_REGEXP_DECIMAL:
967: fprintf(output, "decimal "); break;
968: case XML_REGEXP_NOTDECIMAL:
969: fprintf(output, "notdecimal "); break;
970: case XML_REGEXP_REALCHAR:
971: fprintf(output, "realchar "); break;
972: case XML_REGEXP_NOTREALCHAR:
973: fprintf(output, "notrealchar "); break;
974: case XML_REGEXP_LETTER:
975: fprintf(output, "LETTER "); break;
976: case XML_REGEXP_LETTER_UPPERCASE:
977: fprintf(output, "LETTER_UPPERCASE "); break;
978: case XML_REGEXP_LETTER_LOWERCASE:
979: fprintf(output, "LETTER_LOWERCASE "); break;
980: case XML_REGEXP_LETTER_TITLECASE:
981: fprintf(output, "LETTER_TITLECASE "); break;
982: case XML_REGEXP_LETTER_MODIFIER:
983: fprintf(output, "LETTER_MODIFIER "); break;
984: case XML_REGEXP_LETTER_OTHERS:
985: fprintf(output, "LETTER_OTHERS "); break;
986: case XML_REGEXP_MARK:
987: fprintf(output, "MARK "); break;
988: case XML_REGEXP_MARK_NONSPACING:
989: fprintf(output, "MARK_NONSPACING "); break;
990: case XML_REGEXP_MARK_SPACECOMBINING:
991: fprintf(output, "MARK_SPACECOMBINING "); break;
992: case XML_REGEXP_MARK_ENCLOSING:
993: fprintf(output, "MARK_ENCLOSING "); break;
994: case XML_REGEXP_NUMBER:
995: fprintf(output, "NUMBER "); break;
996: case XML_REGEXP_NUMBER_DECIMAL:
997: fprintf(output, "NUMBER_DECIMAL "); break;
998: case XML_REGEXP_NUMBER_LETTER:
999: fprintf(output, "NUMBER_LETTER "); break;
1000: case XML_REGEXP_NUMBER_OTHERS:
1001: fprintf(output, "NUMBER_OTHERS "); break;
1002: case XML_REGEXP_PUNCT:
1003: fprintf(output, "PUNCT "); break;
1004: case XML_REGEXP_PUNCT_CONNECTOR:
1005: fprintf(output, "PUNCT_CONNECTOR "); break;
1006: case XML_REGEXP_PUNCT_DASH:
1007: fprintf(output, "PUNCT_DASH "); break;
1008: case XML_REGEXP_PUNCT_OPEN:
1009: fprintf(output, "PUNCT_OPEN "); break;
1010: case XML_REGEXP_PUNCT_CLOSE:
1011: fprintf(output, "PUNCT_CLOSE "); break;
1012: case XML_REGEXP_PUNCT_INITQUOTE:
1013: fprintf(output, "PUNCT_INITQUOTE "); break;
1014: case XML_REGEXP_PUNCT_FINQUOTE:
1015: fprintf(output, "PUNCT_FINQUOTE "); break;
1016: case XML_REGEXP_PUNCT_OTHERS:
1017: fprintf(output, "PUNCT_OTHERS "); break;
1018: case XML_REGEXP_SEPAR:
1019: fprintf(output, "SEPAR "); break;
1020: case XML_REGEXP_SEPAR_SPACE:
1021: fprintf(output, "SEPAR_SPACE "); break;
1022: case XML_REGEXP_SEPAR_LINE:
1023: fprintf(output, "SEPAR_LINE "); break;
1024: case XML_REGEXP_SEPAR_PARA:
1025: fprintf(output, "SEPAR_PARA "); break;
1026: case XML_REGEXP_SYMBOL:
1027: fprintf(output, "SYMBOL "); break;
1028: case XML_REGEXP_SYMBOL_MATH:
1029: fprintf(output, "SYMBOL_MATH "); break;
1030: case XML_REGEXP_SYMBOL_CURRENCY:
1031: fprintf(output, "SYMBOL_CURRENCY "); break;
1032: case XML_REGEXP_SYMBOL_MODIFIER:
1033: fprintf(output, "SYMBOL_MODIFIER "); break;
1034: case XML_REGEXP_SYMBOL_OTHERS:
1035: fprintf(output, "SYMBOL_OTHERS "); break;
1036: case XML_REGEXP_OTHER:
1037: fprintf(output, "OTHER "); break;
1038: case XML_REGEXP_OTHER_CONTROL:
1039: fprintf(output, "OTHER_CONTROL "); break;
1040: case XML_REGEXP_OTHER_FORMAT:
1041: fprintf(output, "OTHER_FORMAT "); break;
1042: case XML_REGEXP_OTHER_PRIVATE:
1043: fprintf(output, "OTHER_PRIVATE "); break;
1044: case XML_REGEXP_OTHER_NA:
1045: fprintf(output, "OTHER_NA "); break;
1046: case XML_REGEXP_BLOCK_NAME:
1047: fprintf(output, "BLOCK "); break;
1048: }
1049: }
1050:
1051: static void
1052: xmlRegPrintQuantType(FILE *output, xmlRegQuantType type) {
1053: switch (type) {
1054: case XML_REGEXP_QUANT_EPSILON:
1055: fprintf(output, "epsilon "); break;
1056: case XML_REGEXP_QUANT_ONCE:
1057: fprintf(output, "once "); break;
1058: case XML_REGEXP_QUANT_OPT:
1059: fprintf(output, "? "); break;
1060: case XML_REGEXP_QUANT_MULT:
1061: fprintf(output, "* "); break;
1062: case XML_REGEXP_QUANT_PLUS:
1063: fprintf(output, "+ "); break;
1064: case XML_REGEXP_QUANT_RANGE:
1065: fprintf(output, "range "); break;
1066: case XML_REGEXP_QUANT_ONCEONLY:
1067: fprintf(output, "onceonly "); break;
1068: case XML_REGEXP_QUANT_ALL:
1069: fprintf(output, "all "); break;
1070: }
1071: }
1072: static void
1073: xmlRegPrintRange(FILE *output, xmlRegRangePtr range) {
1074: fprintf(output, " range: ");
1075: if (range->neg)
1076: fprintf(output, "negative ");
1077: xmlRegPrintAtomType(output, range->type);
1078: fprintf(output, "%c - %c\n", range->start, range->end);
1079: }
1080:
1081: static void
1082: xmlRegPrintAtom(FILE *output, xmlRegAtomPtr atom) {
1083: fprintf(output, " atom: ");
1084: if (atom == NULL) {
1085: fprintf(output, "NULL\n");
1086: return;
1087: }
1088: if (atom->neg)
1089: fprintf(output, "not ");
1090: xmlRegPrintAtomType(output, atom->type);
1091: xmlRegPrintQuantType(output, atom->quant);
1092: if (atom->quant == XML_REGEXP_QUANT_RANGE)
1093: fprintf(output, "%d-%d ", atom->min, atom->max);
1094: if (atom->type == XML_REGEXP_STRING)
1095: fprintf(output, "'%s' ", (char *) atom->valuep);
1096: if (atom->type == XML_REGEXP_CHARVAL)
1097: fprintf(output, "char %c\n", atom->codepoint);
1098: else if (atom->type == XML_REGEXP_RANGES) {
1099: int i;
1100: fprintf(output, "%d entries\n", atom->nbRanges);
1101: for (i = 0; i < atom->nbRanges;i++)
1102: xmlRegPrintRange(output, atom->ranges[i]);
1103: } else if (atom->type == XML_REGEXP_SUBREG) {
1104: fprintf(output, "start %d end %d\n", atom->start->no, atom->stop->no);
1105: } else {
1106: fprintf(output, "\n");
1107: }
1108: }
1109:
1110: static void
1111: xmlRegPrintTrans(FILE *output, xmlRegTransPtr trans) {
1112: fprintf(output, " trans: ");
1113: if (trans == NULL) {
1114: fprintf(output, "NULL\n");
1115: return;
1116: }
1117: if (trans->to < 0) {
1118: fprintf(output, "removed\n");
1119: return;
1120: }
1121: if (trans->nd != 0) {
1122: if (trans->nd == 2)
1123: fprintf(output, "last not determinist, ");
1124: else
1125: fprintf(output, "not determinist, ");
1126: }
1127: if (trans->counter >= 0) {
1128: fprintf(output, "counted %d, ", trans->counter);
1129: }
1130: if (trans->count == REGEXP_ALL_COUNTER) {
1131: fprintf(output, "all transition, ");
1132: } else if (trans->count >= 0) {
1133: fprintf(output, "count based %d, ", trans->count);
1134: }
1135: if (trans->atom == NULL) {
1136: fprintf(output, "epsilon to %d\n", trans->to);
1137: return;
1138: }
1139: if (trans->atom->type == XML_REGEXP_CHARVAL)
1140: fprintf(output, "char %c ", trans->atom->codepoint);
1141: fprintf(output, "atom %d, to %d\n", trans->atom->no, trans->to);
1142: }
1143:
1144: static void
1145: xmlRegPrintState(FILE *output, xmlRegStatePtr state) {
1146: int i;
1147:
1148: fprintf(output, " state: ");
1149: if (state == NULL) {
1150: fprintf(output, "NULL\n");
1151: return;
1152: }
1153: if (state->type == XML_REGEXP_START_STATE)
1154: fprintf(output, "START ");
1155: if (state->type == XML_REGEXP_FINAL_STATE)
1156: fprintf(output, "FINAL ");
1157:
1158: fprintf(output, "%d, %d transitions:\n", state->no, state->nbTrans);
1159: for (i = 0;i < state->nbTrans; i++) {
1160: xmlRegPrintTrans(output, &(state->trans[i]));
1161: }
1162: }
1163:
1164: #ifdef DEBUG_REGEXP_GRAPH
1165: static void
1166: xmlRegPrintCtxt(FILE *output, xmlRegParserCtxtPtr ctxt) {
1167: int i;
1168:
1169: fprintf(output, " ctxt: ");
1170: if (ctxt == NULL) {
1171: fprintf(output, "NULL\n");
1172: return;
1173: }
1174: fprintf(output, "'%s' ", ctxt->string);
1175: if (ctxt->error)
1176: fprintf(output, "error ");
1177: if (ctxt->neg)
1178: fprintf(output, "neg ");
1179: fprintf(output, "\n");
1180: fprintf(output, "%d atoms:\n", ctxt->nbAtoms);
1181: for (i = 0;i < ctxt->nbAtoms; i++) {
1182: fprintf(output, " %02d ", i);
1183: xmlRegPrintAtom(output, ctxt->atoms[i]);
1184: }
1185: if (ctxt->atom != NULL) {
1186: fprintf(output, "current atom:\n");
1187: xmlRegPrintAtom(output, ctxt->atom);
1188: }
1189: fprintf(output, "%d states:", ctxt->nbStates);
1190: if (ctxt->start != NULL)
1191: fprintf(output, " start: %d", ctxt->start->no);
1192: if (ctxt->end != NULL)
1193: fprintf(output, " end: %d", ctxt->end->no);
1194: fprintf(output, "\n");
1195: for (i = 0;i < ctxt->nbStates; i++) {
1196: xmlRegPrintState(output, ctxt->states[i]);
1197: }
1198: fprintf(output, "%d counters:\n", ctxt->nbCounters);
1199: for (i = 0;i < ctxt->nbCounters; i++) {
1200: fprintf(output, " %d: min %d max %d\n", i, ctxt->counters[i].min,
1201: ctxt->counters[i].max);
1202: }
1203: }
1204: #endif
1205:
1206: /************************************************************************
1207: * *
1208: * Finite Automata structures manipulations *
1209: * *
1210: ************************************************************************/
1211:
1212: static void
1213: xmlRegAtomAddRange(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom,
1214: int neg, xmlRegAtomType type, int start, int end,
1215: xmlChar *blockName) {
1216: xmlRegRangePtr range;
1217:
1218: if (atom == NULL) {
1219: ERROR("add range: atom is NULL");
1220: return;
1221: }
1222: if (atom->type != XML_REGEXP_RANGES) {
1223: ERROR("add range: atom is not ranges");
1224: return;
1225: }
1226: if (atom->maxRanges == 0) {
1227: atom->maxRanges = 4;
1228: atom->ranges = (xmlRegRangePtr *) xmlMalloc(atom->maxRanges *
1229: sizeof(xmlRegRangePtr));
1230: if (atom->ranges == NULL) {
1231: xmlRegexpErrMemory(ctxt, "adding ranges");
1232: atom->maxRanges = 0;
1233: return;
1234: }
1235: } else if (atom->nbRanges >= atom->maxRanges) {
1236: xmlRegRangePtr *tmp;
1237: atom->maxRanges *= 2;
1238: tmp = (xmlRegRangePtr *) xmlRealloc(atom->ranges, atom->maxRanges *
1239: sizeof(xmlRegRangePtr));
1240: if (tmp == NULL) {
1241: xmlRegexpErrMemory(ctxt, "adding ranges");
1242: atom->maxRanges /= 2;
1243: return;
1244: }
1245: atom->ranges = tmp;
1246: }
1247: range = xmlRegNewRange(ctxt, neg, type, start, end);
1248: if (range == NULL)
1249: return;
1250: range->blockName = blockName;
1251: atom->ranges[atom->nbRanges++] = range;
1252:
1253: }
1254:
1255: static int
1256: xmlRegGetCounter(xmlRegParserCtxtPtr ctxt) {
1257: if (ctxt->maxCounters == 0) {
1258: ctxt->maxCounters = 4;
1259: ctxt->counters = (xmlRegCounter *) xmlMalloc(ctxt->maxCounters *
1260: sizeof(xmlRegCounter));
1261: if (ctxt->counters == NULL) {
1262: xmlRegexpErrMemory(ctxt, "allocating counter");
1263: ctxt->maxCounters = 0;
1264: return(-1);
1265: }
1266: } else if (ctxt->nbCounters >= ctxt->maxCounters) {
1267: xmlRegCounter *tmp;
1268: ctxt->maxCounters *= 2;
1269: tmp = (xmlRegCounter *) xmlRealloc(ctxt->counters, ctxt->maxCounters *
1270: sizeof(xmlRegCounter));
1271: if (tmp == NULL) {
1272: xmlRegexpErrMemory(ctxt, "allocating counter");
1273: ctxt->maxCounters /= 2;
1274: return(-1);
1275: }
1276: ctxt->counters = tmp;
1277: }
1278: ctxt->counters[ctxt->nbCounters].min = -1;
1279: ctxt->counters[ctxt->nbCounters].max = -1;
1280: return(ctxt->nbCounters++);
1281: }
1282:
1283: static int
1284: xmlRegAtomPush(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom) {
1285: if (atom == NULL) {
1286: ERROR("atom push: atom is NULL");
1287: return(-1);
1288: }
1289: if (ctxt->maxAtoms == 0) {
1290: ctxt->maxAtoms = 4;
1291: ctxt->atoms = (xmlRegAtomPtr *) xmlMalloc(ctxt->maxAtoms *
1292: sizeof(xmlRegAtomPtr));
1293: if (ctxt->atoms == NULL) {
1294: xmlRegexpErrMemory(ctxt, "pushing atom");
1295: ctxt->maxAtoms = 0;
1296: return(-1);
1297: }
1298: } else if (ctxt->nbAtoms >= ctxt->maxAtoms) {
1299: xmlRegAtomPtr *tmp;
1300: ctxt->maxAtoms *= 2;
1301: tmp = (xmlRegAtomPtr *) xmlRealloc(ctxt->atoms, ctxt->maxAtoms *
1302: sizeof(xmlRegAtomPtr));
1303: if (tmp == NULL) {
1304: xmlRegexpErrMemory(ctxt, "allocating counter");
1305: ctxt->maxAtoms /= 2;
1306: return(-1);
1307: }
1308: ctxt->atoms = tmp;
1309: }
1310: atom->no = ctxt->nbAtoms;
1311: ctxt->atoms[ctxt->nbAtoms++] = atom;
1312: return(0);
1313: }
1314:
1315: static void
1316: xmlRegStateAddTransTo(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr target,
1317: int from) {
1318: if (target->maxTransTo == 0) {
1319: target->maxTransTo = 8;
1320: target->transTo = (int *) xmlMalloc(target->maxTransTo *
1321: sizeof(int));
1322: if (target->transTo == NULL) {
1323: xmlRegexpErrMemory(ctxt, "adding transition");
1324: target->maxTransTo = 0;
1325: return;
1326: }
1327: } else if (target->nbTransTo >= target->maxTransTo) {
1328: int *tmp;
1329: target->maxTransTo *= 2;
1330: tmp = (int *) xmlRealloc(target->transTo, target->maxTransTo *
1331: sizeof(int));
1332: if (tmp == NULL) {
1333: xmlRegexpErrMemory(ctxt, "adding transition");
1334: target->maxTransTo /= 2;
1335: return;
1336: }
1337: target->transTo = tmp;
1338: }
1339: target->transTo[target->nbTransTo] = from;
1340: target->nbTransTo++;
1341: }
1342:
1343: static void
1344: xmlRegStateAddTrans(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state,
1345: xmlRegAtomPtr atom, xmlRegStatePtr target,
1346: int counter, int count) {
1347:
1348: int nrtrans;
1349:
1350: if (state == NULL) {
1351: ERROR("add state: state is NULL");
1352: return;
1353: }
1354: if (target == NULL) {
1355: ERROR("add state: target is NULL");
1356: return;
1357: }
1358: /*
1359: * Other routines follow the philosophy 'When in doubt, add a transition'
1360: * so we check here whether such a transition is already present and, if
1361: * so, silently ignore this request.
1362: */
1363:
1364: for (nrtrans = state->nbTrans - 1; nrtrans >= 0; nrtrans--) {
1365: xmlRegTransPtr trans = &(state->trans[nrtrans]);
1366: if ((trans->atom == atom) &&
1367: (trans->to == target->no) &&
1368: (trans->counter == counter) &&
1369: (trans->count == count)) {
1370: #ifdef DEBUG_REGEXP_GRAPH
1371: printf("Ignoring duplicate transition from %d to %d\n",
1372: state->no, target->no);
1373: #endif
1374: return;
1375: }
1376: }
1377:
1378: if (state->maxTrans == 0) {
1379: state->maxTrans = 8;
1380: state->trans = (xmlRegTrans *) xmlMalloc(state->maxTrans *
1381: sizeof(xmlRegTrans));
1382: if (state->trans == NULL) {
1383: xmlRegexpErrMemory(ctxt, "adding transition");
1384: state->maxTrans = 0;
1385: return;
1386: }
1387: } else if (state->nbTrans >= state->maxTrans) {
1388: xmlRegTrans *tmp;
1389: state->maxTrans *= 2;
1390: tmp = (xmlRegTrans *) xmlRealloc(state->trans, state->maxTrans *
1391: sizeof(xmlRegTrans));
1392: if (tmp == NULL) {
1393: xmlRegexpErrMemory(ctxt, "adding transition");
1394: state->maxTrans /= 2;
1395: return;
1396: }
1397: state->trans = tmp;
1398: }
1399: #ifdef DEBUG_REGEXP_GRAPH
1400: printf("Add trans from %d to %d ", state->no, target->no);
1401: if (count == REGEXP_ALL_COUNTER)
1402: printf("all transition\n");
1403: else if (count >= 0)
1404: printf("count based %d\n", count);
1405: else if (counter >= 0)
1406: printf("counted %d\n", counter);
1407: else if (atom == NULL)
1408: printf("epsilon transition\n");
1409: else if (atom != NULL)
1410: xmlRegPrintAtom(stdout, atom);
1411: #endif
1412:
1413: state->trans[state->nbTrans].atom = atom;
1414: state->trans[state->nbTrans].to = target->no;
1415: state->trans[state->nbTrans].counter = counter;
1416: state->trans[state->nbTrans].count = count;
1417: state->trans[state->nbTrans].nd = 0;
1418: state->nbTrans++;
1419: xmlRegStateAddTransTo(ctxt, target, state->no);
1420: }
1421:
1422: static int
1423: xmlRegStatePush(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state) {
1424: if (state == NULL) return(-1);
1425: if (ctxt->maxStates == 0) {
1426: ctxt->maxStates = 4;
1427: ctxt->states = (xmlRegStatePtr *) xmlMalloc(ctxt->maxStates *
1428: sizeof(xmlRegStatePtr));
1429: if (ctxt->states == NULL) {
1430: xmlRegexpErrMemory(ctxt, "adding state");
1431: ctxt->maxStates = 0;
1432: return(-1);
1433: }
1434: } else if (ctxt->nbStates >= ctxt->maxStates) {
1435: xmlRegStatePtr *tmp;
1436: ctxt->maxStates *= 2;
1437: tmp = (xmlRegStatePtr *) xmlRealloc(ctxt->states, ctxt->maxStates *
1438: sizeof(xmlRegStatePtr));
1439: if (tmp == NULL) {
1440: xmlRegexpErrMemory(ctxt, "adding state");
1441: ctxt->maxStates /= 2;
1442: return(-1);
1443: }
1444: ctxt->states = tmp;
1445: }
1446: state->no = ctxt->nbStates;
1447: ctxt->states[ctxt->nbStates++] = state;
1448: return(0);
1449: }
1450:
1451: /**
1452: * xmlFAGenerateAllTransition:
1453: * @ctxt: a regexp parser context
1454: * @from: the from state
1455: * @to: the target state or NULL for building a new one
1456: * @lax:
1457: *
1458: */
1459: static void
1460: xmlFAGenerateAllTransition(xmlRegParserCtxtPtr ctxt,
1461: xmlRegStatePtr from, xmlRegStatePtr to,
1462: int lax) {
1463: if (to == NULL) {
1464: to = xmlRegNewState(ctxt);
1465: xmlRegStatePush(ctxt, to);
1466: ctxt->state = to;
1467: }
1468: if (lax)
1469: xmlRegStateAddTrans(ctxt, from, NULL, to, -1, REGEXP_ALL_LAX_COUNTER);
1470: else
1471: xmlRegStateAddTrans(ctxt, from, NULL, to, -1, REGEXP_ALL_COUNTER);
1472: }
1473:
1474: /**
1475: * xmlFAGenerateEpsilonTransition:
1476: * @ctxt: a regexp parser context
1477: * @from: the from state
1478: * @to: the target state or NULL for building a new one
1479: *
1480: */
1481: static void
1482: xmlFAGenerateEpsilonTransition(xmlRegParserCtxtPtr ctxt,
1483: xmlRegStatePtr from, xmlRegStatePtr to) {
1484: if (to == NULL) {
1485: to = xmlRegNewState(ctxt);
1486: xmlRegStatePush(ctxt, to);
1487: ctxt->state = to;
1488: }
1489: xmlRegStateAddTrans(ctxt, from, NULL, to, -1, -1);
1490: }
1491:
1492: /**
1493: * xmlFAGenerateCountedEpsilonTransition:
1494: * @ctxt: a regexp parser context
1495: * @from: the from state
1496: * @to: the target state or NULL for building a new one
1497: * counter: the counter for that transition
1498: *
1499: */
1500: static void
1501: xmlFAGenerateCountedEpsilonTransition(xmlRegParserCtxtPtr ctxt,
1502: xmlRegStatePtr from, xmlRegStatePtr to, int counter) {
1503: if (to == NULL) {
1504: to = xmlRegNewState(ctxt);
1505: xmlRegStatePush(ctxt, to);
1506: ctxt->state = to;
1507: }
1508: xmlRegStateAddTrans(ctxt, from, NULL, to, counter, -1);
1509: }
1510:
1511: /**
1512: * xmlFAGenerateCountedTransition:
1513: * @ctxt: a regexp parser context
1514: * @from: the from state
1515: * @to: the target state or NULL for building a new one
1516: * counter: the counter for that transition
1517: *
1518: */
1519: static void
1520: xmlFAGenerateCountedTransition(xmlRegParserCtxtPtr ctxt,
1521: xmlRegStatePtr from, xmlRegStatePtr to, int counter) {
1522: if (to == NULL) {
1523: to = xmlRegNewState(ctxt);
1524: xmlRegStatePush(ctxt, to);
1525: ctxt->state = to;
1526: }
1527: xmlRegStateAddTrans(ctxt, from, NULL, to, -1, counter);
1528: }
1529:
1530: /**
1531: * xmlFAGenerateTransitions:
1532: * @ctxt: a regexp parser context
1533: * @from: the from state
1534: * @to: the target state or NULL for building a new one
1535: * @atom: the atom generating the transition
1536: *
1537: * Returns 0 if success and -1 in case of error.
1538: */
1539: static int
1540: xmlFAGenerateTransitions(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr from,
1541: xmlRegStatePtr to, xmlRegAtomPtr atom) {
1542: xmlRegStatePtr end;
1543:
1544: if (atom == NULL) {
1545: ERROR("genrate transition: atom == NULL");
1546: return(-1);
1547: }
1548: if (atom->type == XML_REGEXP_SUBREG) {
1549: /*
1550: * this is a subexpression handling one should not need to
1551: * create a new node except for XML_REGEXP_QUANT_RANGE.
1552: */
1553: if (xmlRegAtomPush(ctxt, atom) < 0) {
1554: return(-1);
1555: }
1556: if ((to != NULL) && (atom->stop != to) &&
1557: (atom->quant != XML_REGEXP_QUANT_RANGE)) {
1558: /*
1559: * Generate an epsilon transition to link to the target
1560: */
1561: xmlFAGenerateEpsilonTransition(ctxt, atom->stop, to);
1562: #ifdef DV
1563: } else if ((to == NULL) && (atom->quant != XML_REGEXP_QUANT_RANGE) &&
1564: (atom->quant != XML_REGEXP_QUANT_ONCE)) {
1565: to = xmlRegNewState(ctxt);
1566: xmlRegStatePush(ctxt, to);
1567: ctxt->state = to;
1568: xmlFAGenerateEpsilonTransition(ctxt, atom->stop, to);
1569: #endif
1570: }
1571: switch (atom->quant) {
1572: case XML_REGEXP_QUANT_OPT:
1573: atom->quant = XML_REGEXP_QUANT_ONCE;
1574: /*
1575: * transition done to the state after end of atom.
1576: * 1. set transition from atom start to new state
1577: * 2. set transition from atom end to this state.
1578: */
1579: if (to == NULL) {
1580: xmlFAGenerateEpsilonTransition(ctxt, atom->start, 0);
1581: xmlFAGenerateEpsilonTransition(ctxt, atom->stop,
1582: ctxt->state);
1583: } else {
1584: xmlFAGenerateEpsilonTransition(ctxt, atom->start, to);
1585: }
1586: break;
1587: case XML_REGEXP_QUANT_MULT:
1588: atom->quant = XML_REGEXP_QUANT_ONCE;
1589: xmlFAGenerateEpsilonTransition(ctxt, atom->start, atom->stop);
1590: xmlFAGenerateEpsilonTransition(ctxt, atom->stop, atom->start);
1591: break;
1592: case XML_REGEXP_QUANT_PLUS:
1593: atom->quant = XML_REGEXP_QUANT_ONCE;
1594: xmlFAGenerateEpsilonTransition(ctxt, atom->stop, atom->start);
1595: break;
1596: case XML_REGEXP_QUANT_RANGE: {
1597: int counter;
1598: xmlRegStatePtr inter, newstate;
1599:
1600: /*
1601: * create the final state now if needed
1602: */
1603: if (to != NULL) {
1604: newstate = to;
1605: } else {
1606: newstate = xmlRegNewState(ctxt);
1607: xmlRegStatePush(ctxt, newstate);
1608: }
1609:
1610: /*
1611: * The principle here is to use counted transition
1612: * to avoid explosion in the number of states in the
1613: * graph. This is clearly more complex but should not
1614: * be exploitable at runtime.
1615: */
1616: if ((atom->min == 0) && (atom->start0 == NULL)) {
1617: xmlRegAtomPtr copy;
1618: /*
1619: * duplicate a transition based on atom to count next
1620: * occurences after 1. We cannot loop to atom->start
1621: * directly because we need an epsilon transition to
1622: * newstate.
1623: */
1624: /* ???? For some reason it seems we never reach that
1625: case, I suppose this got optimized out before when
1626: building the automata */
1627: copy = xmlRegCopyAtom(ctxt, atom);
1628: if (copy == NULL)
1629: return(-1);
1630: copy->quant = XML_REGEXP_QUANT_ONCE;
1631: copy->min = 0;
1632: copy->max = 0;
1633:
1634: if (xmlFAGenerateTransitions(ctxt, atom->start, NULL, copy)
1635: < 0)
1636: return(-1);
1637: inter = ctxt->state;
1638: counter = xmlRegGetCounter(ctxt);
1639: ctxt->counters[counter].min = atom->min - 1;
1640: ctxt->counters[counter].max = atom->max - 1;
1641: /* count the number of times we see it again */
1642: xmlFAGenerateCountedEpsilonTransition(ctxt, inter,
1643: atom->stop, counter);
1644: /* allow a way out based on the count */
1645: xmlFAGenerateCountedTransition(ctxt, inter,
1646: newstate, counter);
1647: /* and also allow a direct exit for 0 */
1648: xmlFAGenerateEpsilonTransition(ctxt, atom->start,
1649: newstate);
1650: } else {
1651: /*
1652: * either we need the atom at least once or there
1653: * is an atom->start0 allowing to easilly plug the
1654: * epsilon transition.
1655: */
1656: counter = xmlRegGetCounter(ctxt);
1657: ctxt->counters[counter].min = atom->min - 1;
1658: ctxt->counters[counter].max = atom->max - 1;
1659: /* count the number of times we see it again */
1660: xmlFAGenerateCountedEpsilonTransition(ctxt, atom->stop,
1661: atom->start, counter);
1662: /* allow a way out based on the count */
1663: xmlFAGenerateCountedTransition(ctxt, atom->stop,
1664: newstate, counter);
1665: /* and if needed allow a direct exit for 0 */
1666: if (atom->min == 0)
1667: xmlFAGenerateEpsilonTransition(ctxt, atom->start0,
1668: newstate);
1669:
1670: }
1671: atom->min = 0;
1672: atom->max = 0;
1673: atom->quant = XML_REGEXP_QUANT_ONCE;
1674: ctxt->state = newstate;
1675: }
1676: default:
1677: break;
1678: }
1679: return(0);
1680: }
1681: if ((atom->min == 0) && (atom->max == 0) &&
1682: (atom->quant == XML_REGEXP_QUANT_RANGE)) {
1683: /*
1684: * we can discard the atom and generate an epsilon transition instead
1685: */
1686: if (to == NULL) {
1687: to = xmlRegNewState(ctxt);
1688: if (to != NULL)
1689: xmlRegStatePush(ctxt, to);
1690: else {
1691: return(-1);
1692: }
1693: }
1694: xmlFAGenerateEpsilonTransition(ctxt, from, to);
1695: ctxt->state = to;
1696: xmlRegFreeAtom(atom);
1697: return(0);
1698: }
1699: if (to == NULL) {
1700: to = xmlRegNewState(ctxt);
1701: if (to != NULL)
1702: xmlRegStatePush(ctxt, to);
1703: else {
1704: return(-1);
1705: }
1706: }
1707: end = to;
1708: if ((atom->quant == XML_REGEXP_QUANT_MULT) ||
1709: (atom->quant == XML_REGEXP_QUANT_PLUS)) {
1710: /*
1711: * Do not pollute the target state by adding transitions from
1712: * it as it is likely to be the shared target of multiple branches.
1713: * So isolate with an epsilon transition.
1714: */
1715: xmlRegStatePtr tmp;
1716:
1717: tmp = xmlRegNewState(ctxt);
1718: if (tmp != NULL)
1719: xmlRegStatePush(ctxt, tmp);
1720: else {
1721: return(-1);
1722: }
1723: xmlFAGenerateEpsilonTransition(ctxt, tmp, to);
1724: to = tmp;
1725: }
1726: if (xmlRegAtomPush(ctxt, atom) < 0) {
1727: return(-1);
1728: }
1729: xmlRegStateAddTrans(ctxt, from, atom, to, -1, -1);
1730: ctxt->state = end;
1731: switch (atom->quant) {
1732: case XML_REGEXP_QUANT_OPT:
1733: atom->quant = XML_REGEXP_QUANT_ONCE;
1734: xmlFAGenerateEpsilonTransition(ctxt, from, to);
1735: break;
1736: case XML_REGEXP_QUANT_MULT:
1737: atom->quant = XML_REGEXP_QUANT_ONCE;
1738: xmlFAGenerateEpsilonTransition(ctxt, from, to);
1739: xmlRegStateAddTrans(ctxt, to, atom, to, -1, -1);
1740: break;
1741: case XML_REGEXP_QUANT_PLUS:
1742: atom->quant = XML_REGEXP_QUANT_ONCE;
1743: xmlRegStateAddTrans(ctxt, to, atom, to, -1, -1);
1744: break;
1745: case XML_REGEXP_QUANT_RANGE:
1746: #if DV_test
1747: if (atom->min == 0) {
1748: xmlFAGenerateEpsilonTransition(ctxt, from, to);
1749: }
1750: #endif
1751: break;
1752: default:
1753: break;
1754: }
1755: return(0);
1756: }
1757:
1758: /**
1759: * xmlFAReduceEpsilonTransitions:
1760: * @ctxt: a regexp parser context
1761: * @fromnr: the from state
1762: * @tonr: the to state
1763: * @counter: should that transition be associated to a counted
1764: *
1765: */
1766: static void
1767: xmlFAReduceEpsilonTransitions(xmlRegParserCtxtPtr ctxt, int fromnr,
1768: int tonr, int counter) {
1769: int transnr;
1770: xmlRegStatePtr from;
1771: xmlRegStatePtr to;
1772:
1773: #ifdef DEBUG_REGEXP_GRAPH
1774: printf("xmlFAReduceEpsilonTransitions(%d, %d)\n", fromnr, tonr);
1775: #endif
1776: from = ctxt->states[fromnr];
1777: if (from == NULL)
1778: return;
1779: to = ctxt->states[tonr];
1780: if (to == NULL)
1781: return;
1782: if ((to->mark == XML_REGEXP_MARK_START) ||
1783: (to->mark == XML_REGEXP_MARK_VISITED))
1784: return;
1785:
1786: to->mark = XML_REGEXP_MARK_VISITED;
1787: if (to->type == XML_REGEXP_FINAL_STATE) {
1788: #ifdef DEBUG_REGEXP_GRAPH
1789: printf("State %d is final, so %d becomes final\n", tonr, fromnr);
1790: #endif
1791: from->type = XML_REGEXP_FINAL_STATE;
1792: }
1793: for (transnr = 0;transnr < to->nbTrans;transnr++) {
1794: if (to->trans[transnr].to < 0)
1795: continue;
1796: if (to->trans[transnr].atom == NULL) {
1797: /*
1798: * Don't remove counted transitions
1799: * Don't loop either
1800: */
1801: if (to->trans[transnr].to != fromnr) {
1802: if (to->trans[transnr].count >= 0) {
1803: int newto = to->trans[transnr].to;
1804:
1805: xmlRegStateAddTrans(ctxt, from, NULL,
1806: ctxt->states[newto],
1807: -1, to->trans[transnr].count);
1808: } else {
1809: #ifdef DEBUG_REGEXP_GRAPH
1810: printf("Found epsilon trans %d from %d to %d\n",
1811: transnr, tonr, to->trans[transnr].to);
1812: #endif
1813: if (to->trans[transnr].counter >= 0) {
1814: xmlFAReduceEpsilonTransitions(ctxt, fromnr,
1815: to->trans[transnr].to,
1816: to->trans[transnr].counter);
1817: } else {
1818: xmlFAReduceEpsilonTransitions(ctxt, fromnr,
1819: to->trans[transnr].to,
1820: counter);
1821: }
1822: }
1823: }
1824: } else {
1825: int newto = to->trans[transnr].to;
1826:
1827: if (to->trans[transnr].counter >= 0) {
1828: xmlRegStateAddTrans(ctxt, from, to->trans[transnr].atom,
1829: ctxt->states[newto],
1830: to->trans[transnr].counter, -1);
1831: } else {
1832: xmlRegStateAddTrans(ctxt, from, to->trans[transnr].atom,
1833: ctxt->states[newto], counter, -1);
1834: }
1835: }
1836: }
1837: to->mark = XML_REGEXP_MARK_NORMAL;
1838: }
1839:
1840: /**
1841: * xmlFAEliminateSimpleEpsilonTransitions:
1842: * @ctxt: a regexp parser context
1843: *
1844: * Eliminating general epsilon transitions can get costly in the general
1845: * algorithm due to the large amount of generated new transitions and
1846: * associated comparisons. However for simple epsilon transition used just
1847: * to separate building blocks when generating the automata this can be
1848: * reduced to state elimination:
1849: * - if there exists an epsilon from X to Y
1850: * - if there is no other transition from X
1851: * then X and Y are semantically equivalent and X can be eliminated
1852: * If X is the start state then make Y the start state, else replace the
1853: * target of all transitions to X by transitions to Y.
1854: */
1855: static void
1856: xmlFAEliminateSimpleEpsilonTransitions(xmlRegParserCtxtPtr ctxt) {
1857: int statenr, i, j, newto;
1858: xmlRegStatePtr state, tmp;
1859:
1860: for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
1861: state = ctxt->states[statenr];
1862: if (state == NULL)
1863: continue;
1864: if (state->nbTrans != 1)
1865: continue;
1866: if (state->type == XML_REGEXP_UNREACH_STATE)
1867: continue;
1868: /* is the only transition out a basic transition */
1869: if ((state->trans[0].atom == NULL) &&
1870: (state->trans[0].to >= 0) &&
1871: (state->trans[0].to != statenr) &&
1872: (state->trans[0].counter < 0) &&
1873: (state->trans[0].count < 0)) {
1874: newto = state->trans[0].to;
1875:
1876: if (state->type == XML_REGEXP_START_STATE) {
1877: #ifdef DEBUG_REGEXP_GRAPH
1878: printf("Found simple epsilon trans from start %d to %d\n",
1879: statenr, newto);
1880: #endif
1881: } else {
1882: #ifdef DEBUG_REGEXP_GRAPH
1883: printf("Found simple epsilon trans from %d to %d\n",
1884: statenr, newto);
1885: #endif
1886: for (i = 0;i < state->nbTransTo;i++) {
1887: tmp = ctxt->states[state->transTo[i]];
1888: for (j = 0;j < tmp->nbTrans;j++) {
1889: if (tmp->trans[j].to == statenr) {
1890: #ifdef DEBUG_REGEXP_GRAPH
1891: printf("Changed transition %d on %d to go to %d\n",
1892: j, tmp->no, newto);
1893: #endif
1894: tmp->trans[j].to = -1;
1895: xmlRegStateAddTrans(ctxt, tmp, tmp->trans[j].atom,
1896: ctxt->states[newto],
1897: tmp->trans[j].counter,
1898: tmp->trans[j].count);
1899: }
1900: }
1901: }
1902: if (state->type == XML_REGEXP_FINAL_STATE)
1903: ctxt->states[newto]->type = XML_REGEXP_FINAL_STATE;
1904: /* eliminate the transition completely */
1905: state->nbTrans = 0;
1906:
1907: state->type = XML_REGEXP_UNREACH_STATE;
1908:
1909: }
1910:
1911: }
1912: }
1913: }
1914: /**
1915: * xmlFAEliminateEpsilonTransitions:
1916: * @ctxt: a regexp parser context
1917: *
1918: */
1919: static void
1920: xmlFAEliminateEpsilonTransitions(xmlRegParserCtxtPtr ctxt) {
1921: int statenr, transnr;
1922: xmlRegStatePtr state;
1923: int has_epsilon;
1924:
1925: if (ctxt->states == NULL) return;
1926:
1927: /*
1928: * Eliminate simple epsilon transition and the associated unreachable
1929: * states.
1930: */
1931: xmlFAEliminateSimpleEpsilonTransitions(ctxt);
1932: for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
1933: state = ctxt->states[statenr];
1934: if ((state != NULL) && (state->type == XML_REGEXP_UNREACH_STATE)) {
1935: #ifdef DEBUG_REGEXP_GRAPH
1936: printf("Removed unreachable state %d\n", statenr);
1937: #endif
1938: xmlRegFreeState(state);
1939: ctxt->states[statenr] = NULL;
1940: }
1941: }
1942:
1943: has_epsilon = 0;
1944:
1945: /*
1946: * Build the completed transitions bypassing the epsilons
1947: * Use a marking algorithm to avoid loops
1948: * Mark sink states too.
1949: * Process from the latests states backward to the start when
1950: * there is long cascading epsilon chains this minimize the
1951: * recursions and transition compares when adding the new ones
1952: */
1953: for (statenr = ctxt->nbStates - 1;statenr >= 0;statenr--) {
1954: state = ctxt->states[statenr];
1955: if (state == NULL)
1956: continue;
1957: if ((state->nbTrans == 0) &&
1958: (state->type != XML_REGEXP_FINAL_STATE)) {
1959: state->type = XML_REGEXP_SINK_STATE;
1960: }
1961: for (transnr = 0;transnr < state->nbTrans;transnr++) {
1962: if ((state->trans[transnr].atom == NULL) &&
1963: (state->trans[transnr].to >= 0)) {
1964: if (state->trans[transnr].to == statenr) {
1965: state->trans[transnr].to = -1;
1966: #ifdef DEBUG_REGEXP_GRAPH
1967: printf("Removed loopback epsilon trans %d on %d\n",
1968: transnr, statenr);
1969: #endif
1970: } else if (state->trans[transnr].count < 0) {
1971: int newto = state->trans[transnr].to;
1972:
1973: #ifdef DEBUG_REGEXP_GRAPH
1974: printf("Found epsilon trans %d from %d to %d\n",
1975: transnr, statenr, newto);
1976: #endif
1977: has_epsilon = 1;
1978: state->trans[transnr].to = -2;
1979: state->mark = XML_REGEXP_MARK_START;
1980: xmlFAReduceEpsilonTransitions(ctxt, statenr,
1981: newto, state->trans[transnr].counter);
1982: state->mark = XML_REGEXP_MARK_NORMAL;
1983: #ifdef DEBUG_REGEXP_GRAPH
1984: } else {
1985: printf("Found counted transition %d on %d\n",
1986: transnr, statenr);
1987: #endif
1988: }
1989: }
1990: }
1991: }
1992: /*
1993: * Eliminate the epsilon transitions
1994: */
1995: if (has_epsilon) {
1996: for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
1997: state = ctxt->states[statenr];
1998: if (state == NULL)
1999: continue;
2000: for (transnr = 0;transnr < state->nbTrans;transnr++) {
2001: xmlRegTransPtr trans = &(state->trans[transnr]);
2002: if ((trans->atom == NULL) &&
2003: (trans->count < 0) &&
2004: (trans->to >= 0)) {
2005: trans->to = -1;
2006: }
2007: }
2008: }
2009: }
2010:
2011: /*
2012: * Use this pass to detect unreachable states too
2013: */
2014: for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
2015: state = ctxt->states[statenr];
2016: if (state != NULL)
2017: state->reached = XML_REGEXP_MARK_NORMAL;
2018: }
2019: state = ctxt->states[0];
2020: if (state != NULL)
2021: state->reached = XML_REGEXP_MARK_START;
2022: while (state != NULL) {
2023: xmlRegStatePtr target = NULL;
2024: state->reached = XML_REGEXP_MARK_VISITED;
2025: /*
2026: * Mark all states reachable from the current reachable state
2027: */
2028: for (transnr = 0;transnr < state->nbTrans;transnr++) {
2029: if ((state->trans[transnr].to >= 0) &&
2030: ((state->trans[transnr].atom != NULL) ||
2031: (state->trans[transnr].count >= 0))) {
2032: int newto = state->trans[transnr].to;
2033:
2034: if (ctxt->states[newto] == NULL)
2035: continue;
2036: if (ctxt->states[newto]->reached == XML_REGEXP_MARK_NORMAL) {
2037: ctxt->states[newto]->reached = XML_REGEXP_MARK_START;
2038: target = ctxt->states[newto];
2039: }
2040: }
2041: }
2042:
2043: /*
2044: * find the next accessible state not explored
2045: */
2046: if (target == NULL) {
2047: for (statenr = 1;statenr < ctxt->nbStates;statenr++) {
2048: state = ctxt->states[statenr];
2049: if ((state != NULL) && (state->reached ==
2050: XML_REGEXP_MARK_START)) {
2051: target = state;
2052: break;
2053: }
2054: }
2055: }
2056: state = target;
2057: }
2058: for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
2059: state = ctxt->states[statenr];
2060: if ((state != NULL) && (state->reached == XML_REGEXP_MARK_NORMAL)) {
2061: #ifdef DEBUG_REGEXP_GRAPH
2062: printf("Removed unreachable state %d\n", statenr);
2063: #endif
2064: xmlRegFreeState(state);
2065: ctxt->states[statenr] = NULL;
2066: }
2067: }
2068:
2069: }
2070:
2071: static int
2072: xmlFACompareRanges(xmlRegRangePtr range1, xmlRegRangePtr range2) {
2073: int ret = 0;
2074:
2075: if ((range1->type == XML_REGEXP_RANGES) ||
2076: (range2->type == XML_REGEXP_RANGES) ||
2077: (range2->type == XML_REGEXP_SUBREG) ||
2078: (range1->type == XML_REGEXP_SUBREG) ||
2079: (range1->type == XML_REGEXP_STRING) ||
2080: (range2->type == XML_REGEXP_STRING))
2081: return(-1);
2082:
2083: /* put them in order */
2084: if (range1->type > range2->type) {
2085: xmlRegRangePtr tmp;
2086:
2087: tmp = range1;
2088: range1 = range2;
2089: range2 = tmp;
2090: }
2091: if ((range1->type == XML_REGEXP_ANYCHAR) ||
2092: (range2->type == XML_REGEXP_ANYCHAR)) {
2093: ret = 1;
2094: } else if ((range1->type == XML_REGEXP_EPSILON) ||
2095: (range2->type == XML_REGEXP_EPSILON)) {
2096: return(0);
2097: } else if (range1->type == range2->type) {
2098: if (range1->type != XML_REGEXP_CHARVAL)
2099: ret = 1;
2100: else if ((range1->end < range2->start) ||
2101: (range2->end < range1->start))
2102: ret = 0;
2103: else
2104: ret = 1;
2105: } else if (range1->type == XML_REGEXP_CHARVAL) {
2106: int codepoint;
2107: int neg = 0;
2108:
2109: /*
2110: * just check all codepoints in the range for acceptance,
2111: * this is usually way cheaper since done only once at
2112: * compilation than testing over and over at runtime or
2113: * pushing too many states when evaluating.
2114: */
2115: if (((range1->neg == 0) && (range2->neg != 0)) ||
2116: ((range1->neg != 0) && (range2->neg == 0)))
2117: neg = 1;
2118:
2119: for (codepoint = range1->start;codepoint <= range1->end ;codepoint++) {
2120: ret = xmlRegCheckCharacterRange(range2->type, codepoint,
2121: 0, range2->start, range2->end,
2122: range2->blockName);
2123: if (ret < 0)
2124: return(-1);
2125: if (((neg == 1) && (ret == 0)) ||
2126: ((neg == 0) && (ret == 1)))
2127: return(1);
2128: }
2129: return(0);
2130: } else if ((range1->type == XML_REGEXP_BLOCK_NAME) ||
2131: (range2->type == XML_REGEXP_BLOCK_NAME)) {
2132: if (range1->type == range2->type) {
2133: ret = xmlStrEqual(range1->blockName, range2->blockName);
2134: } else {
2135: /*
2136: * comparing a block range with anything else is way
2137: * too costly, and maintining the table is like too much
2138: * memory too, so let's force the automata to save state
2139: * here.
2140: */
2141: return(1);
2142: }
2143: } else if ((range1->type < XML_REGEXP_LETTER) ||
2144: (range2->type < XML_REGEXP_LETTER)) {
2145: if ((range1->type == XML_REGEXP_ANYSPACE) &&
2146: (range2->type == XML_REGEXP_NOTSPACE))
2147: ret = 0;
2148: else if ((range1->type == XML_REGEXP_INITNAME) &&
2149: (range2->type == XML_REGEXP_NOTINITNAME))
2150: ret = 0;
2151: else if ((range1->type == XML_REGEXP_NAMECHAR) &&
2152: (range2->type == XML_REGEXP_NOTNAMECHAR))
2153: ret = 0;
2154: else if ((range1->type == XML_REGEXP_DECIMAL) &&
2155: (range2->type == XML_REGEXP_NOTDECIMAL))
2156: ret = 0;
2157: else if ((range1->type == XML_REGEXP_REALCHAR) &&
2158: (range2->type == XML_REGEXP_NOTREALCHAR))
2159: ret = 0;
2160: else {
2161: /* same thing to limit complexity */
2162: return(1);
2163: }
2164: } else {
2165: ret = 0;
2166: /* range1->type < range2->type here */
2167: switch (range1->type) {
2168: case XML_REGEXP_LETTER:
2169: /* all disjoint except in the subgroups */
2170: if ((range2->type == XML_REGEXP_LETTER_UPPERCASE) ||
2171: (range2->type == XML_REGEXP_LETTER_LOWERCASE) ||
2172: (range2->type == XML_REGEXP_LETTER_TITLECASE) ||
2173: (range2->type == XML_REGEXP_LETTER_MODIFIER) ||
2174: (range2->type == XML_REGEXP_LETTER_OTHERS))
2175: ret = 1;
2176: break;
2177: case XML_REGEXP_MARK:
2178: if ((range2->type == XML_REGEXP_MARK_NONSPACING) ||
2179: (range2->type == XML_REGEXP_MARK_SPACECOMBINING) ||
2180: (range2->type == XML_REGEXP_MARK_ENCLOSING))
2181: ret = 1;
2182: break;
2183: case XML_REGEXP_NUMBER:
2184: if ((range2->type == XML_REGEXP_NUMBER_DECIMAL) ||
2185: (range2->type == XML_REGEXP_NUMBER_LETTER) ||
2186: (range2->type == XML_REGEXP_NUMBER_OTHERS))
2187: ret = 1;
2188: break;
2189: case XML_REGEXP_PUNCT:
2190: if ((range2->type == XML_REGEXP_PUNCT_CONNECTOR) ||
2191: (range2->type == XML_REGEXP_PUNCT_DASH) ||
2192: (range2->type == XML_REGEXP_PUNCT_OPEN) ||
2193: (range2->type == XML_REGEXP_PUNCT_CLOSE) ||
2194: (range2->type == XML_REGEXP_PUNCT_INITQUOTE) ||
2195: (range2->type == XML_REGEXP_PUNCT_FINQUOTE) ||
2196: (range2->type == XML_REGEXP_PUNCT_OTHERS))
2197: ret = 1;
2198: break;
2199: case XML_REGEXP_SEPAR:
2200: if ((range2->type == XML_REGEXP_SEPAR_SPACE) ||
2201: (range2->type == XML_REGEXP_SEPAR_LINE) ||
2202: (range2->type == XML_REGEXP_SEPAR_PARA))
2203: ret = 1;
2204: break;
2205: case XML_REGEXP_SYMBOL:
2206: if ((range2->type == XML_REGEXP_SYMBOL_MATH) ||
2207: (range2->type == XML_REGEXP_SYMBOL_CURRENCY) ||
2208: (range2->type == XML_REGEXP_SYMBOL_MODIFIER) ||
2209: (range2->type == XML_REGEXP_SYMBOL_OTHERS))
2210: ret = 1;
2211: break;
2212: case XML_REGEXP_OTHER:
2213: if ((range2->type == XML_REGEXP_OTHER_CONTROL) ||
2214: (range2->type == XML_REGEXP_OTHER_FORMAT) ||
2215: (range2->type == XML_REGEXP_OTHER_PRIVATE))
2216: ret = 1;
2217: break;
2218: default:
2219: if ((range2->type >= XML_REGEXP_LETTER) &&
2220: (range2->type < XML_REGEXP_BLOCK_NAME))
2221: ret = 0;
2222: else {
2223: /* safety net ! */
2224: return(1);
2225: }
2226: }
2227: }
2228: if (((range1->neg == 0) && (range2->neg != 0)) ||
2229: ((range1->neg != 0) && (range2->neg == 0)))
2230: ret = !ret;
2231: return(ret);
2232: }
2233:
2234: /**
2235: * xmlFACompareAtomTypes:
2236: * @type1: an atom type
2237: * @type2: an atom type
2238: *
2239: * Compares two atoms type to check whether they intersect in some ways,
2240: * this is used by xmlFACompareAtoms only
2241: *
2242: * Returns 1 if they may intersect and 0 otherwise
2243: */
2244: static int
2245: xmlFACompareAtomTypes(xmlRegAtomType type1, xmlRegAtomType type2) {
2246: if ((type1 == XML_REGEXP_EPSILON) ||
2247: (type1 == XML_REGEXP_CHARVAL) ||
2248: (type1 == XML_REGEXP_RANGES) ||
2249: (type1 == XML_REGEXP_SUBREG) ||
2250: (type1 == XML_REGEXP_STRING) ||
2251: (type1 == XML_REGEXP_ANYCHAR))
2252: return(1);
2253: if ((type2 == XML_REGEXP_EPSILON) ||
2254: (type2 == XML_REGEXP_CHARVAL) ||
2255: (type2 == XML_REGEXP_RANGES) ||
2256: (type2 == XML_REGEXP_SUBREG) ||
2257: (type2 == XML_REGEXP_STRING) ||
2258: (type2 == XML_REGEXP_ANYCHAR))
2259: return(1);
2260:
2261: if (type1 == type2) return(1);
2262:
2263: /* simplify subsequent compares by making sure type1 < type2 */
2264: if (type1 > type2) {
2265: xmlRegAtomType tmp = type1;
2266: type1 = type2;
2267: type2 = tmp;
2268: }
2269: switch (type1) {
2270: case XML_REGEXP_ANYSPACE: /* \s */
2271: /* can't be a letter, number, mark, pontuation, symbol */
2272: if ((type2 == XML_REGEXP_NOTSPACE) ||
2273: ((type2 >= XML_REGEXP_LETTER) &&
2274: (type2 <= XML_REGEXP_LETTER_OTHERS)) ||
2275: ((type2 >= XML_REGEXP_NUMBER) &&
2276: (type2 <= XML_REGEXP_NUMBER_OTHERS)) ||
2277: ((type2 >= XML_REGEXP_MARK) &&
2278: (type2 <= XML_REGEXP_MARK_ENCLOSING)) ||
2279: ((type2 >= XML_REGEXP_PUNCT) &&
2280: (type2 <= XML_REGEXP_PUNCT_OTHERS)) ||
2281: ((type2 >= XML_REGEXP_SYMBOL) &&
2282: (type2 <= XML_REGEXP_SYMBOL_OTHERS))
2283: ) return(0);
2284: break;
2285: case XML_REGEXP_NOTSPACE: /* \S */
2286: break;
2287: case XML_REGEXP_INITNAME: /* \l */
2288: /* can't be a number, mark, separator, pontuation, symbol or other */
2289: if ((type2 == XML_REGEXP_NOTINITNAME) ||
2290: ((type2 >= XML_REGEXP_NUMBER) &&
2291: (type2 <= XML_REGEXP_NUMBER_OTHERS)) ||
2292: ((type2 >= XML_REGEXP_MARK) &&
2293: (type2 <= XML_REGEXP_MARK_ENCLOSING)) ||
2294: ((type2 >= XML_REGEXP_SEPAR) &&
2295: (type2 <= XML_REGEXP_SEPAR_PARA)) ||
2296: ((type2 >= XML_REGEXP_PUNCT) &&
2297: (type2 <= XML_REGEXP_PUNCT_OTHERS)) ||
2298: ((type2 >= XML_REGEXP_SYMBOL) &&
2299: (type2 <= XML_REGEXP_SYMBOL_OTHERS)) ||
2300: ((type2 >= XML_REGEXP_OTHER) &&
2301: (type2 <= XML_REGEXP_OTHER_NA))
2302: ) return(0);
2303: break;
2304: case XML_REGEXP_NOTINITNAME: /* \L */
2305: break;
2306: case XML_REGEXP_NAMECHAR: /* \c */
2307: /* can't be a mark, separator, pontuation, symbol or other */
2308: if ((type2 == XML_REGEXP_NOTNAMECHAR) ||
2309: ((type2 >= XML_REGEXP_MARK) &&
2310: (type2 <= XML_REGEXP_MARK_ENCLOSING)) ||
2311: ((type2 >= XML_REGEXP_PUNCT) &&
2312: (type2 <= XML_REGEXP_PUNCT_OTHERS)) ||
2313: ((type2 >= XML_REGEXP_SEPAR) &&
2314: (type2 <= XML_REGEXP_SEPAR_PARA)) ||
2315: ((type2 >= XML_REGEXP_SYMBOL) &&
2316: (type2 <= XML_REGEXP_SYMBOL_OTHERS)) ||
2317: ((type2 >= XML_REGEXP_OTHER) &&
2318: (type2 <= XML_REGEXP_OTHER_NA))
2319: ) return(0);
2320: break;
2321: case XML_REGEXP_NOTNAMECHAR: /* \C */
2322: break;
2323: case XML_REGEXP_DECIMAL: /* \d */
2324: /* can't be a letter, mark, separator, pontuation, symbol or other */
2325: if ((type2 == XML_REGEXP_NOTDECIMAL) ||
2326: (type2 == XML_REGEXP_REALCHAR) ||
2327: ((type2 >= XML_REGEXP_LETTER) &&
2328: (type2 <= XML_REGEXP_LETTER_OTHERS)) ||
2329: ((type2 >= XML_REGEXP_MARK) &&
2330: (type2 <= XML_REGEXP_MARK_ENCLOSING)) ||
2331: ((type2 >= XML_REGEXP_PUNCT) &&
2332: (type2 <= XML_REGEXP_PUNCT_OTHERS)) ||
2333: ((type2 >= XML_REGEXP_SEPAR) &&
2334: (type2 <= XML_REGEXP_SEPAR_PARA)) ||
2335: ((type2 >= XML_REGEXP_SYMBOL) &&
2336: (type2 <= XML_REGEXP_SYMBOL_OTHERS)) ||
2337: ((type2 >= XML_REGEXP_OTHER) &&
2338: (type2 <= XML_REGEXP_OTHER_NA))
2339: )return(0);
2340: break;
2341: case XML_REGEXP_NOTDECIMAL: /* \D */
2342: break;
2343: case XML_REGEXP_REALCHAR: /* \w */
2344: /* can't be a mark, separator, pontuation, symbol or other */
2345: if ((type2 == XML_REGEXP_NOTDECIMAL) ||
2346: ((type2 >= XML_REGEXP_MARK) &&
2347: (type2 <= XML_REGEXP_MARK_ENCLOSING)) ||
2348: ((type2 >= XML_REGEXP_PUNCT) &&
2349: (type2 <= XML_REGEXP_PUNCT_OTHERS)) ||
2350: ((type2 >= XML_REGEXP_SEPAR) &&
2351: (type2 <= XML_REGEXP_SEPAR_PARA)) ||
2352: ((type2 >= XML_REGEXP_SYMBOL) &&
2353: (type2 <= XML_REGEXP_SYMBOL_OTHERS)) ||
2354: ((type2 >= XML_REGEXP_OTHER) &&
2355: (type2 <= XML_REGEXP_OTHER_NA))
2356: )return(0);
2357: break;
2358: case XML_REGEXP_NOTREALCHAR: /* \W */
2359: break;
2360: /*
2361: * at that point we know both type 1 and type2 are from
2362: * character categories are ordered and are different,
2363: * it becomes simple because this is a partition
2364: */
2365: case XML_REGEXP_LETTER:
2366: if (type2 <= XML_REGEXP_LETTER_OTHERS)
2367: return(1);
2368: return(0);
2369: case XML_REGEXP_LETTER_UPPERCASE:
2370: case XML_REGEXP_LETTER_LOWERCASE:
2371: case XML_REGEXP_LETTER_TITLECASE:
2372: case XML_REGEXP_LETTER_MODIFIER:
2373: case XML_REGEXP_LETTER_OTHERS:
2374: return(0);
2375: case XML_REGEXP_MARK:
2376: if (type2 <= XML_REGEXP_MARK_ENCLOSING)
2377: return(1);
2378: return(0);
2379: case XML_REGEXP_MARK_NONSPACING:
2380: case XML_REGEXP_MARK_SPACECOMBINING:
2381: case XML_REGEXP_MARK_ENCLOSING:
2382: return(0);
2383: case XML_REGEXP_NUMBER:
2384: if (type2 <= XML_REGEXP_NUMBER_OTHERS)
2385: return(1);
2386: return(0);
2387: case XML_REGEXP_NUMBER_DECIMAL:
2388: case XML_REGEXP_NUMBER_LETTER:
2389: case XML_REGEXP_NUMBER_OTHERS:
2390: return(0);
2391: case XML_REGEXP_PUNCT:
2392: if (type2 <= XML_REGEXP_PUNCT_OTHERS)
2393: return(1);
2394: return(0);
2395: case XML_REGEXP_PUNCT_CONNECTOR:
2396: case XML_REGEXP_PUNCT_DASH:
2397: case XML_REGEXP_PUNCT_OPEN:
2398: case XML_REGEXP_PUNCT_CLOSE:
2399: case XML_REGEXP_PUNCT_INITQUOTE:
2400: case XML_REGEXP_PUNCT_FINQUOTE:
2401: case XML_REGEXP_PUNCT_OTHERS:
2402: return(0);
2403: case XML_REGEXP_SEPAR:
2404: if (type2 <= XML_REGEXP_SEPAR_PARA)
2405: return(1);
2406: return(0);
2407: case XML_REGEXP_SEPAR_SPACE:
2408: case XML_REGEXP_SEPAR_LINE:
2409: case XML_REGEXP_SEPAR_PARA:
2410: return(0);
2411: case XML_REGEXP_SYMBOL:
2412: if (type2 <= XML_REGEXP_SYMBOL_OTHERS)
2413: return(1);
2414: return(0);
2415: case XML_REGEXP_SYMBOL_MATH:
2416: case XML_REGEXP_SYMBOL_CURRENCY:
2417: case XML_REGEXP_SYMBOL_MODIFIER:
2418: case XML_REGEXP_SYMBOL_OTHERS:
2419: return(0);
2420: case XML_REGEXP_OTHER:
2421: if (type2 <= XML_REGEXP_OTHER_NA)
2422: return(1);
2423: return(0);
2424: case XML_REGEXP_OTHER_CONTROL:
2425: case XML_REGEXP_OTHER_FORMAT:
2426: case XML_REGEXP_OTHER_PRIVATE:
2427: case XML_REGEXP_OTHER_NA:
2428: return(0);
2429: default:
2430: break;
2431: }
2432: return(1);
2433: }
2434:
2435: /**
2436: * xmlFAEqualAtoms:
2437: * @atom1: an atom
2438: * @atom2: an atom
2439: * @deep: if not set only compare string pointers
2440: *
2441: * Compares two atoms to check whether they are the same exactly
2442: * this is used to remove equivalent transitions
2443: *
2444: * Returns 1 if same and 0 otherwise
2445: */
2446: static int
2447: xmlFAEqualAtoms(xmlRegAtomPtr atom1, xmlRegAtomPtr atom2, int deep) {
2448: int ret = 0;
2449:
2450: if (atom1 == atom2)
2451: return(1);
2452: if ((atom1 == NULL) || (atom2 == NULL))
2453: return(0);
2454:
2455: if (atom1->type != atom2->type)
2456: return(0);
2457: switch (atom1->type) {
2458: case XML_REGEXP_EPSILON:
2459: ret = 0;
2460: break;
2461: case XML_REGEXP_STRING:
2462: if (!deep)
2463: ret = (atom1->valuep == atom2->valuep);
2464: else
2465: ret = xmlStrEqual((xmlChar *)atom1->valuep,
2466: (xmlChar *)atom2->valuep);
2467: break;
2468: case XML_REGEXP_CHARVAL:
2469: ret = (atom1->codepoint == atom2->codepoint);
2470: break;
2471: case XML_REGEXP_RANGES:
2472: /* too hard to do in the general case */
2473: ret = 0;
2474: default:
2475: break;
2476: }
2477: return(ret);
2478: }
2479:
2480: /**
2481: * xmlFACompareAtoms:
2482: * @atom1: an atom
2483: * @atom2: an atom
2484: * @deep: if not set only compare string pointers
2485: *
2486: * Compares two atoms to check whether they intersect in some ways,
2487: * this is used by xmlFAComputesDeterminism and xmlFARecurseDeterminism only
2488: *
2489: * Returns 1 if yes and 0 otherwise
2490: */
2491: static int
2492: xmlFACompareAtoms(xmlRegAtomPtr atom1, xmlRegAtomPtr atom2, int deep) {
2493: int ret = 1;
2494:
2495: if (atom1 == atom2)
2496: return(1);
2497: if ((atom1 == NULL) || (atom2 == NULL))
2498: return(0);
2499:
2500: if ((atom1->type == XML_REGEXP_ANYCHAR) ||
2501: (atom2->type == XML_REGEXP_ANYCHAR))
2502: return(1);
2503:
2504: if (atom1->type > atom2->type) {
2505: xmlRegAtomPtr tmp;
2506: tmp = atom1;
2507: atom1 = atom2;
2508: atom2 = tmp;
2509: }
2510: if (atom1->type != atom2->type) {
2511: ret = xmlFACompareAtomTypes(atom1->type, atom2->type);
2512: /* if they can't intersect at the type level break now */
2513: if (ret == 0)
2514: return(0);
2515: }
2516: switch (atom1->type) {
2517: case XML_REGEXP_STRING:
2518: if (!deep)
2519: ret = (atom1->valuep != atom2->valuep);
2520: else
2521: ret = xmlRegStrEqualWildcard((xmlChar *)atom1->valuep,
2522: (xmlChar *)atom2->valuep);
2523: break;
2524: case XML_REGEXP_EPSILON:
2525: goto not_determinist;
2526: case XML_REGEXP_CHARVAL:
2527: if (atom2->type == XML_REGEXP_CHARVAL) {
2528: ret = (atom1->codepoint == atom2->codepoint);
2529: } else {
2530: ret = xmlRegCheckCharacter(atom2, atom1->codepoint);
2531: if (ret < 0)
2532: ret = 1;
2533: }
2534: break;
2535: case XML_REGEXP_RANGES:
2536: if (atom2->type == XML_REGEXP_RANGES) {
2537: int i, j, res;
2538: xmlRegRangePtr r1, r2;
2539:
2540: /*
2541: * need to check that none of the ranges eventually matches
2542: */
2543: for (i = 0;i < atom1->nbRanges;i++) {
2544: for (j = 0;j < atom2->nbRanges;j++) {
2545: r1 = atom1->ranges[i];
2546: r2 = atom2->ranges[j];
2547: res = xmlFACompareRanges(r1, r2);
2548: if (res == 1) {
2549: ret = 1;
2550: goto done;
2551: }
2552: }
2553: }
2554: ret = 0;
2555: }
2556: break;
2557: default:
2558: goto not_determinist;
2559: }
2560: done:
2561: if (atom1->neg != atom2->neg) {
2562: ret = !ret;
2563: }
2564: if (ret == 0)
2565: return(0);
2566: not_determinist:
2567: return(1);
2568: }
2569:
2570: /**
2571: * xmlFARecurseDeterminism:
2572: * @ctxt: a regexp parser context
2573: *
2574: * Check whether the associated regexp is determinist,
2575: * should be called after xmlFAEliminateEpsilonTransitions()
2576: *
2577: */
2578: static int
2579: xmlFARecurseDeterminism(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state,
2580: int to, xmlRegAtomPtr atom) {
2581: int ret = 1;
2582: int res;
2583: int transnr, nbTrans;
2584: xmlRegTransPtr t1;
2585: int deep = 1;
2586:
2587: if (state == NULL)
2588: return(ret);
2589:
2590: if (ctxt->flags & AM_AUTOMATA_RNG)
2591: deep = 0;
2592:
2593: /*
2594: * don't recurse on transitions potentially added in the course of
2595: * the elimination.
2596: */
2597: nbTrans = state->nbTrans;
2598: for (transnr = 0;transnr < nbTrans;transnr++) {
2599: t1 = &(state->trans[transnr]);
2600: /*
2601: * check transitions conflicting with the one looked at
2602: */
2603: if (t1->atom == NULL) {
2604: if (t1->to < 0)
2605: continue;
2606: res = xmlFARecurseDeterminism(ctxt, ctxt->states[t1->to],
2607: to, atom);
2608: if (res == 0) {
2609: ret = 0;
2610: /* t1->nd = 1; */
2611: }
2612: continue;
2613: }
2614: if (t1->to != to)
2615: continue;
2616: if (xmlFACompareAtoms(t1->atom, atom, deep)) {
2617: ret = 0;
2618: /* mark the transition as non-deterministic */
2619: t1->nd = 1;
2620: }
2621: }
2622: return(ret);
2623: }
2624:
2625: /**
2626: * xmlFAComputesDeterminism:
2627: * @ctxt: a regexp parser context
2628: *
2629: * Check whether the associated regexp is determinist,
2630: * should be called after xmlFAEliminateEpsilonTransitions()
2631: *
2632: */
2633: static int
2634: xmlFAComputesDeterminism(xmlRegParserCtxtPtr ctxt) {
2635: int statenr, transnr;
2636: xmlRegStatePtr state;
2637: xmlRegTransPtr t1, t2, last;
2638: int i;
2639: int ret = 1;
2640: int deep = 1;
2641:
2642: #ifdef DEBUG_REGEXP_GRAPH
2643: printf("xmlFAComputesDeterminism\n");
2644: xmlRegPrintCtxt(stdout, ctxt);
2645: #endif
2646: if (ctxt->determinist != -1)
2647: return(ctxt->determinist);
2648:
2649: if (ctxt->flags & AM_AUTOMATA_RNG)
2650: deep = 0;
2651:
2652: /*
2653: * First cleanup the automata removing cancelled transitions
2654: */
2655: for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
2656: state = ctxt->states[statenr];
2657: if (state == NULL)
2658: continue;
2659: if (state->nbTrans < 2)
2660: continue;
2661: for (transnr = 0;transnr < state->nbTrans;transnr++) {
2662: t1 = &(state->trans[transnr]);
2663: /*
2664: * Determinism checks in case of counted or all transitions
2665: * will have to be handled separately
2666: */
2667: if (t1->atom == NULL) {
2668: /* t1->nd = 1; */
2669: continue;
2670: }
2671: if (t1->to == -1) /* eliminated */
2672: continue;
2673: for (i = 0;i < transnr;i++) {
2674: t2 = &(state->trans[i]);
2675: if (t2->to == -1) /* eliminated */
2676: continue;
2677: if (t2->atom != NULL) {
2678: if (t1->to == t2->to) {
2679: /*
2680: * Here we use deep because we want to keep the
2681: * transitions which indicate a conflict
2682: */
2683: if (xmlFAEqualAtoms(t1->atom, t2->atom, deep) &&
2684: (t1->counter == t2->counter) &&
2685: (t1->count == t2->count))
2686: t2->to = -1; /* eliminated */
2687: }
2688: }
2689: }
2690: }
2691: }
2692:
2693: /*
2694: * Check for all states that there aren't 2 transitions
2695: * with the same atom and a different target.
2696: */
2697: for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
2698: state = ctxt->states[statenr];
2699: if (state == NULL)
2700: continue;
2701: if (state->nbTrans < 2)
2702: continue;
2703: last = NULL;
2704: for (transnr = 0;transnr < state->nbTrans;transnr++) {
2705: t1 = &(state->trans[transnr]);
2706: /*
2707: * Determinism checks in case of counted or all transitions
2708: * will have to be handled separately
2709: */
2710: if (t1->atom == NULL) {
2711: continue;
2712: }
2713: if (t1->to == -1) /* eliminated */
2714: continue;
2715: for (i = 0;i < transnr;i++) {
2716: t2 = &(state->trans[i]);
2717: if (t2->to == -1) /* eliminated */
2718: continue;
2719: if (t2->atom != NULL) {
2720: /*
2721: * But here we don't use deep because we want to
2722: * find transitions which indicate a conflict
2723: */
2724: if (xmlFACompareAtoms(t1->atom, t2->atom, 1)) {
2725: ret = 0;
2726: /* mark the transitions as non-deterministic ones */
2727: t1->nd = 1;
2728: t2->nd = 1;
2729: last = t1;
2730: }
2731: } else if (t1->to != -1) {
2732: /*
2733: * do the closure in case of remaining specific
2734: * epsilon transitions like choices or all
2735: */
2736: ret = xmlFARecurseDeterminism(ctxt, ctxt->states[t1->to],
2737: t2->to, t2->atom);
2738: /* don't shortcut the computation so all non deterministic
2739: transition get marked down
2740: if (ret == 0)
2741: return(0);
2742: */
2743: if (ret == 0) {
2744: t1->nd = 1;
2745: /* t2->nd = 1; */
2746: last = t1;
2747: }
2748: }
2749: }
2750: /* don't shortcut the computation so all non deterministic
2751: transition get marked down
2752: if (ret == 0)
2753: break; */
2754: }
2755:
2756: /*
2757: * mark specifically the last non-deterministic transition
2758: * from a state since there is no need to set-up rollback
2759: * from it
2760: */
2761: if (last != NULL) {
2762: last->nd = 2;
2763: }
2764:
2765: /* don't shortcut the computation so all non deterministic
2766: transition get marked down
2767: if (ret == 0)
2768: break; */
2769: }
2770:
2771: ctxt->determinist = ret;
2772: return(ret);
2773: }
2774:
2775: /************************************************************************
2776: * *
2777: * Routines to check input against transition atoms *
2778: * *
2779: ************************************************************************/
2780:
2781: static int
2782: xmlRegCheckCharacterRange(xmlRegAtomType type, int codepoint, int neg,
2783: int start, int end, const xmlChar *blockName) {
2784: int ret = 0;
2785:
2786: switch (type) {
2787: case XML_REGEXP_STRING:
2788: case XML_REGEXP_SUBREG:
2789: case XML_REGEXP_RANGES:
2790: case XML_REGEXP_EPSILON:
2791: return(-1);
2792: case XML_REGEXP_ANYCHAR:
2793: ret = ((codepoint != '\n') && (codepoint != '\r'));
2794: break;
2795: case XML_REGEXP_CHARVAL:
2796: ret = ((codepoint >= start) && (codepoint <= end));
2797: break;
2798: case XML_REGEXP_NOTSPACE:
2799: neg = !neg;
2800: case XML_REGEXP_ANYSPACE:
2801: ret = ((codepoint == '\n') || (codepoint == '\r') ||
2802: (codepoint == '\t') || (codepoint == ' '));
2803: break;
2804: case XML_REGEXP_NOTINITNAME:
2805: neg = !neg;
2806: case XML_REGEXP_INITNAME:
2807: ret = (IS_LETTER(codepoint) ||
2808: (codepoint == '_') || (codepoint == ':'));
2809: break;
2810: case XML_REGEXP_NOTNAMECHAR:
2811: neg = !neg;
2812: case XML_REGEXP_NAMECHAR:
2813: ret = (IS_LETTER(codepoint) || IS_DIGIT(codepoint) ||
2814: (codepoint == '.') || (codepoint == '-') ||
2815: (codepoint == '_') || (codepoint == ':') ||
2816: IS_COMBINING(codepoint) || IS_EXTENDER(codepoint));
2817: break;
2818: case XML_REGEXP_NOTDECIMAL:
2819: neg = !neg;
2820: case XML_REGEXP_DECIMAL:
2821: ret = xmlUCSIsCatNd(codepoint);
2822: break;
2823: case XML_REGEXP_REALCHAR:
2824: neg = !neg;
2825: case XML_REGEXP_NOTREALCHAR:
2826: ret = xmlUCSIsCatP(codepoint);
2827: if (ret == 0)
2828: ret = xmlUCSIsCatZ(codepoint);
2829: if (ret == 0)
2830: ret = xmlUCSIsCatC(codepoint);
2831: break;
2832: case XML_REGEXP_LETTER:
2833: ret = xmlUCSIsCatL(codepoint);
2834: break;
2835: case XML_REGEXP_LETTER_UPPERCASE:
2836: ret = xmlUCSIsCatLu(codepoint);
2837: break;
2838: case XML_REGEXP_LETTER_LOWERCASE:
2839: ret = xmlUCSIsCatLl(codepoint);
2840: break;
2841: case XML_REGEXP_LETTER_TITLECASE:
2842: ret = xmlUCSIsCatLt(codepoint);
2843: break;
2844: case XML_REGEXP_LETTER_MODIFIER:
2845: ret = xmlUCSIsCatLm(codepoint);
2846: break;
2847: case XML_REGEXP_LETTER_OTHERS:
2848: ret = xmlUCSIsCatLo(codepoint);
2849: break;
2850: case XML_REGEXP_MARK:
2851: ret = xmlUCSIsCatM(codepoint);
2852: break;
2853: case XML_REGEXP_MARK_NONSPACING:
2854: ret = xmlUCSIsCatMn(codepoint);
2855: break;
2856: case XML_REGEXP_MARK_SPACECOMBINING:
2857: ret = xmlUCSIsCatMc(codepoint);
2858: break;
2859: case XML_REGEXP_MARK_ENCLOSING:
2860: ret = xmlUCSIsCatMe(codepoint);
2861: break;
2862: case XML_REGEXP_NUMBER:
2863: ret = xmlUCSIsCatN(codepoint);
2864: break;
2865: case XML_REGEXP_NUMBER_DECIMAL:
2866: ret = xmlUCSIsCatNd(codepoint);
2867: break;
2868: case XML_REGEXP_NUMBER_LETTER:
2869: ret = xmlUCSIsCatNl(codepoint);
2870: break;
2871: case XML_REGEXP_NUMBER_OTHERS:
2872: ret = xmlUCSIsCatNo(codepoint);
2873: break;
2874: case XML_REGEXP_PUNCT:
2875: ret = xmlUCSIsCatP(codepoint);
2876: break;
2877: case XML_REGEXP_PUNCT_CONNECTOR:
2878: ret = xmlUCSIsCatPc(codepoint);
2879: break;
2880: case XML_REGEXP_PUNCT_DASH:
2881: ret = xmlUCSIsCatPd(codepoint);
2882: break;
2883: case XML_REGEXP_PUNCT_OPEN:
2884: ret = xmlUCSIsCatPs(codepoint);
2885: break;
2886: case XML_REGEXP_PUNCT_CLOSE:
2887: ret = xmlUCSIsCatPe(codepoint);
2888: break;
2889: case XML_REGEXP_PUNCT_INITQUOTE:
2890: ret = xmlUCSIsCatPi(codepoint);
2891: break;
2892: case XML_REGEXP_PUNCT_FINQUOTE:
2893: ret = xmlUCSIsCatPf(codepoint);
2894: break;
2895: case XML_REGEXP_PUNCT_OTHERS:
2896: ret = xmlUCSIsCatPo(codepoint);
2897: break;
2898: case XML_REGEXP_SEPAR:
2899: ret = xmlUCSIsCatZ(codepoint);
2900: break;
2901: case XML_REGEXP_SEPAR_SPACE:
2902: ret = xmlUCSIsCatZs(codepoint);
2903: break;
2904: case XML_REGEXP_SEPAR_LINE:
2905: ret = xmlUCSIsCatZl(codepoint);
2906: break;
2907: case XML_REGEXP_SEPAR_PARA:
2908: ret = xmlUCSIsCatZp(codepoint);
2909: break;
2910: case XML_REGEXP_SYMBOL:
2911: ret = xmlUCSIsCatS(codepoint);
2912: break;
2913: case XML_REGEXP_SYMBOL_MATH:
2914: ret = xmlUCSIsCatSm(codepoint);
2915: break;
2916: case XML_REGEXP_SYMBOL_CURRENCY:
2917: ret = xmlUCSIsCatSc(codepoint);
2918: break;
2919: case XML_REGEXP_SYMBOL_MODIFIER:
2920: ret = xmlUCSIsCatSk(codepoint);
2921: break;
2922: case XML_REGEXP_SYMBOL_OTHERS:
2923: ret = xmlUCSIsCatSo(codepoint);
2924: break;
2925: case XML_REGEXP_OTHER:
2926: ret = xmlUCSIsCatC(codepoint);
2927: break;
2928: case XML_REGEXP_OTHER_CONTROL:
2929: ret = xmlUCSIsCatCc(codepoint);
2930: break;
2931: case XML_REGEXP_OTHER_FORMAT:
2932: ret = xmlUCSIsCatCf(codepoint);
2933: break;
2934: case XML_REGEXP_OTHER_PRIVATE:
2935: ret = xmlUCSIsCatCo(codepoint);
2936: break;
2937: case XML_REGEXP_OTHER_NA:
2938: /* ret = xmlUCSIsCatCn(codepoint); */
2939: /* Seems it doesn't exist anymore in recent Unicode releases */
2940: ret = 0;
2941: break;
2942: case XML_REGEXP_BLOCK_NAME:
2943: ret = xmlUCSIsBlock(codepoint, (const char *) blockName);
2944: break;
2945: }
2946: if (neg)
2947: return(!ret);
2948: return(ret);
2949: }
2950:
2951: static int
2952: xmlRegCheckCharacter(xmlRegAtomPtr atom, int codepoint) {
2953: int i, ret = 0;
2954: xmlRegRangePtr range;
2955:
2956: if ((atom == NULL) || (!IS_CHAR(codepoint)))
2957: return(-1);
2958:
2959: switch (atom->type) {
2960: case XML_REGEXP_SUBREG:
2961: case XML_REGEXP_EPSILON:
2962: return(-1);
2963: case XML_REGEXP_CHARVAL:
2964: return(codepoint == atom->codepoint);
2965: case XML_REGEXP_RANGES: {
2966: int accept = 0;
2967:
2968: for (i = 0;i < atom->nbRanges;i++) {
2969: range = atom->ranges[i];
2970: if (range->neg == 2) {
2971: ret = xmlRegCheckCharacterRange(range->type, codepoint,
2972: 0, range->start, range->end,
2973: range->blockName);
2974: if (ret != 0)
2975: return(0); /* excluded char */
2976: } else if (range->neg) {
2977: ret = xmlRegCheckCharacterRange(range->type, codepoint,
2978: 0, range->start, range->end,
2979: range->blockName);
2980: if (ret == 0)
2981: accept = 1;
2982: else
2983: return(0);
2984: } else {
2985: ret = xmlRegCheckCharacterRange(range->type, codepoint,
2986: 0, range->start, range->end,
2987: range->blockName);
2988: if (ret != 0)
2989: accept = 1; /* might still be excluded */
2990: }
2991: }
2992: return(accept);
2993: }
2994: case XML_REGEXP_STRING:
2995: printf("TODO: XML_REGEXP_STRING\n");
2996: return(-1);
2997: case XML_REGEXP_ANYCHAR:
2998: case XML_REGEXP_ANYSPACE:
2999: case XML_REGEXP_NOTSPACE:
3000: case XML_REGEXP_INITNAME:
3001: case XML_REGEXP_NOTINITNAME:
3002: case XML_REGEXP_NAMECHAR:
3003: case XML_REGEXP_NOTNAMECHAR:
3004: case XML_REGEXP_DECIMAL:
3005: case XML_REGEXP_NOTDECIMAL:
3006: case XML_REGEXP_REALCHAR:
3007: case XML_REGEXP_NOTREALCHAR:
3008: case XML_REGEXP_LETTER:
3009: case XML_REGEXP_LETTER_UPPERCASE:
3010: case XML_REGEXP_LETTER_LOWERCASE:
3011: case XML_REGEXP_LETTER_TITLECASE:
3012: case XML_REGEXP_LETTER_MODIFIER:
3013: case XML_REGEXP_LETTER_OTHERS:
3014: case XML_REGEXP_MARK:
3015: case XML_REGEXP_MARK_NONSPACING:
3016: case XML_REGEXP_MARK_SPACECOMBINING:
3017: case XML_REGEXP_MARK_ENCLOSING:
3018: case XML_REGEXP_NUMBER:
3019: case XML_REGEXP_NUMBER_DECIMAL:
3020: case XML_REGEXP_NUMBER_LETTER:
3021: case XML_REGEXP_NUMBER_OTHERS:
3022: case XML_REGEXP_PUNCT:
3023: case XML_REGEXP_PUNCT_CONNECTOR:
3024: case XML_REGEXP_PUNCT_DASH:
3025: case XML_REGEXP_PUNCT_OPEN:
3026: case XML_REGEXP_PUNCT_CLOSE:
3027: case XML_REGEXP_PUNCT_INITQUOTE:
3028: case XML_REGEXP_PUNCT_FINQUOTE:
3029: case XML_REGEXP_PUNCT_OTHERS:
3030: case XML_REGEXP_SEPAR:
3031: case XML_REGEXP_SEPAR_SPACE:
3032: case XML_REGEXP_SEPAR_LINE:
3033: case XML_REGEXP_SEPAR_PARA:
3034: case XML_REGEXP_SYMBOL:
3035: case XML_REGEXP_SYMBOL_MATH:
3036: case XML_REGEXP_SYMBOL_CURRENCY:
3037: case XML_REGEXP_SYMBOL_MODIFIER:
3038: case XML_REGEXP_SYMBOL_OTHERS:
3039: case XML_REGEXP_OTHER:
3040: case XML_REGEXP_OTHER_CONTROL:
3041: case XML_REGEXP_OTHER_FORMAT:
3042: case XML_REGEXP_OTHER_PRIVATE:
3043: case XML_REGEXP_OTHER_NA:
3044: case XML_REGEXP_BLOCK_NAME:
3045: ret = xmlRegCheckCharacterRange(atom->type, codepoint, 0, 0, 0,
3046: (const xmlChar *)atom->valuep);
3047: if (atom->neg)
3048: ret = !ret;
3049: break;
3050: }
3051: return(ret);
3052: }
3053:
3054: /************************************************************************
3055: * *
3056: * Saving and restoring state of an execution context *
3057: * *
3058: ************************************************************************/
3059:
3060: #ifdef DEBUG_REGEXP_EXEC
3061: static void
3062: xmlFARegDebugExec(xmlRegExecCtxtPtr exec) {
3063: printf("state: %d:%d:idx %d", exec->state->no, exec->transno, exec->index);
3064: if (exec->inputStack != NULL) {
3065: int i;
3066: printf(": ");
3067: for (i = 0;(i < 3) && (i < exec->inputStackNr);i++)
3068: printf("%s ", (const char *)
3069: exec->inputStack[exec->inputStackNr - (i + 1)].value);
3070: } else {
3071: printf(": %s", &(exec->inputString[exec->index]));
3072: }
3073: printf("\n");
3074: }
3075: #endif
3076:
3077: static void
3078: xmlFARegExecSave(xmlRegExecCtxtPtr exec) {
3079: #ifdef DEBUG_REGEXP_EXEC
3080: printf("saving ");
3081: exec->transno++;
3082: xmlFARegDebugExec(exec);
3083: exec->transno--;
3084: #endif
3085: #ifdef MAX_PUSH
3086: if (exec->nbPush > MAX_PUSH) {
3087: return;
3088: }
3089: exec->nbPush++;
3090: #endif
3091:
3092: if (exec->maxRollbacks == 0) {
3093: exec->maxRollbacks = 4;
3094: exec->rollbacks = (xmlRegExecRollback *) xmlMalloc(exec->maxRollbacks *
3095: sizeof(xmlRegExecRollback));
3096: if (exec->rollbacks == NULL) {
3097: xmlRegexpErrMemory(NULL, "saving regexp");
3098: exec->maxRollbacks = 0;
3099: return;
3100: }
3101: memset(exec->rollbacks, 0,
3102: exec->maxRollbacks * sizeof(xmlRegExecRollback));
3103: } else if (exec->nbRollbacks >= exec->maxRollbacks) {
3104: xmlRegExecRollback *tmp;
3105: int len = exec->maxRollbacks;
3106:
3107: exec->maxRollbacks *= 2;
3108: tmp = (xmlRegExecRollback *) xmlRealloc(exec->rollbacks,
3109: exec->maxRollbacks * sizeof(xmlRegExecRollback));
3110: if (tmp == NULL) {
3111: xmlRegexpErrMemory(NULL, "saving regexp");
3112: exec->maxRollbacks /= 2;
3113: return;
3114: }
3115: exec->rollbacks = tmp;
3116: tmp = &exec->rollbacks[len];
3117: memset(tmp, 0, (exec->maxRollbacks - len) * sizeof(xmlRegExecRollback));
3118: }
3119: exec->rollbacks[exec->nbRollbacks].state = exec->state;
3120: exec->rollbacks[exec->nbRollbacks].index = exec->index;
3121: exec->rollbacks[exec->nbRollbacks].nextbranch = exec->transno + 1;
3122: if (exec->comp->nbCounters > 0) {
3123: if (exec->rollbacks[exec->nbRollbacks].counts == NULL) {
3124: exec->rollbacks[exec->nbRollbacks].counts = (int *)
3125: xmlMalloc(exec->comp->nbCounters * sizeof(int));
3126: if (exec->rollbacks[exec->nbRollbacks].counts == NULL) {
3127: xmlRegexpErrMemory(NULL, "saving regexp");
3128: exec->status = -5;
3129: return;
3130: }
3131: }
3132: memcpy(exec->rollbacks[exec->nbRollbacks].counts, exec->counts,
3133: exec->comp->nbCounters * sizeof(int));
3134: }
3135: exec->nbRollbacks++;
3136: }
3137:
3138: static void
3139: xmlFARegExecRollBack(xmlRegExecCtxtPtr exec) {
3140: if (exec->nbRollbacks <= 0) {
3141: exec->status = -1;
3142: #ifdef DEBUG_REGEXP_EXEC
3143: printf("rollback failed on empty stack\n");
3144: #endif
3145: return;
3146: }
3147: exec->nbRollbacks--;
3148: exec->state = exec->rollbacks[exec->nbRollbacks].state;
3149: exec->index = exec->rollbacks[exec->nbRollbacks].index;
3150: exec->transno = exec->rollbacks[exec->nbRollbacks].nextbranch;
3151: if (exec->comp->nbCounters > 0) {
3152: if (exec->rollbacks[exec->nbRollbacks].counts == NULL) {
3153: fprintf(stderr, "exec save: allocation failed");
3154: exec->status = -6;
3155: return;
3156: }
3157: memcpy(exec->counts, exec->rollbacks[exec->nbRollbacks].counts,
3158: exec->comp->nbCounters * sizeof(int));
3159: }
3160:
3161: #ifdef DEBUG_REGEXP_EXEC
3162: printf("restored ");
3163: xmlFARegDebugExec(exec);
3164: #endif
3165: }
3166:
3167: /************************************************************************
3168: * *
3169: * Verifier, running an input against a compiled regexp *
3170: * *
3171: ************************************************************************/
3172:
3173: static int
3174: xmlFARegExec(xmlRegexpPtr comp, const xmlChar *content) {
3175: xmlRegExecCtxt execval;
3176: xmlRegExecCtxtPtr exec = &execval;
3177: int ret, codepoint = 0, len, deter;
3178:
3179: exec->inputString = content;
3180: exec->index = 0;
3181: exec->nbPush = 0;
3182: exec->determinist = 1;
3183: exec->maxRollbacks = 0;
3184: exec->nbRollbacks = 0;
3185: exec->rollbacks = NULL;
3186: exec->status = 0;
3187: exec->comp = comp;
3188: exec->state = comp->states[0];
3189: exec->transno = 0;
3190: exec->transcount = 0;
3191: exec->inputStack = NULL;
3192: exec->inputStackMax = 0;
3193: if (comp->nbCounters > 0) {
3194: exec->counts = (int *) xmlMalloc(comp->nbCounters * sizeof(int));
3195: if (exec->counts == NULL) {
3196: xmlRegexpErrMemory(NULL, "running regexp");
3197: return(-1);
3198: }
3199: memset(exec->counts, 0, comp->nbCounters * sizeof(int));
3200: } else
3201: exec->counts = NULL;
3202: while ((exec->status == 0) &&
3203: ((exec->inputString[exec->index] != 0) ||
3204: ((exec->state != NULL) &&
3205: (exec->state->type != XML_REGEXP_FINAL_STATE)))) {
3206: xmlRegTransPtr trans;
3207: xmlRegAtomPtr atom;
3208:
3209: /*
3210: * If end of input on non-terminal state, rollback, however we may
3211: * still have epsilon like transition for counted transitions
3212: * on counters, in that case don't break too early. Additionally,
3213: * if we are working on a range like "AB{0,2}", where B is not present,
3214: * we don't want to break.
3215: */
3216: len = 1;
3217: if ((exec->inputString[exec->index] == 0) && (exec->counts == NULL)) {
3218: /*
3219: * if there is a transition, we must check if
3220: * atom allows minOccurs of 0
3221: */
3222: if (exec->transno < exec->state->nbTrans) {
3223: trans = &exec->state->trans[exec->transno];
3224: if (trans->to >=0) {
3225: atom = trans->atom;
3226: if (!((atom->min == 0) && (atom->max > 0)))
3227: goto rollback;
3228: }
3229: } else
3230: goto rollback;
3231: }
3232:
3233: exec->transcount = 0;
3234: for (;exec->transno < exec->state->nbTrans;exec->transno++) {
3235: trans = &exec->state->trans[exec->transno];
3236: if (trans->to < 0)
3237: continue;
3238: atom = trans->atom;
3239: ret = 0;
3240: deter = 1;
3241: if (trans->count >= 0) {
3242: int count;
3243: xmlRegCounterPtr counter;
3244:
3245: if (exec->counts == NULL) {
3246: exec->status = -1;
3247: goto error;
3248: }
3249: /*
3250: * A counted transition.
3251: */
3252:
3253: count = exec->counts[trans->count];
3254: counter = &exec->comp->counters[trans->count];
3255: #ifdef DEBUG_REGEXP_EXEC
3256: printf("testing count %d: val %d, min %d, max %d\n",
3257: trans->count, count, counter->min, counter->max);
3258: #endif
3259: ret = ((count >= counter->min) && (count <= counter->max));
3260: if ((ret) && (counter->min != counter->max))
3261: deter = 0;
3262: } else if (atom == NULL) {
3263: fprintf(stderr, "epsilon transition left at runtime\n");
3264: exec->status = -2;
3265: break;
3266: } else if (exec->inputString[exec->index] != 0) {
3267: codepoint = CUR_SCHAR(&(exec->inputString[exec->index]), len);
3268: ret = xmlRegCheckCharacter(atom, codepoint);
3269: if ((ret == 1) && (atom->min >= 0) && (atom->max > 0)) {
3270: xmlRegStatePtr to = comp->states[trans->to];
3271:
3272: /*
3273: * this is a multiple input sequence
3274: * If there is a counter associated increment it now.
3275: * before potentially saving and rollback
3276: * do not increment if the counter is already over the
3277: * maximum limit in which case get to next transition
3278: */
3279: if (trans->counter >= 0) {
3280: xmlRegCounterPtr counter;
3281:
3282: if ((exec->counts == NULL) ||
3283: (exec->comp == NULL) ||
3284: (exec->comp->counters == NULL)) {
3285: exec->status = -1;
3286: goto error;
3287: }
3288: counter = &exec->comp->counters[trans->counter];
3289: if (exec->counts[trans->counter] >= counter->max)
3290: continue; /* for loop on transitions */
3291:
3292: #ifdef DEBUG_REGEXP_EXEC
3293: printf("Increasing count %d\n", trans->counter);
3294: #endif
3295: exec->counts[trans->counter]++;
3296: }
3297: if (exec->state->nbTrans > exec->transno + 1) {
3298: xmlFARegExecSave(exec);
3299: }
3300: exec->transcount = 1;
3301: do {
3302: /*
3303: * Try to progress as much as possible on the input
3304: */
3305: if (exec->transcount == atom->max) {
3306: break;
3307: }
3308: exec->index += len;
3309: /*
3310: * End of input: stop here
3311: */
3312: if (exec->inputString[exec->index] == 0) {
3313: exec->index -= len;
3314: break;
3315: }
3316: if (exec->transcount >= atom->min) {
3317: int transno = exec->transno;
3318: xmlRegStatePtr state = exec->state;
3319:
3320: /*
3321: * The transition is acceptable save it
3322: */
3323: exec->transno = -1; /* trick */
3324: exec->state = to;
3325: xmlFARegExecSave(exec);
3326: exec->transno = transno;
3327: exec->state = state;
3328: }
3329: codepoint = CUR_SCHAR(&(exec->inputString[exec->index]),
3330: len);
3331: ret = xmlRegCheckCharacter(atom, codepoint);
3332: exec->transcount++;
3333: } while (ret == 1);
3334: if (exec->transcount < atom->min)
3335: ret = 0;
3336:
3337: /*
3338: * If the last check failed but one transition was found
3339: * possible, rollback
3340: */
3341: if (ret < 0)
3342: ret = 0;
3343: if (ret == 0) {
3344: goto rollback;
3345: }
3346: if (trans->counter >= 0) {
3347: if (exec->counts == NULL) {
3348: exec->status = -1;
3349: goto error;
3350: }
3351: #ifdef DEBUG_REGEXP_EXEC
3352: printf("Decreasing count %d\n", trans->counter);
3353: #endif
3354: exec->counts[trans->counter]--;
3355: }
3356: } else if ((ret == 0) && (atom->min == 0) && (atom->max > 0)) {
3357: /*
3358: * we don't match on the codepoint, but minOccurs of 0
3359: * says that's ok. Setting len to 0 inhibits stepping
3360: * over the codepoint.
3361: */
3362: exec->transcount = 1;
3363: len = 0;
3364: ret = 1;
3365: }
3366: } else if ((atom->min == 0) && (atom->max > 0)) {
3367: /* another spot to match when minOccurs is 0 */
3368: exec->transcount = 1;
3369: len = 0;
3370: ret = 1;
3371: }
3372: if (ret == 1) {
3373: if ((trans->nd == 1) ||
3374: ((trans->count >= 0) && (deter == 0) &&
3375: (exec->state->nbTrans > exec->transno + 1))) {
3376: #ifdef DEBUG_REGEXP_EXEC
3377: if (trans->nd == 1)
3378: printf("Saving on nd transition atom %d for %c at %d\n",
3379: trans->atom->no, codepoint, exec->index);
3380: else
3381: printf("Saving on counted transition count %d for %c at %d\n",
3382: trans->count, codepoint, exec->index);
3383: #endif
3384: xmlFARegExecSave(exec);
3385: }
3386: if (trans->counter >= 0) {
3387: xmlRegCounterPtr counter;
3388:
3389: /* make sure we don't go over the counter maximum value */
3390: if ((exec->counts == NULL) ||
3391: (exec->comp == NULL) ||
3392: (exec->comp->counters == NULL)) {
3393: exec->status = -1;
3394: goto error;
3395: }
3396: counter = &exec->comp->counters[trans->counter];
3397: if (exec->counts[trans->counter] >= counter->max)
3398: continue; /* for loop on transitions */
3399: #ifdef DEBUG_REGEXP_EXEC
3400: printf("Increasing count %d\n", trans->counter);
3401: #endif
3402: exec->counts[trans->counter]++;
3403: }
3404: if ((trans->count >= 0) &&
3405: (trans->count < REGEXP_ALL_COUNTER)) {
3406: if (exec->counts == NULL) {
3407: exec->status = -1;
3408: goto error;
3409: }
3410: #ifdef DEBUG_REGEXP_EXEC
3411: printf("resetting count %d on transition\n",
3412: trans->count);
3413: #endif
3414: exec->counts[trans->count] = 0;
3415: }
3416: #ifdef DEBUG_REGEXP_EXEC
3417: printf("entering state %d\n", trans->to);
3418: #endif
3419: exec->state = comp->states[trans->to];
3420: exec->transno = 0;
3421: if (trans->atom != NULL) {
3422: exec->index += len;
3423: }
3424: goto progress;
3425: } else if (ret < 0) {
3426: exec->status = -4;
3427: break;
3428: }
3429: }
3430: if ((exec->transno != 0) || (exec->state->nbTrans == 0)) {
3431: rollback:
3432: /*
3433: * Failed to find a way out
3434: */
3435: exec->determinist = 0;
3436: #ifdef DEBUG_REGEXP_EXEC
3437: printf("rollback from state %d on %d:%c\n", exec->state->no,
3438: codepoint,codepoint);
3439: #endif
3440: xmlFARegExecRollBack(exec);
3441: }
3442: progress:
3443: continue;
3444: }
3445: error:
3446: if (exec->rollbacks != NULL) {
3447: if (exec->counts != NULL) {
3448: int i;
3449:
3450: for (i = 0;i < exec->maxRollbacks;i++)
3451: if (exec->rollbacks[i].counts != NULL)
3452: xmlFree(exec->rollbacks[i].counts);
3453: }
3454: xmlFree(exec->rollbacks);
3455: }
3456: if (exec->counts != NULL)
3457: xmlFree(exec->counts);
3458: if (exec->status == 0)
3459: return(1);
3460: if (exec->status == -1) {
3461: if (exec->nbPush > MAX_PUSH)
3462: return(-1);
3463: return(0);
3464: }
3465: return(exec->status);
3466: }
3467:
3468: /************************************************************************
3469: * *
3470: * Progressive interface to the verifier one atom at a time *
3471: * *
3472: ************************************************************************/
3473: #ifdef DEBUG_ERR
3474: static void testerr(xmlRegExecCtxtPtr exec);
3475: #endif
3476:
3477: /**
3478: * xmlRegNewExecCtxt:
3479: * @comp: a precompiled regular expression
3480: * @callback: a callback function used for handling progresses in the
3481: * automata matching phase
3482: * @data: the context data associated to the callback in this context
3483: *
3484: * Build a context used for progressive evaluation of a regexp.
3485: *
3486: * Returns the new context
3487: */
3488: xmlRegExecCtxtPtr
3489: xmlRegNewExecCtxt(xmlRegexpPtr comp, xmlRegExecCallbacks callback, void *data) {
3490: xmlRegExecCtxtPtr exec;
3491:
3492: if (comp == NULL)
3493: return(NULL);
3494: if ((comp->compact == NULL) && (comp->states == NULL))
3495: return(NULL);
3496: exec = (xmlRegExecCtxtPtr) xmlMalloc(sizeof(xmlRegExecCtxt));
3497: if (exec == NULL) {
3498: xmlRegexpErrMemory(NULL, "creating execution context");
3499: return(NULL);
3500: }
3501: memset(exec, 0, sizeof(xmlRegExecCtxt));
3502: exec->inputString = NULL;
3503: exec->index = 0;
3504: exec->determinist = 1;
3505: exec->maxRollbacks = 0;
3506: exec->nbRollbacks = 0;
3507: exec->rollbacks = NULL;
3508: exec->status = 0;
3509: exec->comp = comp;
3510: if (comp->compact == NULL)
3511: exec->state = comp->states[0];
3512: exec->transno = 0;
3513: exec->transcount = 0;
3514: exec->callback = callback;
3515: exec->data = data;
3516: if (comp->nbCounters > 0) {
3517: /*
3518: * For error handling, exec->counts is allocated twice the size
3519: * the second half is used to store the data in case of rollback
3520: */
3521: exec->counts = (int *) xmlMalloc(comp->nbCounters * sizeof(int)
3522: * 2);
3523: if (exec->counts == NULL) {
3524: xmlRegexpErrMemory(NULL, "creating execution context");
3525: xmlFree(exec);
3526: return(NULL);
3527: }
3528: memset(exec->counts, 0, comp->nbCounters * sizeof(int) * 2);
3529: exec->errCounts = &exec->counts[comp->nbCounters];
3530: } else {
3531: exec->counts = NULL;
3532: exec->errCounts = NULL;
3533: }
3534: exec->inputStackMax = 0;
3535: exec->inputStackNr = 0;
3536: exec->inputStack = NULL;
3537: exec->errStateNo = -1;
3538: exec->errString = NULL;
3539: exec->nbPush = 0;
3540: return(exec);
3541: }
3542:
3543: /**
3544: * xmlRegFreeExecCtxt:
3545: * @exec: a regular expression evaulation context
3546: *
3547: * Free the structures associated to a regular expression evaulation context.
3548: */
3549: void
3550: xmlRegFreeExecCtxt(xmlRegExecCtxtPtr exec) {
3551: if (exec == NULL)
3552: return;
3553:
3554: if (exec->rollbacks != NULL) {
3555: if (exec->counts != NULL) {
3556: int i;
3557:
3558: for (i = 0;i < exec->maxRollbacks;i++)
3559: if (exec->rollbacks[i].counts != NULL)
3560: xmlFree(exec->rollbacks[i].counts);
3561: }
3562: xmlFree(exec->rollbacks);
3563: }
3564: if (exec->counts != NULL)
3565: xmlFree(exec->counts);
3566: if (exec->inputStack != NULL) {
3567: int i;
3568:
3569: for (i = 0;i < exec->inputStackNr;i++) {
3570: if (exec->inputStack[i].value != NULL)
3571: xmlFree(exec->inputStack[i].value);
3572: }
3573: xmlFree(exec->inputStack);
3574: }
3575: if (exec->errString != NULL)
3576: xmlFree(exec->errString);
3577: xmlFree(exec);
3578: }
3579:
3580: static void
3581: xmlFARegExecSaveInputString(xmlRegExecCtxtPtr exec, const xmlChar *value,
3582: void *data) {
3583: #ifdef DEBUG_PUSH
3584: printf("saving value: %d:%s\n", exec->inputStackNr, value);
3585: #endif
3586: if (exec->inputStackMax == 0) {
3587: exec->inputStackMax = 4;
3588: exec->inputStack = (xmlRegInputTokenPtr)
3589: xmlMalloc(exec->inputStackMax * sizeof(xmlRegInputToken));
3590: if (exec->inputStack == NULL) {
3591: xmlRegexpErrMemory(NULL, "pushing input string");
3592: exec->inputStackMax = 0;
3593: return;
3594: }
3595: } else if (exec->inputStackNr + 1 >= exec->inputStackMax) {
3596: xmlRegInputTokenPtr tmp;
3597:
3598: exec->inputStackMax *= 2;
3599: tmp = (xmlRegInputTokenPtr) xmlRealloc(exec->inputStack,
3600: exec->inputStackMax * sizeof(xmlRegInputToken));
3601: if (tmp == NULL) {
3602: xmlRegexpErrMemory(NULL, "pushing input string");
3603: exec->inputStackMax /= 2;
3604: return;
3605: }
3606: exec->inputStack = tmp;
3607: }
3608: exec->inputStack[exec->inputStackNr].value = xmlStrdup(value);
3609: exec->inputStack[exec->inputStackNr].data = data;
3610: exec->inputStackNr++;
3611: exec->inputStack[exec->inputStackNr].value = NULL;
3612: exec->inputStack[exec->inputStackNr].data = NULL;
3613: }
3614:
3615: /**
3616: * xmlRegStrEqualWildcard:
3617: * @expStr: the string to be evaluated
3618: * @valStr: the validation string
3619: *
3620: * Checks if both strings are equal or have the same content. "*"
3621: * can be used as a wildcard in @valStr; "|" is used as a seperator of
3622: * substrings in both @expStr and @valStr.
3623: *
3624: * Returns 1 if the comparison is satisfied and the number of substrings
3625: * is equal, 0 otherwise.
3626: */
3627:
3628: static int
3629: xmlRegStrEqualWildcard(const xmlChar *expStr, const xmlChar *valStr) {
3630: if (expStr == valStr) return(1);
3631: if (expStr == NULL) return(0);
3632: if (valStr == NULL) return(0);
3633: do {
3634: /*
3635: * Eval if we have a wildcard for the current item.
3636: */
3637: if (*expStr != *valStr) {
3638: /* if one of them starts with a wildcard make valStr be it */
3639: if (*valStr == '*') {
3640: const xmlChar *tmp;
3641:
3642: tmp = valStr;
3643: valStr = expStr;
3644: expStr = tmp;
3645: }
3646: if ((*valStr != 0) && (*expStr != 0) && (*expStr++ == '*')) {
3647: do {
3648: if (*valStr == XML_REG_STRING_SEPARATOR)
3649: break;
3650: valStr++;
3651: } while (*valStr != 0);
3652: continue;
3653: } else
3654: return(0);
3655: }
3656: expStr++;
3657: valStr++;
3658: } while (*valStr != 0);
3659: if (*expStr != 0)
3660: return (0);
3661: else
3662: return (1);
3663: }
3664:
3665: /**
3666: * xmlRegCompactPushString:
3667: * @exec: a regexp execution context
3668: * @comp: the precompiled exec with a compact table
3669: * @value: a string token input
3670: * @data: data associated to the token to reuse in callbacks
3671: *
3672: * Push one input token in the execution context
3673: *
3674: * Returns: 1 if the regexp reached a final state, 0 if non-final, and
3675: * a negative value in case of error.
3676: */
3677: static int
3678: xmlRegCompactPushString(xmlRegExecCtxtPtr exec,
3679: xmlRegexpPtr comp,
3680: const xmlChar *value,
3681: void *data) {
3682: int state = exec->index;
3683: int i, target;
3684:
3685: if ((comp == NULL) || (comp->compact == NULL) || (comp->stringMap == NULL))
3686: return(-1);
3687:
3688: if (value == NULL) {
3689: /*
3690: * are we at a final state ?
3691: */
3692: if (comp->compact[state * (comp->nbstrings + 1)] ==
3693: XML_REGEXP_FINAL_STATE)
3694: return(1);
3695: return(0);
3696: }
3697:
3698: #ifdef DEBUG_PUSH
3699: printf("value pushed: %s\n", value);
3700: #endif
3701:
3702: /*
3703: * Examine all outside transitions from current state
3704: */
3705: for (i = 0;i < comp->nbstrings;i++) {
3706: target = comp->compact[state * (comp->nbstrings + 1) + i + 1];
3707: if ((target > 0) && (target <= comp->nbstates)) {
3708: target--; /* to avoid 0 */
3709: if (xmlRegStrEqualWildcard(comp->stringMap[i], value)) {
3710: exec->index = target;
3711: if ((exec->callback != NULL) && (comp->transdata != NULL)) {
3712: exec->callback(exec->data, value,
3713: comp->transdata[state * comp->nbstrings + i], data);
3714: }
3715: #ifdef DEBUG_PUSH
3716: printf("entering state %d\n", target);
3717: #endif
3718: if (comp->compact[target * (comp->nbstrings + 1)] ==
3719: XML_REGEXP_SINK_STATE)
3720: goto error;
3721:
3722: if (comp->compact[target * (comp->nbstrings + 1)] ==
3723: XML_REGEXP_FINAL_STATE)
3724: return(1);
3725: return(0);
3726: }
3727: }
3728: }
3729: /*
3730: * Failed to find an exit transition out from current state for the
3731: * current token
3732: */
3733: #ifdef DEBUG_PUSH
3734: printf("failed to find a transition for %s on state %d\n", value, state);
3735: #endif
3736: error:
3737: if (exec->errString != NULL)
3738: xmlFree(exec->errString);
3739: exec->errString = xmlStrdup(value);
3740: exec->errStateNo = state;
3741: exec->status = -1;
3742: #ifdef DEBUG_ERR
3743: testerr(exec);
3744: #endif
3745: return(-1);
3746: }
3747:
3748: /**
3749: * xmlRegExecPushStringInternal:
3750: * @exec: a regexp execution context or NULL to indicate the end
3751: * @value: a string token input
3752: * @data: data associated to the token to reuse in callbacks
3753: * @compound: value was assembled from 2 strings
3754: *
3755: * Push one input token in the execution context
3756: *
3757: * Returns: 1 if the regexp reached a final state, 0 if non-final, and
3758: * a negative value in case of error.
3759: */
3760: static int
3761: xmlRegExecPushStringInternal(xmlRegExecCtxtPtr exec, const xmlChar *value,
3762: void *data, int compound) {
3763: xmlRegTransPtr trans;
3764: xmlRegAtomPtr atom;
3765: int ret;
3766: int final = 0;
3767: int progress = 1;
3768:
3769: if (exec == NULL)
3770: return(-1);
3771: if (exec->comp == NULL)
3772: return(-1);
3773: if (exec->status != 0)
3774: return(exec->status);
3775:
3776: if (exec->comp->compact != NULL)
3777: return(xmlRegCompactPushString(exec, exec->comp, value, data));
3778:
3779: if (value == NULL) {
3780: if (exec->state->type == XML_REGEXP_FINAL_STATE)
3781: return(1);
3782: final = 1;
3783: }
3784:
3785: #ifdef DEBUG_PUSH
3786: printf("value pushed: %s\n", value);
3787: #endif
3788: /*
3789: * If we have an active rollback stack push the new value there
3790: * and get back to where we were left
3791: */
3792: if ((value != NULL) && (exec->inputStackNr > 0)) {
3793: xmlFARegExecSaveInputString(exec, value, data);
3794: value = exec->inputStack[exec->index].value;
3795: data = exec->inputStack[exec->index].data;
3796: #ifdef DEBUG_PUSH
3797: printf("value loaded: %s\n", value);
3798: #endif
3799: }
3800:
3801: while ((exec->status == 0) &&
3802: ((value != NULL) ||
3803: ((final == 1) &&
3804: (exec->state->type != XML_REGEXP_FINAL_STATE)))) {
3805:
3806: /*
3807: * End of input on non-terminal state, rollback, however we may
3808: * still have epsilon like transition for counted transitions
3809: * on counters, in that case don't break too early.
3810: */
3811: if ((value == NULL) && (exec->counts == NULL))
3812: goto rollback;
3813:
3814: exec->transcount = 0;
3815: for (;exec->transno < exec->state->nbTrans;exec->transno++) {
3816: trans = &exec->state->trans[exec->transno];
3817: if (trans->to < 0)
3818: continue;
3819: atom = trans->atom;
3820: ret = 0;
3821: if (trans->count == REGEXP_ALL_LAX_COUNTER) {
3822: int i;
3823: int count;
3824: xmlRegTransPtr t;
3825: xmlRegCounterPtr counter;
3826:
3827: ret = 0;
3828:
3829: #ifdef DEBUG_PUSH
3830: printf("testing all lax %d\n", trans->count);
3831: #endif
3832: /*
3833: * Check all counted transitions from the current state
3834: */
3835: if ((value == NULL) && (final)) {
3836: ret = 1;
3837: } else if (value != NULL) {
3838: for (i = 0;i < exec->state->nbTrans;i++) {
3839: t = &exec->state->trans[i];
3840: if ((t->counter < 0) || (t == trans))
3841: continue;
3842: counter = &exec->comp->counters[t->counter];
3843: count = exec->counts[t->counter];
3844: if ((count < counter->max) &&
3845: (t->atom != NULL) &&
3846: (xmlStrEqual(value, t->atom->valuep))) {
3847: ret = 0;
3848: break;
3849: }
3850: if ((count >= counter->min) &&
3851: (count < counter->max) &&
3852: (t->atom != NULL) &&
3853: (xmlStrEqual(value, t->atom->valuep))) {
3854: ret = 1;
3855: break;
3856: }
3857: }
3858: }
3859: } else if (trans->count == REGEXP_ALL_COUNTER) {
3860: int i;
3861: int count;
3862: xmlRegTransPtr t;
3863: xmlRegCounterPtr counter;
3864:
3865: ret = 1;
3866:
3867: #ifdef DEBUG_PUSH
3868: printf("testing all %d\n", trans->count);
3869: #endif
3870: /*
3871: * Check all counted transitions from the current state
3872: */
3873: for (i = 0;i < exec->state->nbTrans;i++) {
3874: t = &exec->state->trans[i];
3875: if ((t->counter < 0) || (t == trans))
3876: continue;
3877: counter = &exec->comp->counters[t->counter];
3878: count = exec->counts[t->counter];
3879: if ((count < counter->min) || (count > counter->max)) {
3880: ret = 0;
3881: break;
3882: }
3883: }
3884: } else if (trans->count >= 0) {
3885: int count;
3886: xmlRegCounterPtr counter;
3887:
3888: /*
3889: * A counted transition.
3890: */
3891:
3892: count = exec->counts[trans->count];
3893: counter = &exec->comp->counters[trans->count];
3894: #ifdef DEBUG_PUSH
3895: printf("testing count %d: val %d, min %d, max %d\n",
3896: trans->count, count, counter->min, counter->max);
3897: #endif
3898: ret = ((count >= counter->min) && (count <= counter->max));
3899: } else if (atom == NULL) {
3900: fprintf(stderr, "epsilon transition left at runtime\n");
3901: exec->status = -2;
3902: break;
3903: } else if (value != NULL) {
3904: ret = xmlRegStrEqualWildcard(atom->valuep, value);
3905: if (atom->neg) {
3906: ret = !ret;
3907: if (!compound)
3908: ret = 0;
3909: }
3910: if ((ret == 1) && (trans->counter >= 0)) {
3911: xmlRegCounterPtr counter;
3912: int count;
3913:
3914: count = exec->counts[trans->counter];
3915: counter = &exec->comp->counters[trans->counter];
3916: if (count >= counter->max)
3917: ret = 0;
3918: }
3919:
3920: if ((ret == 1) && (atom->min > 0) && (atom->max > 0)) {
3921: xmlRegStatePtr to = exec->comp->states[trans->to];
3922:
3923: /*
3924: * this is a multiple input sequence
3925: */
3926: if (exec->state->nbTrans > exec->transno + 1) {
3927: if (exec->inputStackNr <= 0) {
3928: xmlFARegExecSaveInputString(exec, value, data);
3929: }
3930: xmlFARegExecSave(exec);
3931: }
3932: exec->transcount = 1;
3933: do {
3934: /*
3935: * Try to progress as much as possible on the input
3936: */
3937: if (exec->transcount == atom->max) {
3938: break;
3939: }
3940: exec->index++;
3941: value = exec->inputStack[exec->index].value;
3942: data = exec->inputStack[exec->index].data;
3943: #ifdef DEBUG_PUSH
3944: printf("value loaded: %s\n", value);
3945: #endif
3946:
3947: /*
3948: * End of input: stop here
3949: */
3950: if (value == NULL) {
3951: exec->index --;
3952: break;
3953: }
3954: if (exec->transcount >= atom->min) {
3955: int transno = exec->transno;
3956: xmlRegStatePtr state = exec->state;
3957:
3958: /*
3959: * The transition is acceptable save it
3960: */
3961: exec->transno = -1; /* trick */
3962: exec->state = to;
3963: if (exec->inputStackNr <= 0) {
3964: xmlFARegExecSaveInputString(exec, value, data);
3965: }
3966: xmlFARegExecSave(exec);
3967: exec->transno = transno;
3968: exec->state = state;
3969: }
3970: ret = xmlStrEqual(value, atom->valuep);
3971: exec->transcount++;
3972: } while (ret == 1);
3973: if (exec->transcount < atom->min)
3974: ret = 0;
3975:
3976: /*
3977: * If the last check failed but one transition was found
3978: * possible, rollback
3979: */
3980: if (ret < 0)
3981: ret = 0;
3982: if (ret == 0) {
3983: goto rollback;
3984: }
3985: }
3986: }
3987: if (ret == 1) {
3988: if ((exec->callback != NULL) && (atom != NULL) &&
3989: (data != NULL)) {
3990: exec->callback(exec->data, atom->valuep,
3991: atom->data, data);
3992: }
3993: if (exec->state->nbTrans > exec->transno + 1) {
3994: if (exec->inputStackNr <= 0) {
3995: xmlFARegExecSaveInputString(exec, value, data);
3996: }
3997: xmlFARegExecSave(exec);
3998: }
3999: if (trans->counter >= 0) {
4000: #ifdef DEBUG_PUSH
4001: printf("Increasing count %d\n", trans->counter);
4002: #endif
4003: exec->counts[trans->counter]++;
4004: }
4005: if ((trans->count >= 0) &&
4006: (trans->count < REGEXP_ALL_COUNTER)) {
4007: #ifdef DEBUG_REGEXP_EXEC
4008: printf("resetting count %d on transition\n",
4009: trans->count);
4010: #endif
4011: exec->counts[trans->count] = 0;
4012: }
4013: #ifdef DEBUG_PUSH
4014: printf("entering state %d\n", trans->to);
4015: #endif
4016: if ((exec->comp->states[trans->to] != NULL) &&
4017: (exec->comp->states[trans->to]->type ==
4018: XML_REGEXP_SINK_STATE)) {
4019: /*
4020: * entering a sink state, save the current state as error
4021: * state.
4022: */
4023: if (exec->errString != NULL)
4024: xmlFree(exec->errString);
4025: exec->errString = xmlStrdup(value);
4026: exec->errState = exec->state;
4027: memcpy(exec->errCounts, exec->counts,
4028: exec->comp->nbCounters * sizeof(int));
4029: }
4030: exec->state = exec->comp->states[trans->to];
4031: exec->transno = 0;
4032: if (trans->atom != NULL) {
4033: if (exec->inputStack != NULL) {
4034: exec->index++;
4035: if (exec->index < exec->inputStackNr) {
4036: value = exec->inputStack[exec->index].value;
4037: data = exec->inputStack[exec->index].data;
4038: #ifdef DEBUG_PUSH
4039: printf("value loaded: %s\n", value);
4040: #endif
4041: } else {
4042: value = NULL;
4043: data = NULL;
4044: #ifdef DEBUG_PUSH
4045: printf("end of input\n");
4046: #endif
4047: }
4048: } else {
4049: value = NULL;
4050: data = NULL;
4051: #ifdef DEBUG_PUSH
4052: printf("end of input\n");
4053: #endif
4054: }
4055: }
4056: goto progress;
4057: } else if (ret < 0) {
4058: exec->status = -4;
4059: break;
4060: }
4061: }
4062: if ((exec->transno != 0) || (exec->state->nbTrans == 0)) {
4063: rollback:
4064: /*
4065: * if we didn't yet rollback on the current input
4066: * store the current state as the error state.
4067: */
4068: if ((progress) && (exec->state != NULL) &&
4069: (exec->state->type != XML_REGEXP_SINK_STATE)) {
4070: progress = 0;
4071: if (exec->errString != NULL)
4072: xmlFree(exec->errString);
4073: exec->errString = xmlStrdup(value);
4074: exec->errState = exec->state;
4075: memcpy(exec->errCounts, exec->counts,
4076: exec->comp->nbCounters * sizeof(int));
4077: }
4078:
4079: /*
4080: * Failed to find a way out
4081: */
4082: exec->determinist = 0;
4083: xmlFARegExecRollBack(exec);
4084: if (exec->status == 0) {
4085: value = exec->inputStack[exec->index].value;
4086: data = exec->inputStack[exec->index].data;
4087: #ifdef DEBUG_PUSH
4088: printf("value loaded: %s\n", value);
4089: #endif
4090: }
4091: }
4092: continue;
4093: progress:
4094: progress = 1;
4095: continue;
4096: }
4097: if (exec->status == 0) {
4098: return(exec->state->type == XML_REGEXP_FINAL_STATE);
4099: }
4100: #ifdef DEBUG_ERR
4101: if (exec->status < 0) {
4102: testerr(exec);
4103: }
4104: #endif
4105: return(exec->status);
4106: }
4107:
4108: /**
4109: * xmlRegExecPushString:
4110: * @exec: a regexp execution context or NULL to indicate the end
4111: * @value: a string token input
4112: * @data: data associated to the token to reuse in callbacks
4113: *
4114: * Push one input token in the execution context
4115: *
4116: * Returns: 1 if the regexp reached a final state, 0 if non-final, and
4117: * a negative value in case of error.
4118: */
4119: int
4120: xmlRegExecPushString(xmlRegExecCtxtPtr exec, const xmlChar *value,
4121: void *data) {
4122: return(xmlRegExecPushStringInternal(exec, value, data, 0));
4123: }
4124:
4125: /**
4126: * xmlRegExecPushString2:
4127: * @exec: a regexp execution context or NULL to indicate the end
4128: * @value: the first string token input
4129: * @value2: the second string token input
4130: * @data: data associated to the token to reuse in callbacks
4131: *
4132: * Push one input token in the execution context
4133: *
4134: * Returns: 1 if the regexp reached a final state, 0 if non-final, and
4135: * a negative value in case of error.
4136: */
4137: int
4138: xmlRegExecPushString2(xmlRegExecCtxtPtr exec, const xmlChar *value,
4139: const xmlChar *value2, void *data) {
4140: xmlChar buf[150];
4141: int lenn, lenp, ret;
4142: xmlChar *str;
4143:
4144: if (exec == NULL)
4145: return(-1);
4146: if (exec->comp == NULL)
4147: return(-1);
4148: if (exec->status != 0)
4149: return(exec->status);
4150:
4151: if (value2 == NULL)
4152: return(xmlRegExecPushString(exec, value, data));
4153:
4154: lenn = strlen((char *) value2);
4155: lenp = strlen((char *) value);
4156:
4157: if (150 < lenn + lenp + 2) {
4158: str = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2);
4159: if (str == NULL) {
4160: exec->status = -1;
4161: return(-1);
4162: }
4163: } else {
4164: str = buf;
4165: }
4166: memcpy(&str[0], value, lenp);
4167: str[lenp] = XML_REG_STRING_SEPARATOR;
4168: memcpy(&str[lenp + 1], value2, lenn);
4169: str[lenn + lenp + 1] = 0;
4170:
4171: if (exec->comp->compact != NULL)
4172: ret = xmlRegCompactPushString(exec, exec->comp, str, data);
4173: else
4174: ret = xmlRegExecPushStringInternal(exec, str, data, 1);
4175:
4176: if (str != buf)
4177: xmlFree(str);
4178: return(ret);
4179: }
4180:
4181: /**
4182: * xmlRegExecGetValues:
4183: * @exec: a regexp execution context
4184: * @err: error extraction or normal one
4185: * @nbval: pointer to the number of accepted values IN/OUT
4186: * @nbneg: return number of negative transitions
4187: * @values: pointer to the array of acceptable values
4188: * @terminal: return value if this was a terminal state
4189: *
4190: * Extract informations from the regexp execution, internal routine to
4191: * implement xmlRegExecNextValues() and xmlRegExecErrInfo()
4192: *
4193: * Returns: 0 in case of success or -1 in case of error.
4194: */
4195: static int
4196: xmlRegExecGetValues(xmlRegExecCtxtPtr exec, int err,
4197: int *nbval, int *nbneg,
4198: xmlChar **values, int *terminal) {
4199: int maxval;
4200: int nb = 0;
4201:
4202: if ((exec == NULL) || (nbval == NULL) || (nbneg == NULL) ||
4203: (values == NULL) || (*nbval <= 0))
4204: return(-1);
4205:
4206: maxval = *nbval;
4207: *nbval = 0;
4208: *nbneg = 0;
4209: if ((exec->comp != NULL) && (exec->comp->compact != NULL)) {
4210: xmlRegexpPtr comp;
4211: int target, i, state;
4212:
4213: comp = exec->comp;
4214:
4215: if (err) {
4216: if (exec->errStateNo == -1) return(-1);
4217: state = exec->errStateNo;
4218: } else {
4219: state = exec->index;
4220: }
4221: if (terminal != NULL) {
4222: if (comp->compact[state * (comp->nbstrings + 1)] ==
4223: XML_REGEXP_FINAL_STATE)
4224: *terminal = 1;
4225: else
4226: *terminal = 0;
4227: }
4228: for (i = 0;(i < comp->nbstrings) && (nb < maxval);i++) {
4229: target = comp->compact[state * (comp->nbstrings + 1) + i + 1];
4230: if ((target > 0) && (target <= comp->nbstates) &&
4231: (comp->compact[(target - 1) * (comp->nbstrings + 1)] !=
4232: XML_REGEXP_SINK_STATE)) {
4233: values[nb++] = comp->stringMap[i];
4234: (*nbval)++;
4235: }
4236: }
4237: for (i = 0;(i < comp->nbstrings) && (nb < maxval);i++) {
4238: target = comp->compact[state * (comp->nbstrings + 1) + i + 1];
4239: if ((target > 0) && (target <= comp->nbstates) &&
4240: (comp->compact[(target - 1) * (comp->nbstrings + 1)] ==
4241: XML_REGEXP_SINK_STATE)) {
4242: values[nb++] = comp->stringMap[i];
4243: (*nbneg)++;
4244: }
4245: }
4246: } else {
4247: int transno;
4248: xmlRegTransPtr trans;
4249: xmlRegAtomPtr atom;
4250: xmlRegStatePtr state;
4251:
4252: if (terminal != NULL) {
4253: if (exec->state->type == XML_REGEXP_FINAL_STATE)
4254: *terminal = 1;
4255: else
4256: *terminal = 0;
4257: }
4258:
4259: if (err) {
4260: if (exec->errState == NULL) return(-1);
4261: state = exec->errState;
4262: } else {
4263: if (exec->state == NULL) return(-1);
4264: state = exec->state;
4265: }
4266: for (transno = 0;
4267: (transno < state->nbTrans) && (nb < maxval);
4268: transno++) {
4269: trans = &state->trans[transno];
4270: if (trans->to < 0)
4271: continue;
4272: atom = trans->atom;
4273: if ((atom == NULL) || (atom->valuep == NULL))
4274: continue;
4275: if (trans->count == REGEXP_ALL_LAX_COUNTER) {
4276: /* this should not be reached but ... */
4277: TODO;
4278: } else if (trans->count == REGEXP_ALL_COUNTER) {
4279: /* this should not be reached but ... */
4280: TODO;
4281: } else if (trans->counter >= 0) {
4282: xmlRegCounterPtr counter = NULL;
4283: int count;
4284:
4285: if (err)
4286: count = exec->errCounts[trans->counter];
4287: else
4288: count = exec->counts[trans->counter];
4289: if (exec->comp != NULL)
4290: counter = &exec->comp->counters[trans->counter];
4291: if ((counter == NULL) || (count < counter->max)) {
4292: if (atom->neg)
4293: values[nb++] = (xmlChar *) atom->valuep2;
4294: else
4295: values[nb++] = (xmlChar *) atom->valuep;
4296: (*nbval)++;
4297: }
4298: } else {
4299: if ((exec->comp->states[trans->to] != NULL) &&
4300: (exec->comp->states[trans->to]->type !=
4301: XML_REGEXP_SINK_STATE)) {
4302: if (atom->neg)
4303: values[nb++] = (xmlChar *) atom->valuep2;
4304: else
4305: values[nb++] = (xmlChar *) atom->valuep;
4306: (*nbval)++;
4307: }
4308: }
4309: }
4310: for (transno = 0;
4311: (transno < state->nbTrans) && (nb < maxval);
4312: transno++) {
4313: trans = &state->trans[transno];
4314: if (trans->to < 0)
4315: continue;
4316: atom = trans->atom;
4317: if ((atom == NULL) || (atom->valuep == NULL))
4318: continue;
4319: if (trans->count == REGEXP_ALL_LAX_COUNTER) {
4320: continue;
4321: } else if (trans->count == REGEXP_ALL_COUNTER) {
4322: continue;
4323: } else if (trans->counter >= 0) {
4324: continue;
4325: } else {
4326: if ((exec->comp->states[trans->to] != NULL) &&
4327: (exec->comp->states[trans->to]->type ==
4328: XML_REGEXP_SINK_STATE)) {
4329: if (atom->neg)
4330: values[nb++] = (xmlChar *) atom->valuep2;
4331: else
4332: values[nb++] = (xmlChar *) atom->valuep;
4333: (*nbneg)++;
4334: }
4335: }
4336: }
4337: }
4338: return(0);
4339: }
4340:
4341: /**
4342: * xmlRegExecNextValues:
4343: * @exec: a regexp execution context
4344: * @nbval: pointer to the number of accepted values IN/OUT
4345: * @nbneg: return number of negative transitions
4346: * @values: pointer to the array of acceptable values
4347: * @terminal: return value if this was a terminal state
4348: *
4349: * Extract informations from the regexp execution,
4350: * the parameter @values must point to an array of @nbval string pointers
4351: * on return nbval will contain the number of possible strings in that
4352: * state and the @values array will be updated with them. The string values
4353: * returned will be freed with the @exec context and don't need to be
4354: * deallocated.
4355: *
4356: * Returns: 0 in case of success or -1 in case of error.
4357: */
4358: int
4359: xmlRegExecNextValues(xmlRegExecCtxtPtr exec, int *nbval, int *nbneg,
4360: xmlChar **values, int *terminal) {
4361: return(xmlRegExecGetValues(exec, 0, nbval, nbneg, values, terminal));
4362: }
4363:
4364: /**
4365: * xmlRegExecErrInfo:
4366: * @exec: a regexp execution context generating an error
4367: * @string: return value for the error string
4368: * @nbval: pointer to the number of accepted values IN/OUT
4369: * @nbneg: return number of negative transitions
4370: * @values: pointer to the array of acceptable values
4371: * @terminal: return value if this was a terminal state
4372: *
4373: * Extract error informations from the regexp execution, the parameter
4374: * @string will be updated with the value pushed and not accepted,
4375: * the parameter @values must point to an array of @nbval string pointers
4376: * on return nbval will contain the number of possible strings in that
4377: * state and the @values array will be updated with them. The string values
4378: * returned will be freed with the @exec context and don't need to be
4379: * deallocated.
4380: *
4381: * Returns: 0 in case of success or -1 in case of error.
4382: */
4383: int
4384: xmlRegExecErrInfo(xmlRegExecCtxtPtr exec, const xmlChar **string,
4385: int *nbval, int *nbneg, xmlChar **values, int *terminal) {
4386: if (exec == NULL)
4387: return(-1);
4388: if (string != NULL) {
4389: if (exec->status != 0)
4390: *string = exec->errString;
4391: else
4392: *string = NULL;
4393: }
4394: return(xmlRegExecGetValues(exec, 1, nbval, nbneg, values, terminal));
4395: }
4396:
4397: #ifdef DEBUG_ERR
4398: static void testerr(xmlRegExecCtxtPtr exec) {
4399: const xmlChar *string;
4400: xmlChar *values[5];
4401: int nb = 5;
4402: int nbneg;
4403: int terminal;
4404: xmlRegExecErrInfo(exec, &string, &nb, &nbneg, &values[0], &terminal);
4405: }
4406: #endif
4407:
4408: #if 0
4409: static int
4410: xmlRegExecPushChar(xmlRegExecCtxtPtr exec, int UCS) {
4411: xmlRegTransPtr trans;
4412: xmlRegAtomPtr atom;
4413: int ret;
4414: int codepoint, len;
4415:
4416: if (exec == NULL)
4417: return(-1);
4418: if (exec->status != 0)
4419: return(exec->status);
4420:
4421: while ((exec->status == 0) &&
4422: ((exec->inputString[exec->index] != 0) ||
4423: (exec->state->type != XML_REGEXP_FINAL_STATE))) {
4424:
4425: /*
4426: * End of input on non-terminal state, rollback, however we may
4427: * still have epsilon like transition for counted transitions
4428: * on counters, in that case don't break too early.
4429: */
4430: if ((exec->inputString[exec->index] == 0) && (exec->counts == NULL))
4431: goto rollback;
4432:
4433: exec->transcount = 0;
4434: for (;exec->transno < exec->state->nbTrans;exec->transno++) {
4435: trans = &exec->state->trans[exec->transno];
4436: if (trans->to < 0)
4437: continue;
4438: atom = trans->atom;
4439: ret = 0;
4440: if (trans->count >= 0) {
4441: int count;
4442: xmlRegCounterPtr counter;
4443:
4444: /*
4445: * A counted transition.
4446: */
4447:
4448: count = exec->counts[trans->count];
4449: counter = &exec->comp->counters[trans->count];
4450: #ifdef DEBUG_REGEXP_EXEC
4451: printf("testing count %d: val %d, min %d, max %d\n",
4452: trans->count, count, counter->min, counter->max);
4453: #endif
4454: ret = ((count >= counter->min) && (count <= counter->max));
4455: } else if (atom == NULL) {
4456: fprintf(stderr, "epsilon transition left at runtime\n");
4457: exec->status = -2;
4458: break;
4459: } else if (exec->inputString[exec->index] != 0) {
4460: codepoint = CUR_SCHAR(&(exec->inputString[exec->index]), len);
4461: ret = xmlRegCheckCharacter(atom, codepoint);
4462: if ((ret == 1) && (atom->min > 0) && (atom->max > 0)) {
4463: xmlRegStatePtr to = exec->comp->states[trans->to];
4464:
4465: /*
4466: * this is a multiple input sequence
4467: */
4468: if (exec->state->nbTrans > exec->transno + 1) {
4469: xmlFARegExecSave(exec);
4470: }
4471: exec->transcount = 1;
4472: do {
4473: /*
4474: * Try to progress as much as possible on the input
4475: */
4476: if (exec->transcount == atom->max) {
4477: break;
4478: }
4479: exec->index += len;
4480: /*
4481: * End of input: stop here
4482: */
4483: if (exec->inputString[exec->index] == 0) {
4484: exec->index -= len;
4485: break;
4486: }
4487: if (exec->transcount >= atom->min) {
4488: int transno = exec->transno;
4489: xmlRegStatePtr state = exec->state;
4490:
4491: /*
4492: * The transition is acceptable save it
4493: */
4494: exec->transno = -1; /* trick */
4495: exec->state = to;
4496: xmlFARegExecSave(exec);
4497: exec->transno = transno;
4498: exec->state = state;
4499: }
4500: codepoint = CUR_SCHAR(&(exec->inputString[exec->index]),
4501: len);
4502: ret = xmlRegCheckCharacter(atom, codepoint);
4503: exec->transcount++;
4504: } while (ret == 1);
4505: if (exec->transcount < atom->min)
4506: ret = 0;
4507:
4508: /*
4509: * If the last check failed but one transition was found
4510: * possible, rollback
4511: */
4512: if (ret < 0)
4513: ret = 0;
4514: if (ret == 0) {
4515: goto rollback;
4516: }
4517: }
4518: }
4519: if (ret == 1) {
4520: if (exec->state->nbTrans > exec->transno + 1) {
4521: xmlFARegExecSave(exec);
4522: }
4523: /*
4524: * restart count for expressions like this ((abc){2})*
4525: */
4526: if (trans->count >= 0) {
4527: #ifdef DEBUG_REGEXP_EXEC
4528: printf("Reset count %d\n", trans->count);
4529: #endif
4530: exec->counts[trans->count] = 0;
4531: }
4532: if (trans->counter >= 0) {
4533: #ifdef DEBUG_REGEXP_EXEC
4534: printf("Increasing count %d\n", trans->counter);
4535: #endif
4536: exec->counts[trans->counter]++;
4537: }
4538: #ifdef DEBUG_REGEXP_EXEC
4539: printf("entering state %d\n", trans->to);
4540: #endif
4541: exec->state = exec->comp->states[trans->to];
4542: exec->transno = 0;
4543: if (trans->atom != NULL) {
4544: exec->index += len;
4545: }
4546: goto progress;
4547: } else if (ret < 0) {
4548: exec->status = -4;
4549: break;
4550: }
4551: }
4552: if ((exec->transno != 0) || (exec->state->nbTrans == 0)) {
4553: rollback:
4554: /*
4555: * Failed to find a way out
4556: */
4557: exec->determinist = 0;
4558: xmlFARegExecRollBack(exec);
4559: }
4560: progress:
4561: continue;
4562: }
4563: }
4564: #endif
4565: /************************************************************************
4566: * *
4567: * Parser for the Schemas Datatype Regular Expressions *
4568: * http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#regexs *
4569: * *
4570: ************************************************************************/
4571:
4572: /**
4573: * xmlFAIsChar:
4574: * @ctxt: a regexp parser context
4575: *
4576: * [10] Char ::= [^.\?*+()|#x5B#x5D]
4577: */
4578: static int
4579: xmlFAIsChar(xmlRegParserCtxtPtr ctxt) {
4580: int cur;
4581: int len;
4582:
4583: cur = CUR_SCHAR(ctxt->cur, len);
4584: if ((cur == '.') || (cur == '\\') || (cur == '?') ||
4585: (cur == '*') || (cur == '+') || (cur == '(') ||
4586: (cur == ')') || (cur == '|') || (cur == 0x5B) ||
4587: (cur == 0x5D) || (cur == 0))
4588: return(-1);
4589: return(cur);
4590: }
4591:
4592: /**
4593: * xmlFAParseCharProp:
4594: * @ctxt: a regexp parser context
4595: *
4596: * [27] charProp ::= IsCategory | IsBlock
4597: * [28] IsCategory ::= Letters | Marks | Numbers | Punctuation |
4598: * Separators | Symbols | Others
4599: * [29] Letters ::= 'L' [ultmo]?
4600: * [30] Marks ::= 'M' [nce]?
4601: * [31] Numbers ::= 'N' [dlo]?
4602: * [32] Punctuation ::= 'P' [cdseifo]?
4603: * [33] Separators ::= 'Z' [slp]?
4604: * [34] Symbols ::= 'S' [mcko]?
4605: * [35] Others ::= 'C' [cfon]?
4606: * [36] IsBlock ::= 'Is' [a-zA-Z0-9#x2D]+
4607: */
4608: static void
4609: xmlFAParseCharProp(xmlRegParserCtxtPtr ctxt) {
4610: int cur;
4611: xmlRegAtomType type = (xmlRegAtomType) 0;
4612: xmlChar *blockName = NULL;
4613:
4614: cur = CUR;
4615: if (cur == 'L') {
4616: NEXT;
4617: cur = CUR;
4618: if (cur == 'u') {
4619: NEXT;
4620: type = XML_REGEXP_LETTER_UPPERCASE;
4621: } else if (cur == 'l') {
4622: NEXT;
4623: type = XML_REGEXP_LETTER_LOWERCASE;
4624: } else if (cur == 't') {
4625: NEXT;
4626: type = XML_REGEXP_LETTER_TITLECASE;
4627: } else if (cur == 'm') {
4628: NEXT;
4629: type = XML_REGEXP_LETTER_MODIFIER;
4630: } else if (cur == 'o') {
4631: NEXT;
4632: type = XML_REGEXP_LETTER_OTHERS;
4633: } else {
4634: type = XML_REGEXP_LETTER;
4635: }
4636: } else if (cur == 'M') {
4637: NEXT;
4638: cur = CUR;
4639: if (cur == 'n') {
4640: NEXT;
4641: /* nonspacing */
4642: type = XML_REGEXP_MARK_NONSPACING;
4643: } else if (cur == 'c') {
4644: NEXT;
4645: /* spacing combining */
4646: type = XML_REGEXP_MARK_SPACECOMBINING;
4647: } else if (cur == 'e') {
4648: NEXT;
4649: /* enclosing */
4650: type = XML_REGEXP_MARK_ENCLOSING;
4651: } else {
4652: /* all marks */
4653: type = XML_REGEXP_MARK;
4654: }
4655: } else if (cur == 'N') {
4656: NEXT;
4657: cur = CUR;
4658: if (cur == 'd') {
4659: NEXT;
4660: /* digital */
4661: type = XML_REGEXP_NUMBER_DECIMAL;
4662: } else if (cur == 'l') {
4663: NEXT;
4664: /* letter */
4665: type = XML_REGEXP_NUMBER_LETTER;
4666: } else if (cur == 'o') {
4667: NEXT;
4668: /* other */
4669: type = XML_REGEXP_NUMBER_OTHERS;
4670: } else {
4671: /* all numbers */
4672: type = XML_REGEXP_NUMBER;
4673: }
4674: } else if (cur == 'P') {
4675: NEXT;
4676: cur = CUR;
4677: if (cur == 'c') {
4678: NEXT;
4679: /* connector */
4680: type = XML_REGEXP_PUNCT_CONNECTOR;
4681: } else if (cur == 'd') {
4682: NEXT;
4683: /* dash */
4684: type = XML_REGEXP_PUNCT_DASH;
4685: } else if (cur == 's') {
4686: NEXT;
4687: /* open */
4688: type = XML_REGEXP_PUNCT_OPEN;
4689: } else if (cur == 'e') {
4690: NEXT;
4691: /* close */
4692: type = XML_REGEXP_PUNCT_CLOSE;
4693: } else if (cur == 'i') {
4694: NEXT;
4695: /* initial quote */
4696: type = XML_REGEXP_PUNCT_INITQUOTE;
4697: } else if (cur == 'f') {
4698: NEXT;
4699: /* final quote */
4700: type = XML_REGEXP_PUNCT_FINQUOTE;
4701: } else if (cur == 'o') {
4702: NEXT;
4703: /* other */
4704: type = XML_REGEXP_PUNCT_OTHERS;
4705: } else {
4706: /* all punctuation */
4707: type = XML_REGEXP_PUNCT;
4708: }
4709: } else if (cur == 'Z') {
4710: NEXT;
4711: cur = CUR;
4712: if (cur == 's') {
4713: NEXT;
4714: /* space */
4715: type = XML_REGEXP_SEPAR_SPACE;
4716: } else if (cur == 'l') {
4717: NEXT;
4718: /* line */
4719: type = XML_REGEXP_SEPAR_LINE;
4720: } else if (cur == 'p') {
4721: NEXT;
4722: /* paragraph */
4723: type = XML_REGEXP_SEPAR_PARA;
4724: } else {
4725: /* all separators */
4726: type = XML_REGEXP_SEPAR;
4727: }
4728: } else if (cur == 'S') {
4729: NEXT;
4730: cur = CUR;
4731: if (cur == 'm') {
4732: NEXT;
4733: type = XML_REGEXP_SYMBOL_MATH;
4734: /* math */
4735: } else if (cur == 'c') {
4736: NEXT;
4737: type = XML_REGEXP_SYMBOL_CURRENCY;
4738: /* currency */
4739: } else if (cur == 'k') {
4740: NEXT;
4741: type = XML_REGEXP_SYMBOL_MODIFIER;
4742: /* modifiers */
4743: } else if (cur == 'o') {
4744: NEXT;
4745: type = XML_REGEXP_SYMBOL_OTHERS;
4746: /* other */
4747: } else {
4748: /* all symbols */
4749: type = XML_REGEXP_SYMBOL;
4750: }
4751: } else if (cur == 'C') {
4752: NEXT;
4753: cur = CUR;
4754: if (cur == 'c') {
4755: NEXT;
4756: /* control */
4757: type = XML_REGEXP_OTHER_CONTROL;
4758: } else if (cur == 'f') {
4759: NEXT;
4760: /* format */
4761: type = XML_REGEXP_OTHER_FORMAT;
4762: } else if (cur == 'o') {
4763: NEXT;
4764: /* private use */
4765: type = XML_REGEXP_OTHER_PRIVATE;
4766: } else if (cur == 'n') {
4767: NEXT;
4768: /* not assigned */
4769: type = XML_REGEXP_OTHER_NA;
4770: } else {
4771: /* all others */
4772: type = XML_REGEXP_OTHER;
4773: }
4774: } else if (cur == 'I') {
4775: const xmlChar *start;
4776: NEXT;
4777: cur = CUR;
4778: if (cur != 's') {
4779: ERROR("IsXXXX expected");
4780: return;
4781: }
4782: NEXT;
4783: start = ctxt->cur;
4784: cur = CUR;
4785: if (((cur >= 'a') && (cur <= 'z')) ||
4786: ((cur >= 'A') && (cur <= 'Z')) ||
4787: ((cur >= '0') && (cur <= '9')) ||
4788: (cur == 0x2D)) {
4789: NEXT;
4790: cur = CUR;
4791: while (((cur >= 'a') && (cur <= 'z')) ||
4792: ((cur >= 'A') && (cur <= 'Z')) ||
4793: ((cur >= '0') && (cur <= '9')) ||
4794: (cur == 0x2D)) {
4795: NEXT;
4796: cur = CUR;
4797: }
4798: }
4799: type = XML_REGEXP_BLOCK_NAME;
4800: blockName = xmlStrndup(start, ctxt->cur - start);
4801: } else {
4802: ERROR("Unknown char property");
4803: return;
4804: }
4805: if (ctxt->atom == NULL) {
4806: ctxt->atom = xmlRegNewAtom(ctxt, type);
4807: if (ctxt->atom != NULL)
4808: ctxt->atom->valuep = blockName;
4809: } else if (ctxt->atom->type == XML_REGEXP_RANGES) {
4810: xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
4811: type, 0, 0, blockName);
4812: }
4813: }
4814:
4815: /**
4816: * xmlFAParseCharClassEsc:
4817: * @ctxt: a regexp parser context
4818: *
4819: * [23] charClassEsc ::= ( SingleCharEsc | MultiCharEsc | catEsc | complEsc )
4820: * [24] SingleCharEsc ::= '\' [nrt\|.?*+(){}#x2D#x5B#x5D#x5E]
4821: * [25] catEsc ::= '\p{' charProp '}'
4822: * [26] complEsc ::= '\P{' charProp '}'
4823: * [37] MultiCharEsc ::= '.' | ('\' [sSiIcCdDwW])
4824: */
4825: static void
4826: xmlFAParseCharClassEsc(xmlRegParserCtxtPtr ctxt) {
4827: int cur;
4828:
4829: if (CUR == '.') {
4830: if (ctxt->atom == NULL) {
4831: ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_ANYCHAR);
4832: } else if (ctxt->atom->type == XML_REGEXP_RANGES) {
4833: xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
4834: XML_REGEXP_ANYCHAR, 0, 0, NULL);
4835: }
4836: NEXT;
4837: return;
4838: }
4839: if (CUR != '\\') {
4840: ERROR("Escaped sequence: expecting \\");
4841: return;
4842: }
4843: NEXT;
4844: cur = CUR;
4845: if (cur == 'p') {
4846: NEXT;
4847: if (CUR != '{') {
4848: ERROR("Expecting '{'");
4849: return;
4850: }
4851: NEXT;
4852: xmlFAParseCharProp(ctxt);
4853: if (CUR != '}') {
4854: ERROR("Expecting '}'");
4855: return;
4856: }
4857: NEXT;
4858: } else if (cur == 'P') {
4859: NEXT;
4860: if (CUR != '{') {
4861: ERROR("Expecting '{'");
4862: return;
4863: }
4864: NEXT;
4865: xmlFAParseCharProp(ctxt);
4866: ctxt->atom->neg = 1;
4867: if (CUR != '}') {
4868: ERROR("Expecting '}'");
4869: return;
4870: }
4871: NEXT;
4872: } else if ((cur == 'n') || (cur == 'r') || (cur == 't') || (cur == '\\') ||
4873: (cur == '|') || (cur == '.') || (cur == '?') || (cur == '*') ||
4874: (cur == '+') || (cur == '(') || (cur == ')') || (cur == '{') ||
4875: (cur == '}') || (cur == 0x2D) || (cur == 0x5B) || (cur == 0x5D) ||
4876: (cur == 0x5E)) {
4877: if (ctxt->atom == NULL) {
4878: ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_CHARVAL);
4879: if (ctxt->atom != NULL) {
4880: switch (cur) {
4881: case 'n':
4882: ctxt->atom->codepoint = '\n';
4883: break;
4884: case 'r':
4885: ctxt->atom->codepoint = '\r';
4886: break;
4887: case 't':
4888: ctxt->atom->codepoint = '\t';
4889: break;
4890: default:
4891: ctxt->atom->codepoint = cur;
4892: }
4893: }
4894: } else if (ctxt->atom->type == XML_REGEXP_RANGES) {
4895: switch (cur) {
4896: case 'n':
4897: cur = '\n';
4898: break;
4899: case 'r':
4900: cur = '\r';
4901: break;
4902: case 't':
4903: cur = '\t';
4904: break;
4905: }
4906: xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
4907: XML_REGEXP_CHARVAL, cur, cur, NULL);
4908: }
4909: NEXT;
4910: } else if ((cur == 's') || (cur == 'S') || (cur == 'i') || (cur == 'I') ||
4911: (cur == 'c') || (cur == 'C') || (cur == 'd') || (cur == 'D') ||
4912: (cur == 'w') || (cur == 'W')) {
4913: xmlRegAtomType type = XML_REGEXP_ANYSPACE;
4914:
4915: switch (cur) {
4916: case 's':
4917: type = XML_REGEXP_ANYSPACE;
4918: break;
4919: case 'S':
4920: type = XML_REGEXP_NOTSPACE;
4921: break;
4922: case 'i':
4923: type = XML_REGEXP_INITNAME;
4924: break;
4925: case 'I':
4926: type = XML_REGEXP_NOTINITNAME;
4927: break;
4928: case 'c':
4929: type = XML_REGEXP_NAMECHAR;
4930: break;
4931: case 'C':
4932: type = XML_REGEXP_NOTNAMECHAR;
4933: break;
4934: case 'd':
4935: type = XML_REGEXP_DECIMAL;
4936: break;
4937: case 'D':
4938: type = XML_REGEXP_NOTDECIMAL;
4939: break;
4940: case 'w':
4941: type = XML_REGEXP_REALCHAR;
4942: break;
4943: case 'W':
4944: type = XML_REGEXP_NOTREALCHAR;
4945: break;
4946: }
4947: NEXT;
4948: if (ctxt->atom == NULL) {
4949: ctxt->atom = xmlRegNewAtom(ctxt, type);
4950: } else if (ctxt->atom->type == XML_REGEXP_RANGES) {
4951: xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
4952: type, 0, 0, NULL);
4953: }
4954: } else {
4955: ERROR("Wrong escape sequence, misuse of character '\\'");
4956: }
4957: }
4958:
4959: /**
4960: * xmlFAParseCharRange:
4961: * @ctxt: a regexp parser context
4962: *
4963: * [17] charRange ::= seRange | XmlCharRef | XmlCharIncDash
4964: * [18] seRange ::= charOrEsc '-' charOrEsc
4965: * [20] charOrEsc ::= XmlChar | SingleCharEsc
4966: * [21] XmlChar ::= [^\#x2D#x5B#x5D]
4967: * [22] XmlCharIncDash ::= [^\#x5B#x5D]
4968: */
4969: static void
4970: xmlFAParseCharRange(xmlRegParserCtxtPtr ctxt) {
4971: int cur, len;
4972: int start = -1;
4973: int end = -1;
4974:
4975: if (CUR == '\0') {
4976: ERROR("Expecting ']'");
4977: return;
4978: }
4979:
4980: cur = CUR;
4981: if (cur == '\\') {
4982: NEXT;
4983: cur = CUR;
4984: switch (cur) {
4985: case 'n': start = 0xA; break;
4986: case 'r': start = 0xD; break;
4987: case 't': start = 0x9; break;
4988: case '\\': case '|': case '.': case '-': case '^': case '?':
4989: case '*': case '+': case '{': case '}': case '(': case ')':
4990: case '[': case ']':
4991: start = cur; break;
4992: default:
4993: ERROR("Invalid escape value");
4994: return;
4995: }
4996: end = start;
4997: len = 1;
4998: } else if ((cur != 0x5B) && (cur != 0x5D)) {
4999: end = start = CUR_SCHAR(ctxt->cur, len);
5000: } else {
5001: ERROR("Expecting a char range");
5002: return;
5003: }
5004: /*
5005: * Since we are "inside" a range, we can assume ctxt->cur is past
5006: * the start of ctxt->string, and PREV should be safe
5007: */
5008: if ((start == '-') && (NXT(1) != ']') && (PREV != '[') && (PREV != '^')) {
5009: NEXTL(len);
5010: return;
5011: }
5012: NEXTL(len);
5013: cur = CUR;
5014: if ((cur != '-') || (NXT(1) == ']')) {
5015: xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
5016: XML_REGEXP_CHARVAL, start, end, NULL);
5017: return;
5018: }
5019: NEXT;
5020: cur = CUR;
5021: if (cur == '\\') {
5022: NEXT;
5023: cur = CUR;
5024: switch (cur) {
5025: case 'n': end = 0xA; break;
5026: case 'r': end = 0xD; break;
5027: case 't': end = 0x9; break;
5028: case '\\': case '|': case '.': case '-': case '^': case '?':
5029: case '*': case '+': case '{': case '}': case '(': case ')':
5030: case '[': case ']':
5031: end = cur; break;
5032: default:
5033: ERROR("Invalid escape value");
5034: return;
5035: }
5036: len = 1;
5037: } else if ((cur != 0x5B) && (cur != 0x5D)) {
5038: end = CUR_SCHAR(ctxt->cur, len);
5039: } else {
5040: ERROR("Expecting the end of a char range");
5041: return;
5042: }
5043: NEXTL(len);
5044: /* TODO check that the values are acceptable character ranges for XML */
5045: if (end < start) {
5046: ERROR("End of range is before start of range");
5047: } else {
5048: xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
5049: XML_REGEXP_CHARVAL, start, end, NULL);
5050: }
5051: return;
5052: }
5053:
5054: /**
5055: * xmlFAParsePosCharGroup:
5056: * @ctxt: a regexp parser context
5057: *
5058: * [14] posCharGroup ::= ( charRange | charClassEsc )+
5059: */
5060: static void
5061: xmlFAParsePosCharGroup(xmlRegParserCtxtPtr ctxt) {
5062: do {
5063: if (CUR == '\\') {
5064: xmlFAParseCharClassEsc(ctxt);
5065: } else {
5066: xmlFAParseCharRange(ctxt);
5067: }
5068: } while ((CUR != ']') && (CUR != '^') && (CUR != '-') &&
5069: (CUR != 0) && (ctxt->error == 0));
5070: }
5071:
5072: /**
5073: * xmlFAParseCharGroup:
5074: * @ctxt: a regexp parser context
5075: *
5076: * [13] charGroup ::= posCharGroup | negCharGroup | charClassSub
5077: * [15] negCharGroup ::= '^' posCharGroup
5078: * [16] charClassSub ::= ( posCharGroup | negCharGroup ) '-' charClassExpr
5079: * [12] charClassExpr ::= '[' charGroup ']'
5080: */
5081: static void
5082: xmlFAParseCharGroup(xmlRegParserCtxtPtr ctxt) {
5083: int n = ctxt->neg;
5084: while ((CUR != ']') && (ctxt->error == 0)) {
5085: if (CUR == '^') {
5086: int neg = ctxt->neg;
5087:
5088: NEXT;
5089: ctxt->neg = !ctxt->neg;
5090: xmlFAParsePosCharGroup(ctxt);
5091: ctxt->neg = neg;
5092: } else if ((CUR == '-') && (NXT(1) == '[')) {
5093: int neg = ctxt->neg;
5094: ctxt->neg = 2;
5095: NEXT; /* eat the '-' */
5096: NEXT; /* eat the '[' */
5097: xmlFAParseCharGroup(ctxt);
5098: if (CUR == ']') {
5099: NEXT;
5100: } else {
5101: ERROR("charClassExpr: ']' expected");
5102: break;
5103: }
5104: ctxt->neg = neg;
5105: break;
5106: } else if (CUR != ']') {
5107: xmlFAParsePosCharGroup(ctxt);
5108: }
5109: }
5110: ctxt->neg = n;
5111: }
5112:
5113: /**
5114: * xmlFAParseCharClass:
5115: * @ctxt: a regexp parser context
5116: *
5117: * [11] charClass ::= charClassEsc | charClassExpr
5118: * [12] charClassExpr ::= '[' charGroup ']'
5119: */
5120: static void
5121: xmlFAParseCharClass(xmlRegParserCtxtPtr ctxt) {
5122: if (CUR == '[') {
5123: NEXT;
5124: ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_RANGES);
5125: if (ctxt->atom == NULL)
5126: return;
5127: xmlFAParseCharGroup(ctxt);
5128: if (CUR == ']') {
5129: NEXT;
5130: } else {
5131: ERROR("xmlFAParseCharClass: ']' expected");
5132: }
5133: } else {
5134: xmlFAParseCharClassEsc(ctxt);
5135: }
5136: }
5137:
5138: /**
5139: * xmlFAParseQuantExact:
5140: * @ctxt: a regexp parser context
5141: *
5142: * [8] QuantExact ::= [0-9]+
5143: *
5144: * Returns 0 if success or -1 in case of error
5145: */
5146: static int
5147: xmlFAParseQuantExact(xmlRegParserCtxtPtr ctxt) {
5148: int ret = 0;
5149: int ok = 0;
5150:
5151: while ((CUR >= '0') && (CUR <= '9')) {
5152: ret = ret * 10 + (CUR - '0');
5153: ok = 1;
5154: NEXT;
5155: }
5156: if (ok != 1) {
5157: return(-1);
5158: }
5159: return(ret);
5160: }
5161:
5162: /**
5163: * xmlFAParseQuantifier:
5164: * @ctxt: a regexp parser context
5165: *
5166: * [4] quantifier ::= [?*+] | ( '{' quantity '}' )
5167: * [5] quantity ::= quantRange | quantMin | QuantExact
5168: * [6] quantRange ::= QuantExact ',' QuantExact
5169: * [7] quantMin ::= QuantExact ','
5170: * [8] QuantExact ::= [0-9]+
5171: */
5172: static int
5173: xmlFAParseQuantifier(xmlRegParserCtxtPtr ctxt) {
5174: int cur;
5175:
5176: cur = CUR;
5177: if ((cur == '?') || (cur == '*') || (cur == '+')) {
5178: if (ctxt->atom != NULL) {
5179: if (cur == '?')
5180: ctxt->atom->quant = XML_REGEXP_QUANT_OPT;
5181: else if (cur == '*')
5182: ctxt->atom->quant = XML_REGEXP_QUANT_MULT;
5183: else if (cur == '+')
5184: ctxt->atom->quant = XML_REGEXP_QUANT_PLUS;
5185: }
5186: NEXT;
5187: return(1);
5188: }
5189: if (cur == '{') {
5190: int min = 0, max = 0;
5191:
5192: NEXT;
5193: cur = xmlFAParseQuantExact(ctxt);
5194: if (cur >= 0)
5195: min = cur;
5196: if (CUR == ',') {
5197: NEXT;
5198: if (CUR == '}')
5199: max = INT_MAX;
5200: else {
5201: cur = xmlFAParseQuantExact(ctxt);
5202: if (cur >= 0)
5203: max = cur;
5204: else {
5205: ERROR("Improper quantifier");
5206: }
5207: }
5208: }
5209: if (CUR == '}') {
5210: NEXT;
5211: } else {
5212: ERROR("Unterminated quantifier");
5213: }
5214: if (max == 0)
5215: max = min;
5216: if (ctxt->atom != NULL) {
5217: ctxt->atom->quant = XML_REGEXP_QUANT_RANGE;
5218: ctxt->atom->min = min;
5219: ctxt->atom->max = max;
5220: }
5221: return(1);
5222: }
5223: return(0);
5224: }
5225:
5226: /**
5227: * xmlFAParseAtom:
5228: * @ctxt: a regexp parser context
5229: *
5230: * [9] atom ::= Char | charClass | ( '(' regExp ')' )
5231: */
5232: static int
5233: xmlFAParseAtom(xmlRegParserCtxtPtr ctxt) {
5234: int codepoint, len;
5235:
5236: codepoint = xmlFAIsChar(ctxt);
5237: if (codepoint > 0) {
5238: ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_CHARVAL);
5239: if (ctxt->atom == NULL)
5240: return(-1);
5241: codepoint = CUR_SCHAR(ctxt->cur, len);
5242: ctxt->atom->codepoint = codepoint;
5243: NEXTL(len);
5244: return(1);
5245: } else if (CUR == '|') {
5246: return(0);
5247: } else if (CUR == 0) {
5248: return(0);
5249: } else if (CUR == ')') {
5250: return(0);
5251: } else if (CUR == '(') {
5252: xmlRegStatePtr start, oldend, start0;
5253:
5254: NEXT;
5255: /*
5256: * this extra Epsilon transition is needed if we count with 0 allowed
5257: * unfortunately this can't be known at that point
5258: */
5259: xmlFAGenerateEpsilonTransition(ctxt, ctxt->state, NULL);
5260: start0 = ctxt->state;
5261: xmlFAGenerateEpsilonTransition(ctxt, ctxt->state, NULL);
5262: start = ctxt->state;
5263: oldend = ctxt->end;
5264: ctxt->end = NULL;
5265: ctxt->atom = NULL;
5266: xmlFAParseRegExp(ctxt, 0);
5267: if (CUR == ')') {
5268: NEXT;
5269: } else {
5270: ERROR("xmlFAParseAtom: expecting ')'");
5271: }
5272: ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_SUBREG);
5273: if (ctxt->atom == NULL)
5274: return(-1);
5275: ctxt->atom->start = start;
5276: ctxt->atom->start0 = start0;
5277: ctxt->atom->stop = ctxt->state;
5278: ctxt->end = oldend;
5279: return(1);
5280: } else if ((CUR == '[') || (CUR == '\\') || (CUR == '.')) {
5281: xmlFAParseCharClass(ctxt);
5282: return(1);
5283: }
5284: return(0);
5285: }
5286:
5287: /**
5288: * xmlFAParsePiece:
5289: * @ctxt: a regexp parser context
5290: *
5291: * [3] piece ::= atom quantifier?
5292: */
5293: static int
5294: xmlFAParsePiece(xmlRegParserCtxtPtr ctxt) {
5295: int ret;
5296:
5297: ctxt->atom = NULL;
5298: ret = xmlFAParseAtom(ctxt);
5299: if (ret == 0)
5300: return(0);
5301: if (ctxt->atom == NULL) {
5302: ERROR("internal: no atom generated");
5303: }
5304: xmlFAParseQuantifier(ctxt);
5305: return(1);
5306: }
5307:
5308: /**
5309: * xmlFAParseBranch:
5310: * @ctxt: a regexp parser context
5311: * @to: optional target to the end of the branch
5312: *
5313: * @to is used to optimize by removing duplicate path in automata
5314: * in expressions like (a|b)(c|d)
5315: *
5316: * [2] branch ::= piece*
5317: */
5318: static int
5319: xmlFAParseBranch(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr to) {
5320: xmlRegStatePtr previous;
5321: int ret;
5322:
5323: previous = ctxt->state;
5324: ret = xmlFAParsePiece(ctxt);
5325: if (ret != 0) {
5326: if (xmlFAGenerateTransitions(ctxt, previous,
5327: (CUR=='|' || CUR==')') ? to : NULL, ctxt->atom) < 0)
5328: return(-1);
5329: previous = ctxt->state;
5330: ctxt->atom = NULL;
5331: }
5332: while ((ret != 0) && (ctxt->error == 0)) {
5333: ret = xmlFAParsePiece(ctxt);
5334: if (ret != 0) {
5335: if (xmlFAGenerateTransitions(ctxt, previous,
5336: (CUR=='|' || CUR==')') ? to : NULL, ctxt->atom) < 0)
5337: return(-1);
5338: previous = ctxt->state;
5339: ctxt->atom = NULL;
5340: }
5341: }
5342: return(0);
5343: }
5344:
5345: /**
5346: * xmlFAParseRegExp:
5347: * @ctxt: a regexp parser context
5348: * @top: is this the top-level expression ?
5349: *
5350: * [1] regExp ::= branch ( '|' branch )*
5351: */
5352: static void
5353: xmlFAParseRegExp(xmlRegParserCtxtPtr ctxt, int top) {
5354: xmlRegStatePtr start, end;
5355:
5356: /* if not top start should have been generated by an epsilon trans */
5357: start = ctxt->state;
5358: ctxt->end = NULL;
5359: xmlFAParseBranch(ctxt, NULL);
5360: if (top) {
5361: #ifdef DEBUG_REGEXP_GRAPH
5362: printf("State %d is final\n", ctxt->state->no);
5363: #endif
5364: ctxt->state->type = XML_REGEXP_FINAL_STATE;
5365: }
5366: if (CUR != '|') {
5367: ctxt->end = ctxt->state;
5368: return;
5369: }
5370: end = ctxt->state;
5371: while ((CUR == '|') && (ctxt->error == 0)) {
5372: NEXT;
5373: ctxt->state = start;
5374: ctxt->end = NULL;
5375: xmlFAParseBranch(ctxt, end);
5376: }
5377: if (!top) {
5378: ctxt->state = end;
5379: ctxt->end = end;
5380: }
5381: }
5382:
5383: /************************************************************************
5384: * *
5385: * The basic API *
5386: * *
5387: ************************************************************************/
5388:
5389: /**
5390: * xmlRegexpPrint:
5391: * @output: the file for the output debug
5392: * @regexp: the compiled regexp
5393: *
5394: * Print the content of the compiled regular expression
5395: */
5396: void
5397: xmlRegexpPrint(FILE *output, xmlRegexpPtr regexp) {
5398: int i;
5399:
5400: if (output == NULL)
5401: return;
5402: fprintf(output, " regexp: ");
5403: if (regexp == NULL) {
5404: fprintf(output, "NULL\n");
5405: return;
5406: }
5407: fprintf(output, "'%s' ", regexp->string);
5408: fprintf(output, "\n");
5409: fprintf(output, "%d atoms:\n", regexp->nbAtoms);
5410: for (i = 0;i < regexp->nbAtoms; i++) {
5411: fprintf(output, " %02d ", i);
5412: xmlRegPrintAtom(output, regexp->atoms[i]);
5413: }
5414: fprintf(output, "%d states:", regexp->nbStates);
5415: fprintf(output, "\n");
5416: for (i = 0;i < regexp->nbStates; i++) {
5417: xmlRegPrintState(output, regexp->states[i]);
5418: }
5419: fprintf(output, "%d counters:\n", regexp->nbCounters);
5420: for (i = 0;i < regexp->nbCounters; i++) {
5421: fprintf(output, " %d: min %d max %d\n", i, regexp->counters[i].min,
5422: regexp->counters[i].max);
5423: }
5424: }
5425:
5426: /**
5427: * xmlRegexpCompile:
5428: * @regexp: a regular expression string
5429: *
5430: * Parses a regular expression conforming to XML Schemas Part 2 Datatype
5431: * Appendix F and builds an automata suitable for testing strings against
5432: * that regular expression
5433: *
5434: * Returns the compiled expression or NULL in case of error
5435: */
5436: xmlRegexpPtr
5437: xmlRegexpCompile(const xmlChar *regexp) {
5438: xmlRegexpPtr ret;
5439: xmlRegParserCtxtPtr ctxt;
5440:
5441: ctxt = xmlRegNewParserCtxt(regexp);
5442: if (ctxt == NULL)
5443: return(NULL);
5444:
5445: /* initialize the parser */
5446: ctxt->end = NULL;
5447: ctxt->start = ctxt->state = xmlRegNewState(ctxt);
5448: xmlRegStatePush(ctxt, ctxt->start);
5449:
5450: /* parse the expression building an automata */
5451: xmlFAParseRegExp(ctxt, 1);
5452: if (CUR != 0) {
5453: ERROR("xmlFAParseRegExp: extra characters");
5454: }
5455: if (ctxt->error != 0) {
5456: xmlRegFreeParserCtxt(ctxt);
5457: return(NULL);
5458: }
5459: ctxt->end = ctxt->state;
5460: ctxt->start->type = XML_REGEXP_START_STATE;
5461: ctxt->end->type = XML_REGEXP_FINAL_STATE;
5462:
5463: /* remove the Epsilon except for counted transitions */
5464: xmlFAEliminateEpsilonTransitions(ctxt);
5465:
5466:
5467: if (ctxt->error != 0) {
5468: xmlRegFreeParserCtxt(ctxt);
5469: return(NULL);
5470: }
5471: ret = xmlRegEpxFromParse(ctxt);
5472: xmlRegFreeParserCtxt(ctxt);
5473: return(ret);
5474: }
5475:
5476: /**
5477: * xmlRegexpExec:
5478: * @comp: the compiled regular expression
5479: * @content: the value to check against the regular expression
5480: *
5481: * Check if the regular expression generates the value
5482: *
5483: * Returns 1 if it matches, 0 if not and a negative value in case of error
5484: */
5485: int
5486: xmlRegexpExec(xmlRegexpPtr comp, const xmlChar *content) {
5487: if ((comp == NULL) || (content == NULL))
5488: return(-1);
5489: return(xmlFARegExec(comp, content));
5490: }
5491:
5492: /**
5493: * xmlRegexpIsDeterminist:
5494: * @comp: the compiled regular expression
5495: *
5496: * Check if the regular expression is determinist
5497: *
5498: * Returns 1 if it yes, 0 if not and a negative value in case of error
5499: */
5500: int
5501: xmlRegexpIsDeterminist(xmlRegexpPtr comp) {
5502: xmlAutomataPtr am;
5503: int ret;
5504:
5505: if (comp == NULL)
5506: return(-1);
5507: if (comp->determinist != -1)
5508: return(comp->determinist);
5509:
5510: am = xmlNewAutomata();
5511: if (am->states != NULL) {
5512: int i;
5513:
5514: for (i = 0;i < am->nbStates;i++)
5515: xmlRegFreeState(am->states[i]);
5516: xmlFree(am->states);
5517: }
5518: am->nbAtoms = comp->nbAtoms;
5519: am->atoms = comp->atoms;
5520: am->nbStates = comp->nbStates;
5521: am->states = comp->states;
5522: am->determinist = -1;
5523: am->flags = comp->flags;
5524: ret = xmlFAComputesDeterminism(am);
5525: am->atoms = NULL;
5526: am->states = NULL;
5527: xmlFreeAutomata(am);
5528: comp->determinist = ret;
5529: return(ret);
5530: }
5531:
5532: /**
5533: * xmlRegFreeRegexp:
5534: * @regexp: the regexp
5535: *
5536: * Free a regexp
5537: */
5538: void
5539: xmlRegFreeRegexp(xmlRegexpPtr regexp) {
5540: int i;
5541: if (regexp == NULL)
5542: return;
5543:
5544: if (regexp->string != NULL)
5545: xmlFree(regexp->string);
5546: if (regexp->states != NULL) {
5547: for (i = 0;i < regexp->nbStates;i++)
5548: xmlRegFreeState(regexp->states[i]);
5549: xmlFree(regexp->states);
5550: }
5551: if (regexp->atoms != NULL) {
5552: for (i = 0;i < regexp->nbAtoms;i++)
5553: xmlRegFreeAtom(regexp->atoms[i]);
5554: xmlFree(regexp->atoms);
5555: }
5556: if (regexp->counters != NULL)
5557: xmlFree(regexp->counters);
5558: if (regexp->compact != NULL)
5559: xmlFree(regexp->compact);
5560: if (regexp->transdata != NULL)
5561: xmlFree(regexp->transdata);
5562: if (regexp->stringMap != NULL) {
5563: for (i = 0; i < regexp->nbstrings;i++)
5564: xmlFree(regexp->stringMap[i]);
5565: xmlFree(regexp->stringMap);
5566: }
5567:
5568: xmlFree(regexp);
5569: }
5570:
5571: #ifdef LIBXML_AUTOMATA_ENABLED
5572: /************************************************************************
5573: * *
5574: * The Automata interface *
5575: * *
5576: ************************************************************************/
5577:
5578: /**
5579: * xmlNewAutomata:
5580: *
5581: * Create a new automata
5582: *
5583: * Returns the new object or NULL in case of failure
5584: */
5585: xmlAutomataPtr
5586: xmlNewAutomata(void) {
5587: xmlAutomataPtr ctxt;
5588:
5589: ctxt = xmlRegNewParserCtxt(NULL);
5590: if (ctxt == NULL)
5591: return(NULL);
5592:
5593: /* initialize the parser */
5594: ctxt->end = NULL;
5595: ctxt->start = ctxt->state = xmlRegNewState(ctxt);
5596: if (ctxt->start == NULL) {
5597: xmlFreeAutomata(ctxt);
5598: return(NULL);
5599: }
5600: ctxt->start->type = XML_REGEXP_START_STATE;
5601: if (xmlRegStatePush(ctxt, ctxt->start) < 0) {
5602: xmlRegFreeState(ctxt->start);
5603: xmlFreeAutomata(ctxt);
5604: return(NULL);
5605: }
5606: ctxt->flags = 0;
5607:
5608: return(ctxt);
5609: }
5610:
5611: /**
5612: * xmlFreeAutomata:
5613: * @am: an automata
5614: *
5615: * Free an automata
5616: */
5617: void
5618: xmlFreeAutomata(xmlAutomataPtr am) {
5619: if (am == NULL)
5620: return;
5621: xmlRegFreeParserCtxt(am);
5622: }
5623:
5624: /**
5625: * xmlAutomataSetFlags:
5626: * @am: an automata
5627: * @flags: a set of internal flags
5628: *
5629: * Set some flags on the automata
5630: */
5631: void
5632: xmlAutomataSetFlags(xmlAutomataPtr am, int flags) {
5633: if (am == NULL)
5634: return;
5635: am->flags |= flags;
5636: }
5637:
5638: /**
5639: * xmlAutomataGetInitState:
5640: * @am: an automata
5641: *
5642: * Initial state lookup
5643: *
5644: * Returns the initial state of the automata
5645: */
5646: xmlAutomataStatePtr
5647: xmlAutomataGetInitState(xmlAutomataPtr am) {
5648: if (am == NULL)
5649: return(NULL);
5650: return(am->start);
5651: }
5652:
5653: /**
5654: * xmlAutomataSetFinalState:
5655: * @am: an automata
5656: * @state: a state in this automata
5657: *
5658: * Makes that state a final state
5659: *
5660: * Returns 0 or -1 in case of error
5661: */
5662: int
5663: xmlAutomataSetFinalState(xmlAutomataPtr am, xmlAutomataStatePtr state) {
5664: if ((am == NULL) || (state == NULL))
5665: return(-1);
5666: state->type = XML_REGEXP_FINAL_STATE;
5667: return(0);
5668: }
5669:
5670: /**
5671: * xmlAutomataNewTransition:
5672: * @am: an automata
5673: * @from: the starting point of the transition
5674: * @to: the target point of the transition or NULL
5675: * @token: the input string associated to that transition
5676: * @data: data passed to the callback function if the transition is activated
5677: *
5678: * If @to is NULL, this creates first a new target state in the automata
5679: * and then adds a transition from the @from state to the target state
5680: * activated by the value of @token
5681: *
5682: * Returns the target state or NULL in case of error
5683: */
5684: xmlAutomataStatePtr
5685: xmlAutomataNewTransition(xmlAutomataPtr am, xmlAutomataStatePtr from,
5686: xmlAutomataStatePtr to, const xmlChar *token,
5687: void *data) {
5688: xmlRegAtomPtr atom;
5689:
5690: if ((am == NULL) || (from == NULL) || (token == NULL))
5691: return(NULL);
5692: atom = xmlRegNewAtom(am, XML_REGEXP_STRING);
5693: if (atom == NULL)
5694: return(NULL);
5695: atom->data = data;
5696: if (atom == NULL)
5697: return(NULL);
5698: atom->valuep = xmlStrdup(token);
5699:
5700: if (xmlFAGenerateTransitions(am, from, to, atom) < 0) {
5701: xmlRegFreeAtom(atom);
5702: return(NULL);
5703: }
5704: if (to == NULL)
5705: return(am->state);
5706: return(to);
5707: }
5708:
5709: /**
5710: * xmlAutomataNewTransition2:
5711: * @am: an automata
5712: * @from: the starting point of the transition
5713: * @to: the target point of the transition or NULL
5714: * @token: the first input string associated to that transition
5715: * @token2: the second input string associated to that transition
5716: * @data: data passed to the callback function if the transition is activated
5717: *
5718: * If @to is NULL, this creates first a new target state in the automata
5719: * and then adds a transition from the @from state to the target state
5720: * activated by the value of @token
5721: *
5722: * Returns the target state or NULL in case of error
5723: */
5724: xmlAutomataStatePtr
5725: xmlAutomataNewTransition2(xmlAutomataPtr am, xmlAutomataStatePtr from,
5726: xmlAutomataStatePtr to, const xmlChar *token,
5727: const xmlChar *token2, void *data) {
5728: xmlRegAtomPtr atom;
5729:
5730: if ((am == NULL) || (from == NULL) || (token == NULL))
5731: return(NULL);
5732: atom = xmlRegNewAtom(am, XML_REGEXP_STRING);
5733: if (atom == NULL)
5734: return(NULL);
5735: atom->data = data;
5736: if ((token2 == NULL) || (*token2 == 0)) {
5737: atom->valuep = xmlStrdup(token);
5738: } else {
5739: int lenn, lenp;
5740: xmlChar *str;
5741:
5742: lenn = strlen((char *) token2);
5743: lenp = strlen((char *) token);
5744:
5745: str = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2);
5746: if (str == NULL) {
5747: xmlRegFreeAtom(atom);
5748: return(NULL);
5749: }
5750: memcpy(&str[0], token, lenp);
5751: str[lenp] = '|';
5752: memcpy(&str[lenp + 1], token2, lenn);
5753: str[lenn + lenp + 1] = 0;
5754:
5755: atom->valuep = str;
5756: }
5757:
5758: if (xmlFAGenerateTransitions(am, from, to, atom) < 0) {
5759: xmlRegFreeAtom(atom);
5760: return(NULL);
5761: }
5762: if (to == NULL)
5763: return(am->state);
5764: return(to);
5765: }
5766:
5767: /**
5768: * xmlAutomataNewNegTrans:
5769: * @am: an automata
5770: * @from: the starting point of the transition
5771: * @to: the target point of the transition or NULL
5772: * @token: the first input string associated to that transition
5773: * @token2: the second input string associated to that transition
5774: * @data: data passed to the callback function if the transition is activated
5775: *
5776: * If @to is NULL, this creates first a new target state in the automata
5777: * and then adds a transition from the @from state to the target state
5778: * activated by any value except (@token,@token2)
5779: * Note that if @token2 is not NULL, then (X, NULL) won't match to follow
5780: # the semantic of XSD ##other
5781: *
5782: * Returns the target state or NULL in case of error
5783: */
5784: xmlAutomataStatePtr
5785: xmlAutomataNewNegTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
5786: xmlAutomataStatePtr to, const xmlChar *token,
5787: const xmlChar *token2, void *data) {
5788: xmlRegAtomPtr atom;
5789: xmlChar err_msg[200];
5790:
5791: if ((am == NULL) || (from == NULL) || (token == NULL))
5792: return(NULL);
5793: atom = xmlRegNewAtom(am, XML_REGEXP_STRING);
5794: if (atom == NULL)
5795: return(NULL);
5796: atom->data = data;
5797: atom->neg = 1;
5798: if ((token2 == NULL) || (*token2 == 0)) {
5799: atom->valuep = xmlStrdup(token);
5800: } else {
5801: int lenn, lenp;
5802: xmlChar *str;
5803:
5804: lenn = strlen((char *) token2);
5805: lenp = strlen((char *) token);
5806:
5807: str = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2);
5808: if (str == NULL) {
5809: xmlRegFreeAtom(atom);
5810: return(NULL);
5811: }
5812: memcpy(&str[0], token, lenp);
5813: str[lenp] = '|';
5814: memcpy(&str[lenp + 1], token2, lenn);
5815: str[lenn + lenp + 1] = 0;
5816:
5817: atom->valuep = str;
5818: }
5819: snprintf((char *) err_msg, 199, "not %s", (const char *) atom->valuep);
5820: err_msg[199] = 0;
5821: atom->valuep2 = xmlStrdup(err_msg);
5822:
5823: if (xmlFAGenerateTransitions(am, from, to, atom) < 0) {
5824: xmlRegFreeAtom(atom);
5825: return(NULL);
5826: }
5827: am->negs++;
5828: if (to == NULL)
5829: return(am->state);
5830: return(to);
5831: }
5832:
5833: /**
5834: * xmlAutomataNewCountTrans2:
5835: * @am: an automata
5836: * @from: the starting point of the transition
5837: * @to: the target point of the transition or NULL
5838: * @token: the input string associated to that transition
5839: * @token2: the second input string associated to that transition
5840: * @min: the minimum successive occurences of token
5841: * @max: the maximum successive occurences of token
5842: * @data: data associated to the transition
5843: *
5844: * If @to is NULL, this creates first a new target state in the automata
5845: * and then adds a transition from the @from state to the target state
5846: * activated by a succession of input of value @token and @token2 and
5847: * whose number is between @min and @max
5848: *
5849: * Returns the target state or NULL in case of error
5850: */
5851: xmlAutomataStatePtr
5852: xmlAutomataNewCountTrans2(xmlAutomataPtr am, xmlAutomataStatePtr from,
5853: xmlAutomataStatePtr to, const xmlChar *token,
5854: const xmlChar *token2,
5855: int min, int max, void *data) {
5856: xmlRegAtomPtr atom;
5857: int counter;
5858:
5859: if ((am == NULL) || (from == NULL) || (token == NULL))
5860: return(NULL);
5861: if (min < 0)
5862: return(NULL);
5863: if ((max < min) || (max < 1))
5864: return(NULL);
5865: atom = xmlRegNewAtom(am, XML_REGEXP_STRING);
5866: if (atom == NULL)
5867: return(NULL);
5868: if ((token2 == NULL) || (*token2 == 0)) {
5869: atom->valuep = xmlStrdup(token);
5870: } else {
5871: int lenn, lenp;
5872: xmlChar *str;
5873:
5874: lenn = strlen((char *) token2);
5875: lenp = strlen((char *) token);
5876:
5877: str = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2);
5878: if (str == NULL) {
5879: xmlRegFreeAtom(atom);
5880: return(NULL);
5881: }
5882: memcpy(&str[0], token, lenp);
5883: str[lenp] = '|';
5884: memcpy(&str[lenp + 1], token2, lenn);
5885: str[lenn + lenp + 1] = 0;
5886:
5887: atom->valuep = str;
5888: }
5889: atom->data = data;
5890: if (min == 0)
5891: atom->min = 1;
5892: else
5893: atom->min = min;
5894: atom->max = max;
5895:
5896: /*
5897: * associate a counter to the transition.
5898: */
5899: counter = xmlRegGetCounter(am);
5900: am->counters[counter].min = min;
5901: am->counters[counter].max = max;
5902:
5903: /* xmlFAGenerateTransitions(am, from, to, atom); */
5904: if (to == NULL) {
5905: to = xmlRegNewState(am);
5906: xmlRegStatePush(am, to);
5907: }
5908: xmlRegStateAddTrans(am, from, atom, to, counter, -1);
5909: xmlRegAtomPush(am, atom);
5910: am->state = to;
5911:
5912: if (to == NULL)
5913: to = am->state;
5914: if (to == NULL)
5915: return(NULL);
5916: if (min == 0)
5917: xmlFAGenerateEpsilonTransition(am, from, to);
5918: return(to);
5919: }
5920:
5921: /**
5922: * xmlAutomataNewCountTrans:
5923: * @am: an automata
5924: * @from: the starting point of the transition
5925: * @to: the target point of the transition or NULL
5926: * @token: the input string associated to that transition
5927: * @min: the minimum successive occurences of token
5928: * @max: the maximum successive occurences of token
5929: * @data: data associated to the transition
5930: *
5931: * If @to is NULL, this creates first a new target state in the automata
5932: * and then adds a transition from the @from state to the target state
5933: * activated by a succession of input of value @token and whose number
5934: * is between @min and @max
5935: *
5936: * Returns the target state or NULL in case of error
5937: */
5938: xmlAutomataStatePtr
5939: xmlAutomataNewCountTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
5940: xmlAutomataStatePtr to, const xmlChar *token,
5941: int min, int max, void *data) {
5942: xmlRegAtomPtr atom;
5943: int counter;
5944:
5945: if ((am == NULL) || (from == NULL) || (token == NULL))
5946: return(NULL);
5947: if (min < 0)
5948: return(NULL);
5949: if ((max < min) || (max < 1))
5950: return(NULL);
5951: atom = xmlRegNewAtom(am, XML_REGEXP_STRING);
5952: if (atom == NULL)
5953: return(NULL);
5954: atom->valuep = xmlStrdup(token);
5955: atom->data = data;
5956: if (min == 0)
5957: atom->min = 1;
5958: else
5959: atom->min = min;
5960: atom->max = max;
5961:
5962: /*
5963: * associate a counter to the transition.
5964: */
5965: counter = xmlRegGetCounter(am);
5966: am->counters[counter].min = min;
5967: am->counters[counter].max = max;
5968:
5969: /* xmlFAGenerateTransitions(am, from, to, atom); */
5970: if (to == NULL) {
5971: to = xmlRegNewState(am);
5972: xmlRegStatePush(am, to);
5973: }
5974: xmlRegStateAddTrans(am, from, atom, to, counter, -1);
5975: xmlRegAtomPush(am, atom);
5976: am->state = to;
5977:
5978: if (to == NULL)
5979: to = am->state;
5980: if (to == NULL)
5981: return(NULL);
5982: if (min == 0)
5983: xmlFAGenerateEpsilonTransition(am, from, to);
5984: return(to);
5985: }
5986:
5987: /**
5988: * xmlAutomataNewOnceTrans2:
5989: * @am: an automata
5990: * @from: the starting point of the transition
5991: * @to: the target point of the transition or NULL
5992: * @token: the input string associated to that transition
5993: * @token2: the second input string associated to that transition
5994: * @min: the minimum successive occurences of token
5995: * @max: the maximum successive occurences of token
5996: * @data: data associated to the transition
5997: *
5998: * If @to is NULL, this creates first a new target state in the automata
5999: * and then adds a transition from the @from state to the target state
6000: * activated by a succession of input of value @token and @token2 and whose
6001: * number is between @min and @max, moreover that transition can only be
6002: * crossed once.
6003: *
6004: * Returns the target state or NULL in case of error
6005: */
6006: xmlAutomataStatePtr
6007: xmlAutomataNewOnceTrans2(xmlAutomataPtr am, xmlAutomataStatePtr from,
6008: xmlAutomataStatePtr to, const xmlChar *token,
6009: const xmlChar *token2,
6010: int min, int max, void *data) {
6011: xmlRegAtomPtr atom;
6012: int counter;
6013:
6014: if ((am == NULL) || (from == NULL) || (token == NULL))
6015: return(NULL);
6016: if (min < 1)
6017: return(NULL);
6018: if ((max < min) || (max < 1))
6019: return(NULL);
6020: atom = xmlRegNewAtom(am, XML_REGEXP_STRING);
6021: if (atom == NULL)
6022: return(NULL);
6023: if ((token2 == NULL) || (*token2 == 0)) {
6024: atom->valuep = xmlStrdup(token);
6025: } else {
6026: int lenn, lenp;
6027: xmlChar *str;
6028:
6029: lenn = strlen((char *) token2);
6030: lenp = strlen((char *) token);
6031:
6032: str = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2);
6033: if (str == NULL) {
6034: xmlRegFreeAtom(atom);
6035: return(NULL);
6036: }
6037: memcpy(&str[0], token, lenp);
6038: str[lenp] = '|';
6039: memcpy(&str[lenp + 1], token2, lenn);
6040: str[lenn + lenp + 1] = 0;
6041:
6042: atom->valuep = str;
6043: }
6044: atom->data = data;
6045: atom->quant = XML_REGEXP_QUANT_ONCEONLY;
6046: atom->min = min;
6047: atom->max = max;
6048: /*
6049: * associate a counter to the transition.
6050: */
6051: counter = xmlRegGetCounter(am);
6052: am->counters[counter].min = 1;
6053: am->counters[counter].max = 1;
6054:
6055: /* xmlFAGenerateTransitions(am, from, to, atom); */
6056: if (to == NULL) {
6057: to = xmlRegNewState(am);
6058: xmlRegStatePush(am, to);
6059: }
6060: xmlRegStateAddTrans(am, from, atom, to, counter, -1);
6061: xmlRegAtomPush(am, atom);
6062: am->state = to;
6063: return(to);
6064: }
6065:
6066:
6067:
6068: /**
6069: * xmlAutomataNewOnceTrans:
6070: * @am: an automata
6071: * @from: the starting point of the transition
6072: * @to: the target point of the transition or NULL
6073: * @token: the input string associated to that transition
6074: * @min: the minimum successive occurences of token
6075: * @max: the maximum successive occurences of token
6076: * @data: data associated to the transition
6077: *
6078: * If @to is NULL, this creates first a new target state in the automata
6079: * and then adds a transition from the @from state to the target state
6080: * activated by a succession of input of value @token and whose number
6081: * is between @min and @max, moreover that transition can only be crossed
6082: * once.
6083: *
6084: * Returns the target state or NULL in case of error
6085: */
6086: xmlAutomataStatePtr
6087: xmlAutomataNewOnceTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
6088: xmlAutomataStatePtr to, const xmlChar *token,
6089: int min, int max, void *data) {
6090: xmlRegAtomPtr atom;
6091: int counter;
6092:
6093: if ((am == NULL) || (from == NULL) || (token == NULL))
6094: return(NULL);
6095: if (min < 1)
6096: return(NULL);
6097: if ((max < min) || (max < 1))
6098: return(NULL);
6099: atom = xmlRegNewAtom(am, XML_REGEXP_STRING);
6100: if (atom == NULL)
6101: return(NULL);
6102: atom->valuep = xmlStrdup(token);
6103: atom->data = data;
6104: atom->quant = XML_REGEXP_QUANT_ONCEONLY;
6105: atom->min = min;
6106: atom->max = max;
6107: /*
6108: * associate a counter to the transition.
6109: */
6110: counter = xmlRegGetCounter(am);
6111: am->counters[counter].min = 1;
6112: am->counters[counter].max = 1;
6113:
6114: /* xmlFAGenerateTransitions(am, from, to, atom); */
6115: if (to == NULL) {
6116: to = xmlRegNewState(am);
6117: xmlRegStatePush(am, to);
6118: }
6119: xmlRegStateAddTrans(am, from, atom, to, counter, -1);
6120: xmlRegAtomPush(am, atom);
6121: am->state = to;
6122: return(to);
6123: }
6124:
6125: /**
6126: * xmlAutomataNewState:
6127: * @am: an automata
6128: *
6129: * Create a new disconnected state in the automata
6130: *
6131: * Returns the new state or NULL in case of error
6132: */
6133: xmlAutomataStatePtr
6134: xmlAutomataNewState(xmlAutomataPtr am) {
6135: xmlAutomataStatePtr to;
6136:
6137: if (am == NULL)
6138: return(NULL);
6139: to = xmlRegNewState(am);
6140: xmlRegStatePush(am, to);
6141: return(to);
6142: }
6143:
6144: /**
6145: * xmlAutomataNewEpsilon:
6146: * @am: an automata
6147: * @from: the starting point of the transition
6148: * @to: the target point of the transition or NULL
6149: *
6150: * If @to is NULL, this creates first a new target state in the automata
6151: * and then adds an epsilon transition from the @from state to the
6152: * target state
6153: *
6154: * Returns the target state or NULL in case of error
6155: */
6156: xmlAutomataStatePtr
6157: xmlAutomataNewEpsilon(xmlAutomataPtr am, xmlAutomataStatePtr from,
6158: xmlAutomataStatePtr to) {
6159: if ((am == NULL) || (from == NULL))
6160: return(NULL);
6161: xmlFAGenerateEpsilonTransition(am, from, to);
6162: if (to == NULL)
6163: return(am->state);
6164: return(to);
6165: }
6166:
6167: /**
6168: * xmlAutomataNewAllTrans:
6169: * @am: an automata
6170: * @from: the starting point of the transition
6171: * @to: the target point of the transition or NULL
6172: * @lax: allow to transition if not all all transitions have been activated
6173: *
6174: * If @to is NULL, this creates first a new target state in the automata
6175: * and then adds a an ALL transition from the @from state to the
6176: * target state. That transition is an epsilon transition allowed only when
6177: * all transitions from the @from node have been activated.
6178: *
6179: * Returns the target state or NULL in case of error
6180: */
6181: xmlAutomataStatePtr
6182: xmlAutomataNewAllTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
6183: xmlAutomataStatePtr to, int lax) {
6184: if ((am == NULL) || (from == NULL))
6185: return(NULL);
6186: xmlFAGenerateAllTransition(am, from, to, lax);
6187: if (to == NULL)
6188: return(am->state);
6189: return(to);
6190: }
6191:
6192: /**
6193: * xmlAutomataNewCounter:
6194: * @am: an automata
6195: * @min: the minimal value on the counter
6196: * @max: the maximal value on the counter
6197: *
6198: * Create a new counter
6199: *
6200: * Returns the counter number or -1 in case of error
6201: */
6202: int
6203: xmlAutomataNewCounter(xmlAutomataPtr am, int min, int max) {
6204: int ret;
6205:
6206: if (am == NULL)
6207: return(-1);
6208:
6209: ret = xmlRegGetCounter(am);
6210: if (ret < 0)
6211: return(-1);
6212: am->counters[ret].min = min;
6213: am->counters[ret].max = max;
6214: return(ret);
6215: }
6216:
6217: /**
6218: * xmlAutomataNewCountedTrans:
6219: * @am: an automata
6220: * @from: the starting point of the transition
6221: * @to: the target point of the transition or NULL
6222: * @counter: the counter associated to that transition
6223: *
6224: * If @to is NULL, this creates first a new target state in the automata
6225: * and then adds an epsilon transition from the @from state to the target state
6226: * which will increment the counter provided
6227: *
6228: * Returns the target state or NULL in case of error
6229: */
6230: xmlAutomataStatePtr
6231: xmlAutomataNewCountedTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
6232: xmlAutomataStatePtr to, int counter) {
6233: if ((am == NULL) || (from == NULL) || (counter < 0))
6234: return(NULL);
6235: xmlFAGenerateCountedEpsilonTransition(am, from, to, counter);
6236: if (to == NULL)
6237: return(am->state);
6238: return(to);
6239: }
6240:
6241: /**
6242: * xmlAutomataNewCounterTrans:
6243: * @am: an automata
6244: * @from: the starting point of the transition
6245: * @to: the target point of the transition or NULL
6246: * @counter: the counter associated to that transition
6247: *
6248: * If @to is NULL, this creates first a new target state in the automata
6249: * and then adds an epsilon transition from the @from state to the target state
6250: * which will be allowed only if the counter is within the right range.
6251: *
6252: * Returns the target state or NULL in case of error
6253: */
6254: xmlAutomataStatePtr
6255: xmlAutomataNewCounterTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
6256: xmlAutomataStatePtr to, int counter) {
6257: if ((am == NULL) || (from == NULL) || (counter < 0))
6258: return(NULL);
6259: xmlFAGenerateCountedTransition(am, from, to, counter);
6260: if (to == NULL)
6261: return(am->state);
6262: return(to);
6263: }
6264:
6265: /**
6266: * xmlAutomataCompile:
6267: * @am: an automata
6268: *
6269: * Compile the automata into a Reg Exp ready for being executed.
6270: * The automata should be free after this point.
6271: *
6272: * Returns the compiled regexp or NULL in case of error
6273: */
6274: xmlRegexpPtr
6275: xmlAutomataCompile(xmlAutomataPtr am) {
6276: xmlRegexpPtr ret;
6277:
6278: if ((am == NULL) || (am->error != 0)) return(NULL);
6279: xmlFAEliminateEpsilonTransitions(am);
6280: /* xmlFAComputesDeterminism(am); */
6281: ret = xmlRegEpxFromParse(am);
6282:
6283: return(ret);
6284: }
6285:
6286: /**
6287: * xmlAutomataIsDeterminist:
6288: * @am: an automata
6289: *
6290: * Checks if an automata is determinist.
6291: *
6292: * Returns 1 if true, 0 if not, and -1 in case of error
6293: */
6294: int
6295: xmlAutomataIsDeterminist(xmlAutomataPtr am) {
6296: int ret;
6297:
6298: if (am == NULL)
6299: return(-1);
6300:
6301: ret = xmlFAComputesDeterminism(am);
6302: return(ret);
6303: }
6304: #endif /* LIBXML_AUTOMATA_ENABLED */
6305:
6306: #ifdef LIBXML_EXPR_ENABLED
6307: /************************************************************************
6308: * *
6309: * Formal Expression handling code *
6310: * *
6311: ************************************************************************/
6312: /************************************************************************
6313: * *
6314: * Expression handling context *
6315: * *
6316: ************************************************************************/
6317:
6318: struct _xmlExpCtxt {
6319: xmlDictPtr dict;
6320: xmlExpNodePtr *table;
6321: int size;
6322: int nbElems;
6323: int nb_nodes;
6324: int maxNodes;
6325: const char *expr;
6326: const char *cur;
6327: int nb_cons;
6328: int tabSize;
6329: };
6330:
6331: /**
6332: * xmlExpNewCtxt:
6333: * @maxNodes: the maximum number of nodes
6334: * @dict: optional dictionnary to use internally
6335: *
6336: * Creates a new context for manipulating expressions
6337: *
6338: * Returns the context or NULL in case of error
6339: */
6340: xmlExpCtxtPtr
6341: xmlExpNewCtxt(int maxNodes, xmlDictPtr dict) {
6342: xmlExpCtxtPtr ret;
6343: int size = 256;
6344:
6345: if (maxNodes <= 4096)
6346: maxNodes = 4096;
6347:
6348: ret = (xmlExpCtxtPtr) xmlMalloc(sizeof(xmlExpCtxt));
6349: if (ret == NULL)
6350: return(NULL);
6351: memset(ret, 0, sizeof(xmlExpCtxt));
6352: ret->size = size;
6353: ret->nbElems = 0;
6354: ret->maxNodes = maxNodes;
6355: ret->table = xmlMalloc(size * sizeof(xmlExpNodePtr));
6356: if (ret->table == NULL) {
6357: xmlFree(ret);
6358: return(NULL);
6359: }
6360: memset(ret->table, 0, size * sizeof(xmlExpNodePtr));
6361: if (dict == NULL) {
6362: ret->dict = xmlDictCreate();
6363: if (ret->dict == NULL) {
6364: xmlFree(ret->table);
6365: xmlFree(ret);
6366: return(NULL);
6367: }
6368: } else {
6369: ret->dict = dict;
6370: xmlDictReference(ret->dict);
6371: }
6372: return(ret);
6373: }
6374:
6375: /**
6376: * xmlExpFreeCtxt:
6377: * @ctxt: an expression context
6378: *
6379: * Free an expression context
6380: */
6381: void
6382: xmlExpFreeCtxt(xmlExpCtxtPtr ctxt) {
6383: if (ctxt == NULL)
6384: return;
6385: xmlDictFree(ctxt->dict);
6386: if (ctxt->table != NULL)
6387: xmlFree(ctxt->table);
6388: xmlFree(ctxt);
6389: }
6390:
6391: /************************************************************************
6392: * *
6393: * Structure associated to an expression node *
6394: * *
6395: ************************************************************************/
6396: #define MAX_NODES 10000
6397:
6398: /* #define DEBUG_DERIV */
6399:
6400: /*
6401: * TODO:
6402: * - Wildcards
6403: * - public API for creation
6404: *
6405: * Started
6406: * - regression testing
6407: *
6408: * Done
6409: * - split into module and test tool
6410: * - memleaks
6411: */
6412:
6413: typedef enum {
6414: XML_EXP_NILABLE = (1 << 0)
6415: } xmlExpNodeInfo;
6416:
6417: #define IS_NILLABLE(node) ((node)->info & XML_EXP_NILABLE)
6418:
6419: struct _xmlExpNode {
6420: unsigned char type;/* xmlExpNodeType */
6421: unsigned char info;/* OR of xmlExpNodeInfo */
6422: unsigned short key; /* the hash key */
6423: unsigned int ref; /* The number of references */
6424: int c_max; /* the maximum length it can consume */
6425: xmlExpNodePtr exp_left;
6426: xmlExpNodePtr next;/* the next node in the hash table or free list */
6427: union {
6428: struct {
6429: int f_min;
6430: int f_max;
6431: } count;
6432: struct {
6433: xmlExpNodePtr f_right;
6434: } children;
6435: const xmlChar *f_str;
6436: } field;
6437: };
6438:
6439: #define exp_min field.count.f_min
6440: #define exp_max field.count.f_max
6441: /* #define exp_left field.children.f_left */
6442: #define exp_right field.children.f_right
6443: #define exp_str field.f_str
6444:
6445: static xmlExpNodePtr xmlExpNewNode(xmlExpCtxtPtr ctxt, xmlExpNodeType type);
6446: static xmlExpNode forbiddenExpNode = {
6447: XML_EXP_FORBID, 0, 0, 0, 0, NULL, NULL, {{ 0, 0}}
6448: };
6449: xmlExpNodePtr forbiddenExp = &forbiddenExpNode;
6450: static xmlExpNode emptyExpNode = {
6451: XML_EXP_EMPTY, 1, 0, 0, 0, NULL, NULL, {{ 0, 0}}
6452: };
6453: xmlExpNodePtr emptyExp = &emptyExpNode;
6454:
6455: /************************************************************************
6456: * *
6457: * The custom hash table for unicity and canonicalization *
6458: * of sub-expressions pointers *
6459: * *
6460: ************************************************************************/
6461: /*
6462: * xmlExpHashNameComputeKey:
6463: * Calculate the hash key for a token
6464: */
6465: static unsigned short
6466: xmlExpHashNameComputeKey(const xmlChar *name) {
6467: unsigned short value = 0L;
6468: char ch;
6469:
6470: if (name != NULL) {
6471: value += 30 * (*name);
6472: while ((ch = *name++) != 0) {
6473: value = value ^ ((value << 5) + (value >> 3) + (unsigned long)ch);
6474: }
6475: }
6476: return (value);
6477: }
6478:
6479: /*
6480: * xmlExpHashComputeKey:
6481: * Calculate the hash key for a compound expression
6482: */
6483: static unsigned short
6484: xmlExpHashComputeKey(xmlExpNodeType type, xmlExpNodePtr left,
6485: xmlExpNodePtr right) {
6486: unsigned long value;
6487: unsigned short ret;
6488:
6489: switch (type) {
6490: case XML_EXP_SEQ:
6491: value = left->key;
6492: value += right->key;
6493: value *= 3;
6494: ret = (unsigned short) value;
6495: break;
6496: case XML_EXP_OR:
6497: value = left->key;
6498: value += right->key;
6499: value *= 7;
6500: ret = (unsigned short) value;
6501: break;
6502: case XML_EXP_COUNT:
6503: value = left->key;
6504: value += right->key;
6505: ret = (unsigned short) value;
6506: break;
6507: default:
6508: ret = 0;
6509: }
6510: return(ret);
6511: }
6512:
6513:
6514: static xmlExpNodePtr
6515: xmlExpNewNode(xmlExpCtxtPtr ctxt, xmlExpNodeType type) {
6516: xmlExpNodePtr ret;
6517:
6518: if (ctxt->nb_nodes >= MAX_NODES)
6519: return(NULL);
6520: ret = (xmlExpNodePtr) xmlMalloc(sizeof(xmlExpNode));
6521: if (ret == NULL)
6522: return(NULL);
6523: memset(ret, 0, sizeof(xmlExpNode));
6524: ret->type = type;
6525: ret->next = NULL;
6526: ctxt->nb_nodes++;
6527: ctxt->nb_cons++;
6528: return(ret);
6529: }
6530:
6531: /**
6532: * xmlExpHashGetEntry:
6533: * @table: the hash table
6534: *
6535: * Get the unique entry from the hash table. The entry is created if
6536: * needed. @left and @right are consumed, i.e. their ref count will
6537: * be decremented by the operation.
6538: *
6539: * Returns the pointer or NULL in case of error
6540: */
6541: static xmlExpNodePtr
6542: xmlExpHashGetEntry(xmlExpCtxtPtr ctxt, xmlExpNodeType type,
6543: xmlExpNodePtr left, xmlExpNodePtr right,
6544: const xmlChar *name, int min, int max) {
6545: unsigned short kbase, key;
6546: xmlExpNodePtr entry;
6547: xmlExpNodePtr insert;
6548:
6549: if (ctxt == NULL)
6550: return(NULL);
6551:
6552: /*
6553: * Check for duplicate and insertion location.
6554: */
6555: if (type == XML_EXP_ATOM) {
6556: kbase = xmlExpHashNameComputeKey(name);
6557: } else if (type == XML_EXP_COUNT) {
6558: /* COUNT reduction rule 1 */
6559: /* a{1} -> a */
6560: if (min == max) {
6561: if (min == 1) {
6562: return(left);
6563: }
6564: if (min == 0) {
6565: xmlExpFree(ctxt, left);
6566: return(emptyExp);
6567: }
6568: }
6569: if (min < 0) {
6570: xmlExpFree(ctxt, left);
6571: return(forbiddenExp);
6572: }
6573: if (max == -1)
6574: kbase = min + 79;
6575: else
6576: kbase = max - min;
6577: kbase += left->key;
6578: } else if (type == XML_EXP_OR) {
6579: /* Forbid reduction rules */
6580: if (left->type == XML_EXP_FORBID) {
6581: xmlExpFree(ctxt, left);
6582: return(right);
6583: }
6584: if (right->type == XML_EXP_FORBID) {
6585: xmlExpFree(ctxt, right);
6586: return(left);
6587: }
6588:
6589: /* OR reduction rule 1 */
6590: /* a | a reduced to a */
6591: if (left == right) {
6592: left->ref--;
6593: return(left);
6594: }
6595: /* OR canonicalization rule 1 */
6596: /* linearize (a | b) | c into a | (b | c) */
6597: if ((left->type == XML_EXP_OR) && (right->type != XML_EXP_OR)) {
6598: xmlExpNodePtr tmp = left;
6599: left = right;
6600: right = tmp;
6601: }
6602: /* OR reduction rule 2 */
6603: /* a | (a | b) and b | (a | b) are reduced to a | b */
6604: if (right->type == XML_EXP_OR) {
6605: if ((left == right->exp_left) ||
6606: (left == right->exp_right)) {
6607: xmlExpFree(ctxt, left);
6608: return(right);
6609: }
6610: }
6611: /* OR canonicalization rule 2 */
6612: /* linearize (a | b) | c into a | (b | c) */
6613: if (left->type == XML_EXP_OR) {
6614: xmlExpNodePtr tmp;
6615:
6616: /* OR canonicalization rule 2 */
6617: if ((left->exp_right->type != XML_EXP_OR) &&
6618: (left->exp_right->key < left->exp_left->key)) {
6619: tmp = left->exp_right;
6620: left->exp_right = left->exp_left;
6621: left->exp_left = tmp;
6622: }
6623: left->exp_right->ref++;
6624: tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left->exp_right, right,
6625: NULL, 0, 0);
6626: left->exp_left->ref++;
6627: tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left->exp_left, tmp,
6628: NULL, 0, 0);
6629:
6630: xmlExpFree(ctxt, left);
6631: return(tmp);
6632: }
6633: if (right->type == XML_EXP_OR) {
6634: /* Ordering in the tree */
6635: /* C | (A | B) -> A | (B | C) */
6636: if (left->key > right->exp_right->key) {
6637: xmlExpNodePtr tmp;
6638: right->exp_right->ref++;
6639: tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_right,
6640: left, NULL, 0, 0);
6641: right->exp_left->ref++;
6642: tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_left,
6643: tmp, NULL, 0, 0);
6644: xmlExpFree(ctxt, right);
6645: return(tmp);
6646: }
6647: /* Ordering in the tree */
6648: /* B | (A | C) -> A | (B | C) */
6649: if (left->key > right->exp_left->key) {
6650: xmlExpNodePtr tmp;
6651: right->exp_right->ref++;
6652: tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left,
6653: right->exp_right, NULL, 0, 0);
6654: right->exp_left->ref++;
6655: tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_left,
6656: tmp, NULL, 0, 0);
6657: xmlExpFree(ctxt, right);
6658: return(tmp);
6659: }
6660: }
6661: /* we know both types are != XML_EXP_OR here */
6662: else if (left->key > right->key) {
6663: xmlExpNodePtr tmp = left;
6664: left = right;
6665: right = tmp;
6666: }
6667: kbase = xmlExpHashComputeKey(type, left, right);
6668: } else if (type == XML_EXP_SEQ) {
6669: /* Forbid reduction rules */
6670: if (left->type == XML_EXP_FORBID) {
6671: xmlExpFree(ctxt, right);
6672: return(left);
6673: }
6674: if (right->type == XML_EXP_FORBID) {
6675: xmlExpFree(ctxt, left);
6676: return(right);
6677: }
6678: /* Empty reduction rules */
6679: if (right->type == XML_EXP_EMPTY) {
6680: return(left);
6681: }
6682: if (left->type == XML_EXP_EMPTY) {
6683: return(right);
6684: }
6685: kbase = xmlExpHashComputeKey(type, left, right);
6686: } else
6687: return(NULL);
6688:
6689: key = kbase % ctxt->size;
6690: if (ctxt->table[key] != NULL) {
6691: for (insert = ctxt->table[key]; insert != NULL;
6692: insert = insert->next) {
6693: if ((insert->key == kbase) &&
6694: (insert->type == type)) {
6695: if (type == XML_EXP_ATOM) {
6696: if (name == insert->exp_str) {
6697: insert->ref++;
6698: return(insert);
6699: }
6700: } else if (type == XML_EXP_COUNT) {
6701: if ((insert->exp_min == min) && (insert->exp_max == max) &&
6702: (insert->exp_left == left)) {
6703: insert->ref++;
6704: left->ref--;
6705: return(insert);
6706: }
6707: } else if ((insert->exp_left == left) &&
6708: (insert->exp_right == right)) {
6709: insert->ref++;
6710: left->ref--;
6711: right->ref--;
6712: return(insert);
6713: }
6714: }
6715: }
6716: }
6717:
6718: entry = xmlExpNewNode(ctxt, type);
6719: if (entry == NULL)
6720: return(NULL);
6721: entry->key = kbase;
6722: if (type == XML_EXP_ATOM) {
6723: entry->exp_str = name;
6724: entry->c_max = 1;
6725: } else if (type == XML_EXP_COUNT) {
6726: entry->exp_min = min;
6727: entry->exp_max = max;
6728: entry->exp_left = left;
6729: if ((min == 0) || (IS_NILLABLE(left)))
6730: entry->info |= XML_EXP_NILABLE;
6731: if (max < 0)
6732: entry->c_max = -1;
6733: else
6734: entry->c_max = max * entry->exp_left->c_max;
6735: } else {
6736: entry->exp_left = left;
6737: entry->exp_right = right;
6738: if (type == XML_EXP_OR) {
6739: if ((IS_NILLABLE(left)) || (IS_NILLABLE(right)))
6740: entry->info |= XML_EXP_NILABLE;
6741: if ((entry->exp_left->c_max == -1) ||
6742: (entry->exp_right->c_max == -1))
6743: entry->c_max = -1;
6744: else if (entry->exp_left->c_max > entry->exp_right->c_max)
6745: entry->c_max = entry->exp_left->c_max;
6746: else
6747: entry->c_max = entry->exp_right->c_max;
6748: } else {
6749: if ((IS_NILLABLE(left)) && (IS_NILLABLE(right)))
6750: entry->info |= XML_EXP_NILABLE;
6751: if ((entry->exp_left->c_max == -1) ||
6752: (entry->exp_right->c_max == -1))
6753: entry->c_max = -1;
6754: else
6755: entry->c_max = entry->exp_left->c_max + entry->exp_right->c_max;
6756: }
6757: }
6758: entry->ref = 1;
6759: if (ctxt->table[key] != NULL)
6760: entry->next = ctxt->table[key];
6761:
6762: ctxt->table[key] = entry;
6763: ctxt->nbElems++;
6764:
6765: return(entry);
6766: }
6767:
6768: /**
6769: * xmlExpFree:
6770: * @ctxt: the expression context
6771: * @exp: the expression
6772: *
6773: * Dereference the expression
6774: */
6775: void
6776: xmlExpFree(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp) {
6777: if ((exp == NULL) || (exp == forbiddenExp) || (exp == emptyExp))
6778: return;
6779: exp->ref--;
6780: if (exp->ref == 0) {
6781: unsigned short key;
6782:
6783: /* Unlink it first from the hash table */
6784: key = exp->key % ctxt->size;
6785: if (ctxt->table[key] == exp) {
6786: ctxt->table[key] = exp->next;
6787: } else {
6788: xmlExpNodePtr tmp;
6789:
6790: tmp = ctxt->table[key];
6791: while (tmp != NULL) {
6792: if (tmp->next == exp) {
6793: tmp->next = exp->next;
6794: break;
6795: }
6796: tmp = tmp->next;
6797: }
6798: }
6799:
6800: if ((exp->type == XML_EXP_SEQ) || (exp->type == XML_EXP_OR)) {
6801: xmlExpFree(ctxt, exp->exp_left);
6802: xmlExpFree(ctxt, exp->exp_right);
6803: } else if (exp->type == XML_EXP_COUNT) {
6804: xmlExpFree(ctxt, exp->exp_left);
6805: }
6806: xmlFree(exp);
6807: ctxt->nb_nodes--;
6808: }
6809: }
6810:
6811: /**
6812: * xmlExpRef:
6813: * @exp: the expression
6814: *
6815: * Increase the reference count of the expression
6816: */
6817: void
6818: xmlExpRef(xmlExpNodePtr exp) {
6819: if (exp != NULL)
6820: exp->ref++;
6821: }
6822:
6823: /**
6824: * xmlExpNewAtom:
6825: * @ctxt: the expression context
6826: * @name: the atom name
6827: * @len: the atom name lenght in byte (or -1);
6828: *
6829: * Get the atom associated to this name from that context
6830: *
6831: * Returns the node or NULL in case of error
6832: */
6833: xmlExpNodePtr
6834: xmlExpNewAtom(xmlExpCtxtPtr ctxt, const xmlChar *name, int len) {
6835: if ((ctxt == NULL) || (name == NULL))
6836: return(NULL);
6837: name = xmlDictLookup(ctxt->dict, name, len);
6838: if (name == NULL)
6839: return(NULL);
6840: return(xmlExpHashGetEntry(ctxt, XML_EXP_ATOM, NULL, NULL, name, 0, 0));
6841: }
6842:
6843: /**
6844: * xmlExpNewOr:
6845: * @ctxt: the expression context
6846: * @left: left expression
6847: * @right: right expression
6848: *
6849: * Get the atom associated to the choice @left | @right
6850: * Note that @left and @right are consumed in the operation, to keep
6851: * an handle on them use xmlExpRef() and use xmlExpFree() to release them,
6852: * this is true even in case of failure (unless ctxt == NULL).
6853: *
6854: * Returns the node or NULL in case of error
6855: */
6856: xmlExpNodePtr
6857: xmlExpNewOr(xmlExpCtxtPtr ctxt, xmlExpNodePtr left, xmlExpNodePtr right) {
6858: if (ctxt == NULL)
6859: return(NULL);
6860: if ((left == NULL) || (right == NULL)) {
6861: xmlExpFree(ctxt, left);
6862: xmlExpFree(ctxt, right);
6863: return(NULL);
6864: }
6865: return(xmlExpHashGetEntry(ctxt, XML_EXP_OR, left, right, NULL, 0, 0));
6866: }
6867:
6868: /**
6869: * xmlExpNewSeq:
6870: * @ctxt: the expression context
6871: * @left: left expression
6872: * @right: right expression
6873: *
6874: * Get the atom associated to the sequence @left , @right
6875: * Note that @left and @right are consumed in the operation, to keep
6876: * an handle on them use xmlExpRef() and use xmlExpFree() to release them,
6877: * this is true even in case of failure (unless ctxt == NULL).
6878: *
6879: * Returns the node or NULL in case of error
6880: */
6881: xmlExpNodePtr
6882: xmlExpNewSeq(xmlExpCtxtPtr ctxt, xmlExpNodePtr left, xmlExpNodePtr right) {
6883: if (ctxt == NULL)
6884: return(NULL);
6885: if ((left == NULL) || (right == NULL)) {
6886: xmlExpFree(ctxt, left);
6887: xmlExpFree(ctxt, right);
6888: return(NULL);
6889: }
6890: return(xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, left, right, NULL, 0, 0));
6891: }
6892:
6893: /**
6894: * xmlExpNewRange:
6895: * @ctxt: the expression context
6896: * @subset: the expression to be repeated
6897: * @min: the lower bound for the repetition
6898: * @max: the upper bound for the repetition, -1 means infinite
6899: *
6900: * Get the atom associated to the range (@subset){@min, @max}
6901: * Note that @subset is consumed in the operation, to keep
6902: * an handle on it use xmlExpRef() and use xmlExpFree() to release it,
6903: * this is true even in case of failure (unless ctxt == NULL).
6904: *
6905: * Returns the node or NULL in case of error
6906: */
6907: xmlExpNodePtr
6908: xmlExpNewRange(xmlExpCtxtPtr ctxt, xmlExpNodePtr subset, int min, int max) {
6909: if (ctxt == NULL)
6910: return(NULL);
6911: if ((subset == NULL) || (min < 0) || (max < -1) ||
6912: ((max >= 0) && (min > max))) {
6913: xmlExpFree(ctxt, subset);
6914: return(NULL);
6915: }
6916: return(xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, subset,
6917: NULL, NULL, min, max));
6918: }
6919:
6920: /************************************************************************
6921: * *
6922: * Public API for operations on expressions *
6923: * *
6924: ************************************************************************/
6925:
6926: static int
6927: xmlExpGetLanguageInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
6928: const xmlChar**list, int len, int nb) {
6929: int tmp, tmp2;
6930: tail:
6931: switch (exp->type) {
6932: case XML_EXP_EMPTY:
6933: return(0);
6934: case XML_EXP_ATOM:
6935: for (tmp = 0;tmp < nb;tmp++)
6936: if (list[tmp] == exp->exp_str)
6937: return(0);
6938: if (nb >= len)
6939: return(-2);
6940: list[nb] = exp->exp_str;
6941: return(1);
6942: case XML_EXP_COUNT:
6943: exp = exp->exp_left;
6944: goto tail;
6945: case XML_EXP_SEQ:
6946: case XML_EXP_OR:
6947: tmp = xmlExpGetLanguageInt(ctxt, exp->exp_left, list, len, nb);
6948: if (tmp < 0)
6949: return(tmp);
6950: tmp2 = xmlExpGetLanguageInt(ctxt, exp->exp_right, list, len,
6951: nb + tmp);
6952: if (tmp2 < 0)
6953: return(tmp2);
6954: return(tmp + tmp2);
6955: }
6956: return(-1);
6957: }
6958:
6959: /**
6960: * xmlExpGetLanguage:
6961: * @ctxt: the expression context
6962: * @exp: the expression
6963: * @langList: where to store the tokens
6964: * @len: the allocated lenght of @list
6965: *
6966: * Find all the strings used in @exp and store them in @list
6967: *
6968: * Returns the number of unique strings found, -1 in case of errors and
6969: * -2 if there is more than @len strings
6970: */
6971: int
6972: xmlExpGetLanguage(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
6973: const xmlChar**langList, int len) {
6974: if ((ctxt == NULL) || (exp == NULL) || (langList == NULL) || (len <= 0))
6975: return(-1);
6976: return(xmlExpGetLanguageInt(ctxt, exp, langList, len, 0));
6977: }
6978:
6979: static int
6980: xmlExpGetStartInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
6981: const xmlChar**list, int len, int nb) {
6982: int tmp, tmp2;
6983: tail:
6984: switch (exp->type) {
6985: case XML_EXP_FORBID:
6986: return(0);
6987: case XML_EXP_EMPTY:
6988: return(0);
6989: case XML_EXP_ATOM:
6990: for (tmp = 0;tmp < nb;tmp++)
6991: if (list[tmp] == exp->exp_str)
6992: return(0);
6993: if (nb >= len)
6994: return(-2);
6995: list[nb] = exp->exp_str;
6996: return(1);
6997: case XML_EXP_COUNT:
6998: exp = exp->exp_left;
6999: goto tail;
7000: case XML_EXP_SEQ:
7001: tmp = xmlExpGetStartInt(ctxt, exp->exp_left, list, len, nb);
7002: if (tmp < 0)
7003: return(tmp);
7004: if (IS_NILLABLE(exp->exp_left)) {
7005: tmp2 = xmlExpGetStartInt(ctxt, exp->exp_right, list, len,
7006: nb + tmp);
7007: if (tmp2 < 0)
7008: return(tmp2);
7009: tmp += tmp2;
7010: }
7011: return(tmp);
7012: case XML_EXP_OR:
7013: tmp = xmlExpGetStartInt(ctxt, exp->exp_left, list, len, nb);
7014: if (tmp < 0)
7015: return(tmp);
7016: tmp2 = xmlExpGetStartInt(ctxt, exp->exp_right, list, len,
7017: nb + tmp);
7018: if (tmp2 < 0)
7019: return(tmp2);
7020: return(tmp + tmp2);
7021: }
7022: return(-1);
7023: }
7024:
7025: /**
7026: * xmlExpGetStart:
7027: * @ctxt: the expression context
7028: * @exp: the expression
7029: * @tokList: where to store the tokens
7030: * @len: the allocated lenght of @list
7031: *
7032: * Find all the strings that appears at the start of the languages
7033: * accepted by @exp and store them in @list. E.g. for (a, b) | c
7034: * it will return the list [a, c]
7035: *
7036: * Returns the number of unique strings found, -1 in case of errors and
7037: * -2 if there is more than @len strings
7038: */
7039: int
7040: xmlExpGetStart(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
7041: const xmlChar**tokList, int len) {
7042: if ((ctxt == NULL) || (exp == NULL) || (tokList == NULL) || (len <= 0))
7043: return(-1);
7044: return(xmlExpGetStartInt(ctxt, exp, tokList, len, 0));
7045: }
7046:
7047: /**
7048: * xmlExpIsNillable:
7049: * @exp: the expression
7050: *
7051: * Finds if the expression is nillable, i.e. if it accepts the empty sequqnce
7052: *
7053: * Returns 1 if nillable, 0 if not and -1 in case of error
7054: */
7055: int
7056: xmlExpIsNillable(xmlExpNodePtr exp) {
7057: if (exp == NULL)
7058: return(-1);
7059: return(IS_NILLABLE(exp) != 0);
7060: }
7061:
7062: static xmlExpNodePtr
7063: xmlExpStringDeriveInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, const xmlChar *str)
7064: {
7065: xmlExpNodePtr ret;
7066:
7067: switch (exp->type) {
7068: case XML_EXP_EMPTY:
7069: return(forbiddenExp);
7070: case XML_EXP_FORBID:
7071: return(forbiddenExp);
7072: case XML_EXP_ATOM:
7073: if (exp->exp_str == str) {
7074: #ifdef DEBUG_DERIV
7075: printf("deriv atom: equal => Empty\n");
7076: #endif
7077: ret = emptyExp;
7078: } else {
7079: #ifdef DEBUG_DERIV
7080: printf("deriv atom: mismatch => forbid\n");
7081: #endif
7082: /* TODO wildcards here */
7083: ret = forbiddenExp;
7084: }
7085: return(ret);
7086: case XML_EXP_OR: {
7087: xmlExpNodePtr tmp;
7088:
7089: #ifdef DEBUG_DERIV
7090: printf("deriv or: => or(derivs)\n");
7091: #endif
7092: tmp = xmlExpStringDeriveInt(ctxt, exp->exp_left, str);
7093: if (tmp == NULL) {
7094: return(NULL);
7095: }
7096: ret = xmlExpStringDeriveInt(ctxt, exp->exp_right, str);
7097: if (ret == NULL) {
7098: xmlExpFree(ctxt, tmp);
7099: return(NULL);
7100: }
7101: ret = xmlExpHashGetEntry(ctxt, XML_EXP_OR, tmp, ret,
7102: NULL, 0, 0);
7103: return(ret);
7104: }
7105: case XML_EXP_SEQ:
7106: #ifdef DEBUG_DERIV
7107: printf("deriv seq: starting with left\n");
7108: #endif
7109: ret = xmlExpStringDeriveInt(ctxt, exp->exp_left, str);
7110: if (ret == NULL) {
7111: return(NULL);
7112: } else if (ret == forbiddenExp) {
7113: if (IS_NILLABLE(exp->exp_left)) {
7114: #ifdef DEBUG_DERIV
7115: printf("deriv seq: left failed but nillable\n");
7116: #endif
7117: ret = xmlExpStringDeriveInt(ctxt, exp->exp_right, str);
7118: }
7119: } else {
7120: #ifdef DEBUG_DERIV
7121: printf("deriv seq: left match => sequence\n");
7122: #endif
7123: exp->exp_right->ref++;
7124: ret = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret, exp->exp_right,
7125: NULL, 0, 0);
7126: }
7127: return(ret);
7128: case XML_EXP_COUNT: {
7129: int min, max;
7130: xmlExpNodePtr tmp;
7131:
7132: if (exp->exp_max == 0)
7133: return(forbiddenExp);
7134: ret = xmlExpStringDeriveInt(ctxt, exp->exp_left, str);
7135: if (ret == NULL)
7136: return(NULL);
7137: if (ret == forbiddenExp) {
7138: #ifdef DEBUG_DERIV
7139: printf("deriv count: pattern mismatch => forbid\n");
7140: #endif
7141: return(ret);
7142: }
7143: if (exp->exp_max == 1)
7144: return(ret);
7145: if (exp->exp_max < 0) /* unbounded */
7146: max = -1;
7147: else
7148: max = exp->exp_max - 1;
7149: if (exp->exp_min > 0)
7150: min = exp->exp_min - 1;
7151: else
7152: min = 0;
7153: exp->exp_left->ref++;
7154: tmp = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, exp->exp_left, NULL,
7155: NULL, min, max);
7156: if (ret == emptyExp) {
7157: #ifdef DEBUG_DERIV
7158: printf("deriv count: match to empty => new count\n");
7159: #endif
7160: return(tmp);
7161: }
7162: #ifdef DEBUG_DERIV
7163: printf("deriv count: match => sequence with new count\n");
7164: #endif
7165: return(xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret, tmp,
7166: NULL, 0, 0));
7167: }
7168: }
7169: return(NULL);
7170: }
7171:
7172: /**
7173: * xmlExpStringDerive:
7174: * @ctxt: the expression context
7175: * @exp: the expression
7176: * @str: the string
7177: * @len: the string len in bytes if available
7178: *
7179: * Do one step of Brzozowski derivation of the expression @exp with
7180: * respect to the input string
7181: *
7182: * Returns the resulting expression or NULL in case of internal error
7183: */
7184: xmlExpNodePtr
7185: xmlExpStringDerive(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
7186: const xmlChar *str, int len) {
7187: const xmlChar *input;
7188:
7189: if ((exp == NULL) || (ctxt == NULL) || (str == NULL)) {
7190: return(NULL);
7191: }
7192: /*
7193: * check the string is in the dictionnary, if yes use an interned
7194: * copy, otherwise we know it's not an acceptable input
7195: */
7196: input = xmlDictExists(ctxt->dict, str, len);
7197: if (input == NULL) {
7198: return(forbiddenExp);
7199: }
7200: return(xmlExpStringDeriveInt(ctxt, exp, input));
7201: }
7202:
7203: static int
7204: xmlExpCheckCard(xmlExpNodePtr exp, xmlExpNodePtr sub) {
7205: int ret = 1;
7206:
7207: if (sub->c_max == -1) {
7208: if (exp->c_max != -1)
7209: ret = 0;
7210: } else if ((exp->c_max >= 0) && (exp->c_max < sub->c_max)) {
7211: ret = 0;
7212: }
7213: #if 0
7214: if ((IS_NILLABLE(sub)) && (!IS_NILLABLE(exp)))
7215: ret = 0;
7216: #endif
7217: return(ret);
7218: }
7219:
7220: static xmlExpNodePtr xmlExpExpDeriveInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
7221: xmlExpNodePtr sub);
7222: /**
7223: * xmlExpDivide:
7224: * @ctxt: the expressions context
7225: * @exp: the englobing expression
7226: * @sub: the subexpression
7227: * @mult: the multiple expression
7228: * @remain: the remain from the derivation of the multiple
7229: *
7230: * Check if exp is a multiple of sub, i.e. if there is a finite number n
7231: * so that sub{n} subsume exp
7232: *
7233: * Returns the multiple value if successful, 0 if it is not a multiple
7234: * and -1 in case of internel error.
7235: */
7236:
7237: static int
7238: xmlExpDivide(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub,
7239: xmlExpNodePtr *mult, xmlExpNodePtr *remain) {
7240: int i;
7241: xmlExpNodePtr tmp, tmp2;
7242:
7243: if (mult != NULL) *mult = NULL;
7244: if (remain != NULL) *remain = NULL;
7245: if (exp->c_max == -1) return(0);
7246: if (IS_NILLABLE(exp) && (!IS_NILLABLE(sub))) return(0);
7247:
7248: for (i = 1;i <= exp->c_max;i++) {
7249: sub->ref++;
7250: tmp = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT,
7251: sub, NULL, NULL, i, i);
7252: if (tmp == NULL) {
7253: return(-1);
7254: }
7255: if (!xmlExpCheckCard(tmp, exp)) {
7256: xmlExpFree(ctxt, tmp);
7257: continue;
7258: }
7259: tmp2 = xmlExpExpDeriveInt(ctxt, tmp, exp);
7260: if (tmp2 == NULL) {
7261: xmlExpFree(ctxt, tmp);
7262: return(-1);
7263: }
7264: if ((tmp2 != forbiddenExp) && (IS_NILLABLE(tmp2))) {
7265: if (remain != NULL)
7266: *remain = tmp2;
7267: else
7268: xmlExpFree(ctxt, tmp2);
7269: if (mult != NULL)
7270: *mult = tmp;
7271: else
7272: xmlExpFree(ctxt, tmp);
7273: #ifdef DEBUG_DERIV
7274: printf("Divide succeeded %d\n", i);
7275: #endif
7276: return(i);
7277: }
7278: xmlExpFree(ctxt, tmp);
7279: xmlExpFree(ctxt, tmp2);
7280: }
7281: #ifdef DEBUG_DERIV
7282: printf("Divide failed\n");
7283: #endif
7284: return(0);
7285: }
7286:
7287: /**
7288: * xmlExpExpDeriveInt:
7289: * @ctxt: the expressions context
7290: * @exp: the englobing expression
7291: * @sub: the subexpression
7292: *
7293: * Try to do a step of Brzozowski derivation but at a higher level
7294: * the input being a subexpression.
7295: *
7296: * Returns the resulting expression or NULL in case of internal error
7297: */
7298: static xmlExpNodePtr
7299: xmlExpExpDeriveInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
7300: xmlExpNodePtr ret, tmp, tmp2, tmp3;
7301: const xmlChar **tab;
7302: int len, i;
7303:
7304: /*
7305: * In case of equality and if the expression can only consume a finite
7306: * amount, then the derivation is empty
7307: */
7308: if ((exp == sub) && (exp->c_max >= 0)) {
7309: #ifdef DEBUG_DERIV
7310: printf("Equal(exp, sub) and finite -> Empty\n");
7311: #endif
7312: return(emptyExp);
7313: }
7314: /*
7315: * decompose sub sequence first
7316: */
7317: if (sub->type == XML_EXP_EMPTY) {
7318: #ifdef DEBUG_DERIV
7319: printf("Empty(sub) -> Empty\n");
7320: #endif
7321: exp->ref++;
7322: return(exp);
7323: }
7324: if (sub->type == XML_EXP_SEQ) {
7325: #ifdef DEBUG_DERIV
7326: printf("Seq(sub) -> decompose\n");
7327: #endif
7328: tmp = xmlExpExpDeriveInt(ctxt, exp, sub->exp_left);
7329: if (tmp == NULL)
7330: return(NULL);
7331: if (tmp == forbiddenExp)
7332: return(tmp);
7333: ret = xmlExpExpDeriveInt(ctxt, tmp, sub->exp_right);
7334: xmlExpFree(ctxt, tmp);
7335: return(ret);
7336: }
7337: if (sub->type == XML_EXP_OR) {
7338: #ifdef DEBUG_DERIV
7339: printf("Or(sub) -> decompose\n");
7340: #endif
7341: tmp = xmlExpExpDeriveInt(ctxt, exp, sub->exp_left);
7342: if (tmp == forbiddenExp)
7343: return(tmp);
7344: if (tmp == NULL)
7345: return(NULL);
7346: ret = xmlExpExpDeriveInt(ctxt, exp, sub->exp_right);
7347: if ((ret == NULL) || (ret == forbiddenExp)) {
7348: xmlExpFree(ctxt, tmp);
7349: return(ret);
7350: }
7351: return(xmlExpHashGetEntry(ctxt, XML_EXP_OR, tmp, ret, NULL, 0, 0));
7352: }
7353: if (!xmlExpCheckCard(exp, sub)) {
7354: #ifdef DEBUG_DERIV
7355: printf("CheckCard(exp, sub) failed -> Forbid\n");
7356: #endif
7357: return(forbiddenExp);
7358: }
7359: switch (exp->type) {
7360: case XML_EXP_EMPTY:
7361: if (sub == emptyExp)
7362: return(emptyExp);
7363: #ifdef DEBUG_DERIV
7364: printf("Empty(exp) -> Forbid\n");
7365: #endif
7366: return(forbiddenExp);
7367: case XML_EXP_FORBID:
7368: #ifdef DEBUG_DERIV
7369: printf("Forbid(exp) -> Forbid\n");
7370: #endif
7371: return(forbiddenExp);
7372: case XML_EXP_ATOM:
7373: if (sub->type == XML_EXP_ATOM) {
7374: /* TODO: handle wildcards */
7375: if (exp->exp_str == sub->exp_str) {
7376: #ifdef DEBUG_DERIV
7377: printf("Atom match -> Empty\n");
7378: #endif
7379: return(emptyExp);
7380: }
7381: #ifdef DEBUG_DERIV
7382: printf("Atom mismatch -> Forbid\n");
7383: #endif
7384: return(forbiddenExp);
7385: }
7386: if ((sub->type == XML_EXP_COUNT) &&
7387: (sub->exp_max == 1) &&
7388: (sub->exp_left->type == XML_EXP_ATOM)) {
7389: /* TODO: handle wildcards */
7390: if (exp->exp_str == sub->exp_left->exp_str) {
7391: #ifdef DEBUG_DERIV
7392: printf("Atom match -> Empty\n");
7393: #endif
7394: return(emptyExp);
7395: }
7396: #ifdef DEBUG_DERIV
7397: printf("Atom mismatch -> Forbid\n");
7398: #endif
7399: return(forbiddenExp);
7400: }
7401: #ifdef DEBUG_DERIV
7402: printf("Compex exp vs Atom -> Forbid\n");
7403: #endif
7404: return(forbiddenExp);
7405: case XML_EXP_SEQ:
7406: /* try to get the sequence consumed only if possible */
7407: if (xmlExpCheckCard(exp->exp_left, sub)) {
7408: /* See if the sequence can be consumed directly */
7409: #ifdef DEBUG_DERIV
7410: printf("Seq trying left only\n");
7411: #endif
7412: ret = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub);
7413: if ((ret != forbiddenExp) && (ret != NULL)) {
7414: #ifdef DEBUG_DERIV
7415: printf("Seq trying left only worked\n");
7416: #endif
7417: /*
7418: * TODO: assumption here that we are determinist
7419: * i.e. we won't get to a nillable exp left
7420: * subset which could be matched by the right
7421: * part too.
7422: * e.g.: (a | b)+,(a | c) and 'a+,a'
7423: */
7424: exp->exp_right->ref++;
7425: return(xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret,
7426: exp->exp_right, NULL, 0, 0));
7427: }
7428: #ifdef DEBUG_DERIV
7429: } else {
7430: printf("Seq: left too short\n");
7431: #endif
7432: }
7433: /* Try instead to decompose */
7434: if (sub->type == XML_EXP_COUNT) {
7435: int min, max;
7436:
7437: #ifdef DEBUG_DERIV
7438: printf("Seq: sub is a count\n");
7439: #endif
7440: ret = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub->exp_left);
7441: if (ret == NULL)
7442: return(NULL);
7443: if (ret != forbiddenExp) {
7444: #ifdef DEBUG_DERIV
7445: printf("Seq , Count match on left\n");
7446: #endif
7447: if (sub->exp_max < 0)
7448: max = -1;
7449: else
7450: max = sub->exp_max -1;
7451: if (sub->exp_min > 0)
7452: min = sub->exp_min -1;
7453: else
7454: min = 0;
7455: exp->exp_right->ref++;
7456: tmp = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret,
7457: exp->exp_right, NULL, 0, 0);
7458: if (tmp == NULL)
7459: return(NULL);
7460:
7461: sub->exp_left->ref++;
7462: tmp2 = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT,
7463: sub->exp_left, NULL, NULL, min, max);
7464: if (tmp2 == NULL) {
7465: xmlExpFree(ctxt, tmp);
7466: return(NULL);
7467: }
7468: ret = xmlExpExpDeriveInt(ctxt, tmp, tmp2);
7469: xmlExpFree(ctxt, tmp);
7470: xmlExpFree(ctxt, tmp2);
7471: return(ret);
7472: }
7473: }
7474: /* we made no progress on structured operations */
7475: break;
7476: case XML_EXP_OR:
7477: #ifdef DEBUG_DERIV
7478: printf("Or , trying both side\n");
7479: #endif
7480: ret = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub);
7481: if (ret == NULL)
7482: return(NULL);
7483: tmp = xmlExpExpDeriveInt(ctxt, exp->exp_right, sub);
7484: if (tmp == NULL) {
7485: xmlExpFree(ctxt, ret);
7486: return(NULL);
7487: }
7488: return(xmlExpHashGetEntry(ctxt, XML_EXP_OR, ret, tmp, NULL, 0, 0));
7489: case XML_EXP_COUNT: {
7490: int min, max;
7491:
7492: if (sub->type == XML_EXP_COUNT) {
7493: /*
7494: * Try to see if the loop is completely subsumed
7495: */
7496: tmp = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub->exp_left);
7497: if (tmp == NULL)
7498: return(NULL);
7499: if (tmp == forbiddenExp) {
7500: int mult;
7501:
7502: #ifdef DEBUG_DERIV
7503: printf("Count, Count inner don't subsume\n");
7504: #endif
7505: mult = xmlExpDivide(ctxt, sub->exp_left, exp->exp_left,
7506: NULL, &tmp);
7507: if (mult <= 0) {
7508: #ifdef DEBUG_DERIV
7509: printf("Count, Count not multiple => forbidden\n");
7510: #endif
7511: return(forbiddenExp);
7512: }
7513: if (sub->exp_max == -1) {
7514: max = -1;
7515: if (exp->exp_max == -1) {
7516: if (exp->exp_min <= sub->exp_min * mult)
7517: min = 0;
7518: else
7519: min = exp->exp_min - sub->exp_min * mult;
7520: } else {
7521: #ifdef DEBUG_DERIV
7522: printf("Count, Count finite can't subsume infinite\n");
7523: #endif
7524: xmlExpFree(ctxt, tmp);
7525: return(forbiddenExp);
7526: }
7527: } else {
7528: if (exp->exp_max == -1) {
7529: #ifdef DEBUG_DERIV
7530: printf("Infinite loop consume mult finite loop\n");
7531: #endif
7532: if (exp->exp_min > sub->exp_min * mult) {
7533: max = -1;
7534: min = exp->exp_min - sub->exp_min * mult;
7535: } else {
7536: max = -1;
7537: min = 0;
7538: }
7539: } else {
7540: if (exp->exp_max < sub->exp_max * mult) {
7541: #ifdef DEBUG_DERIV
7542: printf("loops max mult mismatch => forbidden\n");
7543: #endif
7544: xmlExpFree(ctxt, tmp);
7545: return(forbiddenExp);
7546: }
7547: if (sub->exp_max * mult > exp->exp_min)
7548: min = 0;
7549: else
7550: min = exp->exp_min - sub->exp_max * mult;
7551: max = exp->exp_max - sub->exp_max * mult;
7552: }
7553: }
7554: } else if (!IS_NILLABLE(tmp)) {
7555: /*
7556: * TODO: loop here to try to grow if working on finite
7557: * blocks.
7558: */
7559: #ifdef DEBUG_DERIV
7560: printf("Count, Count remain not nillable => forbidden\n");
7561: #endif
7562: xmlExpFree(ctxt, tmp);
7563: return(forbiddenExp);
7564: } else if (sub->exp_max == -1) {
7565: if (exp->exp_max == -1) {
7566: if (exp->exp_min <= sub->exp_min) {
7567: #ifdef DEBUG_DERIV
7568: printf("Infinite loops Okay => COUNT(0,Inf)\n");
7569: #endif
7570: max = -1;
7571: min = 0;
7572: } else {
7573: #ifdef DEBUG_DERIV
7574: printf("Infinite loops min => Count(X,Inf)\n");
7575: #endif
7576: max = -1;
7577: min = exp->exp_min - sub->exp_min;
7578: }
7579: } else if (exp->exp_min > sub->exp_min) {
7580: #ifdef DEBUG_DERIV
7581: printf("loops min mismatch 1 => forbidden ???\n");
7582: #endif
7583: xmlExpFree(ctxt, tmp);
7584: return(forbiddenExp);
7585: } else {
7586: max = -1;
7587: min = 0;
7588: }
7589: } else {
7590: if (exp->exp_max == -1) {
7591: #ifdef DEBUG_DERIV
7592: printf("Infinite loop consume finite loop\n");
7593: #endif
7594: if (exp->exp_min > sub->exp_min) {
7595: max = -1;
7596: min = exp->exp_min - sub->exp_min;
7597: } else {
7598: max = -1;
7599: min = 0;
7600: }
7601: } else {
7602: if (exp->exp_max < sub->exp_max) {
7603: #ifdef DEBUG_DERIV
7604: printf("loops max mismatch => forbidden\n");
7605: #endif
7606: xmlExpFree(ctxt, tmp);
7607: return(forbiddenExp);
7608: }
7609: if (sub->exp_max > exp->exp_min)
7610: min = 0;
7611: else
7612: min = exp->exp_min - sub->exp_max;
7613: max = exp->exp_max - sub->exp_max;
7614: }
7615: }
7616: #ifdef DEBUG_DERIV
7617: printf("loops match => SEQ(COUNT())\n");
7618: #endif
7619: exp->exp_left->ref++;
7620: tmp2 = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, exp->exp_left,
7621: NULL, NULL, min, max);
7622: if (tmp2 == NULL) {
7623: return(NULL);
7624: }
7625: ret = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, tmp, tmp2,
7626: NULL, 0, 0);
7627: return(ret);
7628: }
7629: tmp = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub);
7630: if (tmp == NULL)
7631: return(NULL);
7632: if (tmp == forbiddenExp) {
7633: #ifdef DEBUG_DERIV
7634: printf("loop mismatch => forbidden\n");
7635: #endif
7636: return(forbiddenExp);
7637: }
7638: if (exp->exp_min > 0)
7639: min = exp->exp_min - 1;
7640: else
7641: min = 0;
7642: if (exp->exp_max < 0)
7643: max = -1;
7644: else
7645: max = exp->exp_max - 1;
7646:
7647: #ifdef DEBUG_DERIV
7648: printf("loop match => SEQ(COUNT())\n");
7649: #endif
7650: exp->exp_left->ref++;
7651: tmp2 = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, exp->exp_left,
7652: NULL, NULL, min, max);
7653: if (tmp2 == NULL)
7654: return(NULL);
7655: ret = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, tmp, tmp2,
7656: NULL, 0, 0);
7657: return(ret);
7658: }
7659: }
7660:
7661: #ifdef DEBUG_DERIV
7662: printf("Fallback to derivative\n");
7663: #endif
7664: if (IS_NILLABLE(sub)) {
7665: if (!(IS_NILLABLE(exp)))
7666: return(forbiddenExp);
7667: else
7668: ret = emptyExp;
7669: } else
7670: ret = NULL;
7671: /*
7672: * here the structured derivation made no progress so
7673: * we use the default token based derivation to force one more step
7674: */
7675: if (ctxt->tabSize == 0)
7676: ctxt->tabSize = 40;
7677:
7678: tab = (const xmlChar **) xmlMalloc(ctxt->tabSize *
7679: sizeof(const xmlChar *));
7680: if (tab == NULL) {
7681: return(NULL);
7682: }
7683:
7684: /*
7685: * collect all the strings accepted by the subexpression on input
7686: */
7687: len = xmlExpGetStartInt(ctxt, sub, tab, ctxt->tabSize, 0);
7688: while (len < 0) {
7689: const xmlChar **temp;
7690: temp = (const xmlChar **) xmlRealloc((xmlChar **) tab, ctxt->tabSize * 2 *
7691: sizeof(const xmlChar *));
7692: if (temp == NULL) {
7693: xmlFree((xmlChar **) tab);
7694: return(NULL);
7695: }
7696: tab = temp;
7697: ctxt->tabSize *= 2;
7698: len = xmlExpGetStartInt(ctxt, sub, tab, ctxt->tabSize, 0);
7699: }
7700: for (i = 0;i < len;i++) {
7701: tmp = xmlExpStringDeriveInt(ctxt, exp, tab[i]);
7702: if ((tmp == NULL) || (tmp == forbiddenExp)) {
7703: xmlExpFree(ctxt, ret);
7704: xmlFree((xmlChar **) tab);
7705: return(tmp);
7706: }
7707: tmp2 = xmlExpStringDeriveInt(ctxt, sub, tab[i]);
7708: if ((tmp2 == NULL) || (tmp2 == forbiddenExp)) {
7709: xmlExpFree(ctxt, tmp);
7710: xmlExpFree(ctxt, ret);
7711: xmlFree((xmlChar **) tab);
7712: return(tmp);
7713: }
7714: tmp3 = xmlExpExpDeriveInt(ctxt, tmp, tmp2);
7715: xmlExpFree(ctxt, tmp);
7716: xmlExpFree(ctxt, tmp2);
7717:
7718: if ((tmp3 == NULL) || (tmp3 == forbiddenExp)) {
7719: xmlExpFree(ctxt, ret);
7720: xmlFree((xmlChar **) tab);
7721: return(tmp3);
7722: }
7723:
7724: if (ret == NULL)
7725: ret = tmp3;
7726: else {
7727: ret = xmlExpHashGetEntry(ctxt, XML_EXP_OR, ret, tmp3, NULL, 0, 0);
7728: if (ret == NULL) {
7729: xmlFree((xmlChar **) tab);
7730: return(NULL);
7731: }
7732: }
7733: }
7734: xmlFree((xmlChar **) tab);
7735: return(ret);
7736: }
7737:
7738: /**
7739: * xmlExpExpDerive:
7740: * @ctxt: the expressions context
7741: * @exp: the englobing expression
7742: * @sub: the subexpression
7743: *
7744: * Evaluates the expression resulting from @exp consuming a sub expression @sub
7745: * Based on algebraic derivation and sometimes direct Brzozowski derivation
7746: * it usually tatkes less than linear time and can handle expressions generating
7747: * infinite languages.
7748: *
7749: * Returns the resulting expression or NULL in case of internal error, the
7750: * result must be freed
7751: */
7752: xmlExpNodePtr
7753: xmlExpExpDerive(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
7754: if ((exp == NULL) || (ctxt == NULL) || (sub == NULL))
7755: return(NULL);
7756:
7757: /*
7758: * O(1) speedups
7759: */
7760: if (IS_NILLABLE(sub) && (!IS_NILLABLE(exp))) {
7761: #ifdef DEBUG_DERIV
7762: printf("Sub nillable and not exp : can't subsume\n");
7763: #endif
7764: return(forbiddenExp);
7765: }
7766: if (xmlExpCheckCard(exp, sub) == 0) {
7767: #ifdef DEBUG_DERIV
7768: printf("sub generate longuer sequances than exp : can't subsume\n");
7769: #endif
7770: return(forbiddenExp);
7771: }
7772: return(xmlExpExpDeriveInt(ctxt, exp, sub));
7773: }
7774:
7775: /**
7776: * xmlExpSubsume:
7777: * @ctxt: the expressions context
7778: * @exp: the englobing expression
7779: * @sub: the subexpression
7780: *
7781: * Check whether @exp accepts all the languages accexpted by @sub
7782: * the input being a subexpression.
7783: *
7784: * Returns 1 if true 0 if false and -1 in case of failure.
7785: */
7786: int
7787: xmlExpSubsume(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
7788: xmlExpNodePtr tmp;
7789:
7790: if ((exp == NULL) || (ctxt == NULL) || (sub == NULL))
7791: return(-1);
7792:
7793: /*
7794: * TODO: speedup by checking the language of sub is a subset of the
7795: * language of exp
7796: */
7797: /*
7798: * O(1) speedups
7799: */
7800: if (IS_NILLABLE(sub) && (!IS_NILLABLE(exp))) {
7801: #ifdef DEBUG_DERIV
7802: printf("Sub nillable and not exp : can't subsume\n");
7803: #endif
7804: return(0);
7805: }
7806: if (xmlExpCheckCard(exp, sub) == 0) {
7807: #ifdef DEBUG_DERIV
7808: printf("sub generate longuer sequances than exp : can't subsume\n");
7809: #endif
7810: return(0);
7811: }
7812: tmp = xmlExpExpDeriveInt(ctxt, exp, sub);
7813: #ifdef DEBUG_DERIV
7814: printf("Result derivation :\n");
7815: PRINT_EXP(tmp);
7816: #endif
7817: if (tmp == NULL)
7818: return(-1);
7819: if (tmp == forbiddenExp)
7820: return(0);
7821: if (tmp == emptyExp)
7822: return(1);
7823: if ((tmp != NULL) && (IS_NILLABLE(tmp))) {
7824: xmlExpFree(ctxt, tmp);
7825: return(1);
7826: }
7827: xmlExpFree(ctxt, tmp);
7828: return(0);
7829: }
7830:
7831: /************************************************************************
7832: * *
7833: * Parsing expression *
7834: * *
7835: ************************************************************************/
7836:
7837: static xmlExpNodePtr xmlExpParseExpr(xmlExpCtxtPtr ctxt);
7838:
7839: #undef CUR
7840: #define CUR (*ctxt->cur)
7841: #undef NEXT
7842: #define NEXT ctxt->cur++;
7843: #undef IS_BLANK
7844: #define IS_BLANK(c) ((c == ' ') || (c == '\n') || (c == '\r') || (c == '\t'))
7845: #define SKIP_BLANKS while (IS_BLANK(*ctxt->cur)) ctxt->cur++;
7846:
7847: static int
7848: xmlExpParseNumber(xmlExpCtxtPtr ctxt) {
7849: int ret = 0;
7850:
7851: SKIP_BLANKS
7852: if (CUR == '*') {
7853: NEXT
7854: return(-1);
7855: }
7856: if ((CUR < '0') || (CUR > '9'))
7857: return(-1);
7858: while ((CUR >= '0') && (CUR <= '9')) {
7859: ret = ret * 10 + (CUR - '0');
7860: NEXT
7861: }
7862: return(ret);
7863: }
7864:
7865: static xmlExpNodePtr
7866: xmlExpParseOr(xmlExpCtxtPtr ctxt) {
7867: const char *base;
7868: xmlExpNodePtr ret;
7869: const xmlChar *val;
7870:
7871: SKIP_BLANKS
7872: base = ctxt->cur;
7873: if (*ctxt->cur == '(') {
7874: NEXT
7875: ret = xmlExpParseExpr(ctxt);
7876: SKIP_BLANKS
7877: if (*ctxt->cur != ')') {
7878: fprintf(stderr, "unbalanced '(' : %s\n", base);
7879: xmlExpFree(ctxt, ret);
7880: return(NULL);
7881: }
7882: NEXT;
7883: SKIP_BLANKS
7884: goto parse_quantifier;
7885: }
7886: while ((CUR != 0) && (!(IS_BLANK(CUR))) && (CUR != '(') &&
7887: (CUR != ')') && (CUR != '|') && (CUR != ',') && (CUR != '{') &&
7888: (CUR != '*') && (CUR != '+') && (CUR != '?') && (CUR != '}'))
7889: NEXT;
7890: val = xmlDictLookup(ctxt->dict, BAD_CAST base, ctxt->cur - base);
7891: if (val == NULL)
7892: return(NULL);
7893: ret = xmlExpHashGetEntry(ctxt, XML_EXP_ATOM, NULL, NULL, val, 0, 0);
7894: if (ret == NULL)
7895: return(NULL);
7896: SKIP_BLANKS
7897: parse_quantifier:
7898: if (CUR == '{') {
7899: int min, max;
7900:
7901: NEXT
7902: min = xmlExpParseNumber(ctxt);
7903: if (min < 0) {
7904: xmlExpFree(ctxt, ret);
7905: return(NULL);
7906: }
7907: SKIP_BLANKS
7908: if (CUR == ',') {
7909: NEXT
7910: max = xmlExpParseNumber(ctxt);
7911: SKIP_BLANKS
7912: } else
7913: max = min;
7914: if (CUR != '}') {
7915: xmlExpFree(ctxt, ret);
7916: return(NULL);
7917: }
7918: NEXT
7919: ret = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, ret, NULL, NULL,
7920: min, max);
7921: SKIP_BLANKS
7922: } else if (CUR == '?') {
7923: NEXT
7924: ret = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, ret, NULL, NULL,
7925: 0, 1);
7926: SKIP_BLANKS
7927: } else if (CUR == '+') {
7928: NEXT
7929: ret = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, ret, NULL, NULL,
7930: 1, -1);
7931: SKIP_BLANKS
7932: } else if (CUR == '*') {
7933: NEXT
7934: ret = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, ret, NULL, NULL,
7935: 0, -1);
7936: SKIP_BLANKS
7937: }
7938: return(ret);
7939: }
7940:
7941:
7942: static xmlExpNodePtr
7943: xmlExpParseSeq(xmlExpCtxtPtr ctxt) {
7944: xmlExpNodePtr ret, right;
7945:
7946: ret = xmlExpParseOr(ctxt);
7947: SKIP_BLANKS
7948: while (CUR == '|') {
7949: NEXT
7950: right = xmlExpParseOr(ctxt);
7951: if (right == NULL) {
7952: xmlExpFree(ctxt, ret);
7953: return(NULL);
7954: }
7955: ret = xmlExpHashGetEntry(ctxt, XML_EXP_OR, ret, right, NULL, 0, 0);
7956: if (ret == NULL)
7957: return(NULL);
7958: }
7959: return(ret);
7960: }
7961:
7962: static xmlExpNodePtr
7963: xmlExpParseExpr(xmlExpCtxtPtr ctxt) {
7964: xmlExpNodePtr ret, right;
7965:
7966: ret = xmlExpParseSeq(ctxt);
7967: SKIP_BLANKS
7968: while (CUR == ',') {
7969: NEXT
7970: right = xmlExpParseSeq(ctxt);
7971: if (right == NULL) {
7972: xmlExpFree(ctxt, ret);
7973: return(NULL);
7974: }
7975: ret = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret, right, NULL, 0, 0);
7976: if (ret == NULL)
7977: return(NULL);
7978: }
7979: return(ret);
7980: }
7981:
7982: /**
7983: * xmlExpParse:
7984: * @ctxt: the expressions context
7985: * @expr: the 0 terminated string
7986: *
7987: * Minimal parser for regexps, it understand the following constructs
7988: * - string terminals
7989: * - choice operator |
7990: * - sequence operator ,
7991: * - subexpressions (...)
7992: * - usual cardinality operators + * and ?
7993: * - finite sequences { min, max }
7994: * - infinite sequences { min, * }
7995: * There is minimal checkings made especially no checking on strings values
7996: *
7997: * Returns a new expression or NULL in case of failure
7998: */
7999: xmlExpNodePtr
8000: xmlExpParse(xmlExpCtxtPtr ctxt, const char *expr) {
8001: xmlExpNodePtr ret;
8002:
8003: ctxt->expr = expr;
8004: ctxt->cur = expr;
8005:
8006: ret = xmlExpParseExpr(ctxt);
8007: SKIP_BLANKS
8008: if (*ctxt->cur != 0) {
8009: xmlExpFree(ctxt, ret);
8010: return(NULL);
8011: }
8012: return(ret);
8013: }
8014:
8015: static void
8016: xmlExpDumpInt(xmlBufferPtr buf, xmlExpNodePtr expr, int glob) {
8017: xmlExpNodePtr c;
8018:
8019: if (expr == NULL) return;
8020: if (glob) xmlBufferWriteChar(buf, "(");
8021: switch (expr->type) {
8022: case XML_EXP_EMPTY:
8023: xmlBufferWriteChar(buf, "empty");
8024: break;
8025: case XML_EXP_FORBID:
8026: xmlBufferWriteChar(buf, "forbidden");
8027: break;
8028: case XML_EXP_ATOM:
8029: xmlBufferWriteCHAR(buf, expr->exp_str);
8030: break;
8031: case XML_EXP_SEQ:
8032: c = expr->exp_left;
8033: if ((c->type == XML_EXP_SEQ) || (c->type == XML_EXP_OR))
8034: xmlExpDumpInt(buf, c, 1);
8035: else
8036: xmlExpDumpInt(buf, c, 0);
8037: xmlBufferWriteChar(buf, " , ");
8038: c = expr->exp_right;
8039: if ((c->type == XML_EXP_SEQ) || (c->type == XML_EXP_OR))
8040: xmlExpDumpInt(buf, c, 1);
8041: else
8042: xmlExpDumpInt(buf, c, 0);
8043: break;
8044: case XML_EXP_OR:
8045: c = expr->exp_left;
8046: if ((c->type == XML_EXP_SEQ) || (c->type == XML_EXP_OR))
8047: xmlExpDumpInt(buf, c, 1);
8048: else
8049: xmlExpDumpInt(buf, c, 0);
8050: xmlBufferWriteChar(buf, " | ");
8051: c = expr->exp_right;
8052: if ((c->type == XML_EXP_SEQ) || (c->type == XML_EXP_OR))
8053: xmlExpDumpInt(buf, c, 1);
8054: else
8055: xmlExpDumpInt(buf, c, 0);
8056: break;
8057: case XML_EXP_COUNT: {
8058: char rep[40];
8059:
8060: c = expr->exp_left;
8061: if ((c->type == XML_EXP_SEQ) || (c->type == XML_EXP_OR))
8062: xmlExpDumpInt(buf, c, 1);
8063: else
8064: xmlExpDumpInt(buf, c, 0);
8065: if ((expr->exp_min == 0) && (expr->exp_max == 1)) {
8066: rep[0] = '?';
8067: rep[1] = 0;
8068: } else if ((expr->exp_min == 0) && (expr->exp_max == -1)) {
8069: rep[0] = '*';
8070: rep[1] = 0;
8071: } else if ((expr->exp_min == 1) && (expr->exp_max == -1)) {
8072: rep[0] = '+';
8073: rep[1] = 0;
8074: } else if (expr->exp_max == expr->exp_min) {
8075: snprintf(rep, 39, "{%d}", expr->exp_min);
8076: } else if (expr->exp_max < 0) {
8077: snprintf(rep, 39, "{%d,inf}", expr->exp_min);
8078: } else {
8079: snprintf(rep, 39, "{%d,%d}", expr->exp_min, expr->exp_max);
8080: }
8081: rep[39] = 0;
8082: xmlBufferWriteChar(buf, rep);
8083: break;
8084: }
8085: default:
8086: fprintf(stderr, "Error in tree\n");
8087: }
8088: if (glob)
8089: xmlBufferWriteChar(buf, ")");
8090: }
8091: /**
8092: * xmlExpDump:
8093: * @buf: a buffer to receive the output
8094: * @expr: the compiled expression
8095: *
8096: * Serialize the expression as compiled to the buffer
8097: */
8098: void
8099: xmlExpDump(xmlBufferPtr buf, xmlExpNodePtr expr) {
8100: if ((buf == NULL) || (expr == NULL))
8101: return;
8102: xmlExpDumpInt(buf, expr, 0);
8103: }
8104:
8105: /**
8106: * xmlExpMaxToken:
8107: * @expr: a compiled expression
8108: *
8109: * Indicate the maximum number of input a expression can accept
8110: *
8111: * Returns the maximum length or -1 in case of error
8112: */
8113: int
8114: xmlExpMaxToken(xmlExpNodePtr expr) {
8115: if (expr == NULL)
8116: return(-1);
8117: return(expr->c_max);
8118: }
8119:
8120: /**
8121: * xmlExpCtxtNbNodes:
8122: * @ctxt: an expression context
8123: *
8124: * Debugging facility provides the number of allocated nodes at a that point
8125: *
8126: * Returns the number of nodes in use or -1 in case of error
8127: */
8128: int
8129: xmlExpCtxtNbNodes(xmlExpCtxtPtr ctxt) {
8130: if (ctxt == NULL)
8131: return(-1);
8132: return(ctxt->nb_nodes);
8133: }
8134:
8135: /**
8136: * xmlExpCtxtNbCons:
8137: * @ctxt: an expression context
8138: *
8139: * Debugging facility provides the number of allocated nodes over lifetime
8140: *
8141: * Returns the number of nodes ever allocated or -1 in case of error
8142: */
8143: int
8144: xmlExpCtxtNbCons(xmlExpCtxtPtr ctxt) {
8145: if (ctxt == NULL)
8146: return(-1);
8147: return(ctxt->nb_cons);
8148: }
8149:
8150: #endif /* LIBXML_EXPR_ENABLED */
8151: #define bottom_xmlregexp
8152: #include "elfgcchack.h"
8153: #endif /* LIBXML_REGEXP_ENABLED */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xmlregexp.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