Update libxml to 2.7.7.

third_party/libxml/xmlregexp.c

 /*
  * regexp.c: generic and extensible Regular Expression engine
  *
  * 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
  *    - XML Schemas structure part 1
  *    - XML Schemas Datatypes part 2 especially Appendix F
  *    - RELAX-NG/TREX i.e. the counter proposal
@@ skipping 215 matching lines @@
     xmlRegTrans *trans;
     /*  knowing states ponting to us can speed things up */
     int maxTransTo;
     int nbTransTo;
     int *transTo;
 };
 
 typedef struct _xmlAutomata xmlRegParserCtxt;
 typedef xmlRegParserCtxt *xmlRegParserCtxtPtr;
 
+#define AM_AUTOMATA_RNG 1
+
 struct _xmlAutomata {
     xmlChar *string;
     xmlChar *cur;
 
     int error;
     int neg;
 
     xmlRegStatePtr start;
     xmlRegStatePtr end;
     xmlRegStatePtr state;
 
     xmlRegAtomPtr atom;
 
     int maxAtoms;
     int nbAtoms;
     xmlRegAtomPtr *atoms;
 
     int maxStates;
     int nbStates;
     xmlRegStatePtr *states;
 
     int maxCounters;
     int nbCounters;
     xmlRegCounter *counters;
 
     int determinist;
     int negs;
+    int flags;
 };
 
 struct _xmlRegexp {
     xmlChar *string;
     int nbStates;
     xmlRegStatePtr *states;
     int nbAtoms;
     xmlRegAtomPtr *atoms;
     int nbCounters;
     xmlRegCounter *counters;
     int determinist;
+    int flags;
     /*
      * That's the compact form for determinists automatas
      */
     int nbstates;
     int *compact;
     void **transdata;
     int nbstrings;
     xmlChar **stringMap;
 };
 
@@ skipping 62 matching lines @@
 #define REGEXP_ALL_LAX_COUNTER  0x123457
 
 static void xmlFAParseRegExp(xmlRegParserCtxtPtr ctxt, int top);
 static void xmlRegFreeState(xmlRegStatePtr state);
 static void xmlRegFreeAtom(xmlRegAtomPtr atom);
 static int xmlRegStrEqualWildcard(const xmlChar *expStr, const xmlChar *valStr);
 static int xmlRegCheckCharacter(xmlRegAtomPtr atom, int codepoint);
 static int xmlRegCheckCharacterRange(xmlRegAtomType type, int codepoint,
                   int neg, int start, int end, const xmlChar *blockName);
 
+void xmlAutomataSetFlags(xmlAutomataPtr am, int flags);
+
 /************************************************************************
  *                                                                      *
  *              Regexp memory error handler                             *
  *                                                                      *
  ************************************************************************/
 /**
  * xmlRegexpErrMemory:
  * @extra:  extra information
  *
  * Handle an out of memory condition
@@ skipping 61 matching lines @@
     }
     memset(ret, 0, sizeof(xmlRegexp));
     ret->string = ctxt->string;
     ret->nbStates = ctxt->nbStates;
     ret->states = ctxt->states;
     ret->nbAtoms = ctxt->nbAtoms;
     ret->atoms = ctxt->atoms;
     ret->nbCounters = ctxt->nbCounters;
     ret->counters = ctxt->counters;
     ret->determinist = ctxt->determinist;
+    ret->flags = ctxt->flags;
     if (ret->determinist == -1) {
         xmlRegexpIsDeterminist(ret);
     }
 
     if ((ret->determinist != 0) &&
         (ret->nbCounters == 0) &&
         (ctxt->negs == 0) &&
         (ret->atoms != NULL) &&
         (ret->atoms[0] != NULL) &&
         (ret->atoms[0]->type == XML_REGEXP_STRING)) {
@@ skipping 1115 matching lines @@
 #endif
         }
         switch (atom->quant) {
             case XML_REGEXP_QUANT_OPT:
                 atom->quant = XML_REGEXP_QUANT_ONCE;
                 /*
                  * 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. 
                  */
-                xmlFAGenerateEpsilonTransition(ctxt, atom->start, 0);
-                xmlFAGenerateEpsilonTransition(ctxt, atom->stop, ctxt->state);
+                if (to == NULL) {
+                    xmlFAGenerateEpsilonTransition(ctxt, atom->start, 0);
+                    xmlFAGenerateEpsilonTransition(ctxt, atom->stop,
+                                                   ctxt->state);
+                } else {
+                    xmlFAGenerateEpsilonTransition(ctxt, atom->start, to);
+                }
                 break;
             case XML_REGEXP_QUANT_MULT:
                 atom->quant = XML_REGEXP_QUANT_ONCE;
                 xmlFAGenerateEpsilonTransition(ctxt, atom->start, atom->stop);
                 xmlFAGenerateEpsilonTransition(ctxt, atom->stop, atom->start);
                 break;
             case XML_REGEXP_QUANT_PLUS:
                 atom->quant = XML_REGEXP_QUANT_ONCE;
                 xmlFAGenerateEpsilonTransition(ctxt, atom->stop, atom->start);
                 break;
@@ skipping 492 matching lines @@
         range1 = range2;
         range2 = tmp;
     }
     if ((range1->type == XML_REGEXP_ANYCHAR) ||
         (range2->type == XML_REGEXP_ANYCHAR)) {
         ret = 1;
     } else if ((range1->type == XML_REGEXP_EPSILON) ||
                (range2->type == XML_REGEXP_EPSILON)) {
         return(0);
     } else if (range1->type == range2->type) {
-        if ((range1->type != XML_REGEXP_CHARVAL) ||
-            (range1->end < range2->start) ||
-            (range2->end < range1->start))
+        if (range1->type != XML_REGEXP_CHARVAL)
+            ret = 1;
+        else if ((range1->end < range2->start) ||
+                 (range2->end < range1->start))
+            ret = 0;
+        else
             ret = 1;
-        else
-            ret = 0;
     } else if (range1->type == XML_REGEXP_CHARVAL) {
         int codepoint;
         int neg = 0;
 
         /*
          * 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 
          * pushing too many states when evaluating.
          */
@@ skipping 106 matching lines @@
                      ret = 0;
                  else {
                      /* safety net ! */
                      return(1);
                  }
         }
     }
     if (((range1->neg == 0) && (range2->neg != 0)) ||
         ((range1->neg != 0) && (range2->neg == 0)))
         ret = !ret;
-    return(1);
+    return(ret);
 }
 
 /**
  * xmlFACompareAtomTypes:
  * @type1:  an atom type
  * @type2:  an atom type
  *
  * Compares two atoms type to check whether they intersect in some ways,
  * this is used by xmlFACompareAtoms only
  *
@@ skipping 187 matching lines @@
         default:
             break;
     }
     return(1);
 }
 
 /**
  * xmlFAEqualAtoms:
  * @atom1:  an atom
  * @atom2:  an atom
+ * @deep: if not set only compare string pointers
  *
  * Compares two atoms to check whether they are the same exactly
  * this is used to remove equivalent transitions
  *
  * Returns 1 if same and 0 otherwise
  */
 static int
-xmlFAEqualAtoms(xmlRegAtomPtr atom1, xmlRegAtomPtr atom2) {
+xmlFAEqualAtoms(xmlRegAtomPtr atom1, xmlRegAtomPtr atom2, int deep) {
     int ret = 0;
 
     if (atom1 == atom2)
         return(1);
     if ((atom1 == NULL) || (atom2 == NULL))
         return(0);
 
     if (atom1->type != atom2->type)
         return(0);
     switch (atom1->type) {
         case XML_REGEXP_EPSILON:
             ret = 0;
             break;
         case XML_REGEXP_STRING:
-            ret = xmlStrEqual((xmlChar *)atom1->valuep,
-                              (xmlChar *)atom2->valuep);
+            if (!deep)
+                ret = (atom1->valuep == atom2->valuep);
+            else
+                ret = xmlStrEqual((xmlChar *)atom1->valuep,
+                                  (xmlChar *)atom2->valuep);
             break;
         case XML_REGEXP_CHARVAL:
             ret = (atom1->codepoint == atom2->codepoint);
             break;
         case XML_REGEXP_RANGES:
             /* too hard to do in the general case */
             ret = 0;
         default:
             break;
     }
     return(ret);
 }
 
 /**
  * xmlFACompareAtoms:
  * @atom1:  an atom
  * @atom2:  an atom
+ * @deep: if not set only compare string pointers
  *
  * Compares two atoms to check whether they intersect in some ways,
  * this is used by xmlFAComputesDeterminism and xmlFARecurseDeterminism only
  *
  * Returns 1 if yes and 0 otherwise
  */
 static int
-xmlFACompareAtoms(xmlRegAtomPtr atom1, xmlRegAtomPtr atom2) {
+xmlFACompareAtoms(xmlRegAtomPtr atom1, xmlRegAtomPtr atom2, int deep) {
     int ret = 1;
 
     if (atom1 == atom2)
         return(1);
     if ((atom1 == NULL) || (atom2 == NULL))
         return(0);
 
     if ((atom1->type == XML_REGEXP_ANYCHAR) ||
         (atom2->type == XML_REGEXP_ANYCHAR))
         return(1);
 
     if (atom1->type > atom2->type) {
         xmlRegAtomPtr tmp;
         tmp = atom1;
         atom1 = atom2;
         atom2 = tmp;
     }
     if (atom1->type != atom2->type) {
         ret = xmlFACompareAtomTypes(atom1->type, atom2->type);
         /* if they can't intersect at the type level break now */
         if (ret == 0)
             return(0);
     }
     switch (atom1->type) {
         case XML_REGEXP_STRING:
-            ret = xmlRegStrEqualWildcard((xmlChar *)atom1->valuep,
-                                         (xmlChar *)atom2->valuep);
+            if (!deep)
+                ret = (atom1->valuep != atom2->valuep);
+            else
+                ret = xmlRegStrEqualWildcard((xmlChar *)atom1->valuep,
+                                             (xmlChar *)atom2->valuep);
             break;
         case XML_REGEXP_EPSILON:
             goto not_determinist;
         case XML_REGEXP_CHARVAL:
             if (atom2->type == XML_REGEXP_CHARVAL) {
                 ret = (atom1->codepoint == atom2->codepoint);
             } else {
                 ret = xmlRegCheckCharacter(atom2, atom1->codepoint);
                 if (ret < 0)
                     ret = 1;
@@ skipping 42 matching lines @@
  * should be called after xmlFAEliminateEpsilonTransitions()
  *
  */
 static int
 xmlFARecurseDeterminism(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state,
                          int to, xmlRegAtomPtr atom) {
     int ret = 1;
     int res;
     int transnr, nbTrans;
     xmlRegTransPtr t1;
+    int deep = 1;
 
     if (state == NULL)
         return(ret);
+
+    if (ctxt->flags & AM_AUTOMATA_RNG)
+        deep = 0;
+
     /*
      * don't recurse on transitions potentially added in the course of
      * the elimination.
      */
     nbTrans = state->nbTrans;
     for (transnr = 0;transnr < nbTrans;transnr++) {
         t1 = &(state->trans[transnr]);
         /*
          * check transitions conflicting with the one looked at
          */
         if (t1->atom == NULL) {
             if (t1->to < 0)
                 continue;
             res = xmlFARecurseDeterminism(ctxt, ctxt->states[t1->to],
                                            to, atom);
             if (res == 0) {
                 ret = 0;
                 /* t1->nd = 1; */
             }
             continue;
         }
         if (t1->to != to)
             continue;
-        if (xmlFACompareAtoms(t1->atom, atom)) {
+        if (xmlFACompareAtoms(t1->atom, atom, deep)) {
             ret = 0;
             /* mark the transition as non-deterministic */
             t1->nd = 1;
         }
     }
     return(ret);
 }
 
 /**
  * xmlFAComputesDeterminism:
  * @ctxt:  a regexp parser context
  *
  * Check whether the associated regexp is determinist,
  * should be called after xmlFAEliminateEpsilonTransitions()
  *
  */
 static int
 xmlFAComputesDeterminism(xmlRegParserCtxtPtr ctxt) {
     int statenr, transnr;
     xmlRegStatePtr state;
     xmlRegTransPtr t1, t2, last;
     int i;
     int ret = 1;
+    int deep = 1;
 
 #ifdef DEBUG_REGEXP_GRAPH
     printf("xmlFAComputesDeterminism\n");
     xmlRegPrintCtxt(stdout, ctxt);
 #endif
     if (ctxt->determinist != -1)
         return(ctxt->determinist);
 
+    if (ctxt->flags & AM_AUTOMATA_RNG)
+        deep = 0;
+
     /*
      * First cleanup the automata removing cancelled transitions
      */
     for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
         state = ctxt->states[statenr];
         if (state == NULL)
             continue;
         if (state->nbTrans < 2)
             continue;
         for (transnr = 0;transnr < state->nbTrans;transnr++) {
             t1 = &(state->trans[transnr]);
             /*
              * Determinism checks in case of counted or all transitions
              * will have to be handled separately
              */
             if (t1->atom == NULL) {
                 /* t1->nd = 1; */
                 continue;
             }
             if (t1->to == -1) /* eliminated */
                 continue;
             for (i = 0;i < transnr;i++) {
                 t2 = &(state->trans[i]);
                 if (t2->to == -1) /* eliminated */
                     continue;
                 if (t2->atom != NULL) {
                     if (t1->to == t2->to) {
-                        if (xmlFAEqualAtoms(t1->atom, t2->atom))
+                        /*
+                         * Here we use deep because we want to keep the
+                         * transitions which indicate a conflict
+                         */
+                        if (xmlFAEqualAtoms(t1->atom, t2->atom, deep) &&
+                            (t1->counter == t2->counter) &&
+                            (t1->count == t2->count))
                             t2->to = -1; /* eliminated */
                     }
                 }
             }
         }
     }
 
     /*
      * Check for all states that there aren't 2 transitions
      * with the same atom and a different target.
@@ skipping 14 matching lines @@
             if (t1->atom == NULL) {
                 continue;
             }
             if (t1->to == -1) /* eliminated */
                 continue;
             for (i = 0;i < transnr;i++) {
                 t2 = &(state->trans[i]);
                 if (t2->to == -1) /* eliminated */
                     continue;
                 if (t2->atom != NULL) {
-                    /* not determinist ! */
-                    if (xmlFACompareAtoms(t1->atom, t2->atom)) {
+                    /*
+                     * But here we don't use deep because we want to
+                     * find transitions which indicate a conflict
+                     */
+                    if (xmlFACompareAtoms(t1->atom, t2->atom, 1)) {
                         ret = 0;
                         /* mark the transitions as non-deterministic ones */
                         t1->nd = 1;
                         t2->nd = 1;
                         last = t1;
                     }
                 } else if (t1->to != -1) {
                     /*
                      * do the closure in case of remaining specific
                      * epsilon transitions like choices or all
@@ skipping 459 matching lines @@
         exec->counts = (int *) xmlMalloc(comp->nbCounters * sizeof(int));
         if (exec->counts == NULL) {
             xmlRegexpErrMemory(NULL, "running regexp");
             return(-1);
         }
         memset(exec->counts, 0, comp->nbCounters * sizeof(int));
     } else
         exec->counts = NULL;
     while ((exec->status == 0) &&
            ((exec->inputString[exec->index] != 0) ||
-            (exec->state->type != XML_REGEXP_FINAL_STATE))) {
+            ((exec->state != NULL) &&
+             (exec->state->type != XML_REGEXP_FINAL_STATE)))) {
         xmlRegTransPtr trans;
         xmlRegAtomPtr atom;
 
         /*
          * If end of input on non-terminal state, rollback, however we may
          * still have epsilon like transition for counted transitions
          * on counters, in that case don't break too early.  Additionally,
          * if we are working on a range like "AB{0,2}", where B is not present,
          * we don't want to break.
          */
@@ skipping 1669 matching lines @@
                         ctxt->atom->codepoint = '\r';
                         break;
                     case 't':
                         ctxt->atom->codepoint = '\t';
                         break;
                     default:
                         ctxt->atom->codepoint = cur;
                 }
             }
         } else if (ctxt->atom->type == XML_REGEXP_RANGES) {
+            switch (cur) {
+                case 'n':
+                    cur = '\n';
+                    break;
+                case 'r':
+                    cur = '\r';
+                    break;
+                case 't':
+                    cur = '\t';
+                    break;
+            }
             xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
                                XML_REGEXP_CHARVAL, cur, cur, NULL);
         }
         NEXT;
     } else if ((cur == 's') || (cur == 'S') || (cur == 'i') || (cur == 'I') ||
         (cur == 'c') || (cur == 'C') || (cur == 'd') || (cur == 'D') ||
         (cur == 'w') || (cur == 'W')) {
         xmlRegAtomType type = XML_REGEXP_ANYSPACE;
 
         switch (cur) {
@@ skipping 34 matching lines @@
         } else if (ctxt->atom->type == XML_REGEXP_RANGES) {
             xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
                                type, 0, 0, NULL);
         }
     } else {
         ERROR("Wrong escape sequence, misuse of character '\\'");
     }
 }
 
 /**
- * xmlFAParseCharRef:
- * @ctxt:  a regexp parser context
- *
- * [19]   XmlCharRef   ::=   ( '&#' [0-9]+ ';' ) | (' &#x' [0-9a-fA-F]+ ';' )
- */
-static int
-xmlFAParseCharRef(xmlRegParserCtxtPtr ctxt) {
-    int ret = 0, cur;
-
-    if ((CUR != '&') || (NXT(1) != '#'))
-        return(-1);
-    NEXT;
-    NEXT;
-    cur = CUR;
-    if (cur == 'x') {
-        NEXT;
-        cur = CUR;
-        if (((cur >= '0') && (cur <= '9')) ||
-            ((cur >= 'a') && (cur <= 'f')) ||
-            ((cur >= 'A') && (cur <= 'F'))) {
-            while (((cur >= '0') && (cur <= '9')) ||
-                   ((cur >= 'a') && (cur <= 'f')) ||
-                   ((cur >= 'A') && (cur <= 'F'))) {
-                if ((cur >= '0') && (cur <= '9'))
-                    ret = ret * 16 + cur - '0';
-                else if ((cur >= 'a') && (cur <= 'f'))
-                    ret = ret * 16 + 10 + (cur - 'a');
-                else
-                    ret = ret * 16 + 10 + (cur - 'A');
-                NEXT;
-                cur = CUR;
-            }
-        } else {
-            ERROR("Char ref: expecting [0-9A-F]");
-            return(-1);
-        }
-    } else {
-        if ((cur >= '0') && (cur <= '9')) {
-            while ((cur >= '0') && (cur <= '9')) {
-                ret = ret * 10 + cur - '0';
-                NEXT;
-                cur = CUR;
-            }
-        } else {
-            ERROR("Char ref: expecting [0-9]");
-            return(-1);
-        }
-    }
-    if (cur != ';') {
-        ERROR("Char ref: expecting ';'");
-        return(-1);
-    } else {
-        NEXT;
-    }
-    return(ret);
-}
-
-/**
  * xmlFAParseCharRange:
  * @ctxt:  a regexp parser context
  *
  * [17]   charRange   ::=     seRange | XmlCharRef | XmlCharIncDash 
  * [18]   seRange   ::=   charOrEsc '-' charOrEsc
  * [20]   charOrEsc   ::=   XmlChar | SingleCharEsc
  * [21]   XmlChar   ::=   [^\#x2D#x5B#x5D]
  * [22]   XmlCharIncDash   ::=   [^\#x5B#x5D]
  */
 static void
 xmlFAParseCharRange(xmlRegParserCtxtPtr ctxt) {
     int cur, len;
     int start = -1;
     int end = -1;
 
     if (CUR == '\0') {
         ERROR("Expecting ']'");
         return;
     }
 
-    if ((CUR == '&') && (NXT(1) == '#')) {
-        end = start = xmlFAParseCharRef(ctxt);
-        xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
-                           XML_REGEXP_CHARVAL, start, end, NULL);
-        return;
-    }
     cur = CUR;
     if (cur == '\\') {
         NEXT;
         cur = CUR;
         switch (cur) {
             case 'n': start = 0xA; break;
             case 'r': start = 0xD; break;
             case 't': start = 0x9; break;
             case '\\': case '|': case '.': case '-': case '^': case '?':
             case '*': case '+': case '{': case '}': case '(': case ')':
@@ skipping 523 matching lines @@
 
         for (i = 0;i < am->nbStates;i++)
             xmlRegFreeState(am->states[i]);
         xmlFree(am->states);
     }
     am->nbAtoms = comp->nbAtoms;
     am->atoms = comp->atoms;
     am->nbStates = comp->nbStates;
     am->states = comp->states;
     am->determinist = -1;
+    am->flags = comp->flags;
     ret = xmlFAComputesDeterminism(am);
     am->atoms = NULL;
     am->states = NULL;
     xmlFreeAutomata(am);
+    comp->determinist = ret;
     return(ret);
 }
 
 /**
  * xmlRegFreeRegexp:
  * @regexp:  the regexp
  *
  * Free a regexp
  */
 void
@@ skipping 57 matching lines @@
     if (ctxt->start == NULL) {
         xmlFreeAutomata(ctxt);
         return(NULL);
     }
     ctxt->start->type = XML_REGEXP_START_STATE;
     if (xmlRegStatePush(ctxt, ctxt->start) < 0) {
         xmlRegFreeState(ctxt->start);
         xmlFreeAutomata(ctxt);
         return(NULL);
     }
+    ctxt->flags = 0;
 
     return(ctxt);
 }
 
 /**
  * xmlFreeAutomata:
  * @am: an automata
  *
  * Free an automata
  */
 void
 xmlFreeAutomata(xmlAutomataPtr am) {
     if (am == NULL)
         return;
     xmlRegFreeParserCtxt(am);
 }
 
 /**
+ * xmlAutomataSetFlags:
+ * @am: an automata
+ * @flags:  a set of internal flags
+ *
+ * Set some flags on the automata
+ */
+void
+xmlAutomataSetFlags(xmlAutomataPtr am, int flags) {
+    if (am == NULL)
+        return;
+    am->flags |= flags;
+}
+
+/**
  * xmlAutomataGetInitState:
  * @am: an automata
  *
  * Initial state lookup
  *
  * Returns the initial state of the automata
  */
 xmlAutomataStatePtr
 xmlAutomataGetInitState(xmlAutomataPtr am) {
     if (am == NULL)
@@ skipping 665 matching lines @@
  *              Expression handling context                             *
  *                                                                      *
  ************************************************************************/
 
 struct _xmlExpCtxt {
     xmlDictPtr dict;
     xmlExpNodePtr *table;
     int size;
     int nbElems;
     int nb_nodes;
+    int maxNodes;
     const char *expr;
     const char *cur;
     int nb_cons;
     int tabSize;
 };
 
 /**
  * xmlExpNewCtxt:
  * @maxNodes:  the maximum number of nodes
  * @dict:  optional dictionnary to use internally
  *
  * Creates a new context for manipulating expressions
  *
  * Returns the context or NULL in case of error
  */
 xmlExpCtxtPtr
 xmlExpNewCtxt(int maxNodes, xmlDictPtr dict) {
     xmlExpCtxtPtr ret;
     int size = 256;
 
     if (maxNodes <= 4096)
         maxNodes = 4096;
     
     ret = (xmlExpCtxtPtr) xmlMalloc(sizeof(xmlExpCtxt));
     if (ret == NULL)
         return(NULL);
     memset(ret, 0, sizeof(xmlExpCtxt));
     ret->size = size;
     ret->nbElems = 0;
+    ret->maxNodes = maxNodes;
     ret->table = xmlMalloc(size * sizeof(xmlExpNodePtr));
     if (ret->table == NULL) {
         xmlFree(ret);
         return(NULL);
     }
     memset(ret->table, 0, size * sizeof(xmlExpNodePtr));
     if (dict == NULL) {
         ret->dict = xmlDictCreate();
         if (ret->dict == NULL) {
             xmlFree(ret->table);
@@ skipping 565 matching lines @@
 tail:
     switch (exp->type) {
         case XML_EXP_EMPTY:
             return(0);
         case XML_EXP_ATOM:
             for (tmp = 0;tmp < nb;tmp++)
                 if (list[tmp] == exp->exp_str)
                     return(0);
             if (nb >= len)
                 return(-2);
-            list[nb++] = exp->exp_str;
+            list[nb] = exp->exp_str;
             return(1);
         case XML_EXP_COUNT:
             exp = exp->exp_left;
             goto tail;
         case XML_EXP_SEQ:
         case XML_EXP_OR:
             tmp = xmlExpGetLanguageInt(ctxt, exp->exp_left, list, len, nb);
             if (tmp < 0)
                 return(tmp);
             tmp2 = xmlExpGetLanguageInt(ctxt, exp->exp_right, list, len,
@@ skipping 34 matching lines @@
         case XML_EXP_FORBID:
             return(0);
         case XML_EXP_EMPTY:
             return(0);
         case XML_EXP_ATOM:
             for (tmp = 0;tmp < nb;tmp++)
                 if (list[tmp] == exp->exp_str)
                     return(0);
             if (nb >= len)
                 return(-2);
-            list[nb++] = exp->exp_str;
+            list[nb] = exp->exp_str;
             return(1);
         case XML_EXP_COUNT:
             exp = exp->exp_left;
             goto tail;
         case XML_EXP_SEQ:
             tmp = xmlExpGetStartInt(ctxt, exp->exp_left, list, len, nb);
             if (tmp < 0)
                 return(tmp);
             if (IS_NILLABLE(exp->exp_left)) {
                 tmp2 = xmlExpGetStartInt(ctxt, exp->exp_right, list, len,
@@ skipping 1138 matching lines @@
 xmlExpCtxtNbCons(xmlExpCtxtPtr ctxt) {
     if (ctxt == NULL)
         return(-1);
     return(ctxt->nb_cons);
 }
 
 #endif /* LIBXML_EXPR_ENABLED */
 #define bottom_xmlregexp
 #include "elfgcchack.h"
 #endif /* LIBXML_REGEXP_ENABLED */