Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/relaxng.c

 /*
  * relaxng.c : implementation of the Relax-NG handling and validity checking
  *
  * See Copyright for the status of this software.
  *
  * Daniel Veillard <veillard@redhat.com>
  */
 
 /**
  * TODO:
@@ skipping 21 matching lines @@
 #include <libxml/xmlautomata.h>
 #include <libxml/xmlregexp.h>
 #include <libxml/xmlschemastypes.h>
 
 /*
  * The Relax-NG namespace
  */
 static const xmlChar *xmlRelaxNGNs = (const xmlChar *)
     "http://relaxng.org/ns/structure/1.0";
 
-#define IS_RELAXNG(node, type)                                          \
+#define IS_RELAXNG(node, typ)                                           \
    ((node != NULL) && (node->ns != NULL) &&                             \
-    (xmlStrEqual(node->name, (const xmlChar *) type)) &&                \
+    (node->type == XML_ELEMENT_NODE) &&                                 \
+    (xmlStrEqual(node->name, (const xmlChar *) typ)) &&         \
     (xmlStrEqual(node->ns->href, xmlRelaxNGNs)))
 
 
 #if 0
 #define DEBUG 1
 
 #define DEBUG_GRAMMAR 1
 
 #define DEBUG_CONTENT 1
 
 #define DEBUG_TYPE 1
 
 #define DEBUG_VALID 1
 
 #define DEBUG_INTERLEAVE 1
 
 #define DEBUG_LIST 1
 
-#define DEBUG_INCLUDE 1 
+#define DEBUG_INCLUDE 1
 
 #define DEBUG_ERROR 1
 
 #define DEBUG_COMPILE 1
 
 #define DEBUG_PROGRESSIVE 1
 #endif
 
 #define MAX_ERROR 5
 
-#define TODO                                                            \
+#define TODO                                                            \
     xmlGenericError(xmlGenericErrorContext,                             \
             "Unimplemented block at %s:%d\n",                           \
             __FILE__, __LINE__);
 
 typedef struct _xmlRelaxNGSchema xmlRelaxNGSchema;
 typedef xmlRelaxNGSchema *xmlRelaxNGSchemaPtr;
 
 typedef struct _xmlRelaxNGDefine xmlRelaxNGDefine;
 typedef xmlRelaxNGDefine *xmlRelaxNGDefinePtr;
 
@@ skipping 329 matching lines @@
     xmlChar *href;              /* the normalized href value */
     xmlDocPtr doc;              /* the associated XML document */
     xmlRelaxNGDefinePtr content;        /* the definitions */
     xmlRelaxNGPtr schema;       /* the schema */
     int externalRef;            /* 1 if an external ref */
 };
 
 
 /************************************************************************
  *                                                                      *
- *              Some factorized error routines                          *
+ *              Some factorized error routines                          *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xmlRngPErrMemory:
  * @ctxt:  an Relax-NG parser context
  * @extra:  extra informations
  *
  * Handle a redefinition of attribute error
  */
@@ skipping 122 matching lines @@
         ctxt->nbErrors++;
     }
     __xmlRaiseError(schannel, channel, data,
                     NULL, node, XML_FROM_RELAXNGV,
                     error, XML_ERR_ERROR, NULL, 0,
                     (const char *) str1, (const char *) str2, NULL, 0, 0,
                     msg, str1, str2);
 }
 
 /************************************************************************
- *                                                                      *
- *              Preliminary type checking interfaces                    *
- *                                                                      *
+ *                                                                      *
+ *              Preliminary type checking interfaces                    *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xmlRelaxNGTypeHave:
  * @data:  data needed for the library
  * @type:  the type name
  * @value:  the value to check
  *
  * Function provided by a type library to check if a type is exported
  *
@@ skipping 67 matching lines @@
     const xmlChar *namespace;   /* the datatypeLibrary value */
     void *data;                 /* data needed for the library */
     xmlRelaxNGTypeHave have;    /* the export function */
     xmlRelaxNGTypeCheck check;  /* the checking function */
     xmlRelaxNGTypeCompare comp; /* the compare function */
     xmlRelaxNGFacetCheck facet; /* the facet check function */
     xmlRelaxNGTypeFree freef;   /* the freeing function */
 };
 
 /************************************************************************
- *                                                                      *
- *                      Allocation functions                            *
- *                                                                      *
+ *                                                                      *
+ *                      Allocation functions                            *
+ *                                                                      *
  ************************************************************************/
 static void xmlRelaxNGFreeGrammar(xmlRelaxNGGrammarPtr grammar);
 static void xmlRelaxNGFreeDefine(xmlRelaxNGDefinePtr define);
 static void xmlRelaxNGNormExtSpace(xmlChar * value);
 static void xmlRelaxNGFreeInnerSchema(xmlRelaxNGPtr schema);
 static int xmlRelaxNGEqualValidState(xmlRelaxNGValidCtxtPtr ctxt
                                      ATTRIBUTE_UNUSED,
                                      xmlRelaxNGValidStatePtr state1,
                                      xmlRelaxNGValidStatePtr state2);
 static void xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt,
@@ skipping 417 matching lines @@
  *
  * Return 1 in case of success and 0 if this is a duplicate and -1 on error
  */
 static int
 xmlRelaxNGAddStates(xmlRelaxNGValidCtxtPtr ctxt,
                     xmlRelaxNGStatesPtr states,
                     xmlRelaxNGValidStatePtr state)
 {
     int i;
 
-    if (state == NULL) {
+    if (state == NULL || states == NULL) {
         return (-1);
     }
     if (states->nbState >= states->maxState) {
         xmlRelaxNGValidStatePtr *tmp;
         int size;
 
         size = states->maxState * 2;
         tmp = (xmlRelaxNGValidStatePtr *) xmlRealloc(states->tabState,
                                                      (size) *
                                                      sizeof
@@ skipping 282 matching lines @@
     if ((ctxt == NULL) || (ctxt->freeState == NULL)) {
         if (state->attrs != NULL)
             xmlFree(state->attrs);
         xmlFree(state);
     } else {
         xmlRelaxNGAddStatesUniq(ctxt, ctxt->freeState, state);
     }
 }
 
 /************************************************************************
- *                                                                      *
- *                      Semi internal functions                         *
- *                                                                      *
+ *                                                                      *
+ *                      Semi internal functions                         *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xmlRelaxParserSetFlag:
  * @ctxt: a RelaxNG parser context
  * @flags: a set of flags values
  *
  * Semi private function used to pass informations to a parser context
  * which are a combination of xmlRelaxNGParserFlag .
  *
  * Returns 0 if success and -1 in case of error
  */
 int
 xmlRelaxParserSetFlag(xmlRelaxNGParserCtxtPtr ctxt, int flags)
 {
     if (ctxt == NULL) return(-1);
     if (flags & XML_RELAXNGP_FREE_DOC) {
         ctxt->crng |= XML_RELAXNGP_FREE_DOC;
         flags -= XML_RELAXNGP_FREE_DOC;
     }
     if (flags & XML_RELAXNGP_CRNG) {
         ctxt->crng |= XML_RELAXNGP_CRNG;
         flags -= XML_RELAXNGP_CRNG;
     }
     if (flags != 0) return(-1);
     return(0);
 }
 
 /************************************************************************
- *                                                                      *
- *                      Document functions                              *
- *                                                                      *
+ *                                                                      *
+ *                      Document functions                              *
+ *                                                                      *
  ************************************************************************/
 static xmlDocPtr xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt,
                                       xmlDocPtr doc);
 
 /**
  * xmlRelaxNGIncludePush:
  * @ctxt:  the parser context
  * @value:  the element doc
  *
  * Pushes a new include on top of the include stack
@@ skipping 109 matching lines @@
 
             if ((inc != NULL) && (inc->doc != NULL) &&
                 (inc->doc->children != NULL)) {
 
                 if (xmlStrEqual
                     (inc->doc->children->name, BAD_CAST "grammar")) {
 #ifdef DEBUG_INCLUDE
                     href = xmlGetProp(tmp, BAD_CAST "href");
 #endif
                     if (xmlRelaxNGRemoveRedefine(ctxt, href,
-                                                 inc->doc->children->
-                                                 children, name) == 1) {
+                                                 xmlDocGetRootElement(inc->doc)->children,
+                                                 name) == 1) {
                         found = 1;
                     }
 #ifdef DEBUG_INCLUDE
                     if (href != NULL)
                         xmlFree(href);
 #endif
                 }
             }
         }
         tmp = tmp2;
@@ skipping 424 matching lines @@
         ctxt->doc = NULL;
         return (NULL);
     }
 
     xmlRelaxNGDocumentPop(ctxt);
 
     return (ret);
 }
 
 /************************************************************************
- *                                                                      *
- *                      Error functions                                 *
- *                                                                      *
+ *                                                                      *
+ *                      Error functions                                 *
+ *                                                                      *
  ************************************************************************/
 
 #define VALID_ERR(a) xmlRelaxNGAddValidError(ctxt, a, NULL, NULL, 0);
 #define VALID_ERR2(a, b) xmlRelaxNGAddValidError(ctxt, a, b, NULL, 0);
 #define VALID_ERR3(a, b, c) xmlRelaxNGAddValidError(ctxt, a, b, c, 0);
 #define VALID_ERR2P(a, b) xmlRelaxNGAddValidError(ctxt, a, b, NULL, 1);
 #define VALID_ERR3P(a, b, c) xmlRelaxNGAddValidError(ctxt, a, b, c, 1);
 
 static const char *
 xmlRelaxNGDefName(xmlRelaxNGDefinePtr def)
@@ skipping 330 matching lines @@
     if (ctxt->flags & FLAGS_NOERROR)
         return;
 
 #ifdef DEBUG_ERROR
     xmlGenericError(xmlGenericErrorContext, "Adding error %d\n", err);
 #endif
     /*
      * generate the error directly
      */
     if (((ctxt->flags & FLAGS_IGNORABLE) == 0) ||
-         (ctxt->flags & FLAGS_NEGATIVE)) {
+         (ctxt->flags & FLAGS_NEGATIVE)) {
         xmlNodePtr node, seq;
 
         /*
          * Flush first any stacked error which might be the
          * real cause of the problem.
          */
         if (ctxt->errNr != 0)
             xmlRelaxNGDumpValidError(ctxt);
         if (ctxt->state != NULL) {
             node = ctxt->state->node;
             seq = ctxt->state->seq;
         } else {
             node = seq = NULL;
         }
         if ((node == NULL) && (seq == NULL)) {
             node = ctxt->pnode;
         }
         xmlRelaxNGShowValidError(ctxt, err, node, seq, arg1, arg2);
     }
     /*
      * Stack the error for later processing if needed
      */
     else {
         xmlRelaxNGValidErrorPush(ctxt, err, arg1, arg2, dup);
     }
 }
 
 
 /************************************************************************
- *                                                                      *
- *                      Type library hooks                              *
- *                                                                      *
+ *                                                                      *
+ *                      Type library hooks                              *
+ *                                                                      *
  ************************************************************************/
 static xmlChar *xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt,
                                     const xmlChar * str);
 
 /**
  * xmlRelaxNGSchemaTypeHave:
  * @data:  data needed for the library
  * @type:  the type name
  *
  * Check if the given type is provided by
@@ skipping 181 matching lines @@
         ret = xmlSchemaValPredefTypeNode(typ, value1, &res1, ctxt1);
         if (ret != 0)
             return (-1);
         if (res1 == NULL)
             return (-1);
     } else {
         res1 = (xmlSchemaValPtr) comp1;
     }
     ret = xmlSchemaValPredefTypeNode(typ, value2, &res2, ctxt2);
     if (ret != 0) {
-        if ((comp1 == NULL) && (res1 != NULL))
+        if (res1 != (xmlSchemaValPtr) comp1)
             xmlSchemaFreeValue(res1);
         return (-1);
     }
-    if (res1 == NULL) {
-        return (-1);
-    }
     ret = xmlSchemaCompareValues(res1, res2);
     if (res1 != (xmlSchemaValPtr) comp1)
         xmlSchemaFreeValue(res1);
     xmlSchemaFreeValue(res2);
     if (ret == -2)
         return (-1);
     if (ret == 0)
         return (1);
     return (0);
 }
@@ skipping 226 matching lines @@
 {
     xmlSchemaCleanupTypes();
     if (xmlRelaxNGTypeInitialized == 0)
         return;
     xmlHashFree(xmlRelaxNGRegisteredTypes, (xmlHashDeallocator)
                 xmlRelaxNGFreeTypeLibrary);
     xmlRelaxNGTypeInitialized = 0;
 }
 
 /************************************************************************
- *                                                                      *
- *              Compiling element content into regexp                   *
- *                                                                      *
+ *                                                                      *
+ *              Compiling element content into regexp                   *
+ *                                                                      *
  * Sometime the element content can be compiled into a pure regexp,     *
  * This allows a faster execution and streamability at that level       *
- *                                                                      *
+ *                                                                      *
  ************************************************************************/
 
 /* from automata.c but not exported */
 void xmlAutomataSetFlags(xmlAutomataPtr am, int flags);
 
 
 static int xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt,
                                 xmlRelaxNGDefinePtr def);
 
 /**
@@ skipping 186 matching lines @@
                  * thing of exploring both choices.
                  */
                 xmlAutomataSetFlags(ctxt->am, 1);
 
                 ctxt->state = xmlAutomataGetInitState(ctxt->am);
                 while (list != NULL) {
                     xmlRelaxNGCompile(ctxt, list);
                     list = list->next;
                 }
                 xmlAutomataSetFinalState(ctxt->am, ctxt->state);
-                def->contModel = xmlAutomataCompile(ctxt->am);
-                xmlRegexpIsDeterminist(def->contModel);
+                if (xmlAutomataIsDeterminist(ctxt->am))
+                    def->contModel = xmlAutomataCompile(ctxt->am);
 
                 xmlFreeAutomata(ctxt->am);
                 ctxt->state = oldstate;
                 ctxt->am = oldam;
             }
             break;
         case XML_RELAXNG_ELEMENT:
             if ((ctxt->am != NULL) && (def->name != NULL)) {
                 ctxt->state = xmlAutomataNewTransition2(ctxt->am,
                                                         ctxt->state, NULL,
@@ skipping 244 matching lines @@
         case XML_RELAXNG_ATTRIBUTE:
         case XML_RELAXNG_INTERLEAVE:
         case XML_RELAXNG_NOT_ALLOWED:
             ret = 0;
             break;
     }
     return (ret);
 }
 
 /************************************************************************
- *                                                                      *
- *                      Parsing functions                               *
- *                                                                      *
+ *                                                                      *
+ *                      Parsing functions                               *
+ *                                                                      *
  ************************************************************************/
 
 static xmlRelaxNGDefinePtr xmlRelaxNGParseAttribute(xmlRelaxNGParserCtxtPtr
                                                     ctxt, xmlNodePtr node);
 static xmlRelaxNGDefinePtr xmlRelaxNGParseElement(xmlRelaxNGParserCtxtPtr
                                                   ctxt, xmlNodePtr node);
 static xmlRelaxNGDefinePtr xmlRelaxNGParsePatterns(xmlRelaxNGParserCtxtPtr
                                                    ctxt, xmlNodePtr nodes,
                                                    int group);
 static xmlRelaxNGDefinePtr xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr
@@ skipping 473 matching lines @@
                 ret = 0;
             }
         } else {
             ret = 1;
         }
     } else if (def1->type == XML_RELAXNG_TEXT) {
         if (def2->type == XML_RELAXNG_TEXT)
             return (0);
         return (1);
     } else if (def1->type == XML_RELAXNG_EXCEPT) {
-        TODO ret = 0;
+        ret = xmlRelaxNGCompareNameClasses(def1->content, def2);
+        if (ret == 0)
+            ret = 1;
+        else if (ret == 1)
+            ret = 0;
     } else {
         TODO ret = 0;
     }
     if (ret == 0)
         return (ret);
     if ((def2->type == XML_RELAXNG_ELEMENT) ||
         (def2->type == XML_RELAXNG_ATTRIBUTE)) {
         if (def2->name != NULL) {
             node.name = def2->name;
         } else {
@@ skipping 2760 matching lines @@
     ctxt->grammar = ret;
     if (ctxt->grammar == NULL) {
         xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_CONTENT,
                    "Failed to parse <grammar> content\n", NULL, NULL);
     } else if (ctxt->grammar->start == NULL) {
         xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_NO_START,
                    "Element <grammar> has no <start>\n", NULL, NULL);
     }
 
     /*
-     * Apply 4.17 mergingd rules to defines and starts
+     * Apply 4.17 merging rules to defines and starts
      */
     xmlRelaxNGCombineStart(ctxt, ret);
     if (ret->defs != NULL) {
         xmlHashScan(ret->defs, (xmlHashScanner) xmlRelaxNGCheckCombine,
                     ctxt);
     }
 
     /*
      * link together defines and refs in this grammar
      */
@@ skipping 31 matching lines @@
         return (NULL);
 
     schema = xmlRelaxNGNewRelaxNG(ctxt);
     if (schema == NULL)
         return (NULL);
 
     olddefine = ctxt->define;
     ctxt->define = NULL;
     if (IS_RELAXNG(node, "grammar")) {
         schema->topgrammar = xmlRelaxNGParseGrammar(ctxt, node->children);
+        if (schema->topgrammar == NULL) {
+            xmlRelaxNGFree(schema);
+            return (NULL);
+        }
     } else {
         xmlRelaxNGGrammarPtr tmp, ret;
 
         schema->topgrammar = ret = xmlRelaxNGNewGrammar(ctxt);
         if (schema->topgrammar == NULL) {
-            return (schema);
+            xmlRelaxNGFree(schema);
+            return (NULL);
         }
         /*
          * Link the new grammar in the tree
          */
         ret->parent = ctxt->grammar;
         if (ctxt->grammar != NULL) {
             tmp = ctxt->grammar->children;
             if (tmp == NULL) {
                 ctxt->grammar->children = ret;
             } else {
@@ skipping 25 matching lines @@
 #ifdef DEBUG
     if (schema == NULL)
         xmlGenericError(xmlGenericErrorContext,
                         "xmlRelaxNGParseDocument() failed\n");
 #endif
 
     return (schema);
 }
 
 /************************************************************************
- *                                                                      *
- *                      Reading RelaxNGs                                *
- *                                                                      *
+ *                                                                      *
+ *                      Reading RelaxNGs                                *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xmlRelaxNGNewParserCtxt:
  * @URL:  the location of the schema
  *
  * Create an XML RelaxNGs parse context for that file/resource expected
  * to contain an XML RelaxNGs file.
  *
  * Returns the parser context or NULL in case of error
@@ skipping 588 matching lines @@
                                    "Found anyName/except//anyName forbidden construct\n",
                                    NULL, NULL);
                     } else if (ctxt->flags & XML_RELAXNG_IN_NSEXCEPT) {
                         xmlRngPErr(ctxt, cur,
                                    XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME,
                                    "Found nsName/except//anyName forbidden construct\n",
                                    NULL, NULL);
                     }
                 }
                 /*
-                 * Thisd is not an else since "include" is transformed
+                 * This is not an else since "include" is transformed
                  * into a div
                  */
                 if (xmlStrEqual(cur->name, BAD_CAST "div")) {
                     xmlChar *ns;
                     xmlNodePtr child, ins, tmp;
 
                     /*
                      * implements rule 4.11
                      */
 
                     ns = xmlGetProp(cur, BAD_CAST "ns");
 
                     child = cur->children;
                     ins = cur;
                     while (child != NULL) {
                         if (ns != NULL) {
                             if (!xmlHasProp(child, BAD_CAST "ns")) {
                                 xmlSetProp(child, BAD_CAST "ns", ns);
                             }
                         }
                         tmp = child->next;
                         xmlUnlinkNode(child);
                         ins = xmlAddNextSibling(ins, child);
                         child = tmp;
                     }
                     if (ns != NULL)
                         xmlFree(ns);
                     /*
-                     * Since we are about to delete cur, if it's nsDef is non-NULL we
+                     * Since we are about to delete cur, if its nsDef is non-NULL we
                      * need to preserve it (it contains the ns definitions for the
                      * children we just moved).  We'll just stick it on to the end
                      * of cur->parent's list, since it's never going to be re-serialized
                      * (bug 143738).
                      */
-                    if (cur->nsDef != NULL) {
+                    if ((cur->nsDef != NULL) && (cur->parent != NULL)) {
                         xmlNsPtr parDef = (xmlNsPtr)&cur->parent->nsDef;
                         while (parDef->next != NULL)
                             parDef = parDef->next;
                         parDef->next = cur->nsDef;
                         cur->nsDef = NULL;
                     }
                     delete = cur;
                     goto skip_children;
                 }
             }
         }
         /*
          * Simplification 4.2 whitespaces
          */
         else if ((cur->type == XML_TEXT_NODE) ||
                  (cur->type == XML_CDATA_SECTION_NODE)) {
             if (IS_BLANK_NODE(cur)) {
-                if (cur->parent->type == XML_ELEMENT_NODE) {
+                if ((cur->parent != NULL) &&
+                    (cur->parent->type == XML_ELEMENT_NODE)) {
                     if ((!xmlStrEqual(cur->parent->name, BAD_CAST "value"))
                         &&
                         (!xmlStrEqual
                          (cur->parent->name, BAD_CAST "param")))
                         delete = cur;
                 } else {
                     delete = cur;
                     goto skip_children;
                 }
             }
@@ skipping 131 matching lines @@
     }
 
     /*
      * Then do the parsing for good
      */
     root = xmlDocGetRootElement(doc);
     if (root == NULL) {
         xmlRngPErr(ctxt, (xmlNodePtr) doc,
                    XML_RNGP_EMPTY, "xmlRelaxNGParse: %s is empty\n",
                    (ctxt->URL ? ctxt->URL : BAD_CAST "schemas"), NULL);
-        
+
         xmlFreeDoc(ctxt->document);
         ctxt->document = NULL;
         return (NULL);
     }
     ret = xmlRelaxNGParseDocument(ctxt, root);
     if (ret == NULL) {
         xmlFreeDoc(ctxt->document);
         ctxt->document = NULL;
         return (NULL);
     }
@@ skipping 121 matching lines @@
         return;
     ctxt->serror = serror;
     ctxt->error = NULL;
     ctxt->warning = NULL;
     ctxt->userData = ctx;
 }
 
 #ifdef LIBXML_OUTPUT_ENABLED
 
 /************************************************************************
- *                                                                      *
- *                      Dump back a compiled form                       *
- *                                                                      *
+ *                                                                      *
+ *                      Dump back a compiled form                       *
+ *                                                                      *
  ************************************************************************/
 static void xmlRelaxNGDumpDefine(FILE * output,
                                  xmlRelaxNGDefinePtr define);
 
 /**
  * xmlRelaxNGDumpDefines:
  * @output:  the file output
  * @defines:  a list of define structures
  *
  * Dump a RelaxNG structure back
@@ skipping 120 matching lines @@
         case XML_RELAXNG_NOOP:
             xmlRelaxNGDumpDefines(output, define->content);
             break;
     }
 }
 
 /**
  * xmlRelaxNGDumpGrammar:
  * @output:  the file output
  * @grammar:  a grammar structure
- * @top:  is this a top grammar 
+ * @top:  is this a top grammar
  *
  * Dump a RelaxNG structure back
  */
 static void
 xmlRelaxNGDumpGrammar(FILE * output, xmlRelaxNGGrammarPtr grammar, int top)
 {
     if (grammar == NULL)
         return;
 
     fprintf(output, "<grammar");
@@ skipping 72 matching lines @@
     }
     if (schema->doc == NULL) {
         fprintf(output, "no document\n");
     } else {
         xmlDocDump(output, schema->doc);
     }
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
 
 /************************************************************************
- *                                                                      *
- *              Validation of compiled content                          *
- *                                                                      *
+ *                                                                      *
+ *              Validation of compiled content                          *
+ *                                                                      *
  ************************************************************************/
 static int xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt,
                                         xmlRelaxNGDefinePtr define);
 
 /**
  * xmlRelaxNGValidateCompiledCallback:
  * @exec:  the regular expression instance
  * @token:  the token which matched
  * @transdata:  callback data, the define for the subelement if available
  @ @inputdata:  callback data, the Relax NG validation context
@@ skipping 122 matching lines @@
      * regexp validation, e.g. for attribute values.
      */
     if ((ret == 0) && (ctxt->perr != 0)) {
         ret = ctxt->perr;
     }
     ctxt->perr = oldperr;
     return (ret);
 }
 
 /************************************************************************
- *                                                                      *
- *              Progressive validation of when possible                 *
- *                                                                      *
+ *                                                                      *
+ *              Progressive validation of when possible                 *
+ *                                                                      *
  ************************************************************************/
 static int xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
                                            xmlRelaxNGDefinePtr defines);
 static int xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt,
                                         int dolog);
 static void xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt);
 
 /**
  * xmlRelaxNGElemPush:
  * @ctxt:  the validation context
@@ skipping 279 matching lines @@
         xmlGenericError(xmlGenericErrorContext, "PushElem %s failed\n",
                         elem->name);
 #endif
     return (ret);
 }
 
 /**
  * xmlRelaxNGValidatePushCData:
  * @ctxt:  the RelaxNG validation context
  * @data:  some character data read
- * @len:  the lenght of the data
+ * @len:  the length of the data
  *
  * check the CData parsed for validation in the current stack
  *
  * returns 1 if no validation problem was found or -1 otherwise
  */
 int
 xmlRelaxNGValidatePushCData(xmlRelaxNGValidCtxtPtr ctxt,
                             const xmlChar * data, int len ATTRIBUTE_UNUSED)
 {
     int ret = 1;
@@ skipping 113 matching lines @@
     ctxt->state = NULL;
 #ifdef DEBUG_PROGRESSIVE
     if (ret < 0)
         xmlGenericError(xmlGenericErrorContext, "FullElem %s failed\n",
                         elem->name);
 #endif
     return (ret);
 }
 
 /************************************************************************
- *                                                                      *
- *              Generic interpreted validation implementation           *
- *                                                                      *
+ *                                                                      *
+ *              Generic interpreted validation implementation           *
+ *                                                                      *
  ************************************************************************/
 static int xmlRelaxNGValidateValue(xmlRelaxNGValidCtxtPtr ctxt,
                                    xmlRelaxNGDefinePtr define);
 
 /**
  * xmlRelaxNGSkipIgnored:
  * @ctxt:  a schema validation context
  * @node:  the top node.
  *
  * Skip ignorable nodes in that context
@@ skipping 381 matching lines @@
             }
         case XML_RELAXNG_ONEORMORE:
             ret = xmlRelaxNGValidateValueList(ctxt, define->content);
             if (ret != 0) {
                 break;
             }
             /* no break on purpose */
         case XML_RELAXNG_ZEROORMORE:{
                 xmlChar *cur, *temp;
 
+                if ((ctxt->state->value == NULL) ||
+                    (*ctxt->state->value == 0)) {
+                    ret = 0;
+                    break;
+                }
                 oldflags = ctxt->flags;
                 ctxt->flags |= FLAGS_IGNORABLE;
                 cur = ctxt->state->value;
                 temp = NULL;
                 while ((cur != NULL) && (cur != ctxt->state->endvalue) &&
                        (temp != cur)) {
                     temp = cur;
                     ret =
                         xmlRelaxNGValidateValueList(ctxt, define->content);
                     if (ret != 0) {
                         ctxt->state->value = temp;
                         ret = 0;
                         break;
                     }
                     cur = ctxt->state->value;
                 }
                 ctxt->flags = oldflags;
                 if (ctxt->errNr > 0)
                     xmlRelaxNGPopErrors(ctxt, 0);
                 break;
             }
+        case XML_RELAXNG_OPTIONAL:{
+                xmlChar *temp;
+
+                if ((ctxt->state->value == NULL) ||
+                    (*ctxt->state->value == 0)) {
+                    ret = 0;
+                    break;
+                }
+                oldflags = ctxt->flags;
+                ctxt->flags |= FLAGS_IGNORABLE;
+                temp = ctxt->state->value;
+                ret = xmlRelaxNGValidateValue(ctxt, define->content);
+                ctxt->flags = oldflags;
+                if (ret != 0) {
+                    ctxt->state->value = temp;
+                    if (ctxt->errNr > 0)
+                        xmlRelaxNGPopErrors(ctxt, 0);
+                    ret = 0;
+                    break;
+                }
+                if (ctxt->errNr > 0)
+                    xmlRelaxNGPopErrors(ctxt, 0);
+                break;
+            }
         case XML_RELAXNG_EXCEPT:{
                 xmlRelaxNGDefinePtr list;
 
                 list = define->content;
                 while (list != NULL) {
                     ret = xmlRelaxNGValidateValue(ctxt, list);
                     if (ret == 0) {
                         ret = -1;
                         break;
                     } else
@@ skipping 95 matching lines @@
 
         list = define->content;
         while (list != NULL) {
             ret = xmlRelaxNGAttributeMatch(ctxt, list, prop);
             if (ret == 1)
                 return (0);
             if (ret < 0)
                 return (ret);
             list = list->next;
         }
+    } else if (define->type == XML_RELAXNG_CHOICE) {
+        xmlRelaxNGDefinePtr list;
+
+        list = define->nameClass;
+        while (list != NULL) {
+            ret = xmlRelaxNGAttributeMatch(ctxt, list, prop);
+            if (ret == 1)
+                return (1);
+            if (ret < 0)
+                return (ret);
+            list = list->next;
+        }
+        return (0);
     } else {
     TODO}
     return (1);
 }
 
 /**
  * xmlRelaxNGValidateAttribute:
  * @ctxt:  a Relax-NG validation context
  * @define:  the definition to verify
  *
@@ skipping 339 matching lines @@
     }
     if (ret != 0) {
         VALID_ERR(XML_RELAXNG_ERR_INTERSEQ);
         ret = -1;
         goto done;
     }
     lastelem = cur;
     oldstate = ctxt->state;
     for (i = 0; i < nbgroups; i++) {
         ctxt->state = xmlRelaxNGCopyValidState(ctxt, oldstate);
+        if (ctxt->state == NULL) {
+            ret = -1;
+            break;
+        }
         group = partitions->groups[i];
         if (lasts[i] != NULL) {
             last = lasts[i]->next;
             lasts[i]->next = NULL;
         }
         ctxt->state->seq = list[i];
         ret = xmlRelaxNGValidateDefinition(ctxt, group->rule);
         if (ret != 0)
             break;
         if (ctxt->state != NULL) {
@@ skipping 410 matching lines @@
     if (define->name != NULL)
         xmlGenericError(xmlGenericErrorContext, "%s ", define->name);
     if ((node != NULL) && (node->name != NULL))
         xmlGenericError(xmlGenericErrorContext, "on %s\n", node->name);
     else
         xmlGenericError(xmlGenericErrorContext, "\n");
 #endif
     ctxt->depth++;
     switch (define->type) {
         case XML_RELAXNG_EMPTY:
-            node = xmlRelaxNGSkipIgnored(ctxt, node);
+            xmlRelaxNGSkipIgnored(ctxt, node);
             ret = 0;
             break;
         case XML_RELAXNG_NOT_ALLOWED:
             ret = -1;
             break;
         case XML_RELAXNG_TEXT:
             while ((node != NULL) &&
                    ((node->type == XML_TEXT_NODE) ||
                     (node->type == XML_COMMENT_NODE) ||
                     (node->type == XML_PI_NODE) ||
@@ skipping 983 matching lines @@
             }
             if (cur->next != NULL) {
                 cur = cur->next;
                 break;
             }
         } while (cur != NULL);
     }
     return;
 }
 /************************************************************************
- *                                                                      *
- *                      Validation interfaces                           *
- *                                                                      *
+ *                                                                      *
+ *                      Validation interfaces                           *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xmlRelaxNGNewValidCtxt:
  * @schema:  a precompiled XML RelaxNGs
  *
  * Create an XML RelaxNGs validation context based on the given schema
  *
  * Returns the validation context or NULL in case of error
  */
@@ skipping 165 matching lines @@
      * TODO: build error codes
      */
     if (ret == -1)
         return (1);
     return (ret);
 }
 
 #define bottom_relaxng
 #include "elfgcchack.h"
 #endif /* LIBXML_SCHEMAS_ENABLED */