Lines Matching defs:ctxt
51 ctxt->error = XML_REGEXP_COMPILE_ERROR; \
52 xmlRegexpErrCompile(ctxt, str);
53 #define NEXT ctxt->cur++
54 #define CUR (*(ctxt->cur))
55 #define NXT(index) (ctxt->cur[index])
58 #define NEXTL(l) ctxt->cur += l;
62 * when it's guaranteed that cur is not at the beginning of ctxt->string!
64 #define PREV (ctxt->cur[-1])
356 static void xmlFAParseRegExp(xmlRegParserCtxtPtr ctxt, int top);
378 xmlRegexpErrMemory(xmlRegParserCtxtPtr ctxt, const char *extra)
381 if (ctxt != NULL) {
382 regexp = (const char *) ctxt->string;
383 ctxt->error = XML_ERR_NO_MEMORY;
398 xmlRegexpErrCompile(xmlRegParserCtxtPtr ctxt, const char *extra)
403 if (ctxt != NULL) {
404 regexp = (const char *) ctxt->string;
405 idx = ctxt->cur - ctxt->string;
406 ctxt->error = XML_REGEXP_COMPILE_ERROR;
420 static int xmlFAComputesDeterminism(xmlRegParserCtxtPtr ctxt);
423 * @ctxt: the parser context used to build it
430 xmlRegEpxFromParse(xmlRegParserCtxtPtr ctxt) {
435 xmlRegexpErrMemory(ctxt, "compiling regexp");
439 ret->string = ctxt->string;
440 ret->nbStates = ctxt->nbStates;
441 ret->states = ctxt->states;
442 ret->nbAtoms = ctxt->nbAtoms;
443 ret->atoms = ctxt->atoms;
444 ret->nbCounters = ctxt->nbCounters;
445 ret->counters = ctxt->counters;
446 ret->determinist = ctxt->determinist;
447 ret->flags = ctxt->flags;
454 (ctxt->negs == 0) &&
476 xmlRegexpErrMemory(ctxt, "compiling regexp");
493 xmlRegexpErrMemory(ctxt, "compiling regexp");
500 xmlRegexpErrMemory(ctxt, "compiling regexp");
584 xmlRegexpErrMemory(ctxt, "compiling regexp");
666 ctxt->string = NULL;
667 ctxt->nbStates = 0;
668 ctxt->states = NULL;
669 ctxt->nbAtoms = 0;
670 ctxt->atoms = NULL;
671 ctxt->nbCounters = 0;
672 ctxt->counters = NULL;
704 * @ctxt: the regexp parser context
715 xmlRegNewRange(xmlRegParserCtxtPtr ctxt,
721 xmlRegexpErrMemory(ctxt, "allocating range");
756 xmlRegCopyRange(xmlRegParserCtxtPtr ctxt, xmlRegRangePtr range) {
762 ret = xmlRegNewRange(ctxt, range->neg, range->type, range->start,
769 xmlRegexpErrMemory(ctxt, "allocating range");
779 * @ctxt: the regexp parser context
787 xmlRegNewAtom(xmlRegParserCtxtPtr ctxt, xmlRegAtomType type) {
792 xmlRegexpErrMemory(ctxt, "allocating atom");
831 * @ctxt: the regexp parser context
839 xmlRegCopyAtom(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom) {
844 xmlRegexpErrMemory(ctxt, "copying atom");
858 xmlRegexpErrMemory(ctxt, "copying atom");
862 ret->ranges[i] = xmlRegCopyRange(ctxt, atom->ranges[i]);
876 xmlRegNewState(xmlRegParserCtxtPtr ctxt) {
881 xmlRegexpErrMemory(ctxt, "allocating state");
910 * @ctxt: the regexp parser context
915 xmlRegFreeParserCtxt(xmlRegParserCtxtPtr ctxt) {
917 if (ctxt == NULL)
920 if (ctxt->string != NULL)
921 xmlFree(ctxt->string);
922 if (ctxt->states != NULL) {
923 for (i = 0;i < ctxt->nbStates;i++)
924 xmlRegFreeState(ctxt->states[i]);
925 xmlFree(ctxt->states);
927 if (ctxt->atoms != NULL) {
928 for (i = 0;i < ctxt->nbAtoms;i++)
929 xmlRegFreeAtom(ctxt->atoms[i]);
930 xmlFree(ctxt->atoms);
932 if (ctxt->counters != NULL)
933 xmlFree(ctxt->counters);
934 xmlFree(ctxt);
1170 xmlRegPrintCtxt(FILE *output, xmlRegParserCtxtPtr ctxt) {
1173 fprintf(output, " ctxt: ");
1174 if (ctxt == NULL) {
1178 fprintf(output, "'%s' ", ctxt->string);
1179 if (ctxt->error)
1181 if (ctxt->neg)
1184 fprintf(output, "%d atoms:\n", ctxt->nbAtoms);
1185 for (i = 0;i < ctxt->nbAtoms; i++) {
1187 xmlRegPrintAtom(output, ctxt->atoms[i]);
1189 if (ctxt->atom != NULL) {
1191 xmlRegPrintAtom(output, ctxt->atom);
1193 fprintf(output, "%d states:", ctxt->nbStates);
1194 if (ctxt->start != NULL)
1195 fprintf(output, " start: %d", ctxt->start->no);
1196 if (ctxt->end != NULL)
1197 fprintf(output, " end: %d", ctxt->end->no);
1199 for (i = 0;i < ctxt->nbStates; i++) {
1200 xmlRegPrintState(output, ctxt->states[i]);
1202 fprintf(output, "%d counters:\n", ctxt->nbCounters);
1203 for (i = 0;i < ctxt->nbCounters; i++) {
1204 fprintf(output, " %d: min %d max %d\n", i, ctxt->counters[i].min,
1205 ctxt->counters[i].max);
1217 xmlRegAtomAddRange(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom,
1235 xmlRegexpErrMemory(ctxt, "adding ranges");
1245 xmlRegexpErrMemory(ctxt, "adding ranges");
1251 range = xmlRegNewRange(ctxt, neg, type, start, end);
1260 xmlRegGetCounter(xmlRegParserCtxtPtr ctxt) {
1261 if (ctxt->maxCounters == 0) {
1262 ctxt->maxCounters = 4;
1263 ctxt->counters = (xmlRegCounter *) xmlMalloc(ctxt->maxCounters *
1265 if (ctxt->counters == NULL) {
1266 xmlRegexpErrMemory(ctxt, "allocating counter");
1267 ctxt->maxCounters = 0;
1270 } else if (ctxt->nbCounters >= ctxt->maxCounters) {
1272 ctxt->maxCounters *= 2;
1273 tmp = (xmlRegCounter *) xmlRealloc(ctxt->counters, ctxt->maxCounters *
1276 xmlRegexpErrMemory(ctxt, "allocating counter");
1277 ctxt->maxCounters /= 2;
1280 ctxt->counters = tmp;
1282 ctxt->counters[ctxt->nbCounters].min = -1;
1283 ctxt->counters[ctxt->nbCounters].max = -1;
1284 return(ctxt->nbCounters++);
1288 xmlRegAtomPush(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom) {
1293 if (ctxt->maxAtoms == 0) {
1294 ctxt->maxAtoms = 4;
1295 ctxt->atoms = (xmlRegAtomPtr *) xmlMalloc(ctxt->maxAtoms *
1297 if (ctxt->atoms == NULL) {
1298 xmlRegexpErrMemory(ctxt, "pushing atom");
1299 ctxt->maxAtoms = 0;
1302 } else if (ctxt->nbAtoms >= ctxt->maxAtoms) {
1304 ctxt->maxAtoms *= 2;
1305 tmp = (xmlRegAtomPtr *) xmlRealloc(ctxt->atoms, ctxt->maxAtoms *
1308 xmlRegexpErrMemory(ctxt, "allocating counter");
1309 ctxt->maxAtoms /= 2;
1312 ctxt->atoms = tmp;
1314 atom->no = ctxt->nbAtoms;
1315 ctxt->atoms[ctxt->nbAtoms++] = atom;
1320 xmlRegStateAddTransTo(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr target,
1327 xmlRegexpErrMemory(ctxt, "adding transition");
1337 xmlRegexpErrMemory(ctxt, "adding transition");
1348 xmlRegStateAddTrans(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state,
1387 xmlRegexpErrMemory(ctxt, "adding transition");
1397 xmlRegexpErrMemory(ctxt, "adding transition");
1423 xmlRegStateAddTransTo(ctxt, target, state->no);
1427 xmlRegStatePush(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state) {
1429 if (ctxt->maxStates == 0) {
1430 ctxt->maxStates = 4;
1431 ctxt->states = (xmlRegStatePtr *) xmlMalloc(ctxt->maxStates *
1433 if (ctxt->states == NULL) {
1434 xmlRegexpErrMemory(ctxt, "adding state");
1435 ctxt->maxStates = 0;
1438 } else if (ctxt->nbStates >= ctxt->maxStates) {
1440 ctxt->maxStates *= 2;
1441 tmp = (xmlRegStatePtr *) xmlRealloc(ctxt->states, ctxt->maxStates *
1444 xmlRegexpErrMemory(ctxt, "adding state");
1445 ctxt->maxStates /= 2;
1448 ctxt->states = tmp;
1450 state->no = ctxt->nbStates;
1451 ctxt->states[ctxt->nbStates++] = state;
1457 * @ctxt: a regexp parser context
1464 xmlFAGenerateAllTransition(xmlRegParserCtxtPtr ctxt,
1468 to = xmlRegNewState(ctxt);
1469 xmlRegStatePush(ctxt, to);
1470 ctxt->state = to;
1473 xmlRegStateAddTrans(ctxt, from, NULL, to, -1, REGEXP_ALL_LAX_COUNTER);
1475 xmlRegStateAddTrans(ctxt, from, NULL, to, -1, REGEXP_ALL_COUNTER);
1480 * @ctxt: a regexp parser context
1486 xmlFAGenerateEpsilonTransition(xmlRegParserCtxtPtr ctxt,
1489 to = xmlRegNewState(ctxt);
1490 xmlRegStatePush(ctxt, to);
1491 ctxt->state = to;
1493 xmlRegStateAddTrans(ctxt, from, NULL, to, -1, -1);
1498 * @ctxt: a regexp parser context
1505 xmlFAGenerateCountedEpsilonTransition(xmlRegParserCtxtPtr ctxt,
1508 to = xmlRegNewState(ctxt);
1509 xmlRegStatePush(ctxt, to);
1510 ctxt->state = to;
1512 xmlRegStateAddTrans(ctxt, from, NULL, to, counter, -1);
1517 * @ctxt: a regexp parser context
1524 xmlFAGenerateCountedTransition(xmlRegParserCtxtPtr ctxt,
1527 to = xmlRegNewState(ctxt);
1528 xmlRegStatePush(ctxt, to);
1529 ctxt->state = to;
1531 xmlRegStateAddTrans(ctxt, from, NULL, to, -1, counter);
1536 * @ctxt: a regexp parser context
1544 xmlFAGenerateTransitions(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr from,
1558 if (xmlRegAtomPush(ctxt, atom) < 0) {
1566 xmlFAGenerateEpsilonTransition(ctxt, atom->stop, to);
1570 to = xmlRegNewState(ctxt);
1571 xmlRegStatePush(ctxt, to);
1572 ctxt->state = to;
1573 xmlFAGenerateEpsilonTransition(ctxt, atom->stop, to);
1585 xmlFAGenerateEpsilonTransition(ctxt, atom->start, 0);
1586 xmlFAGenerateEpsilonTransition(ctxt, atom->stop,
1587 ctxt->state);
1589 xmlFAGenerateEpsilonTransition(ctxt, atom->start, to);
1594 xmlFAGenerateEpsilonTransition(ctxt, atom->start, atom->stop);
1595 xmlFAGenerateEpsilonTransition(ctxt, atom->stop, atom->start);
1599 xmlFAGenerateEpsilonTransition(ctxt, atom->stop, atom->start);
1611 newstate = xmlRegNewState(ctxt);
1612 xmlRegStatePush(ctxt, newstate);
1632 copy = xmlRegCopyAtom(ctxt, atom);
1639 if (xmlFAGenerateTransitions(ctxt, atom->start, NULL, copy)
1642 inter = ctxt->state;
1643 counter = xmlRegGetCounter(ctxt);
1644 ctxt->counters[counter].min = atom->min - 1;
1645 ctxt->counters[counter].max = atom->max - 1;
1647 xmlFAGenerateCountedEpsilonTransition(ctxt, inter,
1650 xmlFAGenerateCountedTransition(ctxt, inter,
1653 xmlFAGenerateEpsilonTransition(ctxt, atom->start,
1661 counter = xmlRegGetCounter(ctxt);
1662 ctxt->counters[counter].min = atom->min - 1;
1663 ctxt->counters[counter].max = atom->max - 1;
1665 xmlFAGenerateCountedEpsilonTransition(ctxt, atom->stop,
1668 xmlFAGenerateCountedTransition(ctxt, atom->stop,
1672 xmlFAGenerateEpsilonTransition(ctxt, atom->start0,
1679 ctxt->state = newstate;
1692 to = xmlRegNewState(ctxt);
1694 xmlRegStatePush(ctxt, to);
1699 xmlFAGenerateEpsilonTransition(ctxt, from, to);
1700 ctxt->state = to;
1705 to = xmlRegNewState(ctxt);
1707 xmlRegStatePush(ctxt, to);
1722 tmp = xmlRegNewState(ctxt);
1724 xmlRegStatePush(ctxt, tmp);
1728 xmlFAGenerateEpsilonTransition(ctxt, tmp, to);
1731 if (xmlRegAtomPush(ctxt, atom) < 0) {
1741 xmlRegStateAddTrans(ctxt, from, atom, to, -1, -1);
1742 ctxt->state = end;
1746 xmlFAGenerateEpsilonTransition(ctxt, from, to);
1750 xmlFAGenerateEpsilonTransition(ctxt, from, to);
1751 xmlRegStateAddTrans(ctxt, to, atom, to, -1, -1);
1755 xmlRegStateAddTrans(ctxt, to, atom, to, -1, -1);
1759 xmlFAGenerateEpsilonTransition(ctxt, from, to);
1769 * @ctxt: a regexp parser context
1776 xmlFAReduceEpsilonTransitions(xmlRegParserCtxtPtr ctxt, int fromnr,
1785 from = ctxt->states[fromnr];
1788 to = ctxt->states[tonr];
1814 xmlRegStateAddTrans(ctxt, from, NULL,
1815 ctxt->states[newto],
1823 xmlFAReduceEpsilonTransitions(ctxt, fromnr,
1827 xmlFAReduceEpsilonTransitions(ctxt, fromnr,
1837 xmlRegStateAddTrans(ctxt, from, to->trans[transnr].atom,
1838 ctxt->states[newto],
1841 xmlRegStateAddTrans(ctxt, from, to->trans[transnr].atom,
1842 ctxt->states[newto], counter, -1);
1851 * @ctxt: a regexp parser context
1865 xmlFAEliminateSimpleEpsilonTransitions(xmlRegParserCtxtPtr ctxt) {
1869 for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
1870 state = ctxt->states[statenr];
1896 tmp = ctxt->states[state->transTo[i]];
1904 xmlRegStateAddTrans(ctxt, tmp, tmp->trans[j].atom,
1905 ctxt->states[newto],
1912 ctxt->states[newto]->type = XML_REGEXP_FINAL_STATE;
1925 * @ctxt: a regexp parser context
1929 xmlFAEliminateEpsilonTransitions(xmlRegParserCtxtPtr ctxt) {
1934 if (ctxt->states == NULL) return;
1940 xmlFAEliminateSimpleEpsilonTransitions(ctxt);
1941 for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
1942 state = ctxt->states[statenr];
1948 ctxt->states[statenr] = NULL;
1962 for (statenr = ctxt->nbStates - 1;statenr >= 0;statenr--) {
1963 state = ctxt->states[statenr];
1989 xmlFAReduceEpsilonTransitions(ctxt, statenr,
2005 for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
2006 state = ctxt->states[statenr];
2023 for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
2024 state = ctxt->states[statenr];
2028 state = ctxt->states[0];
2043 if (ctxt->states[newto] == NULL)
2045 if (ctxt->states[newto]->reached == XML_REGEXP_MARK_NORMAL) {
2046 ctxt->states[newto]->reached = XML_REGEXP_MARK_START;
2047 target = ctxt->states[newto];
2056 for (statenr = 1;statenr < ctxt->nbStates;statenr++) {
2057 state = ctxt->states[statenr];
2067 for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
2068 state = ctxt->states[statenr];
2074 ctxt->states[statenr] = NULL;
2581 * @ctxt: a regexp parser context
2588 xmlFARecurseDeterminism(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state,
2601 if (ctxt->flags & AM_AUTOMATA_RNG)
2618 res = xmlFARecurseDeterminism(ctxt, ctxt->states[t1->to],
2640 * @ctxt: a regexp parser context
2647 xmlFAComputesDeterminism(xmlRegParserCtxtPtr ctxt) {
2657 xmlRegPrintCtxt(stdout, ctxt);
2659 if (ctxt->determinist != -1)
2660 return(ctxt->determinist);
2662 if (ctxt->flags & AM_AUTOMATA_RNG)
2668 for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
2669 state = ctxt->states[statenr];
2710 for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
2711 state = ctxt->states[statenr];
2749 ret = xmlFARecurseDeterminism(ctxt, ctxt->states[t1->to],
2784 ctxt->determinist = ret;
4591 * @ctxt: a regexp parser context
4596 xmlFAIsChar(xmlRegParserCtxtPtr ctxt) {
4600 cur = CUR_SCHAR(ctxt->cur, len);
4611 * @ctxt: a regexp parser context
4626 xmlFAParseCharProp(xmlRegParserCtxtPtr ctxt) {
4800 start = ctxt->cur;
4817 blockName = xmlStrndup(start, ctxt->cur - start);
4822 if (ctxt->atom == NULL) {
4823 ctxt->atom = xmlRegNewAtom(ctxt, type);
4824 if (ctxt->atom != NULL)
4825 ctxt->atom->valuep = blockName;
4826 } else if (ctxt->atom->type == XML_REGEXP_RANGES) {
4827 xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
4834 * @ctxt: a regexp parser context
4843 xmlFAParseCharClassEsc(xmlRegParserCtxtPtr ctxt) {
4847 if (ctxt->atom == NULL) {
4848 ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_ANYCHAR);
4849 } else if (ctxt->atom->type == XML_REGEXP_RANGES) {
4850 xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
4869 xmlFAParseCharProp(ctxt);
4882 xmlFAParseCharProp(ctxt);
4883 ctxt->atom->neg = 1;
4894 if (ctxt->atom == NULL) {
4895 ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_CHARVAL);
4896 if (ctxt->atom != NULL) {
4899 ctxt->atom->codepoint = '\n';
4902 ctxt->atom->codepoint = '\r';
4905 ctxt->atom->codepoint = '\t';
4908 ctxt->atom->codepoint = cur;
4911 } else if (ctxt->atom->type == XML_REGEXP_RANGES) {
4923 xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
4965 if (ctxt->atom == NULL) {
4966 ctxt->atom = xmlRegNewAtom(ctxt, type);
4967 } else if (ctxt->atom->type == XML_REGEXP_RANGES) {
4968 xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
4978 * @ctxt: a regexp parser context
4987 xmlFAParseCharRange(xmlRegParserCtxtPtr ctxt) {
5016 end = start = CUR_SCHAR(ctxt->cur, len);
5022 * Since we are "inside" a range, we can assume ctxt->cur is past
5023 * the start of ctxt->string, and PREV should be safe
5032 xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
5055 end = CUR_SCHAR(ctxt->cur, len);
5066 xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
5074 * @ctxt: a regexp parser context
5079 xmlFAParsePosCharGroup(xmlRegParserCtxtPtr ctxt) {
5082 xmlFAParseCharClassEsc(ctxt);
5084 xmlFAParseCharRange(ctxt);
5087 (CUR != 0) && (ctxt->error == 0));
5092 * @ctxt: a regexp parser context
5100 xmlFAParseCharGroup(xmlRegParserCtxtPtr ctxt) {
5101 int n = ctxt->neg;
5102 while ((CUR != ']') && (ctxt->error == 0)) {
5104 int neg = ctxt->neg;
5107 ctxt->neg = !ctxt->neg;
5108 xmlFAParsePosCharGroup(ctxt);
5109 ctxt->neg = neg;
5111 int neg = ctxt->neg;
5112 ctxt->neg = 2;
5115 xmlFAParseCharGroup(ctxt);
5122 ctxt->neg = neg;
5125 xmlFAParsePosCharGroup(ctxt);
5128 ctxt->neg = n;
5133 * @ctxt: a regexp parser context
5139 xmlFAParseCharClass(xmlRegParserCtxtPtr ctxt) {
5142 ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_RANGES);
5143 if (ctxt->atom == NULL)
5145 xmlFAParseCharGroup(ctxt);
5152 xmlFAParseCharClassEsc(ctxt);
5158 * @ctxt: a regexp parser context
5165 xmlFAParseQuantExact(xmlRegParserCtxtPtr ctxt) {
5182 * @ctxt: a regexp parser context
5191 xmlFAParseQuantifier(xmlRegParserCtxtPtr ctxt) {
5196 if (ctxt->atom != NULL) {
5198 ctxt->atom->quant = XML_REGEXP_QUANT_OPT;
5200 ctxt->atom->quant = XML_REGEXP_QUANT_MULT;
5202 ctxt->atom->quant = XML_REGEXP_QUANT_PLUS;
5211 cur = xmlFAParseQuantExact(ctxt);
5219 cur = xmlFAParseQuantExact(ctxt);
5234 if (ctxt->atom != NULL) {
5235 ctxt->atom->quant = XML_REGEXP_QUANT_RANGE;
5236 ctxt->atom->min = min;
5237 ctxt->atom->max = max;
5246 * @ctxt: a regexp parser context
5251 xmlFAParseAtom(xmlRegParserCtxtPtr ctxt) {
5254 codepoint = xmlFAIsChar(ctxt);
5256 ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_CHARVAL);
5257 if (ctxt->atom == NULL)
5259 codepoint = CUR_SCHAR(ctxt->cur, len);
5260 ctxt->atom->codepoint = codepoint;
5277 xmlFAGenerateEpsilonTransition(ctxt, ctxt->state, NULL);
5278 start0 = ctxt->state;
5279 xmlFAGenerateEpsilonTransition(ctxt, ctxt->state, NULL);
5280 start = ctxt->state;
5281 oldend = ctxt->end;
5282 ctxt->end = NULL;
5283 ctxt->atom = NULL;
5284 xmlFAParseRegExp(ctxt, 0);
5290 ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_SUBREG);
5291 if (ctxt->atom == NULL)
5293 ctxt->atom->start = start;
5294 ctxt->atom->start0 = start0;
5295 ctxt->atom->stop = ctxt->state;
5296 ctxt->end = oldend;
5299 xmlFAParseCharClass(ctxt);
5307 * @ctxt: a regexp parser context
5312 xmlFAParsePiece(xmlRegParserCtxtPtr ctxt) {
5315 ctxt->atom = NULL;
5316 ret = xmlFAParseAtom(ctxt);
5319 if (ctxt->atom == NULL) {
5322 xmlFAParseQuantifier(ctxt);
5328 * @ctxt: a regexp parser context
5337 xmlFAParseBranch(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr to) {
5341 previous = ctxt->state;
5342 ret = xmlFAParsePiece(ctxt);
5344 if (xmlFAGenerateTransitions(ctxt, previous,
5345 (CUR=='|' || CUR==')') ? to : NULL, ctxt->atom) < 0)
5347 previous = ctxt->state;
5348 ctxt->atom = NULL;
5350 while ((ret != 0) && (ctxt->error == 0)) {
5351 ret = xmlFAParsePiece(ctxt);
5353 if (xmlFAGenerateTransitions(ctxt, previous,
5354 (CUR=='|' || CUR==')') ? to : NULL, ctxt->atom) < 0)
5356 previous = ctxt->state;
5357 ctxt->atom = NULL;
5365 * @ctxt: a regexp parser context
5371 xmlFAParseRegExp(xmlRegParserCtxtPtr ctxt, int top) {
5375 start = ctxt->state;
5376 ctxt->end = NULL;
5377 xmlFAParseBranch(ctxt, NULL);
5380 printf("State %d is final\n", ctxt->state->no);
5382 ctxt->state->type = XML_REGEXP_FINAL_STATE;
5385 ctxt->end = ctxt->state;
5388 end = ctxt->state;
5389 while ((CUR == '|') && (ctxt->error == 0)) {
5395 ctxt->state = start;
5396 ctxt->end = NULL;
5397 xmlFAParseBranch(ctxt, end);
5400 ctxt->state = end;
5401 ctxt->end = end;
5461 xmlRegParserCtxtPtr ctxt;
5463 ctxt = xmlRegNewParserCtxt(regexp);
5464 if (ctxt == NULL)
5468 ctxt->end = NULL;
5469 ctxt->start = ctxt->state = xmlRegNewState(ctxt);
5470 xmlRegStatePush(ctxt, ctxt->start);
5473 xmlFAParseRegExp(ctxt, 1);
5477 if (ctxt->error != 0) {
5478 xmlRegFreeParserCtxt(ctxt);
5481 ctxt->end = ctxt->state;
5482 ctxt->start->type = XML_REGEXP_START_STATE;
5483 ctxt->end->type = XML_REGEXP_FINAL_STATE;
5486 xmlFAEliminateEpsilonTransitions(ctxt);
5489 if (ctxt->error != 0) {
5490 xmlRegFreeParserCtxt(ctxt);
5493 ret = xmlRegEpxFromParse(ctxt);
5494 xmlRegFreeParserCtxt(ctxt);
5609 xmlAutomataPtr ctxt;
5611 ctxt = xmlRegNewParserCtxt(NULL);
5612 if (ctxt == NULL)
5616 ctxt->end = NULL;
5617 ctxt->start = ctxt->state = xmlRegNewState(ctxt);
5618 if (ctxt->start == NULL) {
5619 xmlFreeAutomata(ctxt);
5622 ctxt->start->type = XML_REGEXP_START_STATE;
5623 if (xmlRegStatePush(ctxt, ctxt->start) < 0) {
5624 xmlRegFreeState(ctxt->start);
5625 xmlFreeAutomata(ctxt);
5628 ctxt->flags = 0;
5630 return(ctxt);
6397 * @ctxt: an expression context
6402 xmlExpFreeCtxt(xmlExpCtxtPtr ctxt) {
6403 if (ctxt == NULL)
6405 xmlDictFree(ctxt->dict);
6406 if (ctxt->table != NULL)
6407 xmlFree(ctxt->table);
6408 xmlFree(ctxt);
6465 static xmlExpNodePtr xmlExpNewNode(xmlExpCtxtPtr ctxt, xmlExpNodeType type);
6535 xmlExpNewNode(xmlExpCtxtPtr ctxt, xmlExpNodeType type) {
6538 if (ctxt->nb_nodes >= MAX_NODES)
6546 ctxt->nb_nodes++;
6547 ctxt->nb_cons++;
6562 xmlExpHashGetEntry(xmlExpCtxtPtr ctxt, xmlExpNodeType type,
6569 if (ctxt == NULL)
6585 xmlExpFree(ctxt, left);
6590 xmlExpFree(ctxt, left);
6601 xmlExpFree(ctxt, left);
6605 xmlExpFree(ctxt, right);
6627 xmlExpFree(ctxt, left);
6644 tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left->exp_right, right,
6647 tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left->exp_left, tmp,
6650 xmlExpFree(ctxt, left);
6659 tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_right,
6662 tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_left,
6664 xmlExpFree(ctxt, right);
6672 tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left,
6675 tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_left,
6677 xmlExpFree(ctxt, right);
6691 xmlExpFree(ctxt, right);
6695 xmlExpFree(ctxt, left);
6709 key = kbase % ctxt->size;
6710 if (ctxt->table[key] != NULL) {
6711 for (insert = ctxt->table[key]; insert != NULL;
6738 entry = xmlExpNewNode(ctxt, type);
6779 if (ctxt->table[key] != NULL)
6780 entry->next = ctxt->table[key];
6782 ctxt->table[key] = entry;
6783 ctxt->nbElems++;
6790 * @ctxt: the expression context
6796 xmlExpFree(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp) {
6804 key = exp->key % ctxt->size;
6805 if (ctxt->table[key] == exp) {
6806 ctxt->table[key] = exp->next;
6810 tmp = ctxt->table[key];
6821 xmlExpFree(ctxt, exp->exp_left);
6822 xmlExpFree(ctxt, exp->exp_right);
6824 xmlExpFree(ctxt, exp->exp_left);
6827 ctxt->nb_nodes--;
6845 * @ctxt: the expression context
6854 xmlExpNewAtom(xmlExpCtxtPtr ctxt, const xmlChar *name, int len) {
6855 if ((ctxt == NULL) || (name == NULL))
6857 name = xmlDictLookup(ctxt->dict, name, len);
6860 return(xmlExpHashGetEntry(ctxt, XML_EXP_ATOM, NULL, NULL, name, 0, 0));
6865 * @ctxt: the expression context
6872 * this is true even in case of failure (unless ctxt == NULL).
6877 xmlExpNewOr(xmlExpCtxtPtr ctxt, xmlExpNodePtr left, xmlExpNodePtr right) {
6878 if (ctxt == NULL)
6881 xmlExpFree(ctxt, left);
6882 xmlExpFree(ctxt, right);
6885 return(xmlExpHashGetEntry(ctxt, XML_EXP_OR, left, right, NULL, 0, 0));
6890 * @ctxt: the expression context
6897 * this is true even in case of failure (unless ctxt == NULL).
6902 xmlExpNewSeq(xmlExpCtxtPtr ctxt, xmlExpNodePtr left, xmlExpNodePtr right) {
6903 if (ctxt == NULL)
6906 xmlExpFree(ctxt, left);
6907 xmlExpFree(ctxt, right);
6910 return(xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, left, right, NULL, 0, 0));
6915 * @ctxt: the expression context
6923 * this is true even in case of failure (unless ctxt == NULL).
6928 xmlExpNewRange(xmlExpCtxtPtr ctxt, xmlExpNodePtr subset, int min, int max) {
6929 if (ctxt == NULL)
6933 xmlExpFree(ctxt, subset);
6936 return(xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, subset,
6947 xmlExpGetLanguageInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
6967 tmp = xmlExpGetLanguageInt(ctxt, exp->exp_left, list, len, nb);
6970 tmp2 = xmlExpGetLanguageInt(ctxt, exp->exp_right, list, len,
6981 * @ctxt: the expression context
6992 xmlExpGetLanguage(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
6994 if ((ctxt == NULL) || (exp == NULL) || (langList == NULL) || (len <= 0))
6996 return(xmlExpGetLanguageInt(ctxt, exp, langList, len, 0));
7000 xmlExpGetStartInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
7021 tmp = xmlExpGetStartInt(ctxt, exp->exp_left, list, len, nb);
7025 tmp2 = xmlExpGetStartInt(ctxt, exp->exp_right, list, len,
7033 tmp = xmlExpGetStartInt(ctxt, exp->exp_left, list, len, nb);
7036 tmp2 = xmlExpGetStartInt(ctxt, exp->exp_right, list, len,
7047 * @ctxt: the expression context
7060 xmlExpGetStart(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
7062 if ((ctxt == NULL) || (exp == NULL) || (tokList == NULL) || (len <= 0))
7064 return(xmlExpGetStartInt(ctxt, exp, tokList, len, 0));
7083 xmlExpStringDeriveInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, const xmlChar *str)
7112 tmp = xmlExpStringDeriveInt(ctxt, exp->exp_left, str);
7116 ret = xmlExpStringDeriveInt(ctxt, exp->exp_right, str);
7118 xmlExpFree(ctxt, tmp);
7121 ret = xmlExpHashGetEntry(ctxt, XML_EXP_OR, tmp, ret,
7129 ret = xmlExpStringDeriveInt(ctxt, exp->exp_left, str);
7137 ret = xmlExpStringDeriveInt(ctxt, exp->exp_right, str);
7144 ret = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret, exp->exp_right,
7154 ret = xmlExpStringDeriveInt(ctxt, exp->exp_left, str);
7174 tmp = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, exp->exp_left, NULL,
7185 return(xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret, tmp,
7194 * @ctxt: the expression context
7205 xmlExpStringDerive(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
7209 if ((exp == NULL) || (ctxt == NULL) || (str == NULL)) {
7216 input = xmlDictExists(ctxt->dict, str, len);
7220 return(xmlExpStringDeriveInt(ctxt, exp, input));
7240 static xmlExpNodePtr xmlExpExpDeriveInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
7244 * @ctxt: the expressions context
7258 xmlExpDivide(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub,
7270 tmp = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT,
7276 xmlExpFree(ctxt, tmp);
7279 tmp2 = xmlExpExpDeriveInt(ctxt, tmp, exp);
7281 xmlExpFree(ctxt, tmp);
7288 xmlExpFree(ctxt, tmp2);
7292 xmlExpFree(ctxt, tmp);
7298 xmlExpFree(ctxt, tmp);
7299 xmlExpFree(ctxt, tmp2);
7309 * @ctxt: the expressions context
7319 xmlExpExpDeriveInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
7348 tmp = xmlExpExpDeriveInt(ctxt, exp, sub->exp_left);
7353 ret = xmlExpExpDeriveInt(ctxt, tmp, sub->exp_right);
7354 xmlExpFree(ctxt, tmp);
7361 tmp = xmlExpExpDeriveInt(ctxt, exp, sub->exp_left);
7366 ret = xmlExpExpDeriveInt(ctxt, exp, sub->exp_right);
7368 xmlExpFree(ctxt, tmp);
7371 return(xmlExpHashGetEntry(ctxt, XML_EXP_OR, tmp, ret, NULL, 0, 0));
7432 ret = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub);
7445 return(xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret,
7460 ret = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub->exp_left);
7476 tmp = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret,
7482 tmp2 = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT,
7485 xmlExpFree(ctxt, tmp);
7488 ret = xmlExpExpDeriveInt(ctxt, tmp, tmp2);
7489 xmlExpFree(ctxt, tmp);
7490 xmlExpFree(ctxt, tmp2);
7500 ret = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub);
7503 tmp = xmlExpExpDeriveInt(ctxt, exp->exp_right, sub);
7505 xmlExpFree(ctxt, ret);
7508 return(xmlExpHashGetEntry(ctxt, XML_EXP_OR, ret, tmp, NULL, 0, 0));
7516 tmp = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub->exp_left);
7525 mult = xmlExpDivide(ctxt, sub->exp_left, exp->exp_left,
7544 xmlExpFree(ctxt, tmp);
7564 xmlExpFree(ctxt, tmp);
7582 xmlExpFree(ctxt, tmp);
7603 xmlExpFree(ctxt, tmp);
7626 xmlExpFree(ctxt, tmp);
7640 tmp2 = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, exp->exp_left,
7645 ret = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, tmp, tmp2,
7649 tmp = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub);
7671 tmp2 = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, exp->exp_left,
7675 ret = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, tmp, tmp2,
7695 if (ctxt->tabSize == 0)
7696 ctxt->tabSize = 40;
7698 tab = (const xmlChar **) xmlMalloc(ctxt->tabSize *
7707 len = xmlExpGetStartInt(ctxt, sub, tab, ctxt->tabSize, 0);
7710 temp = (const xmlChar **) xmlRealloc((xmlChar **) tab, ctxt->tabSize * 2 *
7717 ctxt->tabSize *= 2;
7718 len = xmlExpGetStartInt(ctxt, sub, tab, ctxt->tabSize, 0);
7721 tmp = xmlExpStringDeriveInt(ctxt, exp, tab[i]);
7723 xmlExpFree(ctxt, ret);
7727 tmp2 = xmlExpStringDeriveInt(ctxt, sub, tab[i]);
7729 xmlExpFree(ctxt, tmp);
7730 xmlExpFree(ctxt, ret);
7734 tmp3 = xmlExpExpDeriveInt(ctxt, tmp, tmp2);
7735 xmlExpFree(ctxt, tmp);
7736 xmlExpFree(ctxt, tmp2);
7739 xmlExpFree(ctxt, ret);
7747 ret = xmlExpHashGetEntry(ctxt, XML_EXP_OR, ret, tmp3, NULL, 0, 0);
7760 * @ctxt: the expressions context
7773 xmlExpExpDerive(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
7774 if ((exp == NULL) || (ctxt == NULL) || (sub == NULL))
7792 return(xmlExpExpDeriveInt(ctxt, exp, sub));
7797 * @ctxt: the expressions context
7807 xmlExpSubsume(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
7810 if ((exp == NULL) || (ctxt == NULL) || (sub == NULL))
7832 tmp = xmlExpExpDeriveInt(ctxt, exp, sub);
7844 xmlExpFree(ctxt, tmp);
7847 xmlExpFree(ctxt, tmp);
7857 static xmlExpNodePtr xmlExpParseExpr(xmlExpCtxtPtr ctxt);
7860 #define CUR (*ctxt->cur)
7862 #define NEXT ctxt->cur++;
7865 #define SKIP_BLANKS while (IS_BLANK(*ctxt->cur)) ctxt->cur++;
7868 xmlExpParseNumber(xmlExpCtxtPtr ctxt) {
7886 xmlExpParseOr(xmlExpCtxtPtr ctxt) {
7892 base = ctxt->cur;
7893 if (*ctxt->cur == '(') {
7895 ret = xmlExpParseExpr(ctxt);
7897 if (*ctxt->cur != ')') {
7899 xmlExpFree(ctxt, ret);
7910 val = xmlDictLookup(ctxt->dict, BAD_CAST base, ctxt->cur - base);
7913 ret = xmlExpHashGetEntry(ctxt, XML_EXP_ATOM, NULL, NULL, val, 0, 0);
7922 min = xmlExpParseNumber(ctxt);
7924 xmlExpFree(ctxt, ret);
7930 max = xmlExpParseNumber(ctxt);
7935 xmlExpFree(ctxt, ret);
7939 ret = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, ret, NULL, NULL,
7944 ret = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, ret, NULL, NULL,
7949 ret = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, ret, NULL, NULL,
7954 ret = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, ret, NULL, NULL,
7963 xmlExpParseSeq(xmlExpCtxtPtr ctxt) {
7966 ret = xmlExpParseOr(ctxt);
7970 right = xmlExpParseOr(ctxt);
7972 xmlExpFree(ctxt, ret);
7975 ret = xmlExpHashGetEntry(ctxt, XML_EXP_OR, ret, right, NULL, 0, 0);
7983 xmlExpParseExpr(xmlExpCtxtPtr ctxt) {
7986 ret = xmlExpParseSeq(ctxt);
7990 right = xmlExpParseSeq(ctxt);
7992 xmlExpFree(ctxt, ret);
7995 ret = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret, right, NULL, 0, 0);
8004 * @ctxt: the expressions context
8020 xmlExpParse(xmlExpCtxtPtr ctxt, const char *expr) {
8023 ctxt->expr = expr;
8024 ctxt->cur = expr;
8026 ret = xmlExpParseExpr(ctxt);
8028 if (*ctxt->cur != 0) {
8029 xmlExpFree(ctxt, ret);
8142 * @ctxt: an expression context
8149 xmlExpCtxtNbNodes(xmlExpCtxtPtr ctxt) {
8150 if (ctxt == NULL)
8152 return(ctxt->nb_nodes);
8157 * @ctxt: an expression context
8164 xmlExpCtxtNbCons(xmlExpCtxtPtr ctxt) {
8165 if (ctxt == NULL)
8167 return(ctxt->nb_cons);
