Lines Matching defs:ctxt
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])
55 #define NEXTL(l) ctxt->cur += l;
59 * when it's guaranteed that cur is not at the beginning of ctxt->string!
61 #define PREV (ctxt->cur[-1])
352 static void xmlFAParseRegExp(xmlRegParserCtxtPtr ctxt, int top);
374 xmlRegexpErrMemory(xmlRegParserCtxtPtr ctxt, const char *extra)
377 if (ctxt != NULL) {
378 regexp = (const char *) ctxt->string;
379 ctxt->error = XML_ERR_NO_MEMORY;
394 xmlRegexpErrCompile(xmlRegParserCtxtPtr ctxt, const char *extra)
399 if (ctxt != NULL) {
400 regexp = (const char *) ctxt->string;
401 idx = ctxt->cur - ctxt->string;
402 ctxt->error = XML_REGEXP_COMPILE_ERROR;
416 static int xmlFAComputesDeterminism(xmlRegParserCtxtPtr ctxt);
419 * @ctxt: the parser context used to build it
426 xmlRegEpxFromParse(xmlRegParserCtxtPtr ctxt) {
431 xmlRegexpErrMemory(ctxt, "compiling regexp");
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;
450 (ctxt->negs == 0) &&
472 xmlRegexpErrMemory(ctxt, "compiling regexp");
489 xmlRegexpErrMemory(ctxt, "compiling regexp");
496 xmlRegexpErrMemory(ctxt, "compiling regexp");
580 xmlRegexpErrMemory(ctxt, "compiling regexp");
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;
700 * @ctxt: the regexp parser context
711 xmlRegNewRange(xmlRegParserCtxtPtr ctxt,
717 xmlRegexpErrMemory(ctxt, "allocating range");
752 xmlRegCopyRange(xmlRegParserCtxtPtr ctxt, xmlRegRangePtr range) {
758 ret = xmlRegNewRange(ctxt, range->neg, range->type, range->start,
765 xmlRegexpErrMemory(ctxt, "allocating range");
775 * @ctxt: the regexp parser context
783 xmlRegNewAtom(xmlRegParserCtxtPtr ctxt, xmlRegAtomType type) {
788 xmlRegexpErrMemory(ctxt, "allocating atom");
827 * @ctxt: the regexp parser context
835 xmlRegCopyAtom(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom) {
840 xmlRegexpErrMemory(ctxt, "copying atom");
854 xmlRegexpErrMemory(ctxt, "copying atom");
858 ret->ranges[i] = xmlRegCopyRange(ctxt, atom->ranges[i]);
872 xmlRegNewState(xmlRegParserCtxtPtr ctxt) {
877 xmlRegexpErrMemory(ctxt, "allocating state");
906 * @ctxt: the regexp parser context
911 xmlRegFreeParserCtxt(xmlRegParserCtxtPtr ctxt) {
913 if (ctxt == NULL)
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);
923 if (ctxt->atoms != NULL) {
924 for (i = 0;i < ctxt->nbAtoms;i++)
925 xmlRegFreeAtom(ctxt->atoms[i]);
926 xmlFree(ctxt->atoms);
928 if (ctxt->counters != NULL)
929 xmlFree(ctxt->counters);
930 xmlFree(ctxt);
1166 xmlRegPrintCtxt(FILE *output, xmlRegParserCtxtPtr ctxt) {
1169 fprintf(output, " ctxt: ");
1170 if (ctxt == NULL) {
1174 fprintf(output, "'%s' ", ctxt->string);
1175 if (ctxt->error)
1177 if (ctxt->neg)
1180 fprintf(output, "%d atoms:\n", ctxt->nbAtoms);
1181 for (i = 0;i < ctxt->nbAtoms; i++) {
1183 xmlRegPrintAtom(output, ctxt->atoms[i]);
1185 if (ctxt->atom != NULL) {
1187 xmlRegPrintAtom(output, ctxt->atom);
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);
1195 for (i = 0;i < ctxt->nbStates; i++) {
1196 xmlRegPrintState(output, ctxt->states[i]);
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);
1213 xmlRegAtomAddRange(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom,
1231 xmlRegexpErrMemory(ctxt, "adding ranges");
1241 xmlRegexpErrMemory(ctxt, "adding ranges");
1247 range = xmlRegNewRange(ctxt, neg, type, start, end);
1256 xmlRegGetCounter(xmlRegParserCtxtPtr ctxt) {
1257 if (ctxt->maxCounters == 0) {
1258 ctxt->maxCounters = 4;
1259 ctxt->counters = (xmlRegCounter *) xmlMalloc(ctxt->maxCounters *
1261 if (ctxt->counters == NULL) {
1262 xmlRegexpErrMemory(ctxt, "allocating counter");
1263 ctxt->maxCounters = 0;
1266 } else if (ctxt->nbCounters >= ctxt->maxCounters) {
1268 ctxt->maxCounters *= 2;
1269 tmp = (xmlRegCounter *) xmlRealloc(ctxt->counters, ctxt->maxCounters *
1272 xmlRegexpErrMemory(ctxt, "allocating counter");
1273 ctxt->maxCounters /= 2;
1276 ctxt->counters = tmp;
1278 ctxt->counters[ctxt->nbCounters].min = -1;
1279 ctxt->counters[ctxt->nbCounters].max = -1;
1280 return(ctxt->nbCounters++);
1284 xmlRegAtomPush(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom) {
1289 if (ctxt->maxAtoms == 0) {
1290 ctxt->maxAtoms = 4;
1291 ctxt->atoms = (xmlRegAtomPtr *) xmlMalloc(ctxt->maxAtoms *
1293 if (ctxt->atoms == NULL) {
1294 xmlRegexpErrMemory(ctxt, "pushing atom");
1295 ctxt->maxAtoms = 0;
1298 } else if (ctxt->nbAtoms >= ctxt->maxAtoms) {
1300 ctxt->maxAtoms *= 2;
1301 tmp = (xmlRegAtomPtr *) xmlRealloc(ctxt->atoms, ctxt->maxAtoms *
1304 xmlRegexpErrMemory(ctxt, "allocating counter");
1305 ctxt->maxAtoms /= 2;
1308 ctxt->atoms = tmp;
1310 atom->no = ctxt->nbAtoms;
1311 ctxt->atoms[ctxt->nbAtoms++] = atom;
1316 xmlRegStateAddTransTo(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr target,
1323 xmlRegexpErrMemory(ctxt, "adding transition");
1333 xmlRegexpErrMemory(ctxt, "adding transition");
1344 xmlRegStateAddTrans(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state,
1383 xmlRegexpErrMemory(ctxt, "adding transition");
1393 xmlRegexpErrMemory(ctxt, "adding transition");
1419 xmlRegStateAddTransTo(ctxt, target, state->no);
1423 xmlRegStatePush(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state) {
1425 if (ctxt->maxStates == 0) {
1426 ctxt->maxStates = 4;
1427 ctxt->states = (xmlRegStatePtr *) xmlMalloc(ctxt->maxStates *
1429 if (ctxt->states == NULL) {
1430 xmlRegexpErrMemory(ctxt, "adding state");
1431 ctxt->maxStates = 0;
1434 } else if (ctxt->nbStates >= ctxt->maxStates) {
1436 ctxt->maxStates *= 2;
1437 tmp = (xmlRegStatePtr *) xmlRealloc(ctxt->states, ctxt->maxStates *
1440 xmlRegexpErrMemory(ctxt, "adding state");
1441 ctxt->maxStates /= 2;
1444 ctxt->states = tmp;
1446 state->no = ctxt->nbStates;
1447 ctxt->states[ctxt->nbStates++] = state;
1453 * @ctxt: a regexp parser context
1460 xmlFAGenerateAllTransition(xmlRegParserCtxtPtr ctxt,
1464 to = xmlRegNewState(ctxt);
1465 xmlRegStatePush(ctxt, to);
1466 ctxt->state = to;
1469 xmlRegStateAddTrans(ctxt, from, NULL, to, -1, REGEXP_ALL_LAX_COUNTER);
1471 xmlRegStateAddTrans(ctxt, from, NULL, to, -1, REGEXP_ALL_COUNTER);
1476 * @ctxt: a regexp parser context
1482 xmlFAGenerateEpsilonTransition(xmlRegParserCtxtPtr ctxt,
1485 to = xmlRegNewState(ctxt);
1486 xmlRegStatePush(ctxt, to);
1487 ctxt->state = to;
1489 xmlRegStateAddTrans(ctxt, from, NULL, to, -1, -1);
1494 * @ctxt: a regexp parser context
1501 xmlFAGenerateCountedEpsilonTransition(xmlRegParserCtxtPtr ctxt,
1504 to = xmlRegNewState(ctxt);
1505 xmlRegStatePush(ctxt, to);
1506 ctxt->state = to;
1508 xmlRegStateAddTrans(ctxt, from, NULL, to, counter, -1);
1513 * @ctxt: a regexp parser context
1520 xmlFAGenerateCountedTransition(xmlRegParserCtxtPtr ctxt,
1523 to = xmlRegNewState(ctxt);
1524 xmlRegStatePush(ctxt, to);
1525 ctxt->state = to;
1527 xmlRegStateAddTrans(ctxt, from, NULL, to, -1, counter);
1532 * @ctxt: a regexp parser context
1540 xmlFAGenerateTransitions(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr from,
1553 if (xmlRegAtomPush(ctxt, atom) < 0) {
1561 xmlFAGenerateEpsilonTransition(ctxt, atom->stop, to);
1565 to = xmlRegNewState(ctxt);
1566 xmlRegStatePush(ctxt, to);
1567 ctxt->state = to;
1568 xmlFAGenerateEpsilonTransition(ctxt, atom->stop, to);
1580 xmlFAGenerateEpsilonTransition(ctxt, atom->start, 0);
1581 xmlFAGenerateEpsilonTransition(ctxt, atom->stop,
1582 ctxt->state);
1584 xmlFAGenerateEpsilonTransition(ctxt, atom->start, to);
1589 xmlFAGenerateEpsilonTransition(ctxt, atom->start, atom->stop);
1590 xmlFAGenerateEpsilonTransition(ctxt, atom->stop, atom->start);
1594 xmlFAGenerateEpsilonTransition(ctxt, atom->stop, atom->start);
1606 newstate = xmlRegNewState(ctxt);
1607 xmlRegStatePush(ctxt, newstate);
1627 copy = xmlRegCopyAtom(ctxt, atom);
1634 if (xmlFAGenerateTransitions(ctxt, atom->start, NULL, copy)
1637 inter = ctxt->state;
1638 counter = xmlRegGetCounter(ctxt);
1639 ctxt->counters[counter].min = atom->min - 1;
1640 ctxt->counters[counter].max = atom->max - 1;
1642 xmlFAGenerateCountedEpsilonTransition(ctxt, inter,
1645 xmlFAGenerateCountedTransition(ctxt, inter,
1648 xmlFAGenerateEpsilonTransition(ctxt, atom->start,
1656 counter = xmlRegGetCounter(ctxt);
1657 ctxt->counters[counter].min = atom->min - 1;
1658 ctxt->counters[counter].max = atom->max - 1;
1660 xmlFAGenerateCountedEpsilonTransition(ctxt, atom->stop,
1663 xmlFAGenerateCountedTransition(ctxt, atom->stop,
1667 xmlFAGenerateEpsilonTransition(ctxt, atom->start0,
1674 ctxt->state = newstate;
1687 to = xmlRegNewState(ctxt);
1689 xmlRegStatePush(ctxt, to);
1694 xmlFAGenerateEpsilonTransition(ctxt, from, to);
1695 ctxt->state = to;
1700 to = xmlRegNewState(ctxt);
1702 xmlRegStatePush(ctxt, to);
1717 tmp = xmlRegNewState(ctxt);
1719 xmlRegStatePush(ctxt, tmp);
1723 xmlFAGenerateEpsilonTransition(ctxt, tmp, to);
1726 if (xmlRegAtomPush(ctxt, atom) < 0) {
1729 xmlRegStateAddTrans(ctxt, from, atom, to, -1, -1);
1730 ctxt->state = end;
1734 xmlFAGenerateEpsilonTransition(ctxt, from, to);
1738 xmlFAGenerateEpsilonTransition(ctxt, from, to);
1739 xmlRegStateAddTrans(ctxt, to, atom, to, -1, -1);
1743 xmlRegStateAddTrans(ctxt, to, atom, to, -1, -1);
1748 xmlFAGenerateEpsilonTransition(ctxt, from, to);
1760 * @ctxt: a regexp parser context
1767 xmlFAReduceEpsilonTransitions(xmlRegParserCtxtPtr ctxt, int fromnr,
1776 from = ctxt->states[fromnr];
1779 to = ctxt->states[tonr];
1805 xmlRegStateAddTrans(ctxt, from, NULL,
1806 ctxt->states[newto],
1814 xmlFAReduceEpsilonTransitions(ctxt, fromnr,
1818 xmlFAReduceEpsilonTransitions(ctxt, fromnr,
1828 xmlRegStateAddTrans(ctxt, from, to->trans[transnr].atom,
1829 ctxt->states[newto],
1832 xmlRegStateAddTrans(ctxt, from, to->trans[transnr].atom,
1833 ctxt->states[newto], counter, -1);
1842 * @ctxt: a regexp parser context
1856 xmlFAEliminateSimpleEpsilonTransitions(xmlRegParserCtxtPtr ctxt) {
1860 for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
1861 state = ctxt->states[statenr];
1887 tmp = ctxt->states[state->transTo[i]];
1895 xmlRegStateAddTrans(ctxt, tmp, tmp->trans[j].atom,
1896 ctxt->states[newto],
1903 ctxt->states[newto]->type = XML_REGEXP_FINAL_STATE;
1916 * @ctxt: a regexp parser context
1920 xmlFAEliminateEpsilonTransitions(xmlRegParserCtxtPtr ctxt) {
1925 if (ctxt->states == NULL) return;
1931 xmlFAEliminateSimpleEpsilonTransitions(ctxt);
1932 for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
1933 state = ctxt->states[statenr];
1939 ctxt->states[statenr] = NULL;
1953 for (statenr = ctxt->nbStates - 1;statenr >= 0;statenr--) {
1954 state = ctxt->states[statenr];
1980 xmlFAReduceEpsilonTransitions(ctxt, statenr,
1996 for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
1997 state = ctxt->states[statenr];
2014 for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
2015 state = ctxt->states[statenr];
2019 state = ctxt->states[0];
2034 if (ctxt->states[newto] == NULL)
2036 if (ctxt->states[newto]->reached == XML_REGEXP_MARK_NORMAL) {
2037 ctxt->states[newto]->reached = XML_REGEXP_MARK_START;
2038 target = ctxt->states[newto];
2047 for (statenr = 1;statenr < ctxt->nbStates;statenr++) {
2048 state = ctxt->states[statenr];
2058 for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
2059 state = ctxt->states[statenr];
2065 ctxt->states[statenr] = NULL;
2572 * @ctxt: a regexp parser context
2579 xmlFARecurseDeterminism(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state,
2590 if (ctxt->flags & AM_AUTOMATA_RNG)
2606 res = xmlFARecurseDeterminism(ctxt, ctxt->states[t1->to],
2627 * @ctxt: a regexp parser context
2634 xmlFAComputesDeterminism(xmlRegParserCtxtPtr ctxt) {
2644 xmlRegPrintCtxt(stdout, ctxt);
2646 if (ctxt->determinist != -1)
2647 return(ctxt->determinist);
2649 if (ctxt->flags & AM_AUTOMATA_RNG)
2655 for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
2656 state = ctxt->states[statenr];
2697 for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
2698 state = ctxt->states[statenr];
2736 ret = xmlFARecurseDeterminism(ctxt, ctxt->states[t1->to],
2771 ctxt->determinist = ret;
4574 * @ctxt: a regexp parser context
4579 xmlFAIsChar(xmlRegParserCtxtPtr ctxt) {
4583 cur = CUR_SCHAR(ctxt->cur, len);
4594 * @ctxt: a regexp parser context
4609 xmlFAParseCharProp(xmlRegParserCtxtPtr ctxt) {
4783 start = ctxt->cur;
4800 blockName = xmlStrndup(start, ctxt->cur - start);
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,
4817 * @ctxt: a regexp parser context
4826 xmlFAParseCharClassEsc(xmlRegParserCtxtPtr ctxt) {
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,
4852 xmlFAParseCharProp(ctxt);
4865 xmlFAParseCharProp(ctxt);
4866 ctxt->atom->neg = 1;
4877 if (ctxt->atom == NULL) {
4878 ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_CHARVAL);
4879 if (ctxt->atom != NULL) {
4882 ctxt->atom->codepoint = '\n';
4885 ctxt->atom->codepoint = '\r';
4888 ctxt->atom->codepoint = '\t';
4891 ctxt->atom->codepoint = cur;
4894 } else if (ctxt->atom->type == XML_REGEXP_RANGES) {
4906 xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
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,
4961 * @ctxt: a regexp parser context
4970 xmlFAParseCharRange(xmlRegParserCtxtPtr ctxt) {
4999 end = start = CUR_SCHAR(ctxt->cur, len);
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
5015 xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
5038 end = CUR_SCHAR(ctxt->cur, len);
5048 xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
5056 * @ctxt: a regexp parser context
5061 xmlFAParsePosCharGroup(xmlRegParserCtxtPtr ctxt) {
5064 xmlFAParseCharClassEsc(ctxt);
5066 xmlFAParseCharRange(ctxt);
5069 (CUR != 0) && (ctxt->error == 0));
5074 * @ctxt: a regexp parser context
5082 xmlFAParseCharGroup(xmlRegParserCtxtPtr ctxt) {
5083 int n = ctxt->neg;
5084 while ((CUR != ']') && (ctxt->error == 0)) {
5086 int neg = ctxt->neg;
5089 ctxt->neg = !ctxt->neg;
5090 xmlFAParsePosCharGroup(ctxt);
5091 ctxt->neg = neg;
5093 int neg = ctxt->neg;
5094 ctxt->neg = 2;
5097 xmlFAParseCharGroup(ctxt);
5104 ctxt->neg = neg;
5107 xmlFAParsePosCharGroup(ctxt);
5110 ctxt->neg = n;
5115 * @ctxt: a regexp parser context
5121 xmlFAParseCharClass(xmlRegParserCtxtPtr ctxt) {
5124 ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_RANGES);
5125 if (ctxt->atom == NULL)
5127 xmlFAParseCharGroup(ctxt);
5134 xmlFAParseCharClassEsc(ctxt);
5140 * @ctxt: a regexp parser context
5147 xmlFAParseQuantExact(xmlRegParserCtxtPtr ctxt) {
5164 * @ctxt: a regexp parser context
5173 xmlFAParseQuantifier(xmlRegParserCtxtPtr ctxt) {
5178 if (ctxt->atom != NULL) {
5180 ctxt->atom->quant = XML_REGEXP_QUANT_OPT;
5182 ctxt->atom->quant = XML_REGEXP_QUANT_MULT;
5184 ctxt->atom->quant = XML_REGEXP_QUANT_PLUS;
5193 cur = xmlFAParseQuantExact(ctxt);
5201 cur = xmlFAParseQuantExact(ctxt);
5216 if (ctxt->atom != NULL) {
5217 ctxt->atom->quant = XML_REGEXP_QUANT_RANGE;
5218 ctxt->atom->min = min;
5219 ctxt->atom->max = max;
5228 * @ctxt: a regexp parser context
5233 xmlFAParseAtom(xmlRegParserCtxtPtr ctxt) {
5236 codepoint = xmlFAIsChar(ctxt);
5238 ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_CHARVAL);
5239 if (ctxt->atom == NULL)
5241 codepoint = CUR_SCHAR(ctxt->cur, len);
5242 ctxt->atom->codepoint = codepoint;
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);
5272 ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_SUBREG);
5273 if (ctxt->atom == NULL)
5275 ctxt->atom->start = start;
5276 ctxt->atom->start0 = start0;
5277 ctxt->atom->stop = ctxt->state;
5278 ctxt->end = oldend;
5281 xmlFAParseCharClass(ctxt);
5289 * @ctxt: a regexp parser context
5294 xmlFAParsePiece(xmlRegParserCtxtPtr ctxt) {
5297 ctxt->atom = NULL;
5298 ret = xmlFAParseAtom(ctxt);
5301 if (ctxt->atom == NULL) {
5304 xmlFAParseQuantifier(ctxt);
5310 * @ctxt: a regexp parser context
5319 xmlFAParseBranch(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr to) {
5323 previous = ctxt->state;
5324 ret = xmlFAParsePiece(ctxt);
5326 if (xmlFAGenerateTransitions(ctxt, previous,
5327 (CUR=='|' || CUR==')') ? to : NULL, ctxt->atom) < 0)
5329 previous = ctxt->state;
5330 ctxt->atom = NULL;
5332 while ((ret != 0) && (ctxt->error == 0)) {
5333 ret = xmlFAParsePiece(ctxt);
5335 if (xmlFAGenerateTransitions(ctxt, previous,
5336 (CUR=='|' || CUR==')') ? to : NULL, ctxt->atom) < 0)
5338 previous = ctxt->state;
5339 ctxt->atom = NULL;
5347 * @ctxt: a regexp parser context
5353 xmlFAParseRegExp(xmlRegParserCtxtPtr ctxt, int top) {
5357 start = ctxt->state;
5358 ctxt->end = NULL;
5359 xmlFAParseBranch(ctxt, NULL);
5362 printf("State %d is final\n", ctxt->state->no);
5364 ctxt->state->type = XML_REGEXP_FINAL_STATE;
5367 ctxt->end = ctxt->state;
5370 end = ctxt->state;
5371 while ((CUR == '|') && (ctxt->error == 0)) {
5373 ctxt->state = start;
5374 ctxt->end = NULL;
5375 xmlFAParseBranch(ctxt, end);
5378 ctxt->state = end;
5379 ctxt->end = end;
5439 xmlRegParserCtxtPtr ctxt;
5441 ctxt = xmlRegNewParserCtxt(regexp);
5442 if (ctxt == NULL)
5446 ctxt->end = NULL;
5447 ctxt->start = ctxt->state = xmlRegNewState(ctxt);
5448 xmlRegStatePush(ctxt, ctxt->start);
5451 xmlFAParseRegExp(ctxt, 1);
5455 if (ctxt->error != 0) {
5456 xmlRegFreeParserCtxt(ctxt);
5459 ctxt->end = ctxt->state;
5460 ctxt->start->type = XML_REGEXP_START_STATE;
5461 ctxt->end->type = XML_REGEXP_FINAL_STATE;
5464 xmlFAEliminateEpsilonTransitions(ctxt);
5467 if (ctxt->error != 0) {
5468 xmlRegFreeParserCtxt(ctxt);
5471 ret = xmlRegEpxFromParse(ctxt);
5472 xmlRegFreeParserCtxt(ctxt);
5587 xmlAutomataPtr ctxt;
5589 ctxt = xmlRegNewParserCtxt(NULL);
5590 if (ctxt == NULL)
5594 ctxt->end = NULL;
5595 ctxt->start = ctxt->state = xmlRegNewState(ctxt);
5596 if (ctxt->start == NULL) {
5597 xmlFreeAutomata(ctxt);
5600 ctxt->start->type = XML_REGEXP_START_STATE;
5601 if (xmlRegStatePush(ctxt, ctxt->start) < 0) {
5602 xmlRegFreeState(ctxt->start);
5603 xmlFreeAutomata(ctxt);
5606 ctxt->flags = 0;
5608 return(ctxt);
6377 * @ctxt: an expression context
6382 xmlExpFreeCtxt(xmlExpCtxtPtr ctxt) {
6383 if (ctxt == NULL)
6385 xmlDictFree(ctxt->dict);
6386 if (ctxt->table != NULL)
6387 xmlFree(ctxt->table);
6388 xmlFree(ctxt);
6445 static xmlExpNodePtr xmlExpNewNode(xmlExpCtxtPtr ctxt, xmlExpNodeType type);
6515 xmlExpNewNode(xmlExpCtxtPtr ctxt, xmlExpNodeType type) {
6518 if (ctxt->nb_nodes >= MAX_NODES)
6526 ctxt->nb_nodes++;
6527 ctxt->nb_cons++;
6542 xmlExpHashGetEntry(xmlExpCtxtPtr ctxt, xmlExpNodeType type,
6549 if (ctxt == NULL)
6565 xmlExpFree(ctxt, left);
6570 xmlExpFree(ctxt, left);
6581 xmlExpFree(ctxt, left);
6585 xmlExpFree(ctxt, right);
6607 xmlExpFree(ctxt, left);
6624 tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left->exp_right, right,
6627 tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left->exp_left, tmp,
6630 xmlExpFree(ctxt, left);
6639 tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_right,
6642 tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_left,
6644 xmlExpFree(ctxt, right);
6652 tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left,
6655 tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_left,
6657 xmlExpFree(ctxt, right);
6671 xmlExpFree(ctxt, right);
6675 xmlExpFree(ctxt, left);
6689 key = kbase % ctxt->size;
6690 if (ctxt->table[key] != NULL) {
6691 for (insert = ctxt->table[key]; insert != NULL;
6718 entry = xmlExpNewNode(ctxt, type);
6759 if (ctxt->table[key] != NULL)
6760 entry->next = ctxt->table[key];
6762 ctxt->table[key] = entry;
6763 ctxt->nbElems++;
6770 * @ctxt: the expression context
6776 xmlExpFree(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp) {
6784 key = exp->key % ctxt->size;
6785 if (ctxt->table[key] == exp) {
6786 ctxt->table[key] = exp->next;
6790 tmp = ctxt->table[key];
6801 xmlExpFree(ctxt, exp->exp_left);
6802 xmlExpFree(ctxt, exp->exp_right);
6804 xmlExpFree(ctxt, exp->exp_left);
6807 ctxt->nb_nodes--;
6825 * @ctxt: the expression context
6834 xmlExpNewAtom(xmlExpCtxtPtr ctxt, const xmlChar *name, int len) {
6835 if ((ctxt == NULL) || (name == NULL))
6837 name = xmlDictLookup(ctxt->dict, name, len);
6840 return(xmlExpHashGetEntry(ctxt, XML_EXP_ATOM, NULL, NULL, name, 0, 0));
6845 * @ctxt: the expression context
6852 * this is true even in case of failure (unless ctxt == NULL).
6857 xmlExpNewOr(xmlExpCtxtPtr ctxt, xmlExpNodePtr left, xmlExpNodePtr right) {
6858 if (ctxt == NULL)
6861 xmlExpFree(ctxt, left);
6862 xmlExpFree(ctxt, right);
6865 return(xmlExpHashGetEntry(ctxt, XML_EXP_OR, left, right, NULL, 0, 0));
6870 * @ctxt: the expression context
6877 * this is true even in case of failure (unless ctxt == NULL).
6882 xmlExpNewSeq(xmlExpCtxtPtr ctxt, xmlExpNodePtr left, xmlExpNodePtr right) {
6883 if (ctxt == NULL)
6886 xmlExpFree(ctxt, left);
6887 xmlExpFree(ctxt, right);
6890 return(xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, left, right, NULL, 0, 0));
6895 * @ctxt: the expression context
6903 * this is true even in case of failure (unless ctxt == NULL).
6908 xmlExpNewRange(xmlExpCtxtPtr ctxt, xmlExpNodePtr subset, int min, int max) {
6909 if (ctxt == NULL)
6913 xmlExpFree(ctxt, subset);
6916 return(xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, subset,
6927 xmlExpGetLanguageInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
6947 tmp = xmlExpGetLanguageInt(ctxt, exp->exp_left, list, len, nb);
6950 tmp2 = xmlExpGetLanguageInt(ctxt, exp->exp_right, list, len,
6961 * @ctxt: the expression context
6972 xmlExpGetLanguage(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
6974 if ((ctxt == NULL) || (exp == NULL) || (langList == NULL) || (len <= 0))
6976 return(xmlExpGetLanguageInt(ctxt, exp, langList, len, 0));
6980 xmlExpGetStartInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
7001 tmp = xmlExpGetStartInt(ctxt, exp->exp_left, list, len, nb);
7005 tmp2 = xmlExpGetStartInt(ctxt, exp->exp_right, list, len,
7013 tmp = xmlExpGetStartInt(ctxt, exp->exp_left, list, len, nb);
7016 tmp2 = xmlExpGetStartInt(ctxt, exp->exp_right, list, len,
7027 * @ctxt: the expression context
7040 xmlExpGetStart(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
7042 if ((ctxt == NULL) || (exp == NULL) || (tokList == NULL) || (len <= 0))
7044 return(xmlExpGetStartInt(ctxt, exp, tokList, len, 0));
7063 xmlExpStringDeriveInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, const xmlChar *str)
7092 tmp = xmlExpStringDeriveInt(ctxt, exp->exp_left, str);
7096 ret = xmlExpStringDeriveInt(ctxt, exp->exp_right, str);
7098 xmlExpFree(ctxt, tmp);
7101 ret = xmlExpHashGetEntry(ctxt, XML_EXP_OR, tmp, ret,
7109 ret = xmlExpStringDeriveInt(ctxt, exp->exp_left, str);
7117 ret = xmlExpStringDeriveInt(ctxt, exp->exp_right, str);
7124 ret = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret, exp->exp_right,
7134 ret = xmlExpStringDeriveInt(ctxt, exp->exp_left, str);
7154 tmp = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, exp->exp_left, NULL,
7165 return(xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret, tmp,
7174 * @ctxt: the expression context
7185 xmlExpStringDerive(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
7189 if ((exp == NULL) || (ctxt == NULL) || (str == NULL)) {
7196 input = xmlDictExists(ctxt->dict, str, len);
7200 return(xmlExpStringDeriveInt(ctxt, exp, input));
7220 static xmlExpNodePtr xmlExpExpDeriveInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
7224 * @ctxt: the expressions context
7238 xmlExpDivide(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub,
7250 tmp = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT,
7256 xmlExpFree(ctxt, tmp);
7259 tmp2 = xmlExpExpDeriveInt(ctxt, tmp, exp);
7261 xmlExpFree(ctxt, tmp);
7268 xmlExpFree(ctxt, tmp2);
7272 xmlExpFree(ctxt, tmp);
7278 xmlExpFree(ctxt, tmp);
7279 xmlExpFree(ctxt, tmp2);
7289 * @ctxt: the expressions context
7299 xmlExpExpDeriveInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
7328 tmp = xmlExpExpDeriveInt(ctxt, exp, sub->exp_left);
7333 ret = xmlExpExpDeriveInt(ctxt, tmp, sub->exp_right);
7334 xmlExpFree(ctxt, tmp);
7341 tmp = xmlExpExpDeriveInt(ctxt, exp, sub->exp_left);
7346 ret = xmlExpExpDeriveInt(ctxt, exp, sub->exp_right);
7348 xmlExpFree(ctxt, tmp);
7351 return(xmlExpHashGetEntry(ctxt, XML_EXP_OR, tmp, ret, NULL, 0, 0));
7412 ret = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub);
7425 return(xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret,
7440 ret = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub->exp_left);
7456 tmp = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret,
7462 tmp2 = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT,
7465 xmlExpFree(ctxt, tmp);
7468 ret = xmlExpExpDeriveInt(ctxt, tmp, tmp2);
7469 xmlExpFree(ctxt, tmp);
7470 xmlExpFree(ctxt, tmp2);
7480 ret = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub);
7483 tmp = xmlExpExpDeriveInt(ctxt, exp->exp_right, sub);
7485 xmlExpFree(ctxt, ret);
7488 return(xmlExpHashGetEntry(ctxt, XML_EXP_OR, ret, tmp, NULL, 0, 0));
7496 tmp = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub->exp_left);
7505 mult = xmlExpDivide(ctxt, sub->exp_left, exp->exp_left,
7524 xmlExpFree(ctxt, tmp);
7544 xmlExpFree(ctxt, tmp);
7562 xmlExpFree(ctxt, tmp);
7583 xmlExpFree(ctxt, tmp);
7606 xmlExpFree(ctxt, tmp);
7620 tmp2 = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, exp->exp_left,
7625 ret = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, tmp, tmp2,
7629 tmp = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub);
7651 tmp2 = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, exp->exp_left,
7655 ret = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, tmp, tmp2,
7675 if (ctxt->tabSize == 0)
7676 ctxt->tabSize = 40;
7678 tab = (const xmlChar **) xmlMalloc(ctxt->tabSize *
7687 len = xmlExpGetStartInt(ctxt, sub, tab, ctxt->tabSize, 0);
7690 temp = (const xmlChar **) xmlRealloc((xmlChar **) tab, ctxt->tabSize * 2 *
7697 ctxt->tabSize *= 2;
7698 len = xmlExpGetStartInt(ctxt, sub, tab, ctxt->tabSize, 0);
7701 tmp = xmlExpStringDeriveInt(ctxt, exp, tab[i]);
7703 xmlExpFree(ctxt, ret);
7707 tmp2 = xmlExpStringDeriveInt(ctxt, sub, tab[i]);
7709 xmlExpFree(ctxt, tmp);
7710 xmlExpFree(ctxt, ret);
7714 tmp3 = xmlExpExpDeriveInt(ctxt, tmp, tmp2);
7715 xmlExpFree(ctxt, tmp);
7716 xmlExpFree(ctxt, tmp2);
7719 xmlExpFree(ctxt, ret);
7727 ret = xmlExpHashGetEntry(ctxt, XML_EXP_OR, ret, tmp3, NULL, 0, 0);
7740 * @ctxt: the expressions context
7753 xmlExpExpDerive(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
7754 if ((exp == NULL) || (ctxt == NULL) || (sub == NULL))
7772 return(xmlExpExpDeriveInt(ctxt, exp, sub));
7777 * @ctxt: the expressions context
7787 xmlExpSubsume(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
7790 if ((exp == NULL) || (ctxt == NULL) || (sub == NULL))
7812 tmp = xmlExpExpDeriveInt(ctxt, exp, sub);
7824 xmlExpFree(ctxt, tmp);
7827 xmlExpFree(ctxt, tmp);
7837 static xmlExpNodePtr xmlExpParseExpr(xmlExpCtxtPtr ctxt);
7840 #define CUR (*ctxt->cur)
7842 #define NEXT ctxt->cur++;
7845 #define SKIP_BLANKS while (IS_BLANK(*ctxt->cur)) ctxt->cur++;
7848 xmlExpParseNumber(xmlExpCtxtPtr ctxt) {
7866 xmlExpParseOr(xmlExpCtxtPtr ctxt) {
7872 base = ctxt->cur;
7873 if (*ctxt->cur == '(') {
7875 ctxt);
7877 if (*ctxt->cur != ')') {
7879 xmlExpFree(ctxt, ret);
7890 val = xmlDictLookup(ctxt->dict, BAD_CAST base, ctxt->cur - base);
7893 ret = xmlExpHashGetEntry(ctxt, XML_EXP_ATOM, NULL, NULL, val, 0, 0);
7902 min = xmlExpParseNumber(ctxt);
7904 xmlExpFree(ctxt, ret);
7910 max = xmlExpParseNumber(ctxt);
7915 xmlExpFree(ctxt, ret);
7919 ret = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, ret, NULL, NULL,
7924 ret = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, ret, NULL, NULL,
7929 ret = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, ret, NULL, NULL,
7934 ret = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, ret, NULL, NULL,
7943 xmlExpParseSeq(xmlExpCtxtPtr ctxt) {
7946 ret = xmlExpParseOr(ctxt);
7950 right = xmlExpParseOr(ctxt);
7952 xmlExpFree(ctxt, ret);
7955 ret = xmlExpHashGetEntry(ctxt, XML_EXP_OR, ret, right, NULL, 0, 0);
7963 xmlExpParseExpr(xmlExpCtxtPtr ctxt) {
7966 ret = xmlExpParseSeq(ctxt);
7970 right = xmlExpParseSeq(ctxt);
7972 xmlExpFree(ctxt, ret);
7975 ret = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret, right, NULL, 0, 0);
7984 * @ctxt: the expressions context
8000 xmlExpParse(xmlExpCtxtPtr ctxt, const char *expr) {
8003 ctxt->expr = expr;
8004 ctxt->cur = expr;
8006 ret = xmlExpParseExpr(ctxt);
8008 if (*ctxt->cur != 0) {
8009 xmlExpFree(ctxt, ret);
8122 * @ctxt: an expression context
8129 xmlExpCtxtNbNodes(xmlExpCtxtPtr ctxt) {
8130 if (ctxt == NULL)
8132 return(ctxt->nb_nodes);
8137 * @ctxt: an expression context
8144 xmlExpCtxtNbCons(xmlExpCtxtPtr ctxt) {
8145 if (ctxt == NULL)
8147 return(ctxt->nb_cons);
