Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/pattern.c

 /*
  * pattern.c: Implemetation of selectors for nodes
  *
  * Reference:
  *   http://www.w3.org/TR/2001/REC-xmlschema-1-20010502/
- *   to some extent 
+ *   to some extent
  *   http://www.w3.org/TR/1999/REC-xml-19991116
  *
  * See Copyright for the status of this software.
  *
  * daniel@veillard.com
  */
 
 /*
  * TODO:
  * - compilation flags to check for specific syntaxes
@@ skipping 15 matching lines @@
 #include <libxml/hash.h>
 #include <libxml/dict.h>
 #include <libxml/xmlerror.h>
 #include <libxml/parserInternals.h>
 #include <libxml/pattern.h>
 
 #ifdef LIBXML_PATTERN_ENABLED
 
 /* #define DEBUG_STREAMING */
 
+#ifdef ERROR
+#undef ERROR
+#endif
 #define ERROR(a, b, c, d)
 #define ERROR5(a, b, c, d, e)
 
 #define XML_STREAM_STEP_DESC    1
 #define XML_STREAM_STEP_FINAL   2
 #define XML_STREAM_STEP_ROOT    4
 #define XML_STREAM_STEP_ATTR    8
 #define XML_STREAM_STEP_NODE    16
 #define XML_STREAM_STEP_IN_SET  32
 
 /*
 * NOTE: Those private flags (XML_STREAM_xxx) are used
 *   in _xmlStreamCtxt->flag. They extend the public
 *   xmlPatternFlags, so be carefull not to interfere with the
-*   reserved values for xmlPatternFlags. 
+*   reserved values for xmlPatternFlags.
 */
 #define XML_STREAM_FINAL_IS_ANY_NODE 1<<14
 #define XML_STREAM_FROM_ROOT 1<<15
 #define XML_STREAM_DESC 1<<16
 
 /*
 * XML_STREAM_ANY_NODE is used for comparison against
 * xmlElementType enums, to indicate a node of any type.
 */
 #define XML_STREAM_ANY_NODE 100
@@ skipping 85 matching lines @@
 struct _xmlStepOp {
     xmlPatOp op;
     const xmlChar *value;
     const xmlChar *value2; /* The namespace name */
 };
 
 #define PAT_FROM_ROOT   (1<<8)
 #define PAT_FROM_CUR    (1<<9)
 
 struct _xmlPattern {
-    void *data;                 /* the associated template */
+    void *data;         /* the associated template */
     xmlDictPtr dict;            /* the optional dictionary */
     struct _xmlPattern *next;   /* next pattern if | is used */
     const xmlChar *pattern;     /* the pattern */
     int flags;                  /* flags */
     int nbStep;
     int maxStep;
     xmlStepOpPtr steps;        /* ops for computation */
     xmlStreamCompPtr stream;    /* the streaming data if any */
 };
 
 typedef struct _xmlPatParserContext xmlPatParserContext;
 typedef xmlPatParserContext *xmlPatParserContextPtr;
 struct _xmlPatParserContext {
     const xmlChar *cur;                 /* the current char being parsed */
     const xmlChar *base;                /* the full expression */
     int            error;               /* error code */
     xmlDictPtr     dict;                /* the dictionary if any */
     xmlPatternPtr  comp;                /* the result */
-    xmlNodePtr     elem;                /* the current node if any */    
+    xmlNodePtr     elem;                /* the current node if any */
     const xmlChar **namespaces;         /* the namespaces definitions */
     int   nb_namespaces;                /* the number of namespaces */
 };
 
 /************************************************************************
- *                                                                      *
- *                      Type functions                                  *
- *                                                                      *
+ *                                                                      *
+ *                      Type functions                                  *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xmlNewPattern:
  *
  * Create a new XSLT Pattern
  *
  * Returns the newly allocated xmlPatternPtr or NULL in case of error
  */
 static xmlPatternPtr
@@ skipping 98 matching lines @@
         ERROR(NULL, NULL, NULL,
                 "xmlNewPatParserContext : malloc failed\n");
         return(NULL);
     }
     memset(cur, 0, sizeof(xmlPatParserContext));
     cur->dict = dict;
     cur->cur = pattern;
     cur->base = pattern;
     if (namespaces != NULL) {
         int i;
-        for (i = 0;namespaces[2 * i] != NULL;i++);
+        for (i = 0;namespaces[2 * i] != NULL;i++)
+            ;
         cur->nb_namespaces = i;
     } else {
         cur->nb_namespaces = 0;
     }
     cur->namespaces = namespaces;
     return(cur);
 }
 
 /**
  * xmlFreePatParserContext:
  * @ctxt:  an XSLT parser context
  *
  * Free up the memory allocated by @ctxt
  */
 static void
 xmlFreePatParserContext(xmlPatParserContextPtr ctxt) {
     if (ctxt == NULL)
-        return;    
+        return;
     memset(ctxt, -1, sizeof(xmlPatParserContext));
     xmlFree(ctxt);
 }
 
 /**
  * xmlPatternAdd:
  * @comp:  the compiled match expression
  * @op:  an op
  * @value:  the first value
  * @value2:  the second value
@@ skipping 107 matching lines @@
         j--;
         i++;
     }
     comp->steps[comp->nbStep].value = NULL;
     comp->steps[comp->nbStep].value2 = NULL;
     comp->steps[comp->nbStep++].op = XML_OP_END;
     return(0);
 }
 
 /************************************************************************
- *                                                                      *
- *              The interpreter for the precompiled patterns            *
- *                                                                      *
+ *                                                                      *
+ *              The interpreter for the precompiled patterns            *
+ *                                                                      *
  ************************************************************************/
 
 static int
 xmlPatPushState(xmlStepStates *states, int step, xmlNodePtr node) {
     if ((states->states == NULL) || (states->maxstates <= 0)) {
         states->maxstates = 4;
         states->nbstates = 0;
         states->states = xmlMalloc(4 * sizeof(xmlStepState));
     }
     else if (states->maxstates <= states->nbstates) {
@@ skipping 231 matching lines @@
 #endif
     goto restart;
 }
 
 /************************************************************************
  *                                                                      *
  *                      Dedicated parser for templates                  *
  *                                                                      *
  ************************************************************************/
 
-#define TODO                                                            \
+#define TODO                                                            \
     xmlGenericError(xmlGenericErrorContext,                             \
             "Unimplemented block at %s:%d\n",                           \
             __FILE__, __LINE__);
 #define CUR (*ctxt->cur)
 #define SKIP(val) ctxt->cur += (val)
 #define NXT(val) ctxt->cur[(val)]
 #define PEEKPREV(val) ctxt->cur[-(val)]
 #define CUR_PTR ctxt->cur
 
-#define SKIP_BLANKS                                                     \
+#define SKIP_BLANKS                                                     \
     while (IS_BLANK_CH(CUR)) NEXT
 
 #define CURRENT (*ctxt->cur)
 #define NEXT ((*ctxt->cur) ?  ctxt->cur++: ctxt->cur)
 
 
-#define PUSH(op, val, val2)                                             \
+#define PUSH(op, val, val2)                                             \
     if (xmlPatternAdd(ctxt, ctxt->comp, (op), (val), (val2))) goto error;
 
 #define XSLT_ERROR(X)                                                   \
     { xsltError(ctxt, __FILE__, __LINE__, X);                           \
       ctxt->error = (X); return; }
 
 #define XSLT_ERROR0(X)                                                  \
     { xsltError(ctxt, __FILE__, __LINE__, X);                           \
       ctxt->error = (X); return(0); }
 
@@ skipping 25 matching lines @@
             cur += len;
             val = xmlStringCurrentChar(NULL, cur, &len);
         }
         if (!IS_CHAR(val)) {
             ctxt->error = 1;
             return(NULL);
         } else {
             if (ctxt->dict)
                 ret = (xmlChar *) xmlDictLookup(ctxt->dict, q, cur - q);
             else
-                ret = xmlStrndup(q, cur - q);       
+                ret = xmlStrndup(q, cur - q);
         }
         cur += len;
         CUR_PTR = cur;
     } else if (CUR == '\'') {
         NEXT;
         cur = q = CUR_PTR;
         val = xmlStringCurrentChar(NULL, cur, &len);
         while ((IS_CHAR(val)) && (val != '\'')) {
             cur += len;
             val = xmlStringCurrentChar(NULL, cur, &len);
         }
         if (!IS_CHAR(val)) {
             ctxt->error = 1;
             return(NULL);
         } else {
             if (ctxt->dict)
                 ret = (xmlChar *) xmlDictLookup(ctxt->dict, q, cur - q);
             else
-                ret = xmlStrndup(q, cur - q);       
+                ret = xmlStrndup(q, cur - q);
         }
         cur += len;
         CUR_PTR = cur;
     } else {
         /* XP_ERROR(XPATH_START_LITERAL_ERROR); */
         ctxt->error = 1;
         return(NULL);
     }
     return(ret);
 }
 #endif
 
 /**
  * xmlPatScanName:
  * @ctxt:  the XPath Parser context
  *
- * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | 
+ * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' |
  *                  CombiningChar | Extender
  *
  * [5] Name ::= (Letter | '_' | ':') (NameChar)*
  *
  * [6] Names ::= Name (S Name)*
  *
  * Returns the Name parsed or NULL
  */
 
 static xmlChar *
 xmlPatScanName(xmlPatParserContextPtr ctxt) {
     const xmlChar *q, *cur;
     xmlChar *ret = NULL;
     int val, len;
 
     SKIP_BLANKS;
 
     cur = q = CUR_PTR;
     val = xmlStringCurrentChar(NULL, cur, &len);
     if (!IS_LETTER(val) && (val != '_') && (val != ':'))
         return(NULL);
 
     while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
            (val == '.') || (val == '-') ||
-           (val == '_') || 
+           (val == '_') ||
            (IS_COMBINING(val)) ||
            (IS_EXTENDER(val))) {
         cur += len;
         val = xmlStringCurrentChar(NULL, cur, &len);
     }
     if (ctxt->dict)
         ret = (xmlChar *) xmlDictLookup(ctxt->dict, q, cur - q);
     else
-        ret = xmlStrndup(q, cur - q);    
+        ret = xmlStrndup(q, cur - q);
     CUR_PTR = cur;
     return(ret);
 }
 
 /**
  * xmlPatScanNCName:
  * @ctxt:  the XPath Parser context
  *
  * Parses a non qualified name
  *
@@ skipping 59 matching lines @@
  * xmlCompileAttributeTest:
  * @ctxt:  the compilation context
  *
  * Compile an attribute test.
  */
 static void
 xmlCompileAttributeTest(xmlPatParserContextPtr ctxt) {
     xmlChar *token = NULL;
     xmlChar *name = NULL;
     xmlChar *URL = NULL;
-    
+
     SKIP_BLANKS;
     name = xmlPatScanNCName(ctxt);
     if (name == NULL) {
         if (CUR == '*') {
             PUSH(XML_OP_ATTR, NULL, NULL);
             NEXT;
         } else {
             ERROR(NULL, NULL, NULL,
                 "xmlCompileAttributeTest : Name expected\n");
             ctxt->error = 1;
         }
         return;
     }
     if (CUR == ':') {
         int i;
         xmlChar *prefix = name;
-        
+
         NEXT;
 
-        if (IS_BLANK_CH(CUR)) {     
+        if (IS_BLANK_CH(CUR)) {
             ERROR5(NULL, NULL, NULL, "Invalid QName.\n", NULL);
             XML_PAT_FREE_STRING(ctxt, prefix);
             ctxt->error = 1;
             goto error;
         }
         /*
         * This is a namespace match
         */
         token = xmlPatScanName(ctxt);
         if ((prefix[0] == 'x') &&
             (prefix[1] == 'm') &&
             (prefix[2] == 'l') &&
             (prefix[3] == 0))
         {
-            XML_PAT_COPY_NSNAME(ctxt, URL, XML_XML_NAMESPACE);      
+            XML_PAT_COPY_NSNAME(ctxt, URL, XML_XML_NAMESPACE);
         } else {
             for (i = 0;i < ctxt->nb_namespaces;i++) {
                 if (xmlStrEqual(ctxt->namespaces[2 * i + 1], prefix)) {
-                    XML_PAT_COPY_NSNAME(ctxt, URL, ctxt->namespaces[2 * i])                 
+                    XML_PAT_COPY_NSNAME(ctxt, URL, ctxt->namespaces[2 * i])
                     break;
                 }
             }
             if (i >= ctxt->nb_namespaces) {
                 ERROR5(NULL, NULL, NULL,
                     "xmlCompileAttributeTest : no namespace bound to prefix %s\n",
                     prefix);
-                ctxt->error = 1;            
+                ctxt->error = 1;
                 goto error;
             }
         }
         XML_PAT_FREE_STRING(ctxt, prefix);
         if (token == NULL) {
             if (CUR == '*') {
                 NEXT;
                 PUSH(XML_OP_ATTR, NULL, URL);
             } else {
                 ERROR(NULL, NULL, NULL,
                     "xmlCompileAttributeTest : Name expected\n");
                 ctxt->error = 1;
                 goto error;
-            }       
+            }
         } else {
             PUSH(XML_OP_ATTR, token, URL);
         }
     } else {
         PUSH(XML_OP_ATTR, name, NULL);
     }
     return;
 error:
     if (URL != NULL)
-        XML_PAT_FREE_STRING(ctxt, URL)  
+        XML_PAT_FREE_STRING(ctxt, URL)
     if (token != NULL)
         XML_PAT_FREE_STRING(ctxt, token);
 }
 
 /**
  * xmlCompileStepPattern:
  * @ctxt:  the compilation context
  *
  * Compile the Step Pattern and generates a precompiled
  * form suitable for fast matching.
  *
  * [3]    Step    ::=    '.' | NameTest
- * [4]    NameTest    ::=    QName | '*' | NCName ':' '*' 
+ * [4]    NameTest    ::=    QName | '*' | NCName ':' '*'
  */
 
 static void
 xmlCompileStepPattern(xmlPatParserContextPtr ctxt) {
     xmlChar *token = NULL;
     xmlChar *name = NULL;
     xmlChar *URL = NULL;
     int hasBlanks = 0;
 
     SKIP_BLANKS;
@@ skipping 10 matching lines @@
         * Attribute test.
         */
         if (XML_STREAM_XS_IDC_SEL(ctxt->comp)) {
             ERROR5(NULL, NULL, NULL,
                 "Unexpected attribute axis in '%s'.\n", ctxt->base);
             ctxt->error = 1;
             return;
         }
         NEXT;
         xmlCompileAttributeTest(ctxt);
-        if (ctxt->error != 0) 
+        if (ctxt->error != 0)
             goto error;
         return;
     }
     name = xmlPatScanNCName(ctxt);
     if (name == NULL) {
         if (CUR == '*') {
             NEXT;
             PUSH(XML_OP_ALL, NULL, NULL);
             return;
         } else {
             ERROR(NULL, NULL, NULL,
                     "xmlCompileStepPattern : Name expected\n");
             ctxt->error = 1;
             return;
         }
     }
     if (IS_BLANK_CH(CUR)) {
         hasBlanks = 1;
         SKIP_BLANKS;
     }
     if (CUR == ':') {
         NEXT;
         if (CUR != ':') {
             xmlChar *prefix = name;
-            int i;          
+            int i;
 
             if (hasBlanks || IS_BLANK_CH(CUR)) {
                 ERROR5(NULL, NULL, NULL, "Invalid QName.\n", NULL);
                 ctxt->error = 1;
                 goto error;
             }
             /*
              * This is a namespace match
              */
             token = xmlPatScanName(ctxt);
@@ skipping 28 matching lines @@
                     ERROR(NULL, NULL, NULL,
                             "xmlCompileStepPattern : Name expected\n");
                     ctxt->error = 1;
                     goto error;
                 }
             } else {
                 PUSH(XML_OP_ELEM, token, URL);
             }
         } else {
             NEXT;
-            if (xmlStrEqual(name, (const xmlChar *) "child")) {         
+            if (xmlStrEqual(name, (const xmlChar *) "child")) {
                 XML_PAT_FREE_STRING(ctxt, name);
                 name = xmlPatScanName(ctxt);
                 if (name == NULL) {
                     if (CUR == '*') {
                         NEXT;
                         PUSH(XML_OP_ALL, NULL, NULL);
                         return;
                     } else {
                         ERROR(NULL, NULL, NULL,
                             "xmlCompileStepPattern : QName expected\n");
                         ctxt->error = 1;
                         goto error;
                     }
                 }
                 if (CUR == ':') {
                     xmlChar *prefix = name;
                     int i;
-                    
+
                     NEXT;
                     if (IS_BLANK_CH(CUR)) {
                         ERROR5(NULL, NULL, NULL, "Invalid QName.\n", NULL);
                         ctxt->error = 1;
                         goto error;
                     }
                     /*
                     * This is a namespace match
                     */
                     token = xmlPatScanName(ctxt);
                     if ((prefix[0] == 'x') &&
                         (prefix[1] == 'm') &&
                         (prefix[2] == 'l') &&
                         (prefix[3] == 0))
                     {
-                        XML_PAT_COPY_NSNAME(ctxt, URL, XML_XML_NAMESPACE)                       
+                        XML_PAT_COPY_NSNAME(ctxt, URL, XML_XML_NAMESPACE)
                     } else {
                         for (i = 0;i < ctxt->nb_namespaces;i++) {
                             if (xmlStrEqual(ctxt->namespaces[2 * i + 1], prefix)) {
-                                XML_PAT_COPY_NSNAME(ctxt, URL, ctxt->namespaces[2 * i])                         
+                                XML_PAT_COPY_NSNAME(ctxt, URL, ctxt->namespaces[2 * i])
                                 break;
                             }
                         }
                         if (i >= ctxt->nb_namespaces) {
                             ERROR5(NULL, NULL, NULL,
                                 "xmlCompileStepPattern : no namespace bound "
                                 "to prefix %s\n", prefix);
                             ctxt->error = 1;
                             goto error;
                         }
@@ skipping 27 matching lines @@
                 }
                 xmlCompileAttributeTest(ctxt);
                 if (ctxt->error != 0)
                     goto error;
                 return;
             } else {
                 ERROR5(NULL, NULL, NULL,
                     "The 'element' or 'attribute' axis is expected.\n", NULL);
                 ctxt->error = 1;
                 goto error;
-            }       
+            }
         }
     } else if (CUR == '*') {
         if (name != NULL) {
             ctxt->error = 1;
             goto error;
         }
         NEXT;
         PUSH(XML_OP_ALL, token, NULL);
     } else {
         PUSH(XML_OP_ELEM, name, NULL);
     }
     return;
 error:
     if (URL != NULL)
-        XML_PAT_FREE_STRING(ctxt, URL)  
+        XML_PAT_FREE_STRING(ctxt, URL)
     if (token != NULL)
         XML_PAT_FREE_STRING(ctxt, token)
     if (name != NULL)
         XML_PAT_FREE_STRING(ctxt, name)
 }
 
 /**
  * xmlCompilePathPattern:
  * @ctxt:  the compilation context
  *
  * Compile the Path Pattern and generates a precompiled
  * form suitable for fast matching.
  *
- * [5]    Path    ::=    ('.//')? ( Step '/' )* ( Step | '@' NameTest ) 
+ * [5]    Path    ::=    ('.//')? ( Step '/' )* ( Step | '@' NameTest )
  */
 static void
 xmlCompilePathPattern(xmlPatParserContextPtr ctxt) {
     SKIP_BLANKS;
     if (CUR == '/') {
         ctxt->comp->flags |= PAT_FROM_ROOT;
     } else if ((CUR == '.') || (ctxt->comp->flags & XML_PATTERN_NOTPATTERN)) {
         ctxt->comp->flags |= PAT_FROM_CUR;
     }
-        
+
     if ((CUR == '/') && (NXT(1) == '/')) {
         PUSH(XML_OP_ANCESTOR, NULL, NULL);
         NEXT;
         NEXT;
     } else if ((CUR == '.') && (NXT(1) == '/') && (NXT(2) == '/')) {
         PUSH(XML_OP_ANCESTOR, NULL, NULL);
         NEXT;
         NEXT;
         NEXT;
         /* Check for incompleteness. */
@@ skipping 42 matching lines @@
                 if (ctxt->error != 0)
                     goto error;
             } else {
                 PUSH(XML_OP_PARENT, NULL, NULL);
                 NEXT;
                 SKIP_BLANKS;
                 if (CUR == 0) {
                     ERROR5(NULL, NULL, NULL,
                     "Incomplete expression '%s'.\n", ctxt->base);
                     ctxt->error = 1;
-                    goto error;             
+                    goto error;
                 }
                 xmlCompileStepPattern(ctxt);
                 if (ctxt->error != 0)
                     goto error;
             }
         }
     }
     if (CUR != 0) {
         ERROR5(NULL, NULL, NULL,
                "Failed to compile pattern %s\n", ctxt->base);
         ctxt->error = 1;
     }
 error:
     return;
 }
 
 /**
  * xmlCompileIDCXPathPath:
  * @ctxt:  the compilation context
  *
  * Compile the Path Pattern and generates a precompiled
  * form suitable for fast matching.
  *
- * [5]    Path    ::=    ('.//')? ( Step '/' )* ( Step | '@' NameTest ) 
+ * [5]    Path    ::=    ('.//')? ( Step '/' )* ( Step | '@' NameTest )
  */
 static void
 xmlCompileIDCXPathPath(xmlPatParserContextPtr ctxt) {
     SKIP_BLANKS;
     if (CUR == '/') {
         ERROR5(NULL, NULL, NULL,
             "Unexpected selection of the document root in '%s'.\n",
             ctxt->base);
         goto error;
     }
@@ skipping 34 matching lines @@
             SKIP_BLANKS;
         }
         if (CUR == 0)
             goto error_unfinished;
     }
     /*
     * Process steps.
     */
     do {
         xmlCompileStepPattern(ctxt);
-        if (ctxt->error != 0) 
+        if (ctxt->error != 0)
             goto error;
         SKIP_BLANKS;
         if (CUR != '/')
             break;
         PUSH(XML_OP_PARENT, NULL, NULL);
         NEXT;
         SKIP_BLANKS;
         if (CUR == '/') {
             /*
             * Disallow subsequent '//'.
             */
             ERROR5(NULL, NULL, NULL,
                 "Unexpected subsequent '//' in '%s'.\n",
                 ctxt->base);
             goto error;
         }
         if (CUR == 0)
             goto error_unfinished;
-        
+
     } while (CUR != 0);
 
     if (CUR != 0) {
         ERROR5(NULL, NULL, NULL,
             "Failed to compile expression '%s'.\n", ctxt->base);
         ctxt->error = 1;
     }
     return;
 error:
     ctxt->error = 1;
     return;
 
 error_unfinished:
     ctxt->error = 1;
     ERROR5(NULL, NULL, NULL,
-        "Unfinished expression '%s'.\n", ctxt->base);    
+        "Unfinished expression '%s'.\n", ctxt->base);
     return;
 }
 
 /************************************************************************
  *                                                                      *
  *                      The streaming code                              *
  *                                                                      *
  ************************************************************************/
 
 #ifdef DEBUG_STREAMING
@@ skipping 134 matching lines @@
     cur->flags = flags;
     cur->name = name;
     cur->ns = ns;
     cur->nodeType = nodeType;
     return(comp->nbStep - 1);
 }
 
 /**
  * xmlStreamCompile:
  * @comp: the precompiled pattern
- * 
+ *
  * Tries to stream compile a pattern
  *
  * Returns -1 in case of failure and 0 in case of success.
  */
 static int
 xmlStreamCompile(xmlPatternPtr comp) {
     xmlStreamCompPtr stream;
     int i, s = 0, root = 0, flags = 0, prevs = -1;
     xmlStepOp step;
 
@@ skipping 16 matching lines @@
     }
 
     stream = xmlNewStreamComp((comp->nbStep / 2) + 1);
     if (stream == NULL)
         return(-1);
     if (comp->dict != NULL) {
         stream->dict = comp->dict;
         xmlDictReference(stream->dict);
     }
 
-    i = 0;        
+    i = 0;
     if (comp->flags & PAT_FROM_ROOT)
         stream->flags |= XML_STREAM_FROM_ROOT;
 
     for (;i < comp->nbStep;i++) {
         step = comp->steps[i];
         switch (step.op) {
             case XML_OP_END:
                 break;
             case XML_OP_ROOT:
                 if (i != 0)
                     goto error;
                 root = 1;
                 break;
             case XML_OP_NS:
                 s = xmlStreamCompAddStep(stream, NULL, step.value,
-                    XML_ELEMENT_NODE, flags);           
+                    XML_ELEMENT_NODE, flags);
                 if (s < 0)
                     goto error;
                 prevs = s;
-                flags = 0;              
-                break;      
+                flags = 0;
+                break;
             case XML_OP_ATTR:
                 flags |= XML_STREAM_STEP_ATTR;
                 prevs = -1;
                 s = xmlStreamCompAddStep(stream,
                     step.value, step.value2, XML_ATTRIBUTE_NODE, flags);
                 flags = 0;
                 if (s < 0)
                     goto error;
                 break;
-            case XML_OP_ELEM:           
+            case XML_OP_ELEM:
                 if ((step.value == NULL) && (step.value2 == NULL)) {
                     /*
                     * We have a "." or "self::node()" here.
                     * Eliminate redundant self::node() tests like in "/./."
                     * or "//./"
                     * The only case we won't eliminate is "//.", i.e. if
                     * self::node() is the last node test and we had
                     * continuation somewhere beforehand.
                     */
                     if ((comp->nbStep == i + 1) &&
                         (flags & XML_STREAM_STEP_DESC)) {
                         /*
                         * Mark the special case where the expression resolves
                         * to any type of node.
                         */
                         if (comp->nbStep == i + 1) {
                             stream->flags |= XML_STREAM_FINAL_IS_ANY_NODE;
                         }
-                        flags |= XML_STREAM_STEP_NODE;                  
+                        flags |= XML_STREAM_STEP_NODE;
                         s = xmlStreamCompAddStep(stream, NULL, NULL,
                             XML_STREAM_ANY_NODE, flags);
                         if (s < 0)
                             goto error;
                         flags = 0;
                         /*
                         * If there was a previous step, mark it to be added to
                         * the result node-set; this is needed since only
                         * the last step will be marked as "final" and only
                         * "final" nodes are added to the resulting set.
                         */
                         if (prevs != -1) {
                             stream->steps[prevs].flags |= XML_STREAM_STEP_IN_SET;
                             prevs = -1;
                         }
-                        break;  
+                        break;
 
                     } else {
                         /* Just skip this one. */
                         continue;
                     }
                 }
-                /* An element node. */          
+                /* An element node. */
                 s = xmlStreamCompAddStep(stream, step.value, step.value2,
-                    XML_ELEMENT_NODE, flags);           
-                if (s < 0)
-                    goto error;
-                prevs = s;
-                flags = 0;              
-                break;          
-            case XML_OP_CHILD:
-                /* An element node child. */
-                s = xmlStreamCompAddStep(stream, step.value, step.value2,
-                    XML_ELEMENT_NODE, flags);           
-                if (s < 0)
-                    goto error;
-                prevs = s;
-                flags = 0;
-                break;      
-            case XML_OP_ALL:
-                s = xmlStreamCompAddStep(stream, NULL, NULL,
-                    XML_ELEMENT_NODE, flags);           
+                    XML_ELEMENT_NODE, flags);
                 if (s < 0)
                     goto error;
                 prevs = s;
                 flags = 0;
                 break;
-            case XML_OP_PARENT: 
+            case XML_OP_CHILD:
+                /* An element node child. */
+                s = xmlStreamCompAddStep(stream, step.value, step.value2,
+                    XML_ELEMENT_NODE, flags);
+                if (s < 0)
+                    goto error;
+                prevs = s;
+                flags = 0;
+                break;
+            case XML_OP_ALL:
+                s = xmlStreamCompAddStep(stream, NULL, NULL,
+                    XML_ELEMENT_NODE, flags);
+                if (s < 0)
+                    goto error;
+                prevs = s;
+                flags = 0;
+                break;
+            case XML_OP_PARENT:
                 break;
             case XML_OP_ANCESTOR:
                 /* Skip redundant continuations. */
                 if (flags & XML_STREAM_STEP_DESC)
                     break;
                 flags |= XML_STREAM_STEP_DESC;
                 /*
                 * Mark the expression as having "//".
                 */
                 if ((stream->flags & XML_STREAM_DESC) == 0)
                     stream->flags |= XML_STREAM_DESC;
                 break;
         }
-    }    
+    }
     if ((! root) && (comp->flags & XML_PATTERN_NOTPATTERN) == 0) {
         /*
         * If this should behave like a real pattern, we will mark
         * the first step as having "//", to be reentrant on every
         * tree level.
         */
         if ((stream->flags & XML_STREAM_DESC) == 0)
             stream->flags |= XML_STREAM_DESC;
 
         if (stream->nbStep > 0) {
             if ((stream->steps[0].flags & XML_STREAM_STEP_DESC) == 0)
-                stream->steps[0].flags |= XML_STREAM_STEP_DESC;     
+                stream->steps[0].flags |= XML_STREAM_STEP_DESC;
         }
     }
     if (stream->nbStep <= s)
         goto error;
     stream->steps[s].flags |= XML_STREAM_STEP_FINAL;
     if (root)
         stream->steps[0].flags |= XML_STREAM_STEP_ROOT;
 #ifdef DEBUG_STREAMING
     xmlDebugStreamComp(stream);
 #endif
@@ skipping 172 matching lines @@
                 continue; /* while */
             }
             /*
             * For non-pattern like evaluation like XML Schema IDCs
             * or traditional XPath expressions, this will match if
             * we are at the first level only, otherwise on every level.
             */
             if ((nodeType != XML_ATTRIBUTE_NODE) &&
                 (((stream->flags & XML_PATTERN_NOTPATTERN) == 0) ||
                 (stream->level == 0))) {
-                    ret = 1;            
+                    ret = 1;
             }
             stream->level++;
             goto stream_next;
         }
         if (stream->blockLevel != -1) {
             /*
             * Skip blocked expressions.
             */
-            stream->level++;
+            stream->level++;
             goto stream_next;
         }
 
         if ((nodeType != XML_ELEMENT_NODE) &&
             (nodeType != XML_ATTRIBUTE_NODE) &&
             ((comp->flags & XML_STREAM_FINAL_IS_ANY_NODE) == 0)) {
             /*
             * No need to process nodes of other types if we don't
             * resolve to those types.
             * TODO: Do we need to block the context here?
@@ skipping 22 matching lines @@
                     return (-1);
                 }
                 desc = 0;
                 /* loop-stopper */
                 i = m;
             } else {
                 /*
                 * If there are "//", then we need to process every "//"
                 * occuring in the states, plus any other state for this
                 * level.
-                */              
+                */
                 stepNr = stream->states[2 * i];
 
                 /* TODO: should not happen anymore: dead states */
                 if (stepNr < 0)
                     goto next_state;
 
                 tmp = stream->states[(2 * i) + 1];
 
                 /* skip new states just added */
                 if (tmp > stream->level)
                     goto next_state;
 
                 /* skip states at ancestor levels, except if "//" */
                 desc = comp->steps[stepNr].flags & XML_STREAM_STEP_DESC;
                 if ((tmp < stream->level) && (!desc))
                     goto next_state;
             }
-            /* 
+            /*
             * Check for correct node-type.
             */
             step = comp->steps[stepNr];
             if (step.nodeType != nodeType) {
                 if (step.nodeType == XML_ATTRIBUTE_NODE) {
                     /*
                     * Block this expression for deeper evaluation.
                     */
                     if ((comp->flags & XML_STREAM_DESC) == 0)
                         stream->blockLevel = stream->level +1;
                     goto next_state;
                 } else if (step.nodeType != XML_STREAM_ANY_NODE)
                     goto next_state;
-            }       
+            }
             /*
             * Compare local/namespace-name.
             */
             match = 0;
             if (step.nodeType == XML_STREAM_ANY_NODE) {
                 match = 1;
             } else if (step.name == NULL) {
                 if (step.ns == NULL) {
                     /*
                     * This lets through all elements/attributes.
                     */
                     match = 1;
                 } else if (ns != NULL)
                     match = xmlStrEqual(step.ns, ns);
             } else if (((step.ns != NULL) == (ns != NULL)) &&
                 (name != NULL) &&
                 (step.name[0] == name[0]) &&
                 xmlStrEqual(step.name, name) &&
                 ((step.ns == ns) || xmlStrEqual(step.ns, ns)))
             {
-                match = 1;          
-            }    
-#if 0 
+                match = 1;
+            }
+#if 0
 /*
 * TODO: Pointer comparison won't work, since not guaranteed that the given
 *  values are in the same dict; especially if it's the namespace name,
 *  normally coming from ns->href. We need a namespace dict mechanism !
 */
             } else if (comp->dict) {
                 if (step.name == NULL) {
                     if (step.ns == NULL)
                         match = 1;
                     else
                         match = (step.ns == ns);
                 } else {
                     match = ((step.name == name) && (step.ns == ns));
                 }
-#endif /* if 0 ------------------------------------------------------- */           
-            if (match) {                
+#endif /* if 0 ------------------------------------------------------- */
+            if (match) {
                 final = step.flags & XML_STREAM_STEP_FINAL;
                 if (desc) {
                     if (final) {
                         ret = 1;
                     } else {
                         /* descending match create a new state */
                         xmlStreamCtxtAddState(stream, stepNr + 1,
                                               stream->level + 1);
                     }
                 } else {
                     if (final) {
                         ret = 1;
                     } else {
                         xmlStreamCtxtAddState(stream, stepNr + 1,
                                               stream->level + 1);
                     }
                 }
                 if ((ret != 1) && (step.flags & XML_STREAM_STEP_IN_SET)) {
                     /*
                     * Check if we have a special case like "foo/bar//.", where
                     * "foo" is selected as well.
                     */
                     ret = 1;
                 }
-            }       
+            }
             if (((comp->flags & XML_STREAM_DESC) == 0) &&
                 ((! match) || final))  {
                 /*
                 * Mark this expression as blocked for any evaluation at
                 * deeper levels. Note that this includes "/foo"
                 * expressions if the *pattern* behaviour is used.
                 */
                 stream->blockLevel = stream->level +1;
             }
 next_state:
@@ skipping 10 matching lines @@
         step = comp->steps[0];
         if (step.flags & XML_STREAM_STEP_ROOT)
             goto stream_next;
 
         desc = step.flags & XML_STREAM_STEP_DESC;
         if (stream->flags & XML_PATTERN_NOTPATTERN) {
             /*
             * Re/enter the expression if it is a "descendant" one,
             * or if we are at the 1st level of evaluation.
             */
-            
+
             if (stream->level == 1) {
                 if (XML_STREAM_XS_IDC(stream)) {
                     /*
                     * XS-IDC: The missing "self::node()" will always
                     * match the first given node.
                     */
                     goto stream_next;
                 } else
                     goto compare;
-            }       
+            }
             /*
             * A "//" is always reentrant.
             */
             if (desc)
                 goto compare;
 
             /*
             * XS-IDC: Process the 2nd level, since the missing
             * "self::node()" is responsible for the 2nd level being
-            * the real start level.         
-            */      
+            * the real start level.
+            */
             if ((stream->level == 2) && XML_STREAM_XS_IDC(stream))
                 goto compare;
 
             goto stream_next;
         }
-        
+
 compare:
         /*
         * Check expected node-type.
         */
         if (step.nodeType != nodeType) {
             if (nodeType == XML_ATTRIBUTE_NODE)
                 goto stream_next;
             else if (step.nodeType != XML_STREAM_ANY_NODE)
-                goto stream_next;            
+                goto stream_next;
         }
         /*
         * Compare local/namespace-name.
         */
         match = 0;
         if (step.nodeType == XML_STREAM_ANY_NODE) {
             match = 1;
         } else if (step.name == NULL) {
             if (step.ns == NULL) {
                 /*
                 * This lets through all elements/attributes.
                 */
                 match = 1;
             } else if (ns != NULL)
                 match = xmlStrEqual(step.ns, ns);
         } else if (((step.ns != NULL) == (ns != NULL)) &&
             (name != NULL) &&
             (step.name[0] == name[0]) &&
             xmlStrEqual(step.name, name) &&
             ((step.ns == ns) || xmlStrEqual(step.ns, ns)))
         {
-            match = 1;      
-        }           
+            match = 1;
+        }
         final = step.flags & XML_STREAM_STEP_FINAL;
-        if (match) {        
+        if (match) {
             if (final)
                 ret = 1;
             else
                 xmlStreamCtxtAddState(stream, 1, stream->level);
             if ((ret != 1) && (step.flags & XML_STREAM_STEP_IN_SET)) {
                 /*
                 * Check if we have a special case like "foo//.", where
                 * "foo" is selected as well.
                 */
                 ret = 1;
             }
         }
         if (((comp->flags & XML_STREAM_DESC) == 0) &&
             ((! match) || final))  {
             /*
             * Mark this expression as blocked for any evaluation at
             * deeper levels.
             */
             stream->blockLevel = stream->level;
         }
 
 stream_next:
         stream = stream->next;
     } /* while stream != NULL */
- 
+
     if (err > 0)
         ret = -1;
 #ifdef DEBUG_STREAMING
     xmlDebugStreamCtxt(orig, ret);
 #endif
     return(ret);
 }
 
 /**
  * xmlStreamPush:
@@ skipping 71 matching lines @@
  * xmlStreamPop:
  * @stream: the stream context
  *
  * push one level from the stream.
  *
  * Returns: -1 in case of error, 0 otherwise.
  */
 int
 xmlStreamPop(xmlStreamCtxtPtr stream) {
     int i, lev;
-    
+
     if (stream == NULL)
         return(-1);
     while (stream != NULL) {
         /*
         * Reset block-level.
         */
         if (stream->blockLevel == stream->level)
             stream->blockLevel = -1;
 
         /*
          *  stream->level can be zero when XML_FINAL_IS_ANY_NODE is set
          *  (see the thread at
          *  http://mail.gnome.org/archives/xslt/2008-July/msg00027.html)
          */
         if (stream->level)
             stream->level--;
         /*
          * Check evolution of existing states
-         */     
+         */
         for (i = stream->nbState -1; i >= 0; i--) {
             /* discard obsoleted states */
             lev = stream->states[(2 * i) + 1];
             if (lev > stream->level)
                 stream->nbState--;
             if (lev <= stream->level)
                 break;
         }
         stream = stream->next;
     }
     return(0);
 }
 
 /**
  * xmlStreamWantsAnyNode:
  * @streamCtxt: the stream context
  *
  * Query if the streaming pattern additionally needs to be fed with
  * text-, cdata-section-, comment- and processing-instruction-nodes.
  * If the result is 0 then only element-nodes and attribute-nodes
  * need to be pushed.
  *
  * Returns: 1 in case of need of nodes of the above described types,
  *          0 otherwise. -1 on API errors.
  */
 int
 xmlStreamWantsAnyNode(xmlStreamCtxtPtr streamCtxt)
-{    
+{
     if (streamCtxt == NULL)
         return(-1);
     while (streamCtxt != NULL) {
-        if (streamCtxt->comp->flags & XML_STREAM_FINAL_IS_ANY_NODE)     
+        if (streamCtxt->comp->flags & XML_STREAM_FINAL_IS_ANY_NODE)
             return(1);
         streamCtxt = streamCtxt->next;
     }
     return(0);
 }
 
 /************************************************************************
  *                                                                      *
  *                      The public interfaces                           *
  *                                                                      *
@@ skipping 30 matching lines @@
         while ((*or != 0) && (*or != '|')) or++;
         if (*or == 0)
             ctxt = xmlNewPatParserContext(start, dict, namespaces);
         else {
             tmp = xmlStrndup(start, or - start);
             if (tmp != NULL) {
                 ctxt = xmlNewPatParserContext(tmp, dict, namespaces);
             }
             or++;
         }
-        if (ctxt == NULL) goto error;   
+        if (ctxt == NULL) goto error;
         cur = xmlNewPattern();
         if (cur == NULL) goto error;
         /*
         * Assign string dict.
         */
-        if (dict) {         
+        if (dict) {
             cur->dict = dict;
             xmlDictReference(dict);
         }
         if (ret == NULL)
             ret = cur;
         else {
             cur->next = ret->next;
             ret->next = cur;
         }
         cur->flags = flags;
@@ skipping 162 matching lines @@
 }
 
 /**
  * xmlPatternMinDepth:
  * @comp: the precompiled pattern
  *
  * Check the minimum depth reachable by a pattern, 0 mean the / or . are
  * part of the set.
  *
  * Returns -1 in case of error otherwise the depth,
- *         
+ *
  */
 int
 xmlPatternMinDepth(xmlPatternPtr comp) {
     int ret = 12345678;
     if (comp == NULL)
         return(-1);
     while (comp != NULL) {
         if (comp->stream == NULL)
             return(-1);
         if (comp->stream->nbStep < ret)
@@ skipping 24 matching lines @@
             return(1);
         comp = comp->next;
     }
     return(0);
 
 }
 
 #define bottom_pattern
 #include "elfgcchack.h"
 #endif /* LIBXML_PATTERN_ENABLED */