mirror of
https://github.com/reactos/reactos.git
synced 2025-08-05 20:23:34 +00:00
[LIBXML2]
- Trim trailing whitespace. Remove spaces before tabs. No code changes. CORE-6907 svn path=/trunk/; revision=58294
This commit is contained in:
Thomas Faber
parent
28bb645017
commit
54a7a551a2
110 changed files with 4235 additions and 4235 deletions
232
reactos/lib/3rdparty/libxml2/xmlregexp.c
vendored
232
reactos/lib/3rdparty/libxml2/xmlregexp.c
vendored
|
|
@ -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
|
||||
|
|
@ -65,15 +65,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 *
|
||||
* *
|
||||
************************************************************************/
|
||||
|
||||
/*
|
||||
|
|
@ -361,7 +361,7 @@ void xmlAutomataSetFlags(xmlAutomataPtr am, int flags);
|
|||
|
||||
/************************************************************************
|
||||
* *
|
||||
* Regexp memory error handler *
|
||||
* Regexp memory error handler *
|
||||
* *
|
||||
************************************************************************/
|
||||
/**
|
||||
|
|
@ -408,9 +408,9 @@ xmlRegexpErrCompile(xmlRegParserCtxtPtr ctxt, const char *extra)
|
|||
}
|
||||
|
||||
/************************************************************************
|
||||
* *
|
||||
* Allocation/Deallocation *
|
||||
* *
|
||||
* *
|
||||
* Allocation/Deallocation *
|
||||
* *
|
||||
************************************************************************/
|
||||
|
||||
static int xmlFAComputesDeterminism(xmlRegParserCtxtPtr ctxt);
|
||||
|
|
@ -931,9 +931,9 @@ xmlRegFreeParserCtxt(xmlRegParserCtxtPtr ctxt) {
|
|||
}
|
||||
|
||||
/************************************************************************
|
||||
* *
|
||||
* Display of Data structures *
|
||||
* *
|
||||
* *
|
||||
* Display of Data structures *
|
||||
* *
|
||||
************************************************************************/
|
||||
|
||||
static void
|
||||
|
|
@ -1140,7 +1140,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 +1154,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 +1204,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 +1249,7 @@ xmlRegAtomAddRange(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom,
|
|||
return;
|
||||
range->blockName = blockName;
|
||||
atom->ranges[atom->nbRanges++] = range;
|
||||
|
||||
|
||||
}
|
||||
|
||||
static int
|
||||
|
|
@ -1280,7 +1280,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 +1312,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 +1340,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 +1406,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 +1560,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 +1574,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 +1618,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 +1677,7 @@ xmlFAGenerateTransitions(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr from,
|
|||
break;
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
if ((atom->min == 0) && (atom->max == 0) &&
|
||||
(atom->quant == XML_REGEXP_QUANT_RANGE)) {
|
||||
/*
|
||||
|
|
@ -1703,9 +1703,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 +1713,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 +1742,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 +1759,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 +1803,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 +1825,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 +1841,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 +1877,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 +1890,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 +1907,7 @@ xmlFAEliminateSimpleEpsilonTransitions(xmlRegParserCtxtPtr ctxt) {
|
|||
state->type = XML_REGEXP_UNREACH_STATE;
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -2109,7 +2109,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)) ||
|
||||
|
|
@ -2773,9 +2773,9 @@ xmlFAComputesDeterminism(xmlRegParserCtxtPtr ctxt) {
|
|||
}
|
||||
|
||||
/************************************************************************
|
||||
* *
|
||||
* *
|
||||
* Routines to check input against transition atoms *
|
||||
* *
|
||||
* *
|
||||
************************************************************************/
|
||||
|
||||
static int
|
||||
|
|
@ -2804,7 +2804,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 +3052,9 @@ xmlRegCheckCharacter(xmlRegAtomPtr atom, int codepoint) {
|
|||
}
|
||||
|
||||
/************************************************************************
|
||||
* *
|
||||
* *
|
||||
* Saving and restoring state of an execution context *
|
||||
* *
|
||||
* *
|
||||
************************************************************************/
|
||||
|
||||
#ifdef DEBUG_REGEXP_EXEC
|
||||
|
|
@ -3165,9 +3165,9 @@ xmlFARegExecRollBack(xmlRegExecCtxtPtr exec) {
|
|||
}
|
||||
|
||||
/************************************************************************
|
||||
* *
|
||||
* *
|
||||
* Verifier, running an input against a compiled regexp *
|
||||
* *
|
||||
* *
|
||||
************************************************************************/
|
||||
|
||||
static int
|
||||
|
|
@ -3466,9 +3466,9 @@ error:
|
|||
}
|
||||
|
||||
/************************************************************************
|
||||
* *
|
||||
* *
|
||||
* Progressive interface to the verifier one atom at a time *
|
||||
* *
|
||||
* *
|
||||
************************************************************************/
|
||||
#ifdef DEBUG_ERR
|
||||
static void testerr(xmlRegExecCtxtPtr exec);
|
||||
|
|
@ -3585,7 +3585,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 +3614,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 +3684,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 +3705,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 +3841,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;
|
||||
|
|
@ -4199,7 +4199,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);
|
||||
|
||||
|
|
@ -4305,7 +4305,7 @@ xmlRegExecGetValues(xmlRegExecCtxtPtr exec, int err,
|
|||
values[nb++] = (xmlChar *) atom->valuep;
|
||||
(*nbval)++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (transno = 0;
|
||||
(transno < state->nbTrans) && (nb < maxval);
|
||||
|
|
@ -4332,7 +4332,7 @@ xmlRegExecGetValues(xmlRegExecCtxtPtr exec, int err,
|
|||
values[nb++] = (xmlChar *) atom->valuep;
|
||||
(*nbneg)++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return(0);
|
||||
|
|
@ -4563,10 +4563,10 @@ progress:
|
|||
}
|
||||
#endif
|
||||
/************************************************************************
|
||||
* *
|
||||
* *
|
||||
* Parser for the Schemas Datatype Regular Expressions *
|
||||
* http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#regexs *
|
||||
* *
|
||||
* *
|
||||
************************************************************************/
|
||||
|
||||
/**
|
||||
|
|
@ -4595,7 +4595,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 +4610,7 @@ xmlFAParseCharProp(xmlRegParserCtxtPtr ctxt) {
|
|||
int cur;
|
||||
xmlRegAtomType type = (xmlRegAtomType) 0;
|
||||
xmlChar *blockName = NULL;
|
||||
|
||||
|
||||
cur = CUR;
|
||||
if (cur == 'L') {
|
||||
NEXT;
|
||||
|
|
@ -4782,15 +4782,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 +4816,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 +4913,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 +4960,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 +5075,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 +5323,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 +5332,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;
|
||||
|
|
@ -5381,9 +5381,9 @@ xmlFAParseRegExp(xmlRegParserCtxtPtr ctxt, int top) {
|
|||
}
|
||||
|
||||
/************************************************************************
|
||||
* *
|
||||
* The basic API *
|
||||
* *
|
||||
* *
|
||||
* The basic API *
|
||||
* *
|
||||
************************************************************************/
|
||||
|
||||
/**
|
||||
|
|
@ -5570,9 +5570,9 @@ xmlRegFreeRegexp(xmlRegexpPtr regexp) {
|
|||
|
||||
#ifdef LIBXML_AUTOMATA_ENABLED
|
||||
/************************************************************************
|
||||
* *
|
||||
* The Automata interface *
|
||||
* *
|
||||
* *
|
||||
* The Automata interface *
|
||||
* *
|
||||
************************************************************************/
|
||||
|
||||
/**
|
||||
|
|
@ -5843,7 +5843,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 +5997,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 +6040,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 +6063,7 @@ xmlAutomataNewOnceTrans2(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
|||
return(to);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* xmlAutomataNewOnceTrans:
|
||||
|
|
@ -6132,7 +6132,7 @@ xmlAutomataNewOnceTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
|||
*/
|
||||
xmlAutomataStatePtr
|
||||
xmlAutomataNewState(xmlAutomataPtr am) {
|
||||
xmlAutomataStatePtr to;
|
||||
xmlAutomataStatePtr to;
|
||||
|
||||
if (am == NULL)
|
||||
return(NULL);
|
||||
|
|
@ -6199,7 +6199,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 +6271,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 +6291,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 +6344,7 @@ xmlExpNewCtxt(int maxNodes, xmlDictPtr dict) {
|
|||
|
||||
if (maxNodes <= 4096)
|
||||
maxNodes = 4096;
|
||||
|
||||
|
||||
ret = (xmlExpCtxtPtr) xmlMalloc(sizeof(xmlExpCtxt));
|
||||
if (ret == NULL)
|
||||
return(NULL);
|
||||
|
|
@ -6398,7 +6398,7 @@ xmlExpFreeCtxt(xmlExpCtxtPtr ctxt) {
|
|||
/* #define DEBUG_DERIV */
|
||||
|
||||
/*
|
||||
* TODO:
|
||||
* TODO:
|
||||
* - Wildcards
|
||||
* - public API for creation
|
||||
*
|
||||
|
|
@ -6466,7 +6466,7 @@ static unsigned short
|
|||
xmlExpHashNameComputeKey(const xmlChar *name) {
|
||||
unsigned short value = 0L;
|
||||
char ch;
|
||||
|
||||
|
||||
if (name != NULL) {
|
||||
value += 30 * (*name);
|
||||
while ((ch = *name++) != 0) {
|
||||
|
|
@ -6485,7 +6485,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 +6626,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 +6683,7 @@ xmlExpHashGetEntry(xmlExpCtxtPtr ctxt, xmlExpNodeType type,
|
|||
return(right);
|
||||
}
|
||||
kbase = xmlExpHashComputeKey(type, left, right);
|
||||
} else
|
||||
} else
|
||||
return(NULL);
|
||||
|
||||
key = kbase % ctxt->size;
|
||||
|
|
@ -6924,7 +6924,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:
|
||||
|
|
@ -6969,7 +6969,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 +6977,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:
|
||||
|
|
@ -7037,7 +7037,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 +7734,7 @@ xmlExpExpDeriveInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
|
|||
xmlFree((xmlChar **) tab);
|
||||
return(ret);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* xmlExpExpDerive:
|
||||
* @ctxt: the expressions context
|
||||
|
|
@ -7786,7 +7786,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 +7830,7 @@ xmlExpSubsume(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
|
|||
|
||||
/************************************************************************
|
||||
* *
|
||||
* Parsing expression *
|
||||
* Parsing expression *
|
||||
* *
|
||||
************************************************************************/
|
||||
|
||||
|
|
@ -7934,7 +7934,7 @@ parse_quantifier:
|
|||
ret = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, ret, NULL, NULL,
|
||||
0, -1);
|
||||
SKIP_BLANKS
|
||||
}
|
||||
}
|
||||
return(ret);
|
||||
}
|
||||
|
||||
|
|
@ -8056,7 +8056,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);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue