Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(802)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: third_party/libxml/src/xmlregexp.c

Issue 1193533007: Upgrade to libxml 2.9.2 and libxslt 1.1.28 (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: no iconv Created 5 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « third_party/libxml/src/xmlreader.c ('k') | third_party/libxml/src/xmlsave.c » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: third_party/libxml/src/xmlregexp.c
diff --git a/third_party/libxml/src/xmlregexp.c b/third_party/libxml/src/xmlregexp.c
index feae87460ed5b58923b78c9dd76ed3deb98a4999..3e912ab92e803abc3e48215f1479b97a296256b1 100644
--- a/third_party/libxml/src/xmlregexp.c
+++ b/third_party/libxml/src/xmlregexp.c
@@ -1,7 +1,7 @@
/*
* regexp.c: generic and extensible Regular Expression engine
*
- * Basically designed with the purpose of compiling regexps for
+ * Basically designed with the purpose of compiling regexps for
* the variety of validation/shemas mechanisms now available in
* XML related specifications these include:
* - XML-1.0 DTD validation
@@ -44,6 +44,9 @@
#define MAX_PUSH 10000000
+#ifdef ERROR
+#undef ERROR
+#endif
#define ERROR(str) \
ctxt->error = XML_REGEXP_COMPILE_ERROR; \
xmlRegexpErrCompile(ctxt, str);
@@ -65,15 +68,15 @@
*
* macro to flag unimplemented blocks
*/
-#define TODO \
+#define TODO \
xmlGenericError(xmlGenericErrorContext, \
"Unimplemented block at %s:%d\n", \
__FILE__, __LINE__);
/************************************************************************
- * *
- * Datatypes and structures *
- * *
+ * *
+ * Datatypes and structures *
+ * *
************************************************************************/
/*
@@ -219,6 +222,7 @@ struct _xmlRegTrans {
struct _xmlAutomataState {
xmlRegStateType type;
xmlRegMarkedType mark;
+ xmlRegMarkedType markd;
xmlRegMarkedType reached;
int no;
int maxTrans;
@@ -361,7 +365,7 @@ void xmlAutomataSetFlags(xmlAutomataPtr am, int flags);
/************************************************************************
* *
- * Regexp memory error handler *
+ * Regexp memory error handler *
* *
************************************************************************/
/**
@@ -408,9 +412,9 @@ xmlRegexpErrCompile(xmlRegParserCtxtPtr ctxt, const char *extra)
}
/************************************************************************
- * *
- * Allocation/Deallocation *
- * *
+ * *
+ * Allocation/Deallocation *
+ * *
************************************************************************/
static int xmlFAComputesDeterminism(xmlRegParserCtxtPtr ctxt);
@@ -931,9 +935,9 @@ xmlRegFreeParserCtxt(xmlRegParserCtxtPtr ctxt) {
}
/************************************************************************
- * *
- * Display of Data structures *
- * *
+ * *
+ * Display of Data structures *
+ * *
************************************************************************/
static void
@@ -1140,7 +1144,7 @@ xmlRegPrintTrans(FILE *output, xmlRegTransPtr trans) {
fprintf(output, "char %c ", trans->atom->codepoint);
fprintf(output, "atom %d, to %d\n", trans->atom->no, trans->to);
}
-
+
static void
xmlRegPrintState(FILE *output, xmlRegStatePtr state) {
int i;
@@ -1154,7 +1158,7 @@ xmlRegPrintState(FILE *output, xmlRegStatePtr state) {
fprintf(output, "START ");
if (state->type == XML_REGEXP_FINAL_STATE)
fprintf(output, "FINAL ");
-
+
fprintf(output, "%d, %d transitions:\n", state->no, state->nbTrans);
for (i = 0;i < state->nbTrans; i++) {
xmlRegPrintTrans(output, &(state->trans[i]));
@@ -1204,12 +1208,12 @@ xmlRegPrintCtxt(FILE *output, xmlRegParserCtxtPtr ctxt) {
#endif
/************************************************************************
- * *
+ * *
* Finite Automata structures manipulations *
- * *
+ * *
************************************************************************/
-static void
+static void
xmlRegAtomAddRange(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom,
int neg, xmlRegAtomType type, int start, int end,
xmlChar *blockName) {
@@ -1249,7 +1253,7 @@ xmlRegAtomAddRange(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom,
return;
range->blockName = blockName;
atom->ranges[atom->nbRanges++] = range;
-
+
}
static int
@@ -1280,7 +1284,7 @@ xmlRegGetCounter(xmlRegParserCtxtPtr ctxt) {
return(ctxt->nbCounters++);
}
-static int
+static int
xmlRegAtomPush(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom) {
if (atom == NULL) {
ERROR("atom push: atom is NULL");
@@ -1312,7 +1316,7 @@ xmlRegAtomPush(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom) {
return(0);
}
-static void
+static void
xmlRegStateAddTransTo(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr target,
int from) {
if (target->maxTransTo == 0) {
@@ -1340,7 +1344,7 @@ xmlRegStateAddTransTo(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr target,
target->nbTransTo++;
}
-static void
+static void
xmlRegStateAddTrans(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state,
xmlRegAtomPtr atom, xmlRegStatePtr target,
int counter, int count) {
@@ -1406,7 +1410,7 @@ xmlRegStateAddTrans(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state,
printf("counted %d\n", counter);
else if (atom == NULL)
printf("epsilon transition\n");
- else if (atom != NULL)
+ else if (atom != NULL)
xmlRegPrintAtom(stdout, atom);
#endif
@@ -1560,7 +1564,7 @@ xmlFAGenerateTransitions(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr from,
*/
xmlFAGenerateEpsilonTransition(ctxt, atom->stop, to);
#ifdef DV
- } else if ((to == NULL) && (atom->quant != XML_REGEXP_QUANT_RANGE) &&
+ } else if ((to == NULL) && (atom->quant != XML_REGEXP_QUANT_RANGE) &&
(atom->quant != XML_REGEXP_QUANT_ONCE)) {
to = xmlRegNewState(ctxt);
xmlRegStatePush(ctxt, to);
@@ -1574,7 +1578,7 @@ xmlFAGenerateTransitions(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr from,
/*
* transition done to the state after end of atom.
* 1. set transition from atom start to new state
- * 2. set transition from atom end to this state.
+ * 2. set transition from atom end to this state.
*/
if (to == NULL) {
xmlFAGenerateEpsilonTransition(ctxt, atom->start, 0);
@@ -1618,7 +1622,7 @@ xmlFAGenerateTransitions(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr from,
/*
* duplicate a transition based on atom to count next
* occurences after 1. We cannot loop to atom->start
- * directly because we need an epsilon transition to
+ * directly because we need an epsilon transition to
* newstate.
*/
/* ???? For some reason it seems we never reach that
@@ -1677,7 +1681,7 @@ xmlFAGenerateTransitions(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr from,
break;
}
return(0);
- }
+ }
if ((atom->min == 0) && (atom->max == 0) &&
(atom->quant == XML_REGEXP_QUANT_RANGE)) {
/*
@@ -1703,9 +1707,9 @@ xmlFAGenerateTransitions(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr from,
else {
return(-1);
}
- }
+ }
end = to;
- if ((atom->quant == XML_REGEXP_QUANT_MULT) ||
+ if ((atom->quant == XML_REGEXP_QUANT_MULT) ||
(atom->quant == XML_REGEXP_QUANT_PLUS)) {
/*
* Do not pollute the target state by adding transitions from
@@ -1713,7 +1717,7 @@ xmlFAGenerateTransitions(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr from,
* So isolate with an epsilon transition.
*/
xmlRegStatePtr tmp;
-
+
tmp = xmlRegNewState(ctxt);
if (tmp != NULL)
xmlRegStatePush(ctxt, tmp);
@@ -1742,7 +1746,7 @@ xmlFAGenerateTransitions(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr from,
atom->quant = XML_REGEXP_QUANT_ONCE;
xmlRegStateAddTrans(ctxt, to, atom, to, -1, -1);
break;
- case XML_REGEXP_QUANT_RANGE:
+ case XML_REGEXP_QUANT_RANGE:
#if DV_test
if (atom->min == 0) {
xmlFAGenerateEpsilonTransition(ctxt, from, to);
@@ -1759,7 +1763,7 @@ xmlFAGenerateTransitions(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr from,
* xmlFAReduceEpsilonTransitions:
* @ctxt: a regexp parser context
* @fromnr: the from state
- * @tonr: the to state
+ * @tonr: the to state
* @counter: should that transition be associated to a counted
*
*/
@@ -1803,7 +1807,7 @@ xmlFAReduceEpsilonTransitions(xmlRegParserCtxtPtr ctxt, int fromnr,
int newto = to->trans[transnr].to;
xmlRegStateAddTrans(ctxt, from, NULL,
- ctxt->states[newto],
+ ctxt->states[newto],
-1, to->trans[transnr].count);
} else {
#ifdef DEBUG_REGEXP_GRAPH
@@ -1825,11 +1829,11 @@ xmlFAReduceEpsilonTransitions(xmlRegParserCtxtPtr ctxt, int fromnr,
int newto = to->trans[transnr].to;
if (to->trans[transnr].counter >= 0) {
- xmlRegStateAddTrans(ctxt, from, to->trans[transnr].atom,
- ctxt->states[newto],
+ xmlRegStateAddTrans(ctxt, from, to->trans[transnr].atom,
+ ctxt->states[newto],
to->trans[transnr].counter, -1);
} else {
- xmlRegStateAddTrans(ctxt, from, to->trans[transnr].atom,
+ xmlRegStateAddTrans(ctxt, from, to->trans[transnr].atom,
ctxt->states[newto], counter, -1);
}
}
@@ -1841,7 +1845,7 @@ xmlFAReduceEpsilonTransitions(xmlRegParserCtxtPtr ctxt, int fromnr,
* xmlFAEliminateSimpleEpsilonTransitions:
* @ctxt: a regexp parser context
*
- * Eliminating general epsilon transitions can get costly in the general
+ * Eliminating general epsilon transitions can get costly in the general
* algorithm due to the large amount of generated new transitions and
* associated comparisons. However for simple epsilon transition used just
* to separate building blocks when generating the automata this can be
@@ -1877,12 +1881,12 @@ xmlFAEliminateSimpleEpsilonTransitions(xmlRegParserCtxtPtr ctxt) {
#ifdef DEBUG_REGEXP_GRAPH
printf("Found simple epsilon trans from start %d to %d\n",
statenr, newto);
-#endif
+#endif
} else {
#ifdef DEBUG_REGEXP_GRAPH
printf("Found simple epsilon trans from %d to %d\n",
statenr, newto);
-#endif
+#endif
for (i = 0;i < state->nbTransTo;i++) {
tmp = ctxt->states[state->transTo[i]];
for (j = 0;j < tmp->nbTrans;j++) {
@@ -1890,10 +1894,10 @@ xmlFAEliminateSimpleEpsilonTransitions(xmlRegParserCtxtPtr ctxt) {
#ifdef DEBUG_REGEXP_GRAPH
printf("Changed transition %d on %d to go to %d\n",
j, tmp->no, newto);
-#endif
+#endif
tmp->trans[j].to = -1;
xmlRegStateAddTrans(ctxt, tmp, tmp->trans[j].atom,
- ctxt->states[newto],
+ ctxt->states[newto],
tmp->trans[j].counter,
tmp->trans[j].count);
}
@@ -1907,7 +1911,7 @@ xmlFAEliminateSimpleEpsilonTransitions(xmlRegParserCtxtPtr ctxt) {
state->type = XML_REGEXP_UNREACH_STATE;
}
-
+
}
}
}
@@ -2109,7 +2113,7 @@ xmlFACompareRanges(xmlRegRangePtr range1, xmlRegRangePtr range2) {
/*
* just check all codepoints in the range for acceptance,
* this is usually way cheaper since done only once at
- * compilation than testing over and over at runtime or
+ * compilation than testing over and over at runtime or
* pushing too many states when evaluating.
*/
if (((range1->neg == 0) && (range2->neg != 0)) ||
@@ -2586,6 +2590,8 @@ xmlFARecurseDeterminism(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state,
if (state == NULL)
return(ret);
+ if (state->markd == XML_REGEXP_MARK_VISITED)
+ return(ret);
if (ctxt->flags & AM_AUTOMATA_RNG)
deep = 0;
@@ -2603,8 +2609,10 @@ xmlFARecurseDeterminism(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state,
if (t1->atom == NULL) {
if (t1->to < 0)
continue;
+ state->markd = XML_REGEXP_MARK_VISITED;
res = xmlFARecurseDeterminism(ctxt, ctxt->states[t1->to],
to, atom);
+ state->markd = 0;
if (res == 0) {
ret = 0;
/* t1->nd = 1; */
@@ -2773,9 +2781,9 @@ xmlFAComputesDeterminism(xmlRegParserCtxtPtr ctxt) {
}
/************************************************************************
- * *
+ * *
* Routines to check input against transition atoms *
- * *
+ * *
************************************************************************/
static int
@@ -2804,7 +2812,7 @@ xmlRegCheckCharacterRange(xmlRegAtomType type, int codepoint, int neg,
case XML_REGEXP_NOTINITNAME:
neg = !neg;
case XML_REGEXP_INITNAME:
- ret = (IS_LETTER(codepoint) ||
+ ret = (IS_LETTER(codepoint) ||
(codepoint == '_') || (codepoint == ':'));
break;
case XML_REGEXP_NOTNAMECHAR:
@@ -3052,9 +3060,9 @@ xmlRegCheckCharacter(xmlRegAtomPtr atom, int codepoint) {
}
/************************************************************************
- * *
+ * *
* Saving and restoring state of an execution context *
- * *
+ * *
************************************************************************/
#ifdef DEBUG_REGEXP_EXEC
@@ -3154,8 +3162,10 @@ xmlFARegExecRollBack(xmlRegExecCtxtPtr exec) {
exec->status = -6;
return;
}
- memcpy(exec->counts, exec->rollbacks[exec->nbRollbacks].counts,
+ if (exec->counts) {
+ memcpy(exec->counts, exec->rollbacks[exec->nbRollbacks].counts,
exec->comp->nbCounters * sizeof(int));
+ }
}
#ifdef DEBUG_REGEXP_EXEC
@@ -3165,9 +3175,9 @@ xmlFARegExecRollBack(xmlRegExecCtxtPtr exec) {
}
/************************************************************************
- * *
+ * *
* Verifier, running an input against a compiled regexp *
- * *
+ * *
************************************************************************/
static int
@@ -3199,7 +3209,7 @@ xmlFARegExec(xmlRegexpPtr comp, const xmlChar *content) {
memset(exec->counts, 0, comp->nbCounters * sizeof(int));
} else
exec->counts = NULL;
- while ((exec->status == 0) &&
+ while ((exec->status == 0) && (exec->state != NULL) &&
((exec->inputString[exec->index] != 0) ||
((exec->state != NULL) &&
(exec->state->type != XML_REGEXP_FINAL_STATE)))) {
@@ -3453,6 +3463,8 @@ error:
}
xmlFree(exec->rollbacks);
}
+ if (exec->state == NULL)
+ return(-1);
if (exec->counts != NULL)
xmlFree(exec->counts);
if (exec->status == 0)
@@ -3466,9 +3478,9 @@ error:
}
/************************************************************************
- * *
+ * *
* Progressive interface to the verifier one atom at a time *
- * *
+ * *
************************************************************************/
#ifdef DEBUG_ERR
static void testerr(xmlRegExecCtxtPtr exec);
@@ -3585,7 +3597,7 @@ xmlFARegExecSaveInputString(xmlRegExecCtxtPtr exec, const xmlChar *value,
#endif
if (exec->inputStackMax == 0) {
exec->inputStackMax = 4;
- exec->inputStack = (xmlRegInputTokenPtr)
+ exec->inputStack = (xmlRegInputTokenPtr)
xmlMalloc(exec->inputStackMax * sizeof(xmlRegInputToken));
if (exec->inputStack == NULL) {
xmlRegexpErrMemory(NULL, "pushing input string");
@@ -3614,11 +3626,11 @@ xmlFARegExecSaveInputString(xmlRegExecCtxtPtr exec, const xmlChar *value,
/**
* xmlRegStrEqualWildcard:
- * @expStr: the string to be evaluated
+ * @expStr: the string to be evaluated
* @valStr: the validation string
*
* Checks if both strings are equal or have the same content. "*"
- * can be used as a wildcard in @valStr; "|" is used as a seperator of
+ * can be used as a wildcard in @valStr; "|" is used as a seperator of
* substrings in both @expStr and @valStr.
*
* Returns 1 if the comparison is satisfied and the number of substrings
@@ -3684,7 +3696,7 @@ xmlRegCompactPushString(xmlRegExecCtxtPtr exec,
if ((comp == NULL) || (comp->compact == NULL) || (comp->stringMap == NULL))
return(-1);
-
+
if (value == NULL) {
/*
* are we at a final state ?
@@ -3705,9 +3717,9 @@ xmlRegCompactPushString(xmlRegExecCtxtPtr exec,
for (i = 0;i < comp->nbstrings;i++) {
target = comp->compact[state * (comp->nbstrings + 1) + i + 1];
if ((target > 0) && (target <= comp->nbstates)) {
- target--; /* to avoid 0 */
+ target--; /* to avoid 0 */
if (xmlRegStrEqualWildcard(comp->stringMap[i], value)) {
- exec->index = target;
+ exec->index = target;
if ((exec->callback != NULL) && (comp->transdata != NULL)) {
exec->callback(exec->data, value,
comp->transdata[state * comp->nbstrings + i], data);
@@ -3841,7 +3853,7 @@ xmlRegExecPushStringInternal(xmlRegExecCtxtPtr exec, const xmlChar *value,
continue;
counter = &exec->comp->counters[t->counter];
count = exec->counts[t->counter];
- if ((count < counter->max) &&
+ if ((count < counter->max) &&
(t->atom != NULL) &&
(xmlStrEqual(value, t->atom->valuep))) {
ret = 0;
@@ -4081,7 +4093,7 @@ rollback:
*/
exec->determinist = 0;
xmlFARegExecRollBack(exec);
- if (exec->status == 0) {
+ if ((exec->inputStack != NULL ) && (exec->status == 0)) {
value = exec->inputStack[exec->index].value;
data = exec->inputStack[exec->index].data;
#ifdef DEBUG_PUSH
@@ -4199,7 +4211,7 @@ xmlRegExecGetValues(xmlRegExecCtxtPtr exec, int err,
int maxval;
int nb = 0;
- if ((exec == NULL) || (nbval == NULL) || (nbneg == NULL) ||
+ if ((exec == NULL) || (nbval == NULL) || (nbneg == NULL) ||
(values == NULL) || (*nbval <= 0))
return(-1);
@@ -4296,7 +4308,7 @@ xmlRegExecGetValues(xmlRegExecCtxtPtr exec, int err,
(*nbval)++;
}
} else {
- if ((exec->comp->states[trans->to] != NULL) &&
+ if ((exec->comp != NULL) && (exec->comp->states[trans->to] != NULL) &&
(exec->comp->states[trans->to]->type !=
XML_REGEXP_SINK_STATE)) {
if (atom->neg)
@@ -4305,7 +4317,7 @@ xmlRegExecGetValues(xmlRegExecCtxtPtr exec, int err,
values[nb++] = (xmlChar *) atom->valuep;
(*nbval)++;
}
- }
+ }
}
for (transno = 0;
(transno < state->nbTrans) && (nb < maxval);
@@ -4332,7 +4344,7 @@ xmlRegExecGetValues(xmlRegExecCtxtPtr exec, int err,
values[nb++] = (xmlChar *) atom->valuep;
(*nbneg)++;
}
- }
+ }
}
}
return(0);
@@ -4563,10 +4575,10 @@ progress:
}
#endif
/************************************************************************
- * *
+ * *
* Parser for the Schemas Datatype Regular Expressions *
* http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#regexs *
- * *
+ * *
************************************************************************/
/**
@@ -4595,7 +4607,7 @@ xmlFAIsChar(xmlRegParserCtxtPtr ctxt) {
*
* [27] charProp ::= IsCategory | IsBlock
* [28] IsCategory ::= Letters | Marks | Numbers | Punctuation |
- * Separators | Symbols | Others
+ * Separators | Symbols | Others
* [29] Letters ::= 'L' [ultmo]?
* [30] Marks ::= 'M' [nce]?
* [31] Numbers ::= 'N' [dlo]?
@@ -4610,7 +4622,7 @@ xmlFAParseCharProp(xmlRegParserCtxtPtr ctxt) {
int cur;
xmlRegAtomType type = (xmlRegAtomType) 0;
xmlChar *blockName = NULL;
-
+
cur = CUR;
if (cur == 'L') {
NEXT;
@@ -4782,15 +4794,15 @@ xmlFAParseCharProp(xmlRegParserCtxtPtr ctxt) {
NEXT;
start = ctxt->cur;
cur = CUR;
- if (((cur >= 'a') && (cur <= 'z')) ||
- ((cur >= 'A') && (cur <= 'Z')) ||
- ((cur >= '0') && (cur <= '9')) ||
+ if (((cur >= 'a') && (cur <= 'z')) ||
+ ((cur >= 'A') && (cur <= 'Z')) ||
+ ((cur >= '0') && (cur <= '9')) ||
(cur == 0x2D)) {
NEXT;
cur = CUR;
- while (((cur >= 'a') && (cur <= 'z')) ||
- ((cur >= 'A') && (cur <= 'Z')) ||
- ((cur >= '0') && (cur <= '9')) ||
+ while (((cur >= 'a') && (cur <= 'z')) ||
+ ((cur >= 'A') && (cur <= 'Z')) ||
+ ((cur >= '0') && (cur <= '9')) ||
(cur == 0x2D)) {
NEXT;
cur = CUR;
@@ -4816,7 +4828,7 @@ xmlFAParseCharProp(xmlRegParserCtxtPtr ctxt) {
* xmlFAParseCharClassEsc:
* @ctxt: a regexp parser context
*
- * [23] charClassEsc ::= ( SingleCharEsc | MultiCharEsc | catEsc | complEsc )
+ * [23] charClassEsc ::= ( SingleCharEsc | MultiCharEsc | catEsc | complEsc )
* [24] SingleCharEsc ::= '\' [nrt\|.?*+(){}#x2D#x5B#x5D#x5E]
* [25] catEsc ::= '\p{' charProp '}'
* [26] complEsc ::= '\P{' charProp '}'
@@ -4913,34 +4925,34 @@ xmlFAParseCharClassEsc(xmlRegParserCtxtPtr ctxt) {
xmlRegAtomType type = XML_REGEXP_ANYSPACE;
switch (cur) {
- case 's':
+ case 's':
type = XML_REGEXP_ANYSPACE;
break;
- case 'S':
+ case 'S':
type = XML_REGEXP_NOTSPACE;
break;
- case 'i':
+ case 'i':
type = XML_REGEXP_INITNAME;
break;
- case 'I':
+ case 'I':
type = XML_REGEXP_NOTINITNAME;
break;
- case 'c':
+ case 'c':
type = XML_REGEXP_NAMECHAR;
break;
- case 'C':
+ case 'C':
type = XML_REGEXP_NOTNAMECHAR;
break;
- case 'd':
+ case 'd':
type = XML_REGEXP_DECIMAL;
break;
- case 'D':
+ case 'D':
type = XML_REGEXP_NOTDECIMAL;
break;
- case 'w':
+ case 'w':
type = XML_REGEXP_REALCHAR;
break;
- case 'W':
+ case 'W':
type = XML_REGEXP_NOTREALCHAR;
break;
}
@@ -4960,7 +4972,7 @@ xmlFAParseCharClassEsc(xmlRegParserCtxtPtr ctxt) {
* xmlFAParseCharRange:
* @ctxt: a regexp parser context
*
- * [17] charRange ::= seRange | XmlCharRef | XmlCharIncDash
+ * [17] charRange ::= seRange | XmlCharRef | XmlCharIncDash
* [18] seRange ::= charOrEsc '-' charOrEsc
* [20] charOrEsc ::= XmlChar | SingleCharEsc
* [21] XmlChar ::= [^\#x2D#x5B#x5D]
@@ -5075,7 +5087,7 @@ xmlFAParsePosCharGroup(xmlRegParserCtxtPtr ctxt) {
*
* [13] charGroup ::= posCharGroup | negCharGroup | charClassSub
* [15] negCharGroup ::= '^' posCharGroup
- * [16] charClassSub ::= ( posCharGroup | negCharGroup ) '-' charClassExpr
+ * [16] charClassSub ::= ( posCharGroup | negCharGroup ) '-' charClassExpr
* [12] charClassExpr ::= '[' charGroup ']'
*/
static void
@@ -5323,7 +5335,7 @@ xmlFAParseBranch(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr to) {
previous = ctxt->state;
ret = xmlFAParsePiece(ctxt);
if (ret != 0) {
- if (xmlFAGenerateTransitions(ctxt, previous,
+ if (xmlFAGenerateTransitions(ctxt, previous,
(CUR=='|' || CUR==')') ? to : NULL, ctxt->atom) < 0)
return(-1);
previous = ctxt->state;
@@ -5332,7 +5344,7 @@ xmlFAParseBranch(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr to) {
while ((ret != 0) && (ctxt->error == 0)) {
ret = xmlFAParsePiece(ctxt);
if (ret != 0) {
- if (xmlFAGenerateTransitions(ctxt, previous,
+ if (xmlFAGenerateTransitions(ctxt, previous,
(CUR=='|' || CUR==')') ? to : NULL, ctxt->atom) < 0)
return(-1);
previous = ctxt->state;
@@ -5370,6 +5382,10 @@ xmlFAParseRegExp(xmlRegParserCtxtPtr ctxt, int top) {
end = ctxt->state;
while ((CUR == '|') && (ctxt->error == 0)) {
NEXT;
+ if (CUR == 0) {
+ ERROR("expecting a branch after |")
+ return;
+ }
ctxt->state = start;
ctxt->end = NULL;
xmlFAParseBranch(ctxt, end);
@@ -5381,9 +5397,9 @@ xmlFAParseRegExp(xmlRegParserCtxtPtr ctxt, int top) {
}
/************************************************************************
- * *
- * The basic API *
- * *
+ * *
+ * The basic API *
+ * *
************************************************************************/
/**
@@ -5570,9 +5586,9 @@ xmlRegFreeRegexp(xmlRegexpPtr regexp) {
#ifdef LIBXML_AUTOMATA_ENABLED
/************************************************************************
- * *
- * The Automata interface *
- * *
+ * *
+ * The Automata interface *
+ * *
************************************************************************/
/**
@@ -5693,8 +5709,6 @@ xmlAutomataNewTransition(xmlAutomataPtr am, xmlAutomataStatePtr from,
if (atom == NULL)
return(NULL);
atom->data = data;
- if (atom == NULL)
- return(NULL);
atom->valuep = xmlStrdup(token);
if (xmlFAGenerateTransitions(am, from, to, atom) < 0) {
@@ -5843,7 +5857,7 @@ xmlAutomataNewNegTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
*
* If @to is NULL, this creates first a new target state in the automata
* and then adds a transition from the @from state to the target state
- * activated by a succession of input of value @token and @token2 and
+ * activated by a succession of input of value @token and @token2 and
* whose number is between @min and @max
*
* Returns the target state or NULL in case of error
@@ -5997,8 +6011,8 @@ xmlAutomataNewCountTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
*
* If @to is NULL, this creates first a new target state in the automata
* and then adds a transition from the @from state to the target state
- * activated by a succession of input of value @token and @token2 and whose
- * number is between @min and @max, moreover that transition can only be
+ * activated by a succession of input of value @token and @token2 and whose
+ * number is between @min and @max, moreover that transition can only be
* crossed once.
*
* Returns the target state or NULL in case of error
@@ -6040,7 +6054,7 @@ xmlAutomataNewOnceTrans2(xmlAutomataPtr am, xmlAutomataStatePtr from,
str[lenn + lenp + 1] = 0;
atom->valuep = str;
- }
+ }
atom->data = data;
atom->quant = XML_REGEXP_QUANT_ONCEONLY;
atom->min = min;
@@ -6063,7 +6077,7 @@ xmlAutomataNewOnceTrans2(xmlAutomataPtr am, xmlAutomataStatePtr from,
return(to);
}
-
+
/**
* xmlAutomataNewOnceTrans:
@@ -6132,7 +6146,7 @@ xmlAutomataNewOnceTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
*/
xmlAutomataStatePtr
xmlAutomataNewState(xmlAutomataPtr am) {
- xmlAutomataStatePtr to;
+ xmlAutomataStatePtr to;
if (am == NULL)
return(NULL);
@@ -6199,7 +6213,7 @@ xmlAutomataNewAllTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
*
* Returns the counter number or -1 in case of error
*/
-int
+int
xmlAutomataNewCounter(xmlAutomataPtr am, int min, int max) {
int ret;
@@ -6271,7 +6285,7 @@ xmlAutomataNewCounterTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
*
* Returns the compiled regexp or NULL in case of error
*/
-xmlRegexpPtr
+xmlRegexpPtr
xmlAutomataCompile(xmlAutomataPtr am) {
xmlRegexpPtr ret;
@@ -6291,7 +6305,7 @@ xmlAutomataCompile(xmlAutomataPtr am) {
*
* Returns 1 if true, 0 if not, and -1 in case of error
*/
-int
+int
xmlAutomataIsDeterminist(xmlAutomataPtr am) {
int ret;
@@ -6344,7 +6358,7 @@ xmlExpNewCtxt(int maxNodes, xmlDictPtr dict) {
if (maxNodes <= 4096)
maxNodes = 4096;
-
+
ret = (xmlExpCtxtPtr) xmlMalloc(sizeof(xmlExpCtxt));
if (ret == NULL)
return(NULL);
@@ -6398,7 +6412,7 @@ xmlExpFreeCtxt(xmlExpCtxtPtr ctxt) {
/* #define DEBUG_DERIV */
/*
- * TODO:
+ * TODO:
* - Wildcards
* - public API for creation
*
@@ -6466,11 +6480,11 @@ static unsigned short
xmlExpHashNameComputeKey(const xmlChar *name) {
unsigned short value = 0L;
char ch;
-
+
if (name != NULL) {
value += 30 * (*name);
while ((ch = *name++) != 0) {
- value = value ^ ((value << 5) + (value >> 3) + (unsigned short)ch);
+ value = value ^ ((value << 5) + (value >> 3) + (unsigned long)ch);
}
}
return (value);
@@ -6485,7 +6499,7 @@ xmlExpHashComputeKey(xmlExpNodeType type, xmlExpNodePtr left,
xmlExpNodePtr right) {
unsigned long value;
unsigned short ret;
-
+
switch (type) {
case XML_EXP_SEQ:
value = left->key;
@@ -6626,7 +6640,7 @@ xmlExpHashGetEntry(xmlExpCtxtPtr ctxt, xmlExpNodeType type,
left->exp_left->ref++;
tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left->exp_left, tmp,
NULL, 0, 0);
-
+
xmlExpFree(ctxt, left);
return(tmp);
}
@@ -6683,7 +6697,7 @@ xmlExpHashGetEntry(xmlExpCtxtPtr ctxt, xmlExpNodeType type,
return(right);
}
kbase = xmlExpHashComputeKey(type, left, right);
- } else
+ } else
return(NULL);
key = kbase % ctxt->size;
@@ -6824,7 +6838,7 @@ xmlExpRef(xmlExpNodePtr exp) {
* xmlExpNewAtom:
* @ctxt: the expression context
* @name: the atom name
- * @len: the atom name lenght in byte (or -1);
+ * @len: the atom name length in byte (or -1);
*
* Get the atom associated to this name from that context
*
@@ -6924,7 +6938,7 @@ xmlExpNewRange(xmlExpCtxtPtr ctxt, xmlExpNodePtr subset, int min, int max) {
************************************************************************/
static int
-xmlExpGetLanguageInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
+xmlExpGetLanguageInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
const xmlChar**list, int len, int nb) {
int tmp, tmp2;
tail:
@@ -6961,7 +6975,7 @@ tail:
* @ctxt: the expression context
* @exp: the expression
* @langList: where to store the tokens
- * @len: the allocated lenght of @list
+ * @len: the allocated length of @list
*
* Find all the strings used in @exp and store them in @list
*
@@ -6969,7 +6983,7 @@ tail:
* -2 if there is more than @len strings
*/
int
-xmlExpGetLanguage(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
+xmlExpGetLanguage(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
const xmlChar**langList, int len) {
if ((ctxt == NULL) || (exp == NULL) || (langList == NULL) || (len <= 0))
return(-1);
@@ -6977,7 +6991,7 @@ xmlExpGetLanguage(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
}
static int
-xmlExpGetStartInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
+xmlExpGetStartInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
const xmlChar**list, int len, int nb) {
int tmp, tmp2;
tail:
@@ -7027,7 +7041,7 @@ tail:
* @ctxt: the expression context
* @exp: the expression
* @tokList: where to store the tokens
- * @len: the allocated lenght of @list
+ * @len: the allocated length of @list
*
* Find all the strings that appears at the start of the languages
* accepted by @exp and store them in @list. E.g. for (a, b) | c
@@ -7037,7 +7051,7 @@ tail:
* -2 if there is more than @len strings
*/
int
-xmlExpGetStart(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
+xmlExpGetStart(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
const xmlChar**tokList, int len) {
if ((ctxt == NULL) || (exp == NULL) || (tokList == NULL) || (len <= 0))
return(-1);
@@ -7734,7 +7748,7 @@ xmlExpExpDeriveInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
xmlFree((xmlChar **) tab);
return(ret);
}
-
+
/**
* xmlExpExpDerive:
* @ctxt: the expressions context
@@ -7786,7 +7800,7 @@ xmlExpExpDerive(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
int
xmlExpSubsume(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
xmlExpNodePtr tmp;
-
+
if ((exp == NULL) || (ctxt == NULL) || (sub == NULL))
return(-1);
@@ -7830,7 +7844,7 @@ xmlExpSubsume(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
/************************************************************************
* *
- * Parsing expression *
+ * Parsing expression *
* *
************************************************************************/
@@ -7934,7 +7948,7 @@ parse_quantifier:
ret = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, ret, NULL, NULL,
0, -1);
SKIP_BLANKS
- }
+ }
return(ret);
}
@@ -8056,7 +8070,7 @@ xmlExpDumpInt(xmlBufferPtr buf, xmlExpNodePtr expr, int glob) {
break;
case XML_EXP_COUNT: {
char rep[40];
-
+
c = expr->exp_left;
if ((c->type == XML_EXP_SEQ) || (c->type == XML_EXP_OR))
xmlExpDumpInt(buf, c, 1);
« no previous file with comments | « third_party/libxml/src/xmlreader.c ('k') | third_party/libxml/src/xmlsave.c » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698