relaxng.c - platform/external/libxml2 - Gitiles

 /*
  * 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:
  * - add support for DTD compatibility spec
  *   http://www.oasis-open.org/committees/relax-ng/compatibility-20011203.html
  * - report better mem allocations pbms at runtime and abort immediately.
  */

 #define IN_LIBXML
 #include "libxml.h"

 #ifdef LIBXML_SCHEMAS_ENABLED

 #include <string.h>
 #include <stdio.h>
 #include <libxml/xmlmemory.h>
 #include <libxml/parser.h>
 #include <libxml/parserInternals.h>
 #include <libxml/hash.h>
 #include <libxml/uri.h>

 #include <libxml/relaxng.h>

 #include <libxml/xmlschemastypes.h>
 #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)						\
    ((node != NULL) && (node->ns != NULL) &&				\
     (xmlStrEqual(node->name, (const xmlChar *) type)) &&		\
     (xmlStrEqual(node->ns->href, xmlRelaxNGNs)))


 /* #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 */

 /* #define DEBUG_ERROR 1 */

 /* #define DEBUG_COMPILE 1 */

 /* #define DEBUG_PROGRESSIVE 1 */

 #define MAX_ERROR 5

 #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;

 typedef struct _xmlRelaxNGDocument xmlRelaxNGDocument;
 typedef xmlRelaxNGDocument *xmlRelaxNGDocumentPtr;

 typedef struct _xmlRelaxNGInclude xmlRelaxNGInclude;
 typedef xmlRelaxNGInclude *xmlRelaxNGIncludePtr;

 typedef enum {
     XML_RELAXNG_COMBINE_UNDEFINED = 0,  /* undefined */
     XML_RELAXNG_COMBINE_CHOICE, /* choice */
     XML_RELAXNG_COMBINE_INTERLEAVE      /* interleave */
 } xmlRelaxNGCombine;

 typedef enum {
     XML_RELAXNG_CONTENT_ERROR = -1,
     XML_RELAXNG_CONTENT_EMPTY = 0,
     XML_RELAXNG_CONTENT_SIMPLE,
     XML_RELAXNG_CONTENT_COMPLEX
 } xmlRelaxNGContentType;

 typedef struct _xmlRelaxNGGrammar xmlRelaxNGGrammar;
 typedef xmlRelaxNGGrammar *xmlRelaxNGGrammarPtr;

 struct _xmlRelaxNGGrammar {
     xmlRelaxNGGrammarPtr parent;        /* the parent grammar if any */
     xmlRelaxNGGrammarPtr children;      /* the children grammar if any */
     xmlRelaxNGGrammarPtr next;  /* the next grammar if any */
     xmlRelaxNGDefinePtr start;  /* <start> content */
     xmlRelaxNGCombine combine;  /* the default combine value */
     xmlRelaxNGDefinePtr startList;      /* list of <start> definitions */
     xmlHashTablePtr defs;       /* define* */
     xmlHashTablePtr refs;       /* references */
 };


 typedef enum {
     XML_RELAXNG_NOOP = -1,      /* a no operation from simplification  */
     XML_RELAXNG_EMPTY = 0,      /* an empty pattern */
     XML_RELAXNG_NOT_ALLOWED,    /* not allowed top */
     XML_RELAXNG_EXCEPT,         /* except present in nameclass defs */
     XML_RELAXNG_TEXT,           /* textual content */
     XML_RELAXNG_ELEMENT,        /* an element */
     XML_RELAXNG_DATATYPE,       /* extenal data type definition */
     XML_RELAXNG_PARAM,          /* extenal data type parameter */
     XML_RELAXNG_VALUE,          /* value from an extenal data type definition */
     XML_RELAXNG_LIST,           /* a list of patterns */
     XML_RELAXNG_ATTRIBUTE,      /* an attrbute following a pattern */
     XML_RELAXNG_DEF,            /* a definition */
     XML_RELAXNG_REF,            /* reference to a definition */
     XML_RELAXNG_EXTERNALREF,    /* reference to an external def */
     XML_RELAXNG_PARENTREF,      /* reference to a def in the parent grammar */
     XML_RELAXNG_OPTIONAL,       /* optional patterns */
     XML_RELAXNG_ZEROORMORE,     /* zero or more non empty patterns */
     XML_RELAXNG_ONEORMORE,      /* one or more non empty patterns */
     XML_RELAXNG_CHOICE,         /* a choice between non empty patterns */
     XML_RELAXNG_GROUP,          /* a pair/group of non empty patterns */
     XML_RELAXNG_INTERLEAVE,     /* interleaving choice of non-empty patterns */
     XML_RELAXNG_START           /* Used to keep track of starts on grammars */
 } xmlRelaxNGType;

 #define IS_NULLABLE		(1 << 0)
 #define IS_NOT_NULLABLE		(1 << 1)
 #define IS_INDETERMINIST	(1 << 2)
 #define IS_MIXED		(1 << 3)
 #define IS_TRIABLE		(1 << 4)
 #define IS_PROCESSED		(1 << 5)
 #define IS_COMPILABLE		(1 << 6)
 #define IS_NOT_COMPILABLE	(1 << 7)

 struct _xmlRelaxNGDefine {
     xmlRelaxNGType type;        /* the type of definition */
     xmlNodePtr node;            /* the node in the source */
     xmlChar *name;              /* the element local name if present */
     xmlChar *ns;                /* the namespace local name if present */
     xmlChar *value;             /* value when available */
     void *data;                 /* data lib or specific pointer */
     xmlRelaxNGDefinePtr content;        /* the expected content */
     xmlRelaxNGDefinePtr parent; /* the parent definition, if any */
     xmlRelaxNGDefinePtr next;   /* list within grouping sequences */
     xmlRelaxNGDefinePtr attrs;  /* list of attributes for elements */
     xmlRelaxNGDefinePtr nameClass;      /* the nameClass definition if any */
     xmlRelaxNGDefinePtr nextHash;       /* next define in defs/refs hash tables */
     short depth;                /* used for the cycle detection */
     short dflags;               /* define related flags */
     xmlRegexpPtr contModel;     /* a compiled content model if available */
 };

 /**
  * _xmlRelaxNG:
  *
  * A RelaxNGs definition
  */
 struct _xmlRelaxNG {
     void *_private;             /* unused by the library for users or bindings */
     xmlRelaxNGGrammarPtr topgrammar;
     xmlDocPtr doc;

     int idref;                  /* requires idref checking */

     xmlHashTablePtr defs;       /* define */
     xmlHashTablePtr refs;       /* references */
     xmlRelaxNGDocumentPtr documents;    /* all the documents loaded */
     xmlRelaxNGIncludePtr includes;      /* all the includes loaded */
     int defNr;                  /* number of defines used */
     xmlRelaxNGDefinePtr *defTab;        /* pointer to the allocated definitions */

 };

 #define XML_RELAXNG_IN_ATTRIBUTE	(1 << 0)
 #define XML_RELAXNG_IN_ONEORMORE	(1 << 1)
 #define XML_RELAXNG_IN_LIST		(1 << 2)
 #define XML_RELAXNG_IN_DATAEXCEPT	(1 << 3)
 #define XML_RELAXNG_IN_START		(1 << 4)
 #define XML_RELAXNG_IN_OOMGROUP		(1 << 5)
 #define XML_RELAXNG_IN_OOMINTERLEAVE	(1 << 6)
 #define XML_RELAXNG_IN_EXTERNALREF	(1 << 7)
 #define XML_RELAXNG_IN_ANYEXCEPT	(1 << 8)
 #define XML_RELAXNG_IN_NSEXCEPT		(1 << 9)

 struct _xmlRelaxNGParserCtxt {
     void *userData;             /* user specific data block */
     xmlRelaxNGValidityErrorFunc error;  /* the callback in case of errors */
     xmlRelaxNGValidityWarningFunc warning;      /* the callback in case of warning */
     xmlStructuredErrorFunc serror;
     xmlRelaxNGValidErr err;

     xmlRelaxNGPtr schema;       /* The schema in use */
     xmlRelaxNGGrammarPtr grammar;       /* the current grammar */
     xmlRelaxNGGrammarPtr parentgrammar; /* the parent grammar */
     int flags;                  /* parser flags */
     int nbErrors;               /* number of errors at parse time */
     int nbWarnings;             /* number of warnings at parse time */
     const xmlChar *define;      /* the current define scope */
     xmlRelaxNGDefinePtr def;    /* the current define */

     int nbInterleaves;
     xmlHashTablePtr interleaves;        /* keep track of all the interleaves */

     xmlRelaxNGDocumentPtr documents;    /* all the documents loaded */
     xmlRelaxNGIncludePtr includes;      /* all the includes loaded */
     xmlChar *URL;
     xmlDocPtr document;

     int defNr;                  /* number of defines used */
     int defMax;                 /* number of defines aloocated */
     xmlRelaxNGDefinePtr *defTab;        /* pointer to the allocated definitions */

     const char *buffer;
     int size;

     /* the document stack */
     xmlRelaxNGDocumentPtr doc;  /* Current parsed external ref */
     int docNr;                  /* Depth of the parsing stack */
     int docMax;                 /* Max depth of the parsing stack */
     xmlRelaxNGDocumentPtr *docTab;      /* array of docs */

     /* the include stack */
     xmlRelaxNGIncludePtr inc;   /* Current parsed include */
     int incNr;                  /* Depth of the include parsing stack */
     int incMax;                 /* Max depth of the parsing stack */
     xmlRelaxNGIncludePtr *incTab;       /* array of incs */

     int idref;                  /* requires idref checking */

     /* used to compile content models */
     xmlAutomataPtr am;          /* the automata */
     xmlAutomataStatePtr state;  /* used to build the automata */

     int crng;			/* compact syntax and other flags */
     int freedoc;		/* need to free the document */
 };

 #define FLAGS_IGNORABLE		1
 #define FLAGS_NEGATIVE		2
 #define FLAGS_MIXED_CONTENT	4
 #define FLAGS_NOERROR		8

 /**
  * xmlRelaxNGInterleaveGroup:
  *
  * A RelaxNGs partition set associated to lists of definitions
  */
 typedef struct _xmlRelaxNGInterleaveGroup xmlRelaxNGInterleaveGroup;
 typedef xmlRelaxNGInterleaveGroup *xmlRelaxNGInterleaveGroupPtr;
 struct _xmlRelaxNGInterleaveGroup {
     xmlRelaxNGDefinePtr rule;   /* the rule to satisfy */
     xmlRelaxNGDefinePtr *defs;  /* the array of element definitions */
     xmlRelaxNGDefinePtr *attrs; /* the array of attributes definitions */
 };

 #define IS_DETERMINIST		1
 #define IS_NEEDCHECK		2

 /**
  * xmlRelaxNGPartitions:
  *
  * A RelaxNGs partition associated to an interleave group
  */
 typedef struct _xmlRelaxNGPartition xmlRelaxNGPartition;
 typedef xmlRelaxNGPartition *xmlRelaxNGPartitionPtr;
 struct _xmlRelaxNGPartition {
     int nbgroups;               /* number of groups in the partitions */
     xmlHashTablePtr triage;     /* hash table used to direct nodes to the
                                  * right group when possible */
     int flags;                  /* determinist ? */
     xmlRelaxNGInterleaveGroupPtr *groups;
 };

 /**
  * xmlRelaxNGValidState:
  *
  * A RelaxNGs validation state
  */
 #define MAX_ATTR 20
 typedef struct _xmlRelaxNGValidState xmlRelaxNGValidState;
 typedef xmlRelaxNGValidState *xmlRelaxNGValidStatePtr;
 struct _xmlRelaxNGValidState {
     xmlNodePtr node;            /* the current node */
     xmlNodePtr seq;             /* the sequence of children left to validate */
     int nbAttrs;                /* the number of attributes */
     int maxAttrs;               /* the size of attrs */
     int nbAttrLeft;             /* the number of attributes left to validate */
     xmlChar *value;             /* the value when operating on string */
     xmlChar *endvalue;          /* the end value when operating on string */
     xmlAttrPtr *attrs;          /* the array of attributes */
 };

 /**
  * xmlRelaxNGStates:
  *
  * A RelaxNGs container for validation state
  */
 typedef struct _xmlRelaxNGStates xmlRelaxNGStates;
 typedef xmlRelaxNGStates *xmlRelaxNGStatesPtr;
 struct _xmlRelaxNGStates {
     int nbState;                /* the number of states */
     int maxState;               /* the size of the array */
     xmlRelaxNGValidStatePtr *tabState;
 };

 #define ERROR_IS_DUP	1

 /**
  * xmlRelaxNGValidError:
  *
  * A RelaxNGs validation error
  */
 typedef struct _xmlRelaxNGValidError xmlRelaxNGValidError;
 typedef xmlRelaxNGValidError *xmlRelaxNGValidErrorPtr;
 struct _xmlRelaxNGValidError {
     xmlRelaxNGValidErr err;     /* the error number */
     int flags;                  /* flags */
     xmlNodePtr node;            /* the current node */
     xmlNodePtr seq;             /* the current child */
     const xmlChar *arg1;        /* first arg */
     const xmlChar *arg2;        /* second arg */
 };

 /**
  * xmlRelaxNGValidCtxt:
  *
  * A RelaxNGs validation context
  */

 struct _xmlRelaxNGValidCtxt {
     void *userData;             /* user specific data block */
     xmlRelaxNGValidityErrorFunc error;  /* the callback in case of errors */
     xmlRelaxNGValidityWarningFunc warning;      /* the callback in case of warning */
     xmlStructuredErrorFunc serror;
     int nbErrors;               /* number of errors in validation */

     xmlRelaxNGPtr schema;       /* The schema in use */
     xmlDocPtr doc;              /* the document being validated */
     int flags;                  /* validation flags */
     int depth;                  /* validation depth */
     int idref;                  /* requires idref checking */
     int errNo;                  /* the first error found */

     /*
      * Errors accumulated in branches may have to be stacked to be
      * provided back when it's sure they affect validation.
      */
     xmlRelaxNGValidErrorPtr err;        /* Last error */
     int errNr;                  /* Depth of the error stack */
     int errMax;                 /* Max depth of the error stack */
     xmlRelaxNGValidErrorPtr errTab;     /* stack of errors */

     xmlRelaxNGValidStatePtr state;      /* the current validation state */
     xmlRelaxNGStatesPtr states; /* the accumulated state list */

     xmlRelaxNGStatesPtr freeState;      /* the pool of free valid states */
     int freeStatesNr;
     int freeStatesMax;
     xmlRelaxNGStatesPtr *freeStates;    /* the pool of free state groups */

     /*
      * This is used for "progressive" validation
      */
     xmlRegExecCtxtPtr elem;     /* the current element regexp */
     int elemNr;                 /* the number of element validated */
     int elemMax;                /* the max depth of elements */
     xmlRegExecCtxtPtr *elemTab; /* the stack of regexp runtime */
     int pstate;                 /* progressive state */
     xmlNodePtr pnode;           /* the current node */
     xmlRelaxNGDefinePtr pdef;   /* the non-streamable definition */
     int perr;                   /* signal error in content model
                                  * outside the regexp */
 };

 /**
  * xmlRelaxNGInclude:
  *
  * Structure associated to a RelaxNGs document element
  */
 struct _xmlRelaxNGInclude {
     xmlRelaxNGIncludePtr next;  /* keep a chain of includes */
     xmlChar *href;              /* the normalized href value */
     xmlDocPtr doc;              /* the associated XML document */
     xmlRelaxNGDefinePtr content;        /* the definitions */
     xmlRelaxNGPtr schema;       /* the schema */
 };

 /**
  * xmlRelaxNGDocument:
  *
  * Structure associated to a RelaxNGs document element
  */
 struct _xmlRelaxNGDocument {
     xmlRelaxNGDocumentPtr next; /* keep a chain of documents */
     xmlChar *href;              /* the normalized href value */
     xmlDocPtr doc;              /* the associated XML document */
     xmlRelaxNGDefinePtr content;        /* the definitions */
     xmlRelaxNGPtr schema;       /* the schema */
 };


 /************************************************************************
  *									*
  * 		Some factorized error routines				*
  *									*
  ************************************************************************/

 /**
  * xmlRngPErrMemory:
  * @ctxt:  an Relax-NG parser context
  * @extra:  extra informations
  *
  * Handle a redefinition of attribute error
  */
 static void
 xmlRngPErrMemory(xmlRelaxNGParserCtxtPtr ctxt, const char *extra)
 {
     xmlStructuredErrorFunc schannel = NULL;
     xmlGenericErrorFunc channel = NULL;
     void *data = NULL;

     if (ctxt != NULL) {
         if (ctxt->serror != NULL)
 	    schannel = ctxt->serror;
 	else
 	    channel = ctxt->error;
         data = ctxt->userData;
         ctxt->nbErrors++;
     }
     if (extra)
         __xmlRaiseError(schannel, channel, data,
                         NULL, NULL, XML_FROM_RELAXNGP,
                         XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
                         NULL, NULL, 0, 0,
                         "Memory allocation failed : %s\n", extra);
     else
         __xmlRaiseError(schannel, channel, data,
                         NULL, NULL, XML_FROM_RELAXNGP,
                         XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
                         NULL, NULL, 0, 0, "Memory allocation failed\n");
 }

 /**
  * xmlRngVErrMemory:
  * @ctxt:  a Relax-NG validation context
  * @extra:  extra informations
  *
  * Handle a redefinition of attribute error
  */
 static void
 xmlRngVErrMemory(xmlRelaxNGValidCtxtPtr ctxt, const char *extra)
 {
     xmlStructuredErrorFunc schannel = NULL;
     xmlGenericErrorFunc channel = NULL;
     void *data = NULL;

     if (ctxt != NULL) {
         if (ctxt->serror != NULL)
 	    schannel = ctxt->serror;
 	else
 	    channel = ctxt->error;
         data = ctxt->userData;
         ctxt->nbErrors++;
     }
     if (extra)
         __xmlRaiseError(schannel, channel, data,
                         NULL, NULL, XML_FROM_RELAXNGV,
                         XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
                         NULL, NULL, 0, 0,
                         "Memory allocation failed : %s\n", extra);
     else
         __xmlRaiseError(schannel, channel, data,
                         NULL, NULL, XML_FROM_RELAXNGV,
                         XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
                         NULL, NULL, 0, 0, "Memory allocation failed\n");
 }

 /**
  * xmlRngPErr:
  * @ctxt:  a Relax-NG parser context
  * @node:  the node raising the error
  * @error:  the error code
  * @msg:  message
  * @str1:  extra info
  * @str2:  extra info
  *
  * Handle a Relax NG Parsing error
  */
 static void
 xmlRngPErr(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node, int error,
            const char *msg, const xmlChar * str1, const xmlChar * str2)
 {
     xmlStructuredErrorFunc schannel = NULL;
     xmlGenericErrorFunc channel = NULL;
     void *data = NULL;

     if (ctxt != NULL) {
         if (ctxt->serror != NULL)
 	    schannel = ctxt->serror;
 	else
 	    channel = ctxt->error;
         data = ctxt->userData;
         ctxt->nbErrors++;
     }
     __xmlRaiseError(schannel, channel, data,
                     NULL, node, XML_FROM_RELAXNGP,
                     error, XML_ERR_ERROR, NULL, 0,
                     (const char *) str1, (const char *) str2, NULL, 0, 0,
                     msg, str1, str2);
 }

 /**
  * xmlRngVErr:
  * @ctxt:  a Relax-NG validation context
  * @node:  the node raising the error
  * @error:  the error code
  * @msg:  message
  * @str1:  extra info
  * @str2:  extra info
  *
  * Handle a Relax NG Validation error
  */
 static void
 xmlRngVErr(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node, int error,
            const char *msg, const xmlChar * str1, const xmlChar * str2)
 {
     xmlStructuredErrorFunc schannel = NULL;
     xmlGenericErrorFunc channel = NULL;
     void *data = NULL;

     if (ctxt != NULL) {
         if (ctxt->serror != NULL)
 	    schannel = ctxt->serror;
 	else
 	    channel = ctxt->error;
         data = ctxt->userData;
         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			*
  * 									*
  ************************************************************************/

 /**
  * 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
  *
  * Returns 1 if yes, 0 if no and -1 in case of error.
  */
 typedef int (*xmlRelaxNGTypeHave) (void *data, const xmlChar * type);

 /**
  * xmlRelaxNGTypeCheck:
  * @data:  data needed for the library
  * @type:  the type name
  * @value:  the value to check
  * @result:  place to store the result if needed
  *
  * Function provided by a type library to check if a value match a type
  *
  * Returns 1 if yes, 0 if no and -1 in case of error.
  */
 typedef int (*xmlRelaxNGTypeCheck) (void *data, const xmlChar * type,
                                     const xmlChar * value, void **result,
                                     xmlNodePtr node);

 /**
  * xmlRelaxNGFacetCheck:
  * @data:  data needed for the library
  * @type:  the type name
  * @facet:  the facet name
  * @val:  the facet value
  * @strval:  the string value
  * @value:  the value to check
  *
  * Function provided by a type library to check a value facet
  *
  * Returns 1 if yes, 0 if no and -1 in case of error.
  */
 typedef int (*xmlRelaxNGFacetCheck) (void *data, const xmlChar * type,
                                      const xmlChar * facet,
                                      const xmlChar * val,
                                      const xmlChar * strval, void *value);

 /**
  * xmlRelaxNGTypeFree:
  * @data:  data needed for the library
  * @result:  the value to free
  *
  * Function provided by a type library to free a returned result
  */
 typedef void (*xmlRelaxNGTypeFree) (void *data, void *result);

 /**
  * xmlRelaxNGTypeCompare:
  * @data:  data needed for the library
  * @type:  the type name
  * @value1:  the first value
  * @value2:  the second value
  *
  * Function provided by a type library to compare two values accordingly
  * to a type.
  *
  * Returns 1 if yes, 0 if no and -1 in case of error.
  */
 typedef int (*xmlRelaxNGTypeCompare) (void *data, const xmlChar * type,
                                       const xmlChar * value1,
                                       xmlNodePtr ctxt1,
                                       void *comp1,
                                       const xmlChar * value2,
                                       xmlNodePtr ctxt2);
 typedef struct _xmlRelaxNGTypeLibrary xmlRelaxNGTypeLibrary;
 typedef xmlRelaxNGTypeLibrary *xmlRelaxNGTypeLibraryPtr;
 struct _xmlRelaxNGTypeLibrary {
     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				*
  * 									*
  ************************************************************************/
 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,
                                      xmlRelaxNGValidStatePtr state);

 /**
  * xmlRelaxNGFreeDocument:
  * @docu:  a document structure
  *
  * Deallocate a RelaxNG document structure.
  */
 static void
 xmlRelaxNGFreeDocument(xmlRelaxNGDocumentPtr docu)
 {
     if (docu == NULL)
         return;

     if (docu->href != NULL)
         xmlFree(docu->href);
     if (docu->doc != NULL)
         xmlFreeDoc(docu->doc);
     if (docu->schema != NULL)
         xmlRelaxNGFreeInnerSchema(docu->schema);
     xmlFree(docu);
 }

 /**
  * xmlRelaxNGFreeDocumentList:
  * @docu:  a list of  document structure
  *
  * Deallocate a RelaxNG document structures.
  */
 static void
 xmlRelaxNGFreeDocumentList(xmlRelaxNGDocumentPtr docu)
 {
     xmlRelaxNGDocumentPtr next;

     while (docu != NULL) {
         next = docu->next;
         xmlRelaxNGFreeDocument(docu);
         docu = next;
     }
 }

 /**
  * xmlRelaxNGFreeInclude:
  * @incl:  a include structure
  *
  * Deallocate a RelaxNG include structure.
  */
 static void
 xmlRelaxNGFreeInclude(xmlRelaxNGIncludePtr incl)
 {
     if (incl == NULL)
         return;

     if (incl->href != NULL)
         xmlFree(incl->href);
     if (incl->doc != NULL)
         xmlFreeDoc(incl->doc);
     if (incl->schema != NULL)
         xmlRelaxNGFree(incl->schema);
     xmlFree(incl);
 }

 /**
  * xmlRelaxNGFreeIncludeList:
  * @incl:  a include structure list
  *
  * Deallocate a RelaxNG include structure.
  */
 static void
 xmlRelaxNGFreeIncludeList(xmlRelaxNGIncludePtr incl)
 {
     xmlRelaxNGIncludePtr next;

     while (incl != NULL) {
         next = incl->next;
         xmlRelaxNGFreeInclude(incl);
         incl = next;
     }
 }

 /**
  * xmlRelaxNGNewRelaxNG:
  * @ctxt:  a Relax-NG validation context (optional)
  *
  * Allocate a new RelaxNG structure.
  *
  * Returns the newly allocated structure or NULL in case or error
  */
 static xmlRelaxNGPtr
 xmlRelaxNGNewRelaxNG(xmlRelaxNGParserCtxtPtr ctxt)
 {
     xmlRelaxNGPtr ret;

     ret = (xmlRelaxNGPtr) xmlMalloc(sizeof(xmlRelaxNG));
     if (ret == NULL) {
         xmlRngPErrMemory(ctxt, NULL);
         return (NULL);
     }
     memset(ret, 0, sizeof(xmlRelaxNG));

     return (ret);
 }

 /**
  * xmlRelaxNGFreeInnerSchema:
  * @schema:  a schema structure
  *
  * Deallocate a RelaxNG schema structure.
  */
 static void
 xmlRelaxNGFreeInnerSchema(xmlRelaxNGPtr schema)
 {
     if (schema == NULL)
         return;

     if (schema->doc != NULL)
         xmlFreeDoc(schema->doc);
     if (schema->defTab != NULL) {
         int i;

         for (i = 0; i < schema->defNr; i++)
             xmlRelaxNGFreeDefine(schema->defTab[i]);
         xmlFree(schema->defTab);
     }

     xmlFree(schema);
 }

 /**
  * xmlRelaxNGFree:
  * @schema:  a schema structure
  *
  * Deallocate a RelaxNG structure.
  */
 void
 xmlRelaxNGFree(xmlRelaxNGPtr schema)
 {
     if (schema == NULL)
         return;

     if (schema->topgrammar != NULL)
         xmlRelaxNGFreeGrammar(schema->topgrammar);
     if (schema->doc != NULL)
         xmlFreeDoc(schema->doc);
     if (schema->documents != NULL)
         xmlRelaxNGFreeDocumentList(schema->documents);
     if (schema->includes != NULL)
         xmlRelaxNGFreeIncludeList(schema->includes);
     if (schema->defTab != NULL) {
         int i;

         for (i = 0; i < schema->defNr; i++)
             xmlRelaxNGFreeDefine(schema->defTab[i]);
         xmlFree(schema->defTab);
     }

     xmlFree(schema);
 }

 /**
  * xmlRelaxNGNewGrammar:
  * @ctxt:  a Relax-NG validation context (optional)
  *
  * Allocate a new RelaxNG grammar.
  *
  * Returns the newly allocated structure or NULL in case or error
  */
 static xmlRelaxNGGrammarPtr
 xmlRelaxNGNewGrammar(xmlRelaxNGParserCtxtPtr ctxt)
 {
     xmlRelaxNGGrammarPtr ret;

     ret = (xmlRelaxNGGrammarPtr) xmlMalloc(sizeof(xmlRelaxNGGrammar));
     if (ret == NULL) {
         xmlRngPErrMemory(ctxt, NULL);
         return (NULL);
     }
     memset(ret, 0, sizeof(xmlRelaxNGGrammar));

     return (ret);
 }

 /**
  * xmlRelaxNGFreeGrammar:
  * @grammar:  a grammar structure
  *
  * Deallocate a RelaxNG grammar structure.
  */
 static void
 xmlRelaxNGFreeGrammar(xmlRelaxNGGrammarPtr grammar)
 {
     if (grammar == NULL)
         return;

     if (grammar->children != NULL) {
         xmlRelaxNGFreeGrammar(grammar->children);
     }
     if (grammar->next != NULL) {
         xmlRelaxNGFreeGrammar(grammar->next);
     }
     if (grammar->refs != NULL) {
         xmlHashFree(grammar->refs, NULL);
     }
     if (grammar->defs != NULL) {
         xmlHashFree(grammar->defs, NULL);
     }

     xmlFree(grammar);
 }

 /**
  * xmlRelaxNGNewDefine:
  * @ctxt:  a Relax-NG validation context
  * @node:  the node in the input document.
  *
  * Allocate a new RelaxNG define.
  *
  * Returns the newly allocated structure or NULL in case or error
  */
 static xmlRelaxNGDefinePtr
 xmlRelaxNGNewDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
 {
     xmlRelaxNGDefinePtr ret;

     if (ctxt->defMax == 0) {
         ctxt->defMax = 16;
         ctxt->defNr = 0;
         ctxt->defTab = (xmlRelaxNGDefinePtr *)
             xmlMalloc(ctxt->defMax * sizeof(xmlRelaxNGDefinePtr));
         if (ctxt->defTab == NULL) {
             xmlRngPErrMemory(ctxt, "allocating define\n");
             return (NULL);
         }
     } else if (ctxt->defMax <= ctxt->defNr) {
         xmlRelaxNGDefinePtr *tmp;

         ctxt->defMax *= 2;
         tmp = (xmlRelaxNGDefinePtr *) xmlRealloc(ctxt->defTab,
                                                  ctxt->defMax *
                                                  sizeof
                                                  (xmlRelaxNGDefinePtr));
         if (tmp == NULL) {
             xmlRngPErrMemory(ctxt, "allocating define\n");
             return (NULL);
         }
         ctxt->defTab = tmp;
     }
     ret = (xmlRelaxNGDefinePtr) xmlMalloc(sizeof(xmlRelaxNGDefine));
     if (ret == NULL) {
         xmlRngPErrMemory(ctxt, "allocating define\n");
         return (NULL);
     }
     memset(ret, 0, sizeof(xmlRelaxNGDefine));
     ctxt->defTab[ctxt->defNr++] = ret;
     ret->node = node;
     ret->depth = -1;
     return (ret);
 }

 /**
  * xmlRelaxNGFreePartition:
  * @partitions:  a partition set structure
  *
  * Deallocate RelaxNG partition set structures.
  */
 static void
 xmlRelaxNGFreePartition(xmlRelaxNGPartitionPtr partitions)
 {
     xmlRelaxNGInterleaveGroupPtr group;
     int j;

     if (partitions != NULL) {
         if (partitions->groups != NULL) {
             for (j = 0; j < partitions->nbgroups; j++) {
                 group = partitions->groups[j];
                 if (group != NULL) {
                     if (group->defs != NULL)
                         xmlFree(group->defs);
                     if (group->attrs != NULL)
                         xmlFree(group->attrs);
                     xmlFree(group);
                 }
             }
             xmlFree(partitions->groups);
         }
         if (partitions->triage != NULL) {
             xmlHashFree(partitions->triage, NULL);
         }
         xmlFree(partitions);
     }
 }

 /**
  * xmlRelaxNGFreeDefine:
  * @define:  a define structure
  *
  * Deallocate a RelaxNG define structure.
  */
 static void
 xmlRelaxNGFreeDefine(xmlRelaxNGDefinePtr define)
 {
     if (define == NULL)
         return;

     if ((define->type == XML_RELAXNG_VALUE) && (define->attrs != NULL)) {
         xmlRelaxNGTypeLibraryPtr lib;

         lib = (xmlRelaxNGTypeLibraryPtr) define->data;
         if ((lib != NULL) && (lib->freef != NULL))
             lib->freef(lib->data, (void *) define->attrs);
     }
     if ((define->data != NULL) && (define->type == XML_RELAXNG_INTERLEAVE))
         xmlRelaxNGFreePartition((xmlRelaxNGPartitionPtr) define->data);
     if ((define->data != NULL) && (define->type == XML_RELAXNG_CHOICE))
         xmlHashFree((xmlHashTablePtr) define->data, NULL);
     if (define->name != NULL)
         xmlFree(define->name);
     if (define->ns != NULL)
         xmlFree(define->ns);
     if (define->value != NULL)
         xmlFree(define->value);
     if (define->contModel != NULL)
         xmlRegFreeRegexp(define->contModel);
     xmlFree(define);
 }

 /**
  * xmlRelaxNGNewStates:
  * @ctxt:  a Relax-NG validation context
  * @size:  the default size for the container
  *
  * Allocate a new RelaxNG validation state container
  *
  * Returns the newly allocated structure or NULL in case or error
  */
 static xmlRelaxNGStatesPtr
 xmlRelaxNGNewStates(xmlRelaxNGValidCtxtPtr ctxt, int size)
 {
     xmlRelaxNGStatesPtr ret;

     if ((ctxt != NULL) &&
         (ctxt->freeState != NULL) && (ctxt->freeStatesNr > 0)) {
         ctxt->freeStatesNr--;
         ret = ctxt->freeStates[ctxt->freeStatesNr];
         ret->nbState = 0;
         return (ret);
     }
     if (size < 16)
         size = 16;

     ret = (xmlRelaxNGStatesPtr) xmlMalloc(sizeof(xmlRelaxNGStates) +
                                           (size -
                                            1) *
                                           sizeof(xmlRelaxNGValidStatePtr));
     if (ret == NULL) {
         xmlRngVErrMemory(ctxt, "allocating states\n");
         return (NULL);
     }
     ret->nbState = 0;
     ret->maxState = size;
     ret->tabState = (xmlRelaxNGValidStatePtr *) xmlMalloc((size) *
                                                           sizeof
                                                           (xmlRelaxNGValidStatePtr));
     if (ret->tabState == NULL) {
         xmlRngVErrMemory(ctxt, "allocating states\n");
         xmlFree(ret);
         return (NULL);
     }
     return (ret);
 }

 /**
  * xmlRelaxNGAddStateUniq:
  * @ctxt:  a Relax-NG validation context
  * @states:  the states container
  * @state:  the validation state
  *
  * Add a RelaxNG validation state to the container without checking
  * for unicity.
  *
  * Return 1 in case of success and 0 if this is a duplicate and -1 on error
  */
 static int
 xmlRelaxNGAddStatesUniq(xmlRelaxNGValidCtxtPtr ctxt,
                         xmlRelaxNGStatesPtr states,
                         xmlRelaxNGValidStatePtr state)
 {
     if (state == NULL) {
         return (-1);
     }
     if (states->nbState >= states->maxState) {
         xmlRelaxNGValidStatePtr *tmp;
         int size;

         size = states->maxState * 2;
         tmp = (xmlRelaxNGValidStatePtr *) xmlRealloc(states->tabState,
                                                      (size) *
                                                      sizeof
                                                      (xmlRelaxNGValidStatePtr));
         if (tmp == NULL) {
             xmlRngVErrMemory(ctxt, "adding states\n");
             return (-1);
         }
         states->tabState = tmp;
         states->maxState = size;
     }
     states->tabState[states->nbState++] = state;
     return (1);
 }

 /**
  * xmlRelaxNGAddState:
  * @ctxt:  a Relax-NG validation context
  * @states:  the states container
  * @state:  the validation state
  *
  * Add a RelaxNG validation state to the container
  *
  * 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) {
         return (-1);
     }
     if (states->nbState >= states->maxState) {
         xmlRelaxNGValidStatePtr *tmp;
         int size;

         size = states->maxState * 2;
         tmp = (xmlRelaxNGValidStatePtr *) xmlRealloc(states->tabState,
                                                      (size) *
                                                      sizeof
                                                      (xmlRelaxNGValidStatePtr));
         if (tmp == NULL) {
             xmlRngVErrMemory(ctxt, "adding states\n");
             return (-1);
         }
         states->tabState = tmp;
         states->maxState = size;
     }
     for (i = 0; i < states->nbState; i++) {
         if (xmlRelaxNGEqualValidState(ctxt, state, states->tabState[i])) {
             xmlRelaxNGFreeValidState(ctxt, state);
             return (0);
         }
     }
     states->tabState[states->nbState++] = state;
     return (1);
 }

 /**
  * xmlRelaxNGFreeStates:
  * @ctxt:  a Relax-NG validation context
  * @states:  teh container
  *
  * Free a RelaxNG validation state container
  */
 static void
 xmlRelaxNGFreeStates(xmlRelaxNGValidCtxtPtr ctxt,
                      xmlRelaxNGStatesPtr states)
 {
     if (states == NULL)
         return;
     if ((ctxt != NULL) && (ctxt->freeStates == NULL)) {
         ctxt->freeStatesMax = 40;
         ctxt->freeStatesNr = 0;
         ctxt->freeStates = (xmlRelaxNGStatesPtr *)
             xmlMalloc(ctxt->freeStatesMax * sizeof(xmlRelaxNGStatesPtr));
         if (ctxt->freeStates == NULL) {
             xmlRngVErrMemory(ctxt, "storing states\n");
         }
     } else if ((ctxt != NULL)
                && (ctxt->freeStatesNr >= ctxt->freeStatesMax)) {
         xmlRelaxNGStatesPtr *tmp;

         tmp = (xmlRelaxNGStatesPtr *) xmlRealloc(ctxt->freeStates,
                                                  2 * ctxt->freeStatesMax *
                                                  sizeof
                                                  (xmlRelaxNGStatesPtr));
         if (tmp == NULL) {
             xmlRngVErrMemory(ctxt, "storing states\n");
             xmlFree(states->tabState);
             xmlFree(states);
             return;
         }
         ctxt->freeStates = tmp;
         ctxt->freeStatesMax *= 2;
     }
     if ((ctxt == NULL) || (ctxt->freeState == NULL)) {
         xmlFree(states->tabState);
         xmlFree(states);
     } else {
         ctxt->freeStates[ctxt->freeStatesNr++] = states;
     }
 }

 /**
  * xmlRelaxNGNewValidState:
  * @ctxt:  a Relax-NG validation context
  * @node:  the current node or NULL for the document
  *
  * Allocate a new RelaxNG validation state
  *
  * Returns the newly allocated structure or NULL in case or error
  */
 static xmlRelaxNGValidStatePtr
 xmlRelaxNGNewValidState(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node)
 {
     xmlRelaxNGValidStatePtr ret;
     xmlAttrPtr attr;
     xmlAttrPtr attrs[MAX_ATTR];
     int nbAttrs = 0;
     xmlNodePtr root = NULL;

     if (node == NULL) {
         root = xmlDocGetRootElement(ctxt->doc);
         if (root == NULL)
             return (NULL);
     } else {
         attr = node->properties;
         while (attr != NULL) {
             if (nbAttrs < MAX_ATTR)
                 attrs[nbAttrs++] = attr;
             else
                 nbAttrs++;
             attr = attr->next;
         }
     }
     if ((ctxt->freeState != NULL) && (ctxt->freeState->nbState > 0)) {
         ctxt->freeState->nbState--;
         ret = ctxt->freeState->tabState[ctxt->freeState->nbState];
     } else {
         ret =
             (xmlRelaxNGValidStatePtr)
             xmlMalloc(sizeof(xmlRelaxNGValidState));
         if (ret == NULL) {
             xmlRngVErrMemory(ctxt, "allocating states\n");
             return (NULL);
         }
         memset(ret, 0, sizeof(xmlRelaxNGValidState));
     }
     ret->value = NULL;
     ret->endvalue = NULL;
     if (node == NULL) {
         ret->node = (xmlNodePtr) ctxt->doc;
         ret->seq = root;
     } else {
         ret->node = node;
         ret->seq = node->children;
     }
     ret->nbAttrs = 0;
     if (nbAttrs > 0) {
         if (ret->attrs == NULL) {
             if (nbAttrs < 4)
                 ret->maxAttrs = 4;
             else
                 ret->maxAttrs = nbAttrs;
             ret->attrs = (xmlAttrPtr *) xmlMalloc(ret->maxAttrs *
                                                   sizeof(xmlAttrPtr));
             if (ret->attrs == NULL) {
                 xmlRngVErrMemory(ctxt, "allocating states\n");
                 return (ret);
             }
         } else if (ret->maxAttrs < nbAttrs) {
             xmlAttrPtr *tmp;

             tmp = (xmlAttrPtr *) xmlRealloc(ret->attrs, nbAttrs *
                                             sizeof(xmlAttrPtr));
             if (tmp == NULL) {
                 xmlRngVErrMemory(ctxt, "allocating states\n");
                 return (ret);
             }
             ret->attrs = tmp;
             ret->maxAttrs = nbAttrs;
         }
         ret->nbAttrs = nbAttrs;
         if (nbAttrs < MAX_ATTR) {
             memcpy(ret->attrs, attrs, sizeof(xmlAttrPtr) * nbAttrs);
         } else {
             attr = node->properties;
             nbAttrs = 0;
             while (attr != NULL) {
                 ret->attrs[nbAttrs++] = attr;
                 attr = attr->next;
             }
         }
     }
     ret->nbAttrLeft = ret->nbAttrs;
     return (ret);
 }

 /**
  * xmlRelaxNGCopyValidState:
  * @ctxt:  a Relax-NG validation context
  * @state:  a validation state
  *
  * Copy the validation state
  *
  * Returns the newly allocated structure or NULL in case or error
  */
 static xmlRelaxNGValidStatePtr
 xmlRelaxNGCopyValidState(xmlRelaxNGValidCtxtPtr ctxt,
                          xmlRelaxNGValidStatePtr state)
 {
     xmlRelaxNGValidStatePtr ret;
     unsigned int maxAttrs;
     xmlAttrPtr *attrs;

     if (state == NULL)
         return (NULL);
     if ((ctxt->freeState != NULL) && (ctxt->freeState->nbState > 0)) {
         ctxt->freeState->nbState--;
         ret = ctxt->freeState->tabState[ctxt->freeState->nbState];
     } else {
         ret =
             (xmlRelaxNGValidStatePtr)
             xmlMalloc(sizeof(xmlRelaxNGValidState));
         if (ret == NULL) {
             xmlRngVErrMemory(ctxt, "allocating states\n");
             return (NULL);
         }
         memset(ret, 0, sizeof(xmlRelaxNGValidState));
     }
     attrs = ret->attrs;
     maxAttrs = ret->maxAttrs;
     memcpy(ret, state, sizeof(xmlRelaxNGValidState));
     ret->attrs = attrs;
     ret->maxAttrs = maxAttrs;
     if (state->nbAttrs > 0) {
         if (ret->attrs == NULL) {
             ret->maxAttrs = state->maxAttrs;
             ret->attrs = (xmlAttrPtr *) xmlMalloc(ret->maxAttrs *
                                                   sizeof(xmlAttrPtr));
             if (ret->attrs == NULL) {
                 xmlRngVErrMemory(ctxt, "allocating states\n");
                 ret->nbAttrs = 0;
                 return (ret);
             }
         } else if (ret->maxAttrs < state->nbAttrs) {
             xmlAttrPtr *tmp;

             tmp = (xmlAttrPtr *) xmlRealloc(ret->attrs, state->maxAttrs *
                                             sizeof(xmlAttrPtr));
             if (tmp == NULL) {
                 xmlRngVErrMemory(ctxt, "allocating states\n");
                 ret->nbAttrs = 0;
                 return (ret);
             }
             ret->maxAttrs = state->maxAttrs;
             ret->attrs = tmp;
         }
         memcpy(ret->attrs, state->attrs,
                state->nbAttrs * sizeof(xmlAttrPtr));
     }
     return (ret);
 }

 /**
  * xmlRelaxNGEqualValidState:
  * @ctxt:  a Relax-NG validation context
  * @state1:  a validation state
  * @state2:  a validation state
  *
  * Compare the validation states for equality
  *
  * Returns 1 if equald, 0 otherwise
  */
 static int
 xmlRelaxNGEqualValidState(xmlRelaxNGValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
                           xmlRelaxNGValidStatePtr state1,
                           xmlRelaxNGValidStatePtr state2)
 {
     int i;

     if ((state1 == NULL) || (state2 == NULL))
         return (0);
     if (state1 == state2)
         return (1);
     if (state1->node != state2->node)
         return (0);
     if (state1->seq != state2->seq)
         return (0);
     if (state1->nbAttrLeft != state2->nbAttrLeft)
         return (0);
     if (state1->nbAttrs != state2->nbAttrs)
         return (0);
     if (state1->endvalue != state2->endvalue)
         return (0);
     if ((state1->value != state2->value) &&
         (!xmlStrEqual(state1->value, state2->value)))
         return (0);
     for (i = 0; i < state1->nbAttrs; i++) {
         if (state1->attrs[i] != state2->attrs[i])
             return (0);
     }
     return (1);
 }

 /**
  * xmlRelaxNGFreeValidState:
  * @state:  a validation state structure
  *
  * Deallocate a RelaxNG validation state structure.
  */
 static void
 xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt,
                          xmlRelaxNGValidStatePtr state)
 {
     if (state == NULL)
         return;

     if ((ctxt != NULL) && (ctxt->freeState == NULL)) {
         ctxt->freeState = xmlRelaxNGNewStates(ctxt, 40);
     }
     if ((ctxt == NULL) || (ctxt->freeState == NULL)) {
         if (state->attrs != NULL)
             xmlFree(state->attrs);
         xmlFree(state);
     } else {
         xmlRelaxNGAddStatesUniq(ctxt, ctxt->freeState, state);
     }
 }

 /************************************************************************
  * 									*
  * 			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				*
  * 									*
  ************************************************************************/
 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
  *
  * Returns 0 in case of error, the index in the stack otherwise
  */
 static int
 xmlRelaxNGIncludePush(xmlRelaxNGParserCtxtPtr ctxt,
                       xmlRelaxNGIncludePtr value)
 {
     if (ctxt->incTab == NULL) {
         ctxt->incMax = 4;
         ctxt->incNr = 0;
         ctxt->incTab =
             (xmlRelaxNGIncludePtr *) xmlMalloc(ctxt->incMax *
                                                sizeof(ctxt->incTab[0]));
         if (ctxt->incTab == NULL) {
             xmlRngPErrMemory(ctxt, "allocating include\n");
             return (0);
         }
     }
     if (ctxt->incNr >= ctxt->incMax) {
         ctxt->incMax *= 2;
         ctxt->incTab =
             (xmlRelaxNGIncludePtr *) xmlRealloc(ctxt->incTab,
                                                 ctxt->incMax *
                                                 sizeof(ctxt->incTab[0]));
         if (ctxt->incTab == NULL) {
             xmlRngPErrMemory(ctxt, "allocating include\n");
             return (0);
         }
     }
     ctxt->incTab[ctxt->incNr] = value;
     ctxt->inc = value;
     return (ctxt->incNr++);
 }

 /**
  * xmlRelaxNGIncludePop:
  * @ctxt: the parser context
  *
  * Pops the top include from the include stack
  *
  * Returns the include just removed
  */
 static xmlRelaxNGIncludePtr
 xmlRelaxNGIncludePop(xmlRelaxNGParserCtxtPtr ctxt)
 {
     xmlRelaxNGIncludePtr ret;

     if (ctxt->incNr <= 0)
         return (NULL);
     ctxt->incNr--;
     if (ctxt->incNr > 0)
         ctxt->inc = ctxt->incTab[ctxt->incNr - 1];
     else
         ctxt->inc = NULL;
     ret = ctxt->incTab[ctxt->incNr];
     ctxt->incTab[ctxt->incNr] = NULL;
     return (ret);
 }

 /**
  * xmlRelaxNGRemoveRedefine:
  * @ctxt: the parser context
  * @URL:  the normalized URL
  * @target:  the included target
  * @name:  the define name to eliminate
  *
  * Applies the elimination algorithm of 4.7
  *
  * Returns 0 in case of error, 1 in case of success.
  */
 static int
 xmlRelaxNGRemoveRedefine(xmlRelaxNGParserCtxtPtr ctxt,
                          const xmlChar * URL ATTRIBUTE_UNUSED,
                          xmlNodePtr target, const xmlChar * name)
 {
     int found = 0;
     xmlNodePtr tmp, tmp2;
     xmlChar *name2;

 #ifdef DEBUG_INCLUDE
     if (name == NULL)
         xmlGenericError(xmlGenericErrorContext,
                         "Elimination of <include> start from %s\n", URL);
     else
         xmlGenericError(xmlGenericErrorContext,
                         "Elimination of <include> define %s from %s\n",
                         name, URL);
 #endif
     tmp = target;
     while (tmp != NULL) {
         tmp2 = tmp->next;
         if ((name == NULL) && (IS_RELAXNG(tmp, "start"))) {
             found = 1;
             xmlUnlinkNode(tmp);
             xmlFreeNode(tmp);
         } else if ((name != NULL) && (IS_RELAXNG(tmp, "define"))) {
             name2 = xmlGetProp(tmp, BAD_CAST "name");
             xmlRelaxNGNormExtSpace(name2);
             if (name2 != NULL) {
                 if (xmlStrEqual(name, name2)) {
                     found = 1;
                     xmlUnlinkNode(tmp);
                     xmlFreeNode(tmp);
                 }
                 xmlFree(name2);
             }
         } else if (IS_RELAXNG(tmp, "include")) {
             xmlChar *href = NULL;
             xmlRelaxNGDocumentPtr inc = tmp->psvi;

             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) {
                         found = 1;
                     }
                     if (href != NULL)
                         xmlFree(href);
                 }
             }
         }
         tmp = tmp2;
     }
     return (found);
 }

 /**
  * xmlRelaxNGLoadInclude:
  * @ctxt: the parser context
  * @URL:  the normalized URL
  * @node: the include node.
  * @ns:  the namespace passed from the context.
  *
  * First lookup if the document is already loaded into the parser context,
  * check against recursion. If not found the resource is loaded and
  * the content is preprocessed before being returned back to the caller.
  *
  * Returns the xmlRelaxNGIncludePtr or NULL in case of error
  */
 static xmlRelaxNGIncludePtr
 xmlRelaxNGLoadInclude(xmlRelaxNGParserCtxtPtr ctxt, const xmlChar * URL,
                       xmlNodePtr node, const xmlChar * ns)
 {
     xmlRelaxNGIncludePtr ret = NULL;
     xmlDocPtr doc;
     int i;
     xmlNodePtr root, cur;

 #ifdef DEBUG_INCLUDE
     xmlGenericError(xmlGenericErrorContext,
                     "xmlRelaxNGLoadInclude(%s)\n", URL);
 #endif

     /*
      * check against recursion in the stack
      */
     for (i = 0; i < ctxt->incNr; i++) {
         if (xmlStrEqual(ctxt->incTab[i]->href, URL)) {
             xmlRngPErr(ctxt, NULL, XML_RNGP_INCLUDE_RECURSE,
                        "Detected an Include recursion for %s\n", URL,
                        NULL);
             return (NULL);
         }
     }

     /*
      * load the document
      */
     doc = xmlReadFile((const char *) URL,NULL,0);
     if (doc == NULL) {
         xmlRngPErr(ctxt, node, XML_RNGP_PARSE_ERROR,
                    "xmlRelaxNG: could not load %s\n", URL, NULL);
         return (NULL);
     }
 #ifdef DEBUG_INCLUDE
     xmlGenericError(xmlGenericErrorContext, "Parsed %s Okay\n", URL);
 #endif

     /*
      * Allocate the document structures and register it first.
      */
     ret = (xmlRelaxNGIncludePtr) xmlMalloc(sizeof(xmlRelaxNGInclude));
     if (ret == NULL) {
         xmlRngPErrMemory(ctxt, "allocating include\n");
         xmlFreeDoc(doc);
         return (NULL);
     }
     memset(ret, 0, sizeof(xmlRelaxNGInclude));
     ret->doc = doc;
     ret->href = xmlStrdup(URL);
     ret->next = ctxt->includes;
     ctxt->includes = ret;

     /*
      * transmit the ns if needed
      */
     if (ns != NULL) {
         root = xmlDocGetRootElement(doc);
         if (root != NULL) {
             if (xmlHasProp(root, BAD_CAST "ns") == NULL) {
                 xmlSetProp(root, BAD_CAST "ns", ns);
             }
         }
     }

     /*
      * push it on the stack
      */
     xmlRelaxNGIncludePush(ctxt, ret);

     /*
      * Some preprocessing of the document content, this include recursing
      * in the include stack.
      */
 #ifdef DEBUG_INCLUDE
     xmlGenericError(xmlGenericErrorContext, "cleanup of %s\n", URL);
 #endif

     doc = xmlRelaxNGCleanupDoc(ctxt, doc);
     if (doc == NULL) {
         ctxt->inc = NULL;
         return (NULL);
     }

     /*
      * Pop up the include from the stack
      */
     xmlRelaxNGIncludePop(ctxt);

 #ifdef DEBUG_INCLUDE
     xmlGenericError(xmlGenericErrorContext, "Checking of %s\n", URL);
 #endif
     /*
      * Check that the top element is a grammar
      */
     root = xmlDocGetRootElement(doc);
     if (root == NULL) {
         xmlRngPErr(ctxt, node, XML_RNGP_EMPTY,
                    "xmlRelaxNG: included document is empty %s\n", URL,
                    NULL);
         return (NULL);
     }
     if (!IS_RELAXNG(root, "grammar")) {
         xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
                    "xmlRelaxNG: included document %s root is not a grammar\n",
                    URL, NULL);
         return (NULL);
     }

     /*
      * Elimination of redefined rules in the include.
      */
     cur = node->children;
     while (cur != NULL) {
         if (IS_RELAXNG(cur, "start")) {
             int found = 0;

             found =
                 xmlRelaxNGRemoveRedefine(ctxt, URL, root->children, NULL);
             if (!found) {
                 xmlRngPErr(ctxt, node, XML_RNGP_START_MISSING,
                            "xmlRelaxNG: include %s has a start but not the included grammar\n",
                            URL, NULL);
             }
         } else if (IS_RELAXNG(cur, "define")) {
             xmlChar *name;

             name = xmlGetProp(cur, BAD_CAST "name");
             if (name == NULL) {
                 xmlRngPErr(ctxt, node, XML_RNGP_NAME_MISSING,
                            "xmlRelaxNG: include %s has define without name\n",
                            URL, NULL);
             } else {
                 int found;

                 xmlRelaxNGNormExtSpace(name);
                 found = xmlRelaxNGRemoveRedefine(ctxt, URL,
                                                  root->children, name);
                 if (!found) {
                     xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_MISSING,
                                "xmlRelaxNG: include %s has a define %s but not the included grammar\n",
                                URL, name);
                 }
                 xmlFree(name);
             }
         }
         cur = cur->next;
     }


     return (ret);
 }

 /**
  * xmlRelaxNGValidErrorPush:
  * @ctxt:  the validation context
  * @err:  the error code
  * @arg1:  the first string argument
  * @arg2:  the second string argument
  * @dup:  arg need to be duplicated
  *
  * Pushes a new error on top of the error stack
  *
  * Returns 0 in case of error, the index in the stack otherwise
  */
 static int
 xmlRelaxNGValidErrorPush(xmlRelaxNGValidCtxtPtr ctxt,
                          xmlRelaxNGValidErr err, const xmlChar * arg1,
                          const xmlChar * arg2, int dup)
 {
     xmlRelaxNGValidErrorPtr cur;

 #ifdef DEBUG_ERROR
     xmlGenericError(xmlGenericErrorContext,
                     "Pushing error %d at %d on stack\n", err, ctxt->errNr);
 #endif
     if (ctxt->errTab == NULL) {
         ctxt->errMax = 8;
         ctxt->errNr = 0;
         ctxt->errTab =
             (xmlRelaxNGValidErrorPtr) xmlMalloc(ctxt->errMax *
                                                 sizeof
                                                 (xmlRelaxNGValidError));
         if (ctxt->errTab == NULL) {
             xmlRngVErrMemory(ctxt, "pushing error\n");
             return (0);
         }
         ctxt->err = NULL;
     }
     if (ctxt->errNr >= ctxt->errMax) {
         ctxt->errMax *= 2;
         ctxt->errTab =
             (xmlRelaxNGValidErrorPtr) xmlRealloc(ctxt->errTab,
                                                  ctxt->errMax *
                                                  sizeof
                                                  (xmlRelaxNGValidError));
         if (ctxt->errTab == NULL) {
             xmlRngVErrMemory(ctxt, "pushing error\n");
             return (0);
         }
         ctxt->err = &ctxt->errTab[ctxt->errNr - 1];
     }
     if ((ctxt->err != NULL) && (ctxt->state != NULL) &&
         (ctxt->err->node == ctxt->state->node) && (ctxt->err->err == err))
         return (ctxt->errNr);
     cur = &ctxt->errTab[ctxt->errNr];
     cur->err = err;
     if (dup) {
         cur->arg1 = xmlStrdup(arg1);
         cur->arg2 = xmlStrdup(arg2);
         cur->flags = ERROR_IS_DUP;
     } else {
         cur->arg1 = arg1;
         cur->arg2 = arg2;
         cur->flags = 0;
     }
     if (ctxt->state != NULL) {
         cur->node = ctxt->state->node;
         cur->seq = ctxt->state->seq;
     } else {
         cur->node = NULL;
         cur->seq = NULL;
     }
     ctxt->err = cur;
     return (ctxt->errNr++);
 }

 /**
  * xmlRelaxNGValidErrorPop:
  * @ctxt: the validation context
  *
  * Pops the top error from the error stack
  */
 static void
 xmlRelaxNGValidErrorPop(xmlRelaxNGValidCtxtPtr ctxt)
 {
     xmlRelaxNGValidErrorPtr cur;

     if (ctxt->errNr <= 0) {
         ctxt->err = NULL;
         return;
     }
     ctxt->errNr--;
     if (ctxt->errNr > 0)
         ctxt->err = &ctxt->errTab[ctxt->errNr - 1];
     else
         ctxt->err = NULL;
     cur = &ctxt->errTab[ctxt->errNr];
     if (cur->flags & ERROR_IS_DUP) {
         if (cur->arg1 != NULL)
             xmlFree((xmlChar *) cur->arg1);
         cur->arg1 = NULL;
         if (cur->arg2 != NULL)
             xmlFree((xmlChar *) cur->arg2);
         cur->arg2 = NULL;
         cur->flags = 0;
     }
 }

 /**
  * xmlRelaxNGDocumentPush:
  * @ctxt:  the parser context
  * @value:  the element doc
  *
  * Pushes a new doc on top of the doc stack
  *
  * Returns 0 in case of error, the index in the stack otherwise
  */
 static int
 xmlRelaxNGDocumentPush(xmlRelaxNGParserCtxtPtr ctxt,
                        xmlRelaxNGDocumentPtr value)
 {
     if (ctxt->docTab == NULL) {
         ctxt->docMax = 4;
         ctxt->docNr = 0;
         ctxt->docTab =
             (xmlRelaxNGDocumentPtr *) xmlMalloc(ctxt->docMax *
                                                 sizeof(ctxt->docTab[0]));
         if (ctxt->docTab == NULL) {
             xmlRngPErrMemory(ctxt, "adding document\n");
             return (0);
         }
     }
     if (ctxt->docNr >= ctxt->docMax) {
         ctxt->docMax *= 2;
         ctxt->docTab =
             (xmlRelaxNGDocumentPtr *) xmlRealloc(ctxt->docTab,
                                                  ctxt->docMax *
                                                  sizeof(ctxt->docTab[0]));
         if (ctxt->docTab == NULL) {
             xmlRngPErrMemory(ctxt, "adding document\n");
             return (0);
         }
     }
     ctxt->docTab[ctxt->docNr] = value;
     ctxt->doc = value;
     return (ctxt->docNr++);
 }

 /**
  * xmlRelaxNGDocumentPop:
  * @ctxt: the parser context
  *
  * Pops the top doc from the doc stack
  *
  * Returns the doc just removed
  */
 static xmlRelaxNGDocumentPtr
 xmlRelaxNGDocumentPop(xmlRelaxNGParserCtxtPtr ctxt)
 {
     xmlRelaxNGDocumentPtr ret;

     if (ctxt->docNr <= 0)
         return (NULL);
     ctxt->docNr--;
     if (ctxt->docNr > 0)
         ctxt->doc = ctxt->docTab[ctxt->docNr - 1];
     else
         ctxt->doc = NULL;
     ret = ctxt->docTab[ctxt->docNr];
     ctxt->docTab[ctxt->docNr] = NULL;
     return (ret);
 }

 /**
  * xmlRelaxNGLoadExternalRef:
  * @ctxt: the parser context
  * @URL:  the normalized URL
  * @ns:  the inherited ns if any
  *
  * First lookup if the document is already loaded into the parser context,
  * check against recursion. If not found the resource is loaded and
  * the content is preprocessed before being returned back to the caller.
  *
  * Returns the xmlRelaxNGDocumentPtr or NULL in case of error
  */
 static xmlRelaxNGDocumentPtr
 xmlRelaxNGLoadExternalRef(xmlRelaxNGParserCtxtPtr ctxt,
                           const xmlChar * URL, const xmlChar * ns)
 {
     xmlRelaxNGDocumentPtr ret = NULL;
     xmlDocPtr doc;
     xmlNodePtr root;
     int i;

     /*
      * check against recursion in the stack
      */
     for (i = 0; i < ctxt->docNr; i++) {
         if (xmlStrEqual(ctxt->docTab[i]->href, URL)) {
             xmlRngPErr(ctxt, NULL, XML_RNGP_EXTERNALREF_RECURSE,
                        "Detected an externalRef recursion for %s\n", URL,
                        NULL);
             return (NULL);
         }
     }

     /*
      * load the document
      */
     doc = xmlReadFile((const char *) URL,NULL,0);
     if (doc == NULL) {
         xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
                    "xmlRelaxNG: could not load %s\n", URL, NULL);
         return (NULL);
     }

     /*
      * Allocate the document structures and register it first.
      */
     ret = (xmlRelaxNGDocumentPtr) xmlMalloc(sizeof(xmlRelaxNGDocument));
     if (ret == NULL) {
         xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_ERR_NO_MEMORY,
                    "xmlRelaxNG: allocate memory for doc %s\n", URL, NULL);
         xmlFreeDoc(doc);
         return (NULL);
     }
     memset(ret, 0, sizeof(xmlRelaxNGDocument));
     ret->doc = doc;
     ret->href = xmlStrdup(URL);
     ret->next = ctxt->documents;
     ctxt->documents = ret;

     /*
      * transmit the ns if needed
      */
     if (ns != NULL) {
         root = xmlDocGetRootElement(doc);
         if (root != NULL) {
             if (xmlHasProp(root, BAD_CAST "ns") == NULL) {
                 xmlSetProp(root, BAD_CAST "ns", ns);
             }
         }
     }

     /*
      * push it on the stack and register it in the hash table
      */
     xmlRelaxNGDocumentPush(ctxt, ret);

     /*
      * Some preprocessing of the document content
      */
     doc = xmlRelaxNGCleanupDoc(ctxt, doc);
     if (doc == NULL) {
         ctxt->doc = NULL;
         return (NULL);
     }

     xmlRelaxNGDocumentPop(ctxt);

     return (ret);
 }

 /************************************************************************
  * 									*
  * 			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)
 {
     if (def == NULL)
         return ("none");
     switch (def->type) {
         case XML_RELAXNG_EMPTY:
             return ("empty");
         case XML_RELAXNG_NOT_ALLOWED:
             return ("notAllowed");
         case XML_RELAXNG_EXCEPT:
             return ("except");
         case XML_RELAXNG_TEXT:
             return ("text");
         case XML_RELAXNG_ELEMENT:
             return ("element");
         case XML_RELAXNG_DATATYPE:
             return ("datatype");
         case XML_RELAXNG_VALUE:
             return ("value");
         case XML_RELAXNG_LIST:
             return ("list");
         case XML_RELAXNG_ATTRIBUTE:
             return ("attribute");
         case XML_RELAXNG_DEF:
             return ("def");
         case XML_RELAXNG_REF:
             return ("ref");
         case XML_RELAXNG_EXTERNALREF:
             return ("externalRef");
         case XML_RELAXNG_PARENTREF:
             return ("parentRef");
         case XML_RELAXNG_OPTIONAL:
             return ("optional");
         case XML_RELAXNG_ZEROORMORE:
             return ("zeroOrMore");
         case XML_RELAXNG_ONEORMORE:
             return ("oneOrMore");
         case XML_RELAXNG_CHOICE:
             return ("choice");
         case XML_RELAXNG_GROUP:
             return ("group");
         case XML_RELAXNG_INTERLEAVE:
             return ("interleave");
         case XML_RELAXNG_START:
             return ("start");
         case XML_RELAXNG_NOOP:
             return ("noop");
         case XML_RELAXNG_PARAM:
             return ("param");
     }
     return ("unknown");
 }

 /**
  * xmlRelaxNGGetErrorString:
  * @err:  the error code
  * @arg1:  the first string argument
  * @arg2:  the second string argument
  *
  * computes a formatted error string for the given error code and args
  *
  * Returns the error string, it must be deallocated by the caller
  */
 static xmlChar *
 xmlRelaxNGGetErrorString(xmlRelaxNGValidErr err, const xmlChar * arg1,
                          const xmlChar * arg2)
 {
     char msg[1000];

     if (arg1 == NULL)
         arg1 = BAD_CAST "";
     if (arg2 == NULL)
         arg2 = BAD_CAST "";

     msg[0] = 0;
     switch (err) {
         case XML_RELAXNG_OK:
             return (NULL);
         case XML_RELAXNG_ERR_MEMORY:
             return (xmlCharStrdup("out of memory\n"));
         case XML_RELAXNG_ERR_TYPE:
             snprintf(msg, 1000, "failed to validate type %s\n", arg1);
             break;
         case XML_RELAXNG_ERR_TYPEVAL:
             snprintf(msg, 1000, "Type %s doesn't allow value '%s'\n", arg1,
                      arg2);
             break;
         case XML_RELAXNG_ERR_DUPID:
             snprintf(msg, 1000, "ID %s redefined\n", arg1);
             break;
         case XML_RELAXNG_ERR_TYPECMP:
             snprintf(msg, 1000, "failed to compare type %s\n", arg1);
             break;
         case XML_RELAXNG_ERR_NOSTATE:
             return (xmlCharStrdup("Internal error: no state\n"));
         case XML_RELAXNG_ERR_NODEFINE:
             return (xmlCharStrdup("Internal error: no define\n"));
         case XML_RELAXNG_ERR_INTERNAL:
             snprintf(msg, 1000, "Internal error: %s\n", arg1);
             break;
         case XML_RELAXNG_ERR_LISTEXTRA:
             snprintf(msg, 1000, "Extra data in list: %s\n", arg1);
             break;
         case XML_RELAXNG_ERR_INTERNODATA:
             return (xmlCharStrdup
                     ("Internal: interleave block has no data\n"));
         case XML_RELAXNG_ERR_INTERSEQ:
             return (xmlCharStrdup("Invalid sequence in interleave\n"));
         case XML_RELAXNG_ERR_INTEREXTRA:
             snprintf(msg, 1000, "Extra element %s in interleave\n", arg1);
             break;
         case XML_RELAXNG_ERR_ELEMNAME:
             snprintf(msg, 1000, "Expecting element %s, got %s\n", arg1,
                      arg2);
             break;
         case XML_RELAXNG_ERR_ELEMNONS:
             snprintf(msg, 1000, "Expecting a namespace for element %s\n",
                      arg1);
             break;
         case XML_RELAXNG_ERR_ELEMWRONGNS:
             snprintf(msg, 1000,
                      "Element %s has wrong namespace: expecting %s\n", arg1,
                      arg2);
             break;
         case XML_RELAXNG_ERR_ELEMWRONG:
             snprintf(msg, 1000, "Did not expect element %s there\n", arg1);
             break;
         case XML_RELAXNG_ERR_TEXTWRONG:
             snprintf(msg, 1000,
                      "Did not expect text in element %s content\n", arg1);
             break;
         case XML_RELAXNG_ERR_ELEMEXTRANS:
             snprintf(msg, 1000, "Expecting no namespace for element %s\n",
                      arg1);
             break;
         case XML_RELAXNG_ERR_ELEMNOTEMPTY:
             snprintf(msg, 1000, "Expecting element %s to be empty\n", arg1);
             break;
         case XML_RELAXNG_ERR_NOELEM:
             snprintf(msg, 1000, "Expecting an element %s, got nothing\n",
                      arg1);
             break;
         case XML_RELAXNG_ERR_NOTELEM:
             return (xmlCharStrdup("Expecting an element got text\n"));
         case XML_RELAXNG_ERR_ATTRVALID:
             snprintf(msg, 1000, "Element %s failed to validate attributes\n",
                      arg1);
             break;
         case XML_RELAXNG_ERR_CONTENTVALID:
             snprintf(msg, 1000, "Element %s failed to validate content\n",
                      arg1);
             break;
         case XML_RELAXNG_ERR_EXTRACONTENT:
             snprintf(msg, 1000, "Element %s has extra content: %s\n",
                      arg1, arg2);
             break;
         case XML_RELAXNG_ERR_INVALIDATTR:
             snprintf(msg, 1000, "Invalid attribute %s for element %s\n",
                      arg1, arg2);
             break;
         case XML_RELAXNG_ERR_LACKDATA:
             snprintf(msg, 1000, "Datatype element %s contains no data\n",
                      arg1);
             break;
         case XML_RELAXNG_ERR_DATAELEM:
             snprintf(msg, 1000, "Datatype element %s has child elements\n",
                      arg1);
             break;
         case XML_RELAXNG_ERR_VALELEM:
             snprintf(msg, 1000, "Value element %s has child elements\n",
                      arg1);
             break;
         case XML_RELAXNG_ERR_LISTELEM:
             snprintf(msg, 1000, "List element %s has child elements\n",
                      arg1);
             break;
         case XML_RELAXNG_ERR_DATATYPE:
             snprintf(msg, 1000, "Error validating datatype %s\n", arg1);
             break;
         case XML_RELAXNG_ERR_VALUE:
             snprintf(msg, 1000, "Error validating value %s\n", arg1);
             break;
         case XML_RELAXNG_ERR_LIST:
             return (xmlCharStrdup("Error validating list\n"));
         case XML_RELAXNG_ERR_NOGRAMMAR:
             return (xmlCharStrdup("No top grammar defined\n"));
         case XML_RELAXNG_ERR_EXTRADATA:
             return (xmlCharStrdup("Extra data in the document\n"));
         default:
             return (xmlCharStrdup("Unknown error !\n"));
     }
     if (msg[0] == 0) {
         snprintf(msg, 1000, "Unknown error code %d\n", err);
     }
     msg[1000 - 1] = 0;
     return (xmlStrdup((xmlChar *) msg));
 }

 /**
  * xmlRelaxNGShowValidError:
  * @ctxt:  the validation context
  * @err:  the error number
  * @node:  the node
  * @child:  the node child generating the problem.
  * @arg1:  the first argument
  * @arg2:  the second argument
  *
  * Show a validation error.
  */
 static void
 xmlRelaxNGShowValidError(xmlRelaxNGValidCtxtPtr ctxt,
                          xmlRelaxNGValidErr err, xmlNodePtr node,
                          xmlNodePtr child, const xmlChar * arg1,
                          const xmlChar * arg2)
 {
     xmlChar *msg;

     if (ctxt->flags & FLAGS_NOERROR)
         return;

 #ifdef DEBUG_ERROR
     xmlGenericError(xmlGenericErrorContext, "Show error %d\n", err);
 #endif
     msg = xmlRelaxNGGetErrorString(err, arg1, arg2);
     if (msg == NULL)
         return;

     if (ctxt->errNo == XML_RELAXNG_OK)
         ctxt->errNo = err;
     xmlRngVErr(ctxt, (child == NULL ? node : child), err,
                (const char *) msg, arg1, arg2);
     xmlFree(msg);
 }

 /**
  * xmlRelaxNGPopErrors:
  * @ctxt:  the validation context
  * @level:  the error level in the stack
  *
  * pop and discard all errors until the given level is reached
  */
 static void
 xmlRelaxNGPopErrors(xmlRelaxNGValidCtxtPtr ctxt, int level)
 {
     int i;
     xmlRelaxNGValidErrorPtr err;

 #ifdef DEBUG_ERROR
     xmlGenericError(xmlGenericErrorContext,
                     "Pop errors till level %d\n", level);
 #endif
     for (i = level; i < ctxt->errNr; i++) {
         err = &ctxt->errTab[i];
         if (err->flags & ERROR_IS_DUP) {
             if (err->arg1 != NULL)
                 xmlFree((xmlChar *) err->arg1);
             err->arg1 = NULL;
             if (err->arg2 != NULL)
                 xmlFree((xmlChar *) err->arg2);
             err->arg2 = NULL;
             err->flags = 0;
         }
     }
     ctxt->errNr = level;
     if (ctxt->errNr <= 0)
         ctxt->err = NULL;
 }

 /**
  * xmlRelaxNGDumpValidError:
  * @ctxt:  the validation context
  *
  * Show all validation error over a given index.
  */
 static void
 xmlRelaxNGDumpValidError(xmlRelaxNGValidCtxtPtr ctxt)
 {
     int i, j, k;
     xmlRelaxNGValidErrorPtr err, dup;

 #ifdef DEBUG_ERROR
     xmlGenericError(xmlGenericErrorContext,
                     "Dumping error stack %d errors\n", ctxt->errNr);
 #endif
     for (i = 0, k = 0; i < ctxt->errNr; i++) {
         err = &ctxt->errTab[i];
         if (k < MAX_ERROR) {
             for (j = 0; j < i; j++) {
                 dup = &ctxt->errTab[j];
                 if ((err->err == dup->err) && (err->node == dup->node) &&
                     (xmlStrEqual(err->arg1, dup->arg1)) &&
                     (xmlStrEqual(err->arg2, dup->arg2))) {
                     goto skip;
                 }
             }
             xmlRelaxNGShowValidError(ctxt, err->err, err->node, err->seq,
                                      err->arg1, err->arg2);
             k++;
         }
       skip:
         if (err->flags & ERROR_IS_DUP) {
             if (err->arg1 != NULL)
                 xmlFree((xmlChar *) err->arg1);
             err->arg1 = NULL;
             if (err->arg2 != NULL)
                 xmlFree((xmlChar *) err->arg2);
             err->arg2 = NULL;
             err->flags = 0;
         }
     }
     ctxt->errNr = 0;
 }

 /**
  * xmlRelaxNGAddValidError:
  * @ctxt:  the validation context
  * @err:  the error number
  * @arg1:  the first argument
  * @arg2:  the second argument
  * @dup:  need to dup the args
  *
  * Register a validation error, either generating it if it's sure
  * or stacking it for later handling if unsure.
  */
 static void
 xmlRelaxNGAddValidError(xmlRelaxNGValidCtxtPtr ctxt,
                         xmlRelaxNGValidErr err, const xmlChar * arg1,
                         const xmlChar * arg2, int dup)
 {
     if (ctxt == NULL)
         return;
     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)) {
         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;
         }
         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				*
  * 									*
  ************************************************************************/
 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
  * the W3C XMLSchema Datatype library.
  *
  * Returns 1 if yes, 0 if no and -1 in case of error.
  */
 static int
 xmlRelaxNGSchemaTypeHave(void *data ATTRIBUTE_UNUSED, const xmlChar * type)
 {
     xmlSchemaTypePtr typ;

     if (type == NULL)
         return (-1);
     typ = xmlSchemaGetPredefinedType(type,
                                      BAD_CAST
                                      "http://www.w3.org/2001/XMLSchema");
     if (typ == NULL)
         return (0);
     return (1);
 }

 /**
  * xmlRelaxNGSchemaTypeCheck:
  * @data:  data needed for the library
  * @type:  the type name
  * @value:  the value to check
  * @node:  the node
  *
  * Check if the given type and value are validated by
  * the W3C XMLSchema Datatype library.
  *
  * Returns 1 if yes, 0 if no and -1 in case of error.
  */
 static int
 xmlRelaxNGSchemaTypeCheck(void *data ATTRIBUTE_UNUSED,
                           const xmlChar * type,
                           const xmlChar * value,
                           void **result, xmlNodePtr node)
 {
     xmlSchemaTypePtr typ;
     int ret;

     if ((type == NULL) || (value == NULL))
         return (-1);
     typ = xmlSchemaGetPredefinedType(type,
                                      BAD_CAST
                                      "http://www.w3.org/2001/XMLSchema");
     if (typ == NULL)
         return (-1);
     ret = xmlSchemaValPredefTypeNode(typ, value,
                                      (xmlSchemaValPtr *) result, node);
     if (ret == 2)               /* special ID error code */
         return (2);
     if (ret == 0)
         return (1);
     if (ret > 0)
         return (0);
     return (-1);
 }

 /**
  * xmlRelaxNGSchemaFacetCheck:
  * @data:  data needed for the library
  * @type:  the type name
  * @facet:  the facet name
  * @val:  the facet value
  * @strval:  the string value
  * @value:  the value to check
  *
  * Function provided by a type library to check a value facet
  *
  * Returns 1 if yes, 0 if no and -1 in case of error.
  */
 static int
 xmlRelaxNGSchemaFacetCheck(void *data ATTRIBUTE_UNUSED,
                            const xmlChar * type, const xmlChar * facetname,
                            const xmlChar * val, const xmlChar * strval,
                            void *value)
 {
     xmlSchemaFacetPtr facet;
     xmlSchemaTypePtr typ;
     int ret;

     if ((type == NULL) || (strval == NULL))
         return (-1);
     typ = xmlSchemaGetPredefinedType(type,
                                      BAD_CAST
                                      "http://www.w3.org/2001/XMLSchema");
     if (typ == NULL)
         return (-1);

     facet = xmlSchemaNewFacet();
     if (facet == NULL)
         return (-1);

     if (xmlStrEqual(facetname, BAD_CAST "minInclusive")) {
         facet->type = XML_SCHEMA_FACET_MININCLUSIVE;
     } else if (xmlStrEqual(facetname, BAD_CAST "minExclusive")) {
         facet->type = XML_SCHEMA_FACET_MINEXCLUSIVE;
     } else if (xmlStrEqual(facetname, BAD_CAST "maxInclusive")) {
         facet->type = XML_SCHEMA_FACET_MAXINCLUSIVE;
     } else if (xmlStrEqual(facetname, BAD_CAST "maxExclusive")) {
         facet->type = XML_SCHEMA_FACET_MAXEXCLUSIVE;
     } else if (xmlStrEqual(facetname, BAD_CAST "totalDigits")) {
         facet->type = XML_SCHEMA_FACET_TOTALDIGITS;
     } else if (xmlStrEqual(facetname, BAD_CAST "fractionDigits")) {
         facet->type = XML_SCHEMA_FACET_FRACTIONDIGITS;
     } else if (xmlStrEqual(facetname, BAD_CAST "pattern")) {
         facet->type = XML_SCHEMA_FACET_PATTERN;
     } else if (xmlStrEqual(facetname, BAD_CAST "enumeration")) {
         facet->type = XML_SCHEMA_FACET_ENUMERATION;
     } else if (xmlStrEqual(facetname, BAD_CAST "whiteSpace")) {
         facet->type = XML_SCHEMA_FACET_WHITESPACE;
     } else if (xmlStrEqual(facetname, BAD_CAST "length")) {
         facet->type = XML_SCHEMA_FACET_LENGTH;
     } else if (xmlStrEqual(facetname, BAD_CAST "maxLength")) {
         facet->type = XML_SCHEMA_FACET_MAXLENGTH;
     } else if (xmlStrEqual(facetname, BAD_CAST "minLength")) {
         facet->type = XML_SCHEMA_FACET_MINLENGTH;
     } else {
         xmlSchemaFreeFacet(facet);
         return (-1);
     }
     facet->value = val;
     ret = xmlSchemaCheckFacet(facet, typ, NULL, type);
     if (ret != 0) {
         xmlSchemaFreeFacet(facet);
         return (-1);
     }
     ret = xmlSchemaValidateFacet(typ, facet, strval, value);
     xmlSchemaFreeFacet(facet);
     if (ret != 0)
         return (-1);
     return (0);
 }

 /**
  * xmlRelaxNGSchemaFreeValue:
  * @data:  data needed for the library
  * @value:  the value to free
  *
  * Function provided by a type library to free a Schemas value
  *
  * Returns 1 if yes, 0 if no and -1 in case of error.
  */
 static void
 xmlRelaxNGSchemaFreeValue(void *data ATTRIBUTE_UNUSED, void *value)
 {
     xmlSchemaFreeValue(value);
 }

 /**
  * xmlRelaxNGSchemaTypeCompare:
  * @data:  data needed for the library
  * @type:  the type name
  * @value1:  the first value
  * @value2:  the second value
  *
  * Compare two values for equality accordingly a type from the W3C XMLSchema
  * Datatype library.
  *
  * Returns 1 if equal, 0 if no and -1 in case of error.
  */
 static int
 xmlRelaxNGSchemaTypeCompare(void *data ATTRIBUTE_UNUSED,
                             const xmlChar * type,
                             const xmlChar * value1,
                             xmlNodePtr ctxt1,
                             void *comp1,
                             const xmlChar * value2, xmlNodePtr ctxt2)
 {
     int ret;
     xmlSchemaTypePtr typ;
     xmlSchemaValPtr res1 = NULL, res2 = NULL;

     if ((type == NULL) || (value1 == NULL) || (value2 == NULL))
         return (-1);
     typ = xmlSchemaGetPredefinedType(type,
                                      BAD_CAST
                                      "http://www.w3.org/2001/XMLSchema");
     if (typ == NULL)
         return (-1);
     if (comp1 == NULL) {
         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))
 	    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);
 }

 /**
  * xmlRelaxNGDefaultTypeHave:
  * @data:  data needed for the library
  * @type:  the type name
  *
  * Check if the given type is provided by
  * the default datatype library.
  *
  * Returns 1 if yes, 0 if no and -1 in case of error.
  */
 static int
 xmlRelaxNGDefaultTypeHave(void *data ATTRIBUTE_UNUSED,
                           const xmlChar * type)
 {
     if (type == NULL)
         return (-1);
     if (xmlStrEqual(type, BAD_CAST "string"))
         return (1);
     if (xmlStrEqual(type, BAD_CAST "token"))
         return (1);
     return (0);
 }

 /**
  * xmlRelaxNGDefaultTypeCheck:
  * @data:  data needed for the library
  * @type:  the type name
  * @value:  the value to check
  * @node:  the node
  *
  * Check if the given type and value are validated by
  * the default datatype library.
  *
  * Returns 1 if yes, 0 if no and -1 in case of error.
  */
 static int
 xmlRelaxNGDefaultTypeCheck(void *data ATTRIBUTE_UNUSED,
                            const xmlChar * type ATTRIBUTE_UNUSED,
                            const xmlChar * value ATTRIBUTE_UNUSED,
                            void **result ATTRIBUTE_UNUSED,
                            xmlNodePtr node ATTRIBUTE_UNUSED)
 {
     if (value == NULL)
         return (-1);
     if (xmlStrEqual(type, BAD_CAST "string"))
         return (1);
     if (xmlStrEqual(type, BAD_CAST "token")) {
         return (1);
     }

     return (0);
 }

 /**
  * xmlRelaxNGDefaultTypeCompare:
  * @data:  data needed for the library
  * @type:  the type name
  * @value1:  the first value
  * @value2:  the second value
  *
  * Compare two values accordingly a type from the default
  * datatype library.
  *
  * Returns 1 if yes, 0 if no and -1 in case of error.
  */
 static int
 xmlRelaxNGDefaultTypeCompare(void *data ATTRIBUTE_UNUSED,
                              const xmlChar * type,
                              const xmlChar * value1,
                              xmlNodePtr ctxt1 ATTRIBUTE_UNUSED,
                              void *comp1 ATTRIBUTE_UNUSED,
                              const xmlChar * value2,
                              xmlNodePtr ctxt2 ATTRIBUTE_UNUSED)
 {
     int ret = -1;

     if (xmlStrEqual(type, BAD_CAST "string")) {
         ret = xmlStrEqual(value1, value2);
     } else if (xmlStrEqual(type, BAD_CAST "token")) {
         if (!xmlStrEqual(value1, value2)) {
             xmlChar *nval, *nvalue;

             /*
              * TODO: trivial optimizations are possible by
              * computing at compile-time
              */
             nval = xmlRelaxNGNormalize(NULL, value1);
             nvalue = xmlRelaxNGNormalize(NULL, value2);

             if ((nval == NULL) || (nvalue == NULL))
                 ret = -1;
             else if (xmlStrEqual(nval, nvalue))
                 ret = 1;
             else
                 ret = 0;
             if (nval != NULL)
                 xmlFree(nval);
             if (nvalue != NULL)
                 xmlFree(nvalue);
         } else
             ret = 1;
     }
     return (ret);
 }

 static int xmlRelaxNGTypeInitialized = 0;
 static xmlHashTablePtr xmlRelaxNGRegisteredTypes = NULL;

 /**
  * xmlRelaxNGFreeTypeLibrary:
  * @lib:  the type library structure
  * @namespace:  the URI bound to the library
  *
  * Free the structure associated to the type library
  */
 static void
 xmlRelaxNGFreeTypeLibrary(xmlRelaxNGTypeLibraryPtr lib,
                           const xmlChar * namespace ATTRIBUTE_UNUSED)
 {
     if (lib == NULL)
         return;
     if (lib->namespace != NULL)
         xmlFree((xmlChar *) lib->namespace);
     xmlFree(lib);
 }

 /**
  * xmlRelaxNGRegisterTypeLibrary:
  * @namespace:  the URI bound to the library
  * @data:  data associated to the library
  * @have:  the provide function
  * @check:  the checking function
  * @comp:  the comparison function
  *
  * Register a new type library
  *
  * Returns 0 in case of success and -1 in case of error.
  */
 static int
 xmlRelaxNGRegisterTypeLibrary(const xmlChar * namespace, void *data,
                               xmlRelaxNGTypeHave have,
                               xmlRelaxNGTypeCheck check,
                               xmlRelaxNGTypeCompare comp,
                               xmlRelaxNGFacetCheck facet,
                               xmlRelaxNGTypeFree freef)
 {
     xmlRelaxNGTypeLibraryPtr lib;
     int ret;

     if ((xmlRelaxNGRegisteredTypes == NULL) || (namespace == NULL) ||
         (check == NULL) || (comp == NULL))
         return (-1);
     if (xmlHashLookup(xmlRelaxNGRegisteredTypes, namespace) != NULL) {
         xmlGenericError(xmlGenericErrorContext,
                         "Relax-NG types library '%s' already registered\n",
                         namespace);
         return (-1);
     }
     lib =
         (xmlRelaxNGTypeLibraryPtr)
         xmlMalloc(sizeof(xmlRelaxNGTypeLibrary));
     if (lib == NULL) {
         xmlRngVErrMemory(NULL, "adding types library\n");
         return (-1);
     }
     memset(lib, 0, sizeof(xmlRelaxNGTypeLibrary));
     lib->namespace = xmlStrdup(namespace);
     lib->data = data;
     lib->have = have;
     lib->comp = comp;
     lib->check = check;
     lib->facet = facet;
     lib->freef = freef;
     ret = xmlHashAddEntry(xmlRelaxNGRegisteredTypes, namespace, lib);
     if (ret < 0) {
         xmlGenericError(xmlGenericErrorContext,
                         "Relax-NG types library failed to register '%s'\n",
                         namespace);
         xmlRelaxNGFreeTypeLibrary(lib, namespace);
         return (-1);
     }
     return (0);
 }

 /**
  * xmlRelaxNGInitTypes:
  *
  * Initilize the default type libraries.
  *
  * Returns 0 in case of success and -1 in case of error.
  */
 int
 xmlRelaxNGInitTypes(void)
 {
     if (xmlRelaxNGTypeInitialized != 0)
         return (0);
     xmlRelaxNGRegisteredTypes = xmlHashCreate(10);
     if (xmlRelaxNGRegisteredTypes == NULL) {
         xmlGenericError(xmlGenericErrorContext,
                         "Failed to allocate sh table for Relax-NG types\n");
         return (-1);
     }
     xmlRelaxNGRegisterTypeLibrary(BAD_CAST
                                   "http://www.w3.org/2001/XMLSchema-datatypes",
                                   NULL, xmlRelaxNGSchemaTypeHave,
                                   xmlRelaxNGSchemaTypeCheck,
                                   xmlRelaxNGSchemaTypeCompare,
                                   xmlRelaxNGSchemaFacetCheck,
                                   xmlRelaxNGSchemaFreeValue);
     xmlRelaxNGRegisterTypeLibrary(xmlRelaxNGNs, NULL,
                                   xmlRelaxNGDefaultTypeHave,
                                   xmlRelaxNGDefaultTypeCheck,
                                   xmlRelaxNGDefaultTypeCompare, NULL,
                                   NULL);
     xmlRelaxNGTypeInitialized = 1;
     return (0);
 }

 /**
  * xmlRelaxNGCleanupTypes:
  *
  * Cleanup the default Schemas type library associated to RelaxNG
  */
 void
 xmlRelaxNGCleanupTypes(void)
 {
     xmlSchemaCleanupTypes();
     if (xmlRelaxNGTypeInitialized == 0)
         return;
     xmlHashFree(xmlRelaxNGRegisteredTypes, (xmlHashDeallocator)
                 xmlRelaxNGFreeTypeLibrary);
     xmlRelaxNGTypeInitialized = 0;
 }

 /************************************************************************
  * 									*
  * 		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	*
  * 									*
  ************************************************************************/

 static int xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt,
                                 xmlRelaxNGDefinePtr def);

 /**
  * xmlRelaxNGIsCompileable:
  * @define:  the definition to check
  *
  * Check if a definition is nullable.
  *
  * Returns 1 if yes, 0 if no and -1 in case of error
  */
 static int
 xmlRelaxNGIsCompileable(xmlRelaxNGDefinePtr def)
 {
     int ret = -1;

     if (def == NULL) {
         return (-1);
     }
     if ((def->type != XML_RELAXNG_ELEMENT) &&
         (def->dflags & IS_COMPILABLE))
         return (1);
     if ((def->type != XML_RELAXNG_ELEMENT) &&
         (def->dflags & IS_NOT_COMPILABLE))
         return (0);
     switch (def->type) {
         case XML_RELAXNG_NOOP:
             ret = xmlRelaxNGIsCompileable(def->content);
             break;
         case XML_RELAXNG_TEXT:
         case XML_RELAXNG_EMPTY:
             ret = 1;
             break;
         case XML_RELAXNG_ELEMENT:
             /*
              * Check if the element content is compileable
              */
             if (((def->dflags & IS_NOT_COMPILABLE) == 0) &&
                 ((def->dflags & IS_COMPILABLE) == 0)) {
                 xmlRelaxNGDefinePtr list;

                 list = def->content;
                 while (list != NULL) {
                     ret = xmlRelaxNGIsCompileable(list);
                     if (ret != 1)
                         break;
                     list = list->next;
                 }
 		/*
 		 * Because the routine is recursive, we must guard against
 		 * discovering both COMPILABLE and NOT_COMPILABLE
 		 */
                 if (ret == 0) {
 		    def->dflags &= ~IS_COMPILABLE;
                     def->dflags |= IS_NOT_COMPILABLE;
 		}
                 if ((ret == 1) && !(def->dflags &= IS_NOT_COMPILABLE))
                     def->dflags |= IS_COMPILABLE;
 #ifdef DEBUG_COMPILE
                 if (ret == 1) {
                     xmlGenericError(xmlGenericErrorContext,
                                     "element content for %s is compilable\n",
                                     def->name);
                 } else if (ret == 0) {
                     xmlGenericError(xmlGenericErrorContext,
                                     "element content for %s is not compilable\n",
                                     def->name);
                 } else {
                     xmlGenericError(xmlGenericErrorContext,
                                     "Problem in RelaxNGIsCompileable for element %s\n",
                                     def->name);
                 }
 #endif
             }
             /*
              * All elements return a compileable status unless they
              * are generic like anyName
              */
             if ((def->nameClass != NULL) || (def->name == NULL))
                 ret = 0;
             else
                 ret = 1;
             return (ret);
         case XML_RELAXNG_REF:
         case XML_RELAXNG_EXTERNALREF:
         case XML_RELAXNG_PARENTREF:
             if (def->depth == -20) {
                 return (1);
             } else {
                 xmlRelaxNGDefinePtr list;

                 def->depth = -20;
                 list = def->content;
                 while (list != NULL) {
                     ret = xmlRelaxNGIsCompileable(list);
                     if (ret != 1)
                         break;
                     list = list->next;
                 }
             }
             break;
         case XML_RELAXNG_START:
         case XML_RELAXNG_OPTIONAL:
         case XML_RELAXNG_ZEROORMORE:
         case XML_RELAXNG_ONEORMORE:
         case XML_RELAXNG_CHOICE:
         case XML_RELAXNG_GROUP:
         case XML_RELAXNG_DEF:{
                 xmlRelaxNGDefinePtr list;

                 list = def->content;
                 while (list != NULL) {
                     ret = xmlRelaxNGIsCompileable(list);
                     if (ret != 1)
                         break;
                     list = list->next;
                 }
                 break;
             }
         case XML_RELAXNG_EXCEPT:
         case XML_RELAXNG_ATTRIBUTE:
         case XML_RELAXNG_INTERLEAVE:
         case XML_RELAXNG_DATATYPE:
         case XML_RELAXNG_LIST:
         case XML_RELAXNG_PARAM:
         case XML_RELAXNG_VALUE:
         case XML_RELAXNG_NOT_ALLOWED:
             ret = 0;
             break;
     }
     if (ret == 0)
         def->dflags |= IS_NOT_COMPILABLE;
     if (ret == 1)
         def->dflags |= IS_COMPILABLE;
 #ifdef DEBUG_COMPILE
     if (ret == 1) {
         xmlGenericError(xmlGenericErrorContext,
                         "RelaxNGIsCompileable %s : true\n",
                         xmlRelaxNGDefName(def));
     } else if (ret == 0) {
         xmlGenericError(xmlGenericErrorContext,
                         "RelaxNGIsCompileable %s : false\n",
                         xmlRelaxNGDefName(def));
     } else {
         xmlGenericError(xmlGenericErrorContext,
                         "Problem in RelaxNGIsCompileable %s\n",
                         xmlRelaxNGDefName(def));
     }
 #endif
     return (ret);
 }

 /**
  * xmlRelaxNGCompile:
  * ctxt:  the RelaxNG parser context
  * @define:  the definition tree to compile
  *
  * Compile the set of definitions, it works recursively, till the
  * element boundaries, where it tries to compile the content if possible
  *
  * Returns 0 if success and -1 in case of error
  */
 static int
 xmlRelaxNGCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def)
 {
     int ret = 0;
     xmlRelaxNGDefinePtr list;

     if ((ctxt == NULL) || (def == NULL))
         return (-1);

     switch (def->type) {
         case XML_RELAXNG_START:
             if ((xmlRelaxNGIsCompileable(def) == 1) && (def->depth != -25)) {
                 xmlAutomataPtr oldam = ctxt->am;
                 xmlAutomataStatePtr oldstate = ctxt->state;

                 def->depth = -25;

                 list = def->content;
                 ctxt->am = xmlNewAutomata();
                 if (ctxt->am == NULL)
                     return (-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);

                 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,
                                                         def->name, def->ns,
                                                         def);
             }
             if ((def->dflags & IS_COMPILABLE) && (def->depth != -25)) {
                 xmlAutomataPtr oldam = ctxt->am;
                 xmlAutomataStatePtr oldstate = ctxt->state;

                 def->depth = -25;

                 list = def->content;
                 ctxt->am = xmlNewAutomata();
                 if (ctxt->am == NULL)
                     return (-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);
                 if (!xmlRegexpIsDeterminist(def->contModel)) {
                     /*
                      * we can only use the automata if it is determinist
                      */
                     xmlRegFreeRegexp(def->contModel);
                     def->contModel = NULL;
                 }
                 xmlFreeAutomata(ctxt->am);
                 ctxt->state = oldstate;
                 ctxt->am = oldam;
             } else {
                 xmlAutomataPtr oldam = ctxt->am;

                 /*
                  * we can't build the content model for this element content
                  * but it still might be possible to build it for some of its
                  * children, recurse.
                  */
                 ret = xmlRelaxNGTryCompile(ctxt, def);
                 ctxt->am = oldam;
             }
             break;
         case XML_RELAXNG_NOOP:
             ret = xmlRelaxNGCompile(ctxt, def->content);
             break;
         case XML_RELAXNG_OPTIONAL:{
                 xmlAutomataStatePtr oldstate = ctxt->state;

                 xmlRelaxNGCompile(ctxt, def->content);
                 xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
                 break;
             }
         case XML_RELAXNG_ZEROORMORE:{
                 xmlAutomataStatePtr oldstate;

                 ctxt->state =
                     xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
                 oldstate = ctxt->state;
                 list = def->content;
                 while (list != NULL) {
                     xmlRelaxNGCompile(ctxt, list);
                     list = list->next;
                 }
                 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldstate);
                 ctxt->state =
                     xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
                 break;
             }
         case XML_RELAXNG_ONEORMORE:{
                 xmlAutomataStatePtr oldstate;

                 list = def->content;
                 while (list != NULL) {
                     xmlRelaxNGCompile(ctxt, list);
                     list = list->next;
                 }
                 oldstate = ctxt->state;
                 list = def->content;
                 while (list != NULL) {
                     xmlRelaxNGCompile(ctxt, list);
                     list = list->next;
                 }
                 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldstate);
                 ctxt->state =
                     xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
                 break;
             }
         case XML_RELAXNG_CHOICE:{
                 xmlAutomataStatePtr target = NULL;
                 xmlAutomataStatePtr oldstate = ctxt->state;

                 list = def->content;
                 while (list != NULL) {
                     ctxt->state = oldstate;
                     ret = xmlRelaxNGCompile(ctxt, list);
                     if (ret != 0)
                         break;
                     if (target == NULL)
                         target = ctxt->state;
                     else {
                         xmlAutomataNewEpsilon(ctxt->am, ctxt->state,
                                               target);
                     }
                     list = list->next;
                 }
                 ctxt->state = target;

                 break;
             }
         case XML_RELAXNG_REF:
         case XML_RELAXNG_EXTERNALREF:
         case XML_RELAXNG_PARENTREF:
         case XML_RELAXNG_GROUP:
         case XML_RELAXNG_DEF:
             list = def->content;
             while (list != NULL) {
                 ret = xmlRelaxNGCompile(ctxt, list);
                 if (ret != 0)
                     break;
                 list = list->next;
             }
             break;
         case XML_RELAXNG_TEXT:{
                 xmlAutomataStatePtr oldstate;

                 ctxt->state =
                     xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
                 oldstate = ctxt->state;
                 xmlRelaxNGCompile(ctxt, def->content);
                 xmlAutomataNewTransition(ctxt->am, ctxt->state,
                                          ctxt->state, BAD_CAST "#text",
                                          NULL);
                 ctxt->state =
                     xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
                 break;
             }
         case XML_RELAXNG_EMPTY:
             ctxt->state =
                 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
             break;
         case XML_RELAXNG_EXCEPT:
         case XML_RELAXNG_ATTRIBUTE:
         case XML_RELAXNG_INTERLEAVE:
         case XML_RELAXNG_NOT_ALLOWED:
         case XML_RELAXNG_DATATYPE:
         case XML_RELAXNG_LIST:
         case XML_RELAXNG_PARAM:
         case XML_RELAXNG_VALUE:
             /* This should not happen and generate an internal error */
             fprintf(stderr, "RNG internal error trying to compile %s\n",
                     xmlRelaxNGDefName(def));
             break;
     }
     return (ret);
 }

 /**
  * xmlRelaxNGTryCompile:
  * ctxt:  the RelaxNG parser context
  * @define:  the definition tree to compile
  *
  * Try to compile the set of definitions, it works recursively,
  * possibly ignoring parts which cannot be compiled.
  *
  * Returns 0 if success and -1 in case of error
  */
 static int
 xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def)
 {
     int ret = 0;
     xmlRelaxNGDefinePtr list;

     if ((ctxt == NULL) || (def == NULL))
         return (-1);

     if ((def->type == XML_RELAXNG_START) ||
         (def->type == XML_RELAXNG_ELEMENT)) {
         ret = xmlRelaxNGIsCompileable(def);
         if ((def->dflags & IS_COMPILABLE) && (def->depth != -25)) {
             ctxt->am = NULL;
             ret = xmlRelaxNGCompile(ctxt, def);
 #ifdef DEBUG_PROGRESSIVE
             if (ret == 0) {
                 if (def->type == XML_RELAXNG_START)
                     xmlGenericError(xmlGenericErrorContext,
                                     "compiled the start\n");
                 else
                     xmlGenericError(xmlGenericErrorContext,
                                     "compiled element %s\n", def->name);
             } else {
                 if (def->type == XML_RELAXNG_START)
                     xmlGenericError(xmlGenericErrorContext,
                                     "failed to compile the start\n");
                 else
                     xmlGenericError(xmlGenericErrorContext,
                                     "failed to compile element %s\n",
                                     def->name);
             }
 #endif
             return (ret);
         }
     }
     switch (def->type) {
         case XML_RELAXNG_NOOP:
             ret = xmlRelaxNGTryCompile(ctxt, def->content);
             break;
         case XML_RELAXNG_TEXT:
         case XML_RELAXNG_DATATYPE:
         case XML_RELAXNG_LIST:
         case XML_RELAXNG_PARAM:
         case XML_RELAXNG_VALUE:
         case XML_RELAXNG_EMPTY:
         case XML_RELAXNG_ELEMENT:
             ret = 0;
             break;
         case XML_RELAXNG_OPTIONAL:
         case XML_RELAXNG_ZEROORMORE:
         case XML_RELAXNG_ONEORMORE:
         case XML_RELAXNG_CHOICE:
         case XML_RELAXNG_GROUP:
         case XML_RELAXNG_DEF:
         case XML_RELAXNG_START:
         case XML_RELAXNG_REF:
         case XML_RELAXNG_EXTERNALREF:
         case XML_RELAXNG_PARENTREF:
             list = def->content;
             while (list != NULL) {
                 ret = xmlRelaxNGTryCompile(ctxt, list);
                 if (ret != 0)
                     break;
                 list = list->next;
             }
             break;
         case XML_RELAXNG_EXCEPT:
         case XML_RELAXNG_ATTRIBUTE:
         case XML_RELAXNG_INTERLEAVE:
         case XML_RELAXNG_NOT_ALLOWED:
             ret = 0;
             break;
     }
     return (ret);
 }

 /************************************************************************
  * 									*
  * 			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
                                                   ctxt, xmlNodePtr node);
 static xmlRelaxNGPtr xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt,
                                              xmlNodePtr node);
 static int xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt,
                                          xmlNodePtr nodes);
 static xmlRelaxNGDefinePtr xmlRelaxNGParseNameClass(xmlRelaxNGParserCtxtPtr
                                                     ctxt, xmlNodePtr node,
                                                     xmlRelaxNGDefinePtr
                                                     def);
 static xmlRelaxNGGrammarPtr xmlRelaxNGParseGrammar(xmlRelaxNGParserCtxtPtr
                                                    ctxt, xmlNodePtr nodes);
 static int xmlRelaxNGElementMatch(xmlRelaxNGValidCtxtPtr ctxt,
                                   xmlRelaxNGDefinePtr define,
                                   xmlNodePtr elem);


 #define IS_BLANK_NODE(n) (xmlRelaxNGIsBlank((n)->content))

 /**
  * xmlRelaxNGIsNullable:
  * @define:  the definition to verify
  *
  * Check if a definition is nullable.
  *
  * Returns 1 if yes, 0 if no and -1 in case of error
  */
 static int
 xmlRelaxNGIsNullable(xmlRelaxNGDefinePtr define)
 {
     int ret;

     if (define == NULL)
         return (-1);

     if (define->dflags & IS_NULLABLE)
         return (1);
     if (define->dflags & IS_NOT_NULLABLE)
         return (0);
     switch (define->type) {
         case XML_RELAXNG_EMPTY:
         case XML_RELAXNG_TEXT:
             ret = 1;
             break;
         case XML_RELAXNG_NOOP:
         case XML_RELAXNG_DEF:
         case XML_RELAXNG_REF:
         case XML_RELAXNG_EXTERNALREF:
         case XML_RELAXNG_PARENTREF:
         case XML_RELAXNG_ONEORMORE:
             ret = xmlRelaxNGIsNullable(define->content);
             break;
         case XML_RELAXNG_EXCEPT:
         case XML_RELAXNG_NOT_ALLOWED:
         case XML_RELAXNG_ELEMENT:
         case XML_RELAXNG_DATATYPE:
         case XML_RELAXNG_PARAM:
         case XML_RELAXNG_VALUE:
         case XML_RELAXNG_LIST:
         case XML_RELAXNG_ATTRIBUTE:
             ret = 0;
             break;
         case XML_RELAXNG_CHOICE:{
                 xmlRelaxNGDefinePtr list = define->content;

                 while (list != NULL) {
                     ret = xmlRelaxNGIsNullable(list);
                     if (ret != 0)
                         goto done;
                     list = list->next;
                 }
                 ret = 0;
                 break;
             }
         case XML_RELAXNG_START:
         case XML_RELAXNG_INTERLEAVE:
         case XML_RELAXNG_GROUP:{
                 xmlRelaxNGDefinePtr list = define->content;

                 while (list != NULL) {
                     ret = xmlRelaxNGIsNullable(list);
                     if (ret != 1)
                         goto done;
                     list = list->next;
                 }
                 return (1);
             }
         default:
             return (-1);
     }
   done:
     if (ret == 0)
         define->dflags |= IS_NOT_NULLABLE;
     if (ret == 1)
         define->dflags |= IS_NULLABLE;
     return (ret);
 }

 /**
  * xmlRelaxNGIsBlank:
  * @str:  a string
  *
  * Check if a string is ignorable c.f. 4.2. Whitespace
  *
  * Returns 1 if the string is NULL or made of blanks chars, 0 otherwise
  */
 static int
 xmlRelaxNGIsBlank(xmlChar * str)
 {
     if (str == NULL)
         return (1);
     while (*str != 0) {
         if (!(IS_BLANK_CH(*str)))
             return (0);
         str++;
     }
     return (1);
 }

 /**
  * xmlRelaxNGGetDataTypeLibrary:
  * @ctxt:  a Relax-NG parser context
  * @node:  the current data or value element
  *
  * Applies algorithm from 4.3. datatypeLibrary attribute
  *
  * Returns the datatypeLibary value or NULL if not found
  */
 static xmlChar *
 xmlRelaxNGGetDataTypeLibrary(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
                              xmlNodePtr node)
 {
     xmlChar *ret, *escape;

     if ((IS_RELAXNG(node, "data")) || (IS_RELAXNG(node, "value"))) {
         ret = xmlGetProp(node, BAD_CAST "datatypeLibrary");
         if (ret != NULL) {
             if (ret[0] == 0) {
                 xmlFree(ret);
                 return (NULL);
             }
             escape = xmlURIEscapeStr(ret, BAD_CAST ":/#?");
             if (escape == NULL) {
                 return (ret);
             }
             xmlFree(ret);
             return (escape);
         }
     }
     node = node->parent;
     while ((node != NULL) && (node->type == XML_ELEMENT_NODE)) {
         ret = xmlGetProp(node, BAD_CAST "datatypeLibrary");
         if (ret != NULL) {
             if (ret[0] == 0) {
                 xmlFree(ret);
                 return (NULL);
             }
             escape = xmlURIEscapeStr(ret, BAD_CAST ":/#?");
             if (escape == NULL) {
                 return (ret);
             }
             xmlFree(ret);
             return (escape);
         }
         node = node->parent;
     }
     return (NULL);
 }

 /**
  * xmlRelaxNGParseValue:
  * @ctxt:  a Relax-NG parser context
  * @node:  the data node.
  *
  * parse the content of a RelaxNG value node.
  *
  * Returns the definition pointer or NULL in case of error
  */
 static xmlRelaxNGDefinePtr
 xmlRelaxNGParseValue(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
 {
     xmlRelaxNGDefinePtr def = NULL;
     xmlRelaxNGTypeLibraryPtr lib = NULL;
     xmlChar *type;
     xmlChar *library;
     int success = 0;

     def = xmlRelaxNGNewDefine(ctxt, node);
     if (def == NULL)
         return (NULL);
     def->type = XML_RELAXNG_VALUE;

     type = xmlGetProp(node, BAD_CAST "type");
     if (type != NULL) {
         xmlRelaxNGNormExtSpace(type);
         if (xmlValidateNCName(type, 0)) {
             xmlRngPErr(ctxt, node, XML_RNGP_TYPE_VALUE,
                        "value type '%s' is not an NCName\n", type, NULL);
         }
         library = xmlRelaxNGGetDataTypeLibrary(ctxt, node);
         if (library == NULL)
             library =
                 xmlStrdup(BAD_CAST "http://relaxng.org/ns/structure/1.0");

         def->name = type;
         def->ns = library;

         lib = (xmlRelaxNGTypeLibraryPtr)
             xmlHashLookup(xmlRelaxNGRegisteredTypes, library);
         if (lib == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_TYPE_LIB,
                        "Use of unregistered type library '%s'\n", library,
                        NULL);
             def->data = NULL;
         } else {
             def->data = lib;
             if (lib->have == NULL) {
                 xmlRngPErr(ctxt, node, XML_RNGP_ERROR_TYPE_LIB,
                            "Internal error with type library '%s': no 'have'\n",
                            library, NULL);
             } else {
                 success = lib->have(lib->data, def->name);
                 if (success != 1) {
                     xmlRngPErr(ctxt, node, XML_RNGP_TYPE_NOT_FOUND,
                                "Error type '%s' is not exported by type library '%s'\n",
                                def->name, library);
                 }
             }
         }
     }
     if (node->children == NULL) {
         def->value = xmlStrdup(BAD_CAST "");
     } else if (((node->children->type != XML_TEXT_NODE) &&
                 (node->children->type != XML_CDATA_SECTION_NODE)) ||
                (node->children->next != NULL)) {
         xmlRngPErr(ctxt, node, XML_RNGP_TEXT_EXPECTED,
                    "Expecting a single text value for <value>content\n",
                    NULL, NULL);
     } else if (def != NULL) {
         def->value = xmlNodeGetContent(node);
         if (def->value == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_VALUE_NO_CONTENT,
                        "Element <value> has no content\n", NULL, NULL);
         } else if ((lib != NULL) && (lib->check != NULL) && (success == 1)) {
             void *val = NULL;

             success =
                 lib->check(lib->data, def->name, def->value, &val, node);
             if (success != 1) {
                 xmlRngPErr(ctxt, node, XML_RNGP_INVALID_VALUE,
                            "Value '%s' is not acceptable for type '%s'\n",
                            def->value, def->name);
             } else {
                 if (val != NULL)
                     def->attrs = val;
             }
         }
     }
     return (def);
 }

 /**
  * xmlRelaxNGParseData:
  * @ctxt:  a Relax-NG parser context
  * @node:  the data node.
  *
  * parse the content of a RelaxNG data node.
  *
  * Returns the definition pointer or NULL in case of error
  */
 static xmlRelaxNGDefinePtr
 xmlRelaxNGParseData(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
 {
     xmlRelaxNGDefinePtr def = NULL, except, last = NULL;
     xmlRelaxNGDefinePtr param, lastparam = NULL;
     xmlRelaxNGTypeLibraryPtr lib;
     xmlChar *type;
     xmlChar *library;
     xmlNodePtr content;
     int tmp;

     type = xmlGetProp(node, BAD_CAST "type");
     if (type == NULL) {
         xmlRngPErr(ctxt, node, XML_RNGP_TYPE_MISSING, "data has no type\n", NULL,
                    NULL);
         return (NULL);
     }
     xmlRelaxNGNormExtSpace(type);
     if (xmlValidateNCName(type, 0)) {
         xmlRngPErr(ctxt, node, XML_RNGP_TYPE_VALUE,
                    "data type '%s' is not an NCName\n", type, NULL);
     }
     library = xmlRelaxNGGetDataTypeLibrary(ctxt, node);
     if (library == NULL)
         library =
             xmlStrdup(BAD_CAST "http://relaxng.org/ns/structure/1.0");

     def = xmlRelaxNGNewDefine(ctxt, node);
     if (def == NULL) {
         xmlFree(type);
         return (NULL);
     }
     def->type = XML_RELAXNG_DATATYPE;
     def->name = type;
     def->ns = library;

     lib = (xmlRelaxNGTypeLibraryPtr)
         xmlHashLookup(xmlRelaxNGRegisteredTypes, library);
     if (lib == NULL) {
         xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_TYPE_LIB,
                    "Use of unregistered type library '%s'\n", library,
                    NULL);
         def->data = NULL;
     } else {
         def->data = lib;
         if (lib->have == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_ERROR_TYPE_LIB,
                        "Internal error with type library '%s': no 'have'\n",
                        library, NULL);
         } else {
             tmp = lib->have(lib->data, def->name);
             if (tmp != 1) {
                 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_NOT_FOUND,
                            "Error type '%s' is not exported by type library '%s'\n",
                            def->name, library);
             } else
                 if ((xmlStrEqual
                      (library,
                       BAD_CAST
                       "http://www.w3.org/2001/XMLSchema-datatypes"))
                     && ((xmlStrEqual(def->name, BAD_CAST "IDREF"))
                         || (xmlStrEqual(def->name, BAD_CAST "IDREFS")))) {
                 ctxt->idref = 1;
             }
         }
     }
     content = node->children;

     /*
      * Handle optional params
      */
     while (content != NULL) {
         if (!xmlStrEqual(content->name, BAD_CAST "param"))
             break;
         if (xmlStrEqual(library,
                         BAD_CAST "http://relaxng.org/ns/structure/1.0")) {
             xmlRngPErr(ctxt, node, XML_RNGP_PARAM_FORBIDDEN,
                        "Type library '%s' does not allow type parameters\n",
                        library, NULL);
             content = content->next;
             while ((content != NULL) &&
                    (xmlStrEqual(content->name, BAD_CAST "param")))
                 content = content->next;
         } else {
             param = xmlRelaxNGNewDefine(ctxt, node);
             if (param != NULL) {
                 param->type = XML_RELAXNG_PARAM;
                 param->name = xmlGetProp(content, BAD_CAST "name");
                 if (param->name == NULL) {
                     xmlRngPErr(ctxt, node, XML_RNGP_PARAM_NAME_MISSING,
                                "param has no name\n", NULL, NULL);
                 }
                 param->value = xmlNodeGetContent(content);
                 if (lastparam == NULL) {
                     def->attrs = lastparam = param;
                 } else {
                     lastparam->next = param;
                     lastparam = param;
                 }
                 if (lib != NULL) {
                 }
             }
             content = content->next;
         }
     }
     /*
      * Handle optional except
      */
     if ((content != NULL)
         && (xmlStrEqual(content->name, BAD_CAST "except"))) {
         xmlNodePtr child;
         xmlRelaxNGDefinePtr tmp2, last2 = NULL;

         except = xmlRelaxNGNewDefine(ctxt, node);
         if (except == NULL) {
             return (def);
         }
         except->type = XML_RELAXNG_EXCEPT;
         child = content->children;
         if (last == NULL) {
             def->content = except;
         } else {
             last->next = except;
         }
         if (child == NULL) {
             xmlRngPErr(ctxt, content, XML_RNGP_EXCEPT_NO_CONTENT,
                        "except has no content\n", NULL, NULL);
         }
         while (child != NULL) {
             tmp2 = xmlRelaxNGParsePattern(ctxt, child);
             if (tmp2 != NULL) {
                 if (last2 == NULL) {
                     except->content = last2 = tmp2;
                 } else {
                     last2->next = tmp2;
                     last2 = tmp2;
                 }
             }
             child = child->next;
         }
         content = content->next;
     }
     /*
      * Check there is no unhandled data
      */
     if (content != NULL) {
         xmlRngPErr(ctxt, content, XML_RNGP_DATA_CONTENT,
                    "Element data has unexpected content %s\n",
                    content->name, NULL);
     }

     return (def);
 }

 static const xmlChar *invalidName = BAD_CAST "\1";

 /**
  * xmlRelaxNGCompareNameClasses:
  * @defs1:  the first element/attribute defs
  * @defs2:  the second element/attribute defs
  * @name:  the restriction on the name
  * @ns:  the restriction on the namespace
  *
  * Compare the 2 lists of element definitions. The comparison is
  * that if both lists do not accept the same QNames, it returns 1
  * If the 2 lists can accept the same QName the comparison returns 0
  *
  * Returns 1 disttinct, 0 if equal
  */
 static int
 xmlRelaxNGCompareNameClasses(xmlRelaxNGDefinePtr def1,
                              xmlRelaxNGDefinePtr def2)
 {
     int ret = 1;
     xmlNode node;
     xmlNs ns;
     xmlRelaxNGValidCtxt ctxt;

     memset(&ctxt, 0, sizeof(xmlRelaxNGValidCtxt));

     ctxt.flags = FLAGS_IGNORABLE | FLAGS_NOERROR;

     if ((def1->type == XML_RELAXNG_ELEMENT) ||
         (def1->type == XML_RELAXNG_ATTRIBUTE)) {
         if (def2->type == XML_RELAXNG_TEXT)
             return (1);
         if (def1->name != NULL) {
             node.name = def1->name;
         } else {
             node.name = invalidName;
         }
         if (def1->ns != NULL) {
             if (def1->ns[0] == 0) {
                 node.ns = NULL;
             } else {
 	        node.ns = &ns;
                 ns.href = def1->ns;
             }
         } else {
             node.ns = NULL;
         }
         if (xmlRelaxNGElementMatch(&ctxt, def2, &node)) {
             if (def1->nameClass != NULL) {
                 ret = xmlRelaxNGCompareNameClasses(def1->nameClass, def2);
             } else {
                 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;
     } 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 {
             node.name = invalidName;
         }
         node.ns = &ns;
         if (def2->ns != NULL) {
             if (def2->ns[0] == 0) {
                 node.ns = NULL;
             } else {
                 ns.href = def2->ns;
             }
         } else {
             ns.href = invalidName;
         }
         if (xmlRelaxNGElementMatch(&ctxt, def1, &node)) {
             if (def2->nameClass != NULL) {
                 ret = xmlRelaxNGCompareNameClasses(def2->nameClass, def1);
             } else {
                 ret = 0;
             }
         } else {
             ret = 1;
         }
     } else {
         TODO ret = 0;
     }

     return (ret);
 }

 /**
  * xmlRelaxNGCompareElemDefLists:
  * @ctxt:  a Relax-NG parser context
  * @defs1:  the first list of element/attribute defs
  * @defs2:  the second list of element/attribute defs
  *
  * Compare the 2 lists of element or attribute definitions. The comparison
  * is that if both lists do not accept the same QNames, it returns 1
  * If the 2 lists can accept the same QName the comparison returns 0
  *
  * Returns 1 disttinct, 0 if equal
  */
 static int
 xmlRelaxNGCompareElemDefLists(xmlRelaxNGParserCtxtPtr ctxt
                               ATTRIBUTE_UNUSED, xmlRelaxNGDefinePtr * def1,
                               xmlRelaxNGDefinePtr * def2)
 {
     xmlRelaxNGDefinePtr *basedef2 = def2;

     if ((def1 == NULL) || (def2 == NULL))
         return (1);
     if ((*def1 == NULL) || (*def2 == NULL))
         return (1);
     while (*def1 != NULL) {
         while ((*def2) != NULL) {
             if (xmlRelaxNGCompareNameClasses(*def1, *def2) == 0)
                 return (0);
             def2++;
         }
         def2 = basedef2;
         def1++;
     }
     return (1);
 }

 /**
  * xmlRelaxNGGenerateAttributes:
  * @ctxt:  a Relax-NG parser context
  * @def:  the definition definition
  *
  * Check if the definition can only generate attributes
  *
  * Returns 1 if yes, 0 if no and -1 in case of error.
  */
 static int
 xmlRelaxNGGenerateAttributes(xmlRelaxNGParserCtxtPtr ctxt,
                              xmlRelaxNGDefinePtr def)
 {
     xmlRelaxNGDefinePtr parent, cur, tmp;

     /*
      * Don't run that check in case of error. Infinite recursion
      * becomes possible.
      */
     if (ctxt->nbErrors != 0)
         return (-1);

     parent = NULL;
     cur = def;
     while (cur != NULL) {
         if ((cur->type == XML_RELAXNG_ELEMENT) ||
             (cur->type == XML_RELAXNG_TEXT) ||
             (cur->type == XML_RELAXNG_DATATYPE) ||
             (cur->type == XML_RELAXNG_PARAM) ||
             (cur->type == XML_RELAXNG_LIST) ||
             (cur->type == XML_RELAXNG_VALUE) ||
             (cur->type == XML_RELAXNG_EMPTY))
             return (0);
         if ((cur->type == XML_RELAXNG_CHOICE) ||
             (cur->type == XML_RELAXNG_INTERLEAVE) ||
             (cur->type == XML_RELAXNG_GROUP) ||
             (cur->type == XML_RELAXNG_ONEORMORE) ||
             (cur->type == XML_RELAXNG_ZEROORMORE) ||
             (cur->type == XML_RELAXNG_OPTIONAL) ||
             (cur->type == XML_RELAXNG_PARENTREF) ||
             (cur->type == XML_RELAXNG_EXTERNALREF) ||
             (cur->type == XML_RELAXNG_REF) ||
             (cur->type == XML_RELAXNG_DEF)) {
             if (cur->content != NULL) {
                 parent = cur;
                 cur = cur->content;
                 tmp = cur;
                 while (tmp != NULL) {
                     tmp->parent = parent;
                     tmp = tmp->next;
                 }
                 continue;
             }
         }
         if (cur == def)
             break;
         if (cur->next != NULL) {
             cur = cur->next;
             continue;
         }
         do {
             cur = cur->parent;
             if (cur == NULL)
                 break;
             if (cur == def)
                 return (1);
             if (cur->next != NULL) {
                 cur = cur->next;
                 break;
             }
         } while (cur != NULL);
     }
     return (1);
 }

 /**
  * xmlRelaxNGGetElements:
  * @ctxt:  a Relax-NG parser context
  * @def:  the definition definition
  * @eora:  gather elements (0) or attributes (1)
  *
  * Compute the list of top elements a definition can generate
  *
  * Returns a list of elements or NULL if none was found.
  */
 static xmlRelaxNGDefinePtr *
 xmlRelaxNGGetElements(xmlRelaxNGParserCtxtPtr ctxt,
                       xmlRelaxNGDefinePtr def, int eora)
 {
     xmlRelaxNGDefinePtr *ret = NULL, parent, cur, tmp;
     int len = 0;
     int max = 0;

     /*
      * Don't run that check in case of error. Infinite recursion
      * becomes possible.
      */
     if (ctxt->nbErrors != 0)
         return (NULL);

     parent = NULL;
     cur = def;
     while (cur != NULL) {
         if (((eora == 0) && ((cur->type == XML_RELAXNG_ELEMENT) ||
                              (cur->type == XML_RELAXNG_TEXT))) ||
             ((eora == 1) && (cur->type == XML_RELAXNG_ATTRIBUTE))) {
             if (ret == NULL) {
                 max = 10;
                 ret = (xmlRelaxNGDefinePtr *)
                     xmlMalloc((max + 1) * sizeof(xmlRelaxNGDefinePtr));
                 if (ret == NULL) {
                     xmlRngPErrMemory(ctxt, "getting element list\n");
                     return (NULL);
                 }
             } else if (max <= len) {
 	        xmlRelaxNGDefinePtr *temp;

                 max *= 2;
                 temp = xmlRealloc(ret,
                                (max + 1) * sizeof(xmlRelaxNGDefinePtr));
                 if (temp == NULL) {
                     xmlRngPErrMemory(ctxt, "getting element list\n");
 		    xmlFree(ret);
                     return (NULL);
                 }
 		ret = temp;
             }
             ret[len++] = cur;
             ret[len] = NULL;
         } else if ((cur->type == XML_RELAXNG_CHOICE) ||
                    (cur->type == XML_RELAXNG_INTERLEAVE) ||
                    (cur->type == XML_RELAXNG_GROUP) ||
                    (cur->type == XML_RELAXNG_ONEORMORE) ||
                    (cur->type == XML_RELAXNG_ZEROORMORE) ||
                    (cur->type == XML_RELAXNG_OPTIONAL) ||
                    (cur->type == XML_RELAXNG_PARENTREF) ||
                    (cur->type == XML_RELAXNG_REF) ||
                    (cur->type == XML_RELAXNG_DEF) ||
 		   (cur->type == XML_RELAXNG_EXTERNALREF)) {
             /*
              * Don't go within elements or attributes or string values.
              * Just gather the element top list
              */
             if (cur->content != NULL) {
                 parent = cur;
                 cur = cur->content;
                 tmp = cur;
                 while (tmp != NULL) {
                     tmp->parent = parent;
                     tmp = tmp->next;
                 }
                 continue;
             }
         }
         if (cur == def)
             break;
         if (cur->next != NULL) {
             cur = cur->next;
             continue;
         }
         do {
             cur = cur->parent;
             if (cur == NULL)
                 break;
             if (cur == def)
                 return (ret);
             if (cur->next != NULL) {
                 cur = cur->next;
                 break;
             }
         } while (cur != NULL);
     }
     return (ret);
 }

 /**
  * xmlRelaxNGCheckChoiceDeterminism:
  * @ctxt:  a Relax-NG parser context
  * @def:  the choice definition
  *
  * Also used to find indeterministic pattern in choice
  */
 static void
 xmlRelaxNGCheckChoiceDeterminism(xmlRelaxNGParserCtxtPtr ctxt,
                                  xmlRelaxNGDefinePtr def)
 {
     xmlRelaxNGDefinePtr **list;
     xmlRelaxNGDefinePtr cur;
     int nbchild = 0, i, j, ret;
     int is_nullable = 0;
     int is_indeterminist = 0;
     xmlHashTablePtr triage = NULL;
     int is_triable = 1;

     if ((def == NULL) || (def->type != XML_RELAXNG_CHOICE))
         return;

     if (def->dflags & IS_PROCESSED)
         return;

     /*
      * Don't run that check in case of error. Infinite recursion
      * becomes possible.
      */
     if (ctxt->nbErrors != 0)
         return;

     is_nullable = xmlRelaxNGIsNullable(def);

     cur = def->content;
     while (cur != NULL) {
         nbchild++;
         cur = cur->next;
     }

     list = (xmlRelaxNGDefinePtr **) xmlMalloc(nbchild *
                                               sizeof(xmlRelaxNGDefinePtr
                                                      *));
     if (list == NULL) {
         xmlRngPErrMemory(ctxt, "building choice\n");
         return;
     }
     i = 0;
     /*
      * a bit strong but safe
      */
     if (is_nullable == 0) {
         triage = xmlHashCreate(10);
     } else {
         is_triable = 0;
     }
     cur = def->content;
     while (cur != NULL) {
         list[i] = xmlRelaxNGGetElements(ctxt, cur, 0);
         if ((list[i] == NULL) || (list[i][0] == NULL)) {
             is_triable = 0;
         } else if (is_triable == 1) {
             xmlRelaxNGDefinePtr *tmp;
             int res;

             tmp = list[i];
             while ((*tmp != NULL) && (is_triable == 1)) {
                 if ((*tmp)->type == XML_RELAXNG_TEXT) {
                     res = xmlHashAddEntry2(triage,
                                            BAD_CAST "#text", NULL,
                                            (void *) cur);
                     if (res != 0)
                         is_triable = -1;
                 } else if (((*tmp)->type == XML_RELAXNG_ELEMENT) &&
                            ((*tmp)->name != NULL)) {
                     if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
                         res = xmlHashAddEntry2(triage,
                                                (*tmp)->name, NULL,
                                                (void *) cur);
                     else
                         res = xmlHashAddEntry2(triage,
                                                (*tmp)->name, (*tmp)->ns,
                                                (void *) cur);
                     if (res != 0)
                         is_triable = -1;
                 } else if ((*tmp)->type == XML_RELAXNG_ELEMENT) {
                     if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
                         res = xmlHashAddEntry2(triage,
                                                BAD_CAST "#any", NULL,
                                                (void *) cur);
                     else
                         res = xmlHashAddEntry2(triage,
                                                BAD_CAST "#any", (*tmp)->ns,
                                                (void *) cur);
                     if (res != 0)
                         is_triable = -1;
                 } else {
                     is_triable = -1;
                 }
                 tmp++;
             }
         }
         i++;
         cur = cur->next;
     }

     for (i = 0; i < nbchild; i++) {
         if (list[i] == NULL)
             continue;
         for (j = 0; j < i; j++) {
             if (list[j] == NULL)
                 continue;
             ret = xmlRelaxNGCompareElemDefLists(ctxt, list[i], list[j]);
             if (ret == 0) {
                 is_indeterminist = 1;
             }
         }
     }
     for (i = 0; i < nbchild; i++) {
         if (list[i] != NULL)
             xmlFree(list[i]);
     }

     xmlFree(list);
     if (is_indeterminist) {
         def->dflags |= IS_INDETERMINIST;
     }
     if (is_triable == 1) {
         def->dflags |= IS_TRIABLE;
         def->data = triage;
     } else if (triage != NULL) {
         xmlHashFree(triage, NULL);
     }
     def->dflags |= IS_PROCESSED;
 }

 /**
  * xmlRelaxNGCheckGroupAttrs:
  * @ctxt:  a Relax-NG parser context
  * @def:  the group definition
  *
  * Detects violations of rule 7.3
  */
 static void
 xmlRelaxNGCheckGroupAttrs(xmlRelaxNGParserCtxtPtr ctxt,
                           xmlRelaxNGDefinePtr def)
 {
     xmlRelaxNGDefinePtr **list;
     xmlRelaxNGDefinePtr cur;
     int nbchild = 0, i, j, ret;

     if ((def == NULL) ||
         ((def->type != XML_RELAXNG_GROUP) &&
          (def->type != XML_RELAXNG_ELEMENT)))
         return;

     if (def->dflags & IS_PROCESSED)
         return;

     /*
      * Don't run that check in case of error. Infinite recursion
      * becomes possible.
      */
     if (ctxt->nbErrors != 0)
         return;

     cur = def->attrs;
     while (cur != NULL) {
         nbchild++;
         cur = cur->next;
     }
     cur = def->content;
     while (cur != NULL) {
         nbchild++;
         cur = cur->next;
     }

     list = (xmlRelaxNGDefinePtr **) xmlMalloc(nbchild *
                                               sizeof(xmlRelaxNGDefinePtr
                                                      *));
     if (list == NULL) {
         xmlRngPErrMemory(ctxt, "building group\n");
         return;
     }
     i = 0;
     cur = def->attrs;
     while (cur != NULL) {
         list[i] = xmlRelaxNGGetElements(ctxt, cur, 1);
         i++;
         cur = cur->next;
     }
     cur = def->content;
     while (cur != NULL) {
         list[i] = xmlRelaxNGGetElements(ctxt, cur, 1);
         i++;
         cur = cur->next;
     }

     for (i = 0; i < nbchild; i++) {
         if (list[i] == NULL)
             continue;
         for (j = 0; j < i; j++) {
             if (list[j] == NULL)
                 continue;
             ret = xmlRelaxNGCompareElemDefLists(ctxt, list[i], list[j]);
             if (ret == 0) {
                 xmlRngPErr(ctxt, def->node, XML_RNGP_GROUP_ATTR_CONFLICT,
                            "Attributes conflicts in group\n", NULL, NULL);
             }
         }
     }
     for (i = 0; i < nbchild; i++) {
         if (list[i] != NULL)
             xmlFree(list[i]);
     }

     xmlFree(list);
     def->dflags |= IS_PROCESSED;
 }

 /**
  * xmlRelaxNGComputeInterleaves:
  * @def:  the interleave definition
  * @ctxt:  a Relax-NG parser context
  * @name:  the definition name
  *
  * A lot of work for preprocessing interleave definitions
  * is potentially needed to get a decent execution speed at runtime
  *   - trying to get a total order on the element nodes generated
  *     by the interleaves, order the list of interleave definitions
  *     following that order.
  *   - if <text/> is used to handle mixed content, it is better to
  *     flag this in the define and simplify the runtime checking
  *     algorithm
  */
 static void
 xmlRelaxNGComputeInterleaves(xmlRelaxNGDefinePtr def,
                              xmlRelaxNGParserCtxtPtr ctxt,
                              xmlChar * name ATTRIBUTE_UNUSED)
 {
     xmlRelaxNGDefinePtr cur, *tmp;

     xmlRelaxNGPartitionPtr partitions = NULL;
     xmlRelaxNGInterleaveGroupPtr *groups = NULL;
     xmlRelaxNGInterleaveGroupPtr group;
     int i, j, ret, res;
     int nbgroups = 0;
     int nbchild = 0;
     int is_mixed = 0;
     int is_determinist = 1;

     /*
      * Don't run that check in case of error. Infinite recursion
      * becomes possible.
      */
     if (ctxt->nbErrors != 0)
         return;

 #ifdef DEBUG_INTERLEAVE
     xmlGenericError(xmlGenericErrorContext,
                     "xmlRelaxNGComputeInterleaves(%s)\n", name);
 #endif
     cur = def->content;
     while (cur != NULL) {
         nbchild++;
         cur = cur->next;
     }

 #ifdef DEBUG_INTERLEAVE
     xmlGenericError(xmlGenericErrorContext, "  %d child\n", nbchild);
 #endif
     groups = (xmlRelaxNGInterleaveGroupPtr *)
         xmlMalloc(nbchild * sizeof(xmlRelaxNGInterleaveGroupPtr));
     if (groups == NULL)
         goto error;
     cur = def->content;
     while (cur != NULL) {
         groups[nbgroups] = (xmlRelaxNGInterleaveGroupPtr)
             xmlMalloc(sizeof(xmlRelaxNGInterleaveGroup));
         if (groups[nbgroups] == NULL)
             goto error;
         if (cur->type == XML_RELAXNG_TEXT)
             is_mixed++;
         groups[nbgroups]->rule = cur;
         groups[nbgroups]->defs = xmlRelaxNGGetElements(ctxt, cur, 0);
         groups[nbgroups]->attrs = xmlRelaxNGGetElements(ctxt, cur, 1);
         nbgroups++;
         cur = cur->next;
     }
 #ifdef DEBUG_INTERLEAVE
     xmlGenericError(xmlGenericErrorContext, "  %d groups\n", nbgroups);
 #endif

     /*
      * Let's check that all rules makes a partitions according to 7.4
      */
     partitions = (xmlRelaxNGPartitionPtr)
         xmlMalloc(sizeof(xmlRelaxNGPartition));
     if (partitions == NULL)
         goto error;
     memset(partitions, 0, sizeof(xmlRelaxNGPartition));
     partitions->nbgroups = nbgroups;
     partitions->triage = xmlHashCreate(nbgroups);
     for (i = 0; i < nbgroups; i++) {
         group = groups[i];
         for (j = i + 1; j < nbgroups; j++) {
             if (groups[j] == NULL)
                 continue;

             ret = xmlRelaxNGCompareElemDefLists(ctxt, group->defs,
                                                 groups[j]->defs);
             if (ret == 0) {
                 xmlRngPErr(ctxt, def->node, XML_RNGP_ELEM_TEXT_CONFLICT,
                            "Element or text conflicts in interleave\n",
                            NULL, NULL);
             }
             ret = xmlRelaxNGCompareElemDefLists(ctxt, group->attrs,
                                                 groups[j]->attrs);
             if (ret == 0) {
                 xmlRngPErr(ctxt, def->node, XML_RNGP_ATTR_CONFLICT,
                            "Attributes conflicts in interleave\n", NULL,
                            NULL);
             }
         }
         tmp = group->defs;
         if ((tmp != NULL) && (*tmp != NULL)) {
             while (*tmp != NULL) {
                 if ((*tmp)->type == XML_RELAXNG_TEXT) {
                     res = xmlHashAddEntry2(partitions->triage,
                                            BAD_CAST "#text", NULL,
                                            (void *) (long) (i + 1));
                     if (res != 0)
                         is_determinist = -1;
                 } else if (((*tmp)->type == XML_RELAXNG_ELEMENT) &&
                            ((*tmp)->name != NULL)) {
                     if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
                         res = xmlHashAddEntry2(partitions->triage,
                                                (*tmp)->name, NULL,
                                                (void *) (long) (i + 1));
                     else
                         res = xmlHashAddEntry2(partitions->triage,
                                                (*tmp)->name, (*tmp)->ns,
                                                (void *) (long) (i + 1));
                     if (res != 0)
                         is_determinist = -1;
                 } else if ((*tmp)->type == XML_RELAXNG_ELEMENT) {
                     if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
                         res = xmlHashAddEntry2(partitions->triage,
                                                BAD_CAST "#any", NULL,
                                                (void *) (long) (i + 1));
                     else
                         res = xmlHashAddEntry2(partitions->triage,
                                                BAD_CAST "#any", (*tmp)->ns,
                                                (void *) (long) (i + 1));
                     if ((*tmp)->nameClass != NULL)
                         is_determinist = 2;
                     if (res != 0)
                         is_determinist = -1;
                 } else {
                     is_determinist = -1;
                 }
                 tmp++;
             }
         } else {
             is_determinist = 0;
         }
     }
     partitions->groups = groups;

     /*
      * and save the partition list back in the def
      */
     def->data = partitions;
     if (is_mixed != 0)
         def->dflags |= IS_MIXED;
     if (is_determinist == 1)
         partitions->flags = IS_DETERMINIST;
     if (is_determinist == 2)
         partitions->flags = IS_DETERMINIST | IS_NEEDCHECK;
     return;

   error:
     xmlRngPErrMemory(ctxt, "in interleave computation\n");
     if (groups != NULL) {
         for (i = 0; i < nbgroups; i++)
             if (groups[i] != NULL) {
                 if (groups[i]->defs != NULL)
                     xmlFree(groups[i]->defs);
                 xmlFree(groups[i]);
             }
         xmlFree(groups);
     }
     xmlRelaxNGFreePartition(partitions);
 }

 /**
  * xmlRelaxNGParseInterleave:
  * @ctxt:  a Relax-NG parser context
  * @node:  the data node.
  *
  * parse the content of a RelaxNG interleave node.
  *
  * Returns the definition pointer or NULL in case of error
  */
 static xmlRelaxNGDefinePtr
 xmlRelaxNGParseInterleave(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
 {
     xmlRelaxNGDefinePtr def = NULL;
     xmlRelaxNGDefinePtr last = NULL, cur;
     xmlNodePtr child;

     def = xmlRelaxNGNewDefine(ctxt, node);
     if (def == NULL) {
         return (NULL);
     }
     def->type = XML_RELAXNG_INTERLEAVE;

     if (ctxt->interleaves == NULL)
         ctxt->interleaves = xmlHashCreate(10);
     if (ctxt->interleaves == NULL) {
         xmlRngPErrMemory(ctxt, "create interleaves\n");
     } else {
         char name[32];

         snprintf(name, 32, "interleave%d", ctxt->nbInterleaves++);
         if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST name, def) < 0) {
             xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_ADD,
                        "Failed to add %s to hash table\n",
 		       (const xmlChar *) name, NULL);
         }
     }
     child = node->children;
     if (child == NULL) {
         xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_NO_CONTENT,
                    "Element interleave is empty\n", NULL, NULL);
     }
     while (child != NULL) {
         if (IS_RELAXNG(child, "element")) {
             cur = xmlRelaxNGParseElement(ctxt, child);
         } else {
             cur = xmlRelaxNGParsePattern(ctxt, child);
         }
         if (cur != NULL) {
             cur->parent = def;
             if (last == NULL) {
                 def->content = last = cur;
             } else {
                 last->next = cur;
                 last = cur;
             }
         }
         child = child->next;
     }

     return (def);
 }

 /**
  * xmlRelaxNGParseInclude:
  * @ctxt:  a Relax-NG parser context
  * @node:  the include node
  *
  * Integrate the content of an include node in the current grammar
  *
  * Returns 0 in case of success or -1 in case of error
  */
 static int
 xmlRelaxNGParseInclude(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
 {
     xmlRelaxNGIncludePtr incl;
     xmlNodePtr root;
     int ret = 0, tmp;

     incl = node->psvi;
     if (incl == NULL) {
         xmlRngPErr(ctxt, node, XML_RNGP_INCLUDE_EMPTY,
                    "Include node has no data\n", NULL, NULL);
         return (-1);
     }
     root = xmlDocGetRootElement(incl->doc);
     if (root == NULL) {
         xmlRngPErr(ctxt, node, XML_RNGP_EMPTY, "Include document is empty\n",
                    NULL, NULL);
         return (-1);
     }
     if (!xmlStrEqual(root->name, BAD_CAST "grammar")) {
         xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
                    "Include document root is not a grammar\n", NULL, NULL);
         return (-1);
     }

     /*
      * Merge the definition from both the include and the internal list
      */
     if (root->children != NULL) {
         tmp = xmlRelaxNGParseGrammarContent(ctxt, root->children);
         if (tmp != 0)
             ret = -1;
     }
     if (node->children != NULL) {
         tmp = xmlRelaxNGParseGrammarContent(ctxt, node->children);
         if (tmp != 0)
             ret = -1;
     }
     return (ret);
 }

 /**
  * xmlRelaxNGParseDefine:
  * @ctxt:  a Relax-NG parser context
  * @node:  the define node
  *
  * parse the content of a RelaxNG define element node.
  *
  * Returns 0 in case of success or -1 in case of error
  */
 static int
 xmlRelaxNGParseDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
 {
     xmlChar *name;
     int ret = 0, tmp;
     xmlRelaxNGDefinePtr def;
     const xmlChar *olddefine;

     name = xmlGetProp(node, BAD_CAST "name");
     if (name == NULL) {
         xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_NAME_MISSING,
                    "define has no name\n", NULL, NULL);
     } else {
         xmlRelaxNGNormExtSpace(name);
         if (xmlValidateNCName(name, 0)) {
             xmlRngPErr(ctxt, node, XML_RNGP_INVALID_DEFINE_NAME,
                        "define name '%s' is not an NCName\n", name, NULL);
         }
         def = xmlRelaxNGNewDefine(ctxt, node);
         if (def == NULL) {
             xmlFree(name);
             return (-1);
         }
         def->type = XML_RELAXNG_DEF;
         def->name = name;
         if (node->children == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_EMPTY,
                        "define has no children\n", NULL, NULL);
         } else {
             olddefine = ctxt->define;
             ctxt->define = name;
             def->content =
                 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
             ctxt->define = olddefine;
         }
         if (ctxt->grammar->defs == NULL)
             ctxt->grammar->defs = xmlHashCreate(10);
         if (ctxt->grammar->defs == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED,
                        "Could not create definition hash\n", NULL, NULL);
             ret = -1;
         } else {
             tmp = xmlHashAddEntry(ctxt->grammar->defs, name, def);
             if (tmp < 0) {
                 xmlRelaxNGDefinePtr prev;

                 prev = xmlHashLookup(ctxt->grammar->defs, name);
                 if (prev == NULL) {
                     xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED,
                                "Internal error on define aggregation of %s\n",
                                name, NULL);
                     ret = -1;
                 } else {
                     while (prev->nextHash != NULL)
                         prev = prev->nextHash;
                     prev->nextHash = def;
                 }
             }
         }
     }
     return (ret);
 }

 /**
  * xmlRelaxNGProcessExternalRef:
  * @ctxt: the parser context
  * @node:  the externlRef node
  *
  * Process and compile an externlRef node
  *
  * Returns the xmlRelaxNGDefinePtr or NULL in case of error
  */
 static xmlRelaxNGDefinePtr
 xmlRelaxNGProcessExternalRef(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
 {
     xmlRelaxNGDocumentPtr docu;
     xmlNodePtr root, tmp;
     xmlChar *ns;
     int newNs = 0, oldflags;
     xmlRelaxNGDefinePtr def;

     docu = node->psvi;
     if (docu != NULL) {
         def = xmlRelaxNGNewDefine(ctxt, node);
         if (def == NULL)
             return (NULL);
         def->type = XML_RELAXNG_EXTERNALREF;

         if (docu->content == NULL) {
             /*
              * Then do the parsing for good
              */
             root = xmlDocGetRootElement(docu->doc);
             if (root == NULL) {
                 xmlRngPErr(ctxt, node, XML_RNGP_EXTERNALREF_EMTPY,
                            "xmlRelaxNGParse: %s is empty\n", ctxt->URL,
                            NULL);
                 return (NULL);
             }
             /*
              * ns transmission rules
              */
             ns = xmlGetProp(root, BAD_CAST "ns");
             if (ns == NULL) {
                 tmp = node;
                 while ((tmp != NULL) && (tmp->type == XML_ELEMENT_NODE)) {
                     ns = xmlGetProp(tmp, BAD_CAST "ns");
                     if (ns != NULL) {
                         break;
                     }
                     tmp = tmp->parent;
                 }
                 if (ns != NULL) {
                     xmlSetProp(root, BAD_CAST "ns", ns);
                     newNs = 1;
                     xmlFree(ns);
                 }
             } else {
                 xmlFree(ns);
             }

             /*
              * Parsing to get a precompiled schemas.
              */
             oldflags = ctxt->flags;
             ctxt->flags |= XML_RELAXNG_IN_EXTERNALREF;
             docu->schema = xmlRelaxNGParseDocument(ctxt, root);
             ctxt->flags = oldflags;
             if ((docu->schema != NULL) &&
                 (docu->schema->topgrammar != NULL)) {
                 docu->content = docu->schema->topgrammar->start;
             }

             /*
              * the externalRef may be reused in a different ns context
              */
             if (newNs == 1) {
                 xmlUnsetProp(root, BAD_CAST "ns");
             }
         }
         def->content = docu->content;
     } else {
         def = NULL;
     }
     return (def);
 }

 /**
  * xmlRelaxNGParsePattern:
  * @ctxt:  a Relax-NG parser context
  * @node:  the pattern node.
  *
  * parse the content of a RelaxNG pattern node.
  *
  * Returns the definition pointer or NULL in case of error or if no
  *     pattern is generated.
  */
 static xmlRelaxNGDefinePtr
 xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
 {
     xmlRelaxNGDefinePtr def = NULL;

     if (node == NULL) {
         return (NULL);
     }
     if (IS_RELAXNG(node, "element")) {
         def = xmlRelaxNGParseElement(ctxt, node);
     } else if (IS_RELAXNG(node, "attribute")) {
         def = xmlRelaxNGParseAttribute(ctxt, node);
     } else if (IS_RELAXNG(node, "empty")) {
         def = xmlRelaxNGNewDefine(ctxt, node);
         if (def == NULL)
             return (NULL);
         def->type = XML_RELAXNG_EMPTY;
         if (node->children != NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_NOT_EMPTY,
                        "empty: had a child node\n", NULL, NULL);
         }
     } else if (IS_RELAXNG(node, "text")) {
         def = xmlRelaxNGNewDefine(ctxt, node);
         if (def == NULL)
             return (NULL);
         def->type = XML_RELAXNG_TEXT;
         if (node->children != NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_TEXT_HAS_CHILD,
                        "text: had a child node\n", NULL, NULL);
         }
     } else if (IS_RELAXNG(node, "zeroOrMore")) {
         def = xmlRelaxNGNewDefine(ctxt, node);
         if (def == NULL)
             return (NULL);
         def->type = XML_RELAXNG_ZEROORMORE;
         if (node->children == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
                        "Element %s is empty\n", node->name, NULL);
         } else {
             def->content =
                 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
         }
     } else if (IS_RELAXNG(node, "oneOrMore")) {
         def = xmlRelaxNGNewDefine(ctxt, node);
         if (def == NULL)
             return (NULL);
         def->type = XML_RELAXNG_ONEORMORE;
         if (node->children == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
                        "Element %s is empty\n", node->name, NULL);
         } else {
             def->content =
                 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
         }
     } else if (IS_RELAXNG(node, "optional")) {
         def = xmlRelaxNGNewDefine(ctxt, node);
         if (def == NULL)
             return (NULL);
         def->type = XML_RELAXNG_OPTIONAL;
         if (node->children == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
                        "Element %s is empty\n", node->name, NULL);
         } else {
             def->content =
                 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
         }
     } else if (IS_RELAXNG(node, "choice")) {
         def = xmlRelaxNGNewDefine(ctxt, node);
         if (def == NULL)
             return (NULL);
         def->type = XML_RELAXNG_CHOICE;
         if (node->children == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
                        "Element %s is empty\n", node->name, NULL);
         } else {
             def->content =
                 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
         }
     } else if (IS_RELAXNG(node, "group")) {
         def = xmlRelaxNGNewDefine(ctxt, node);
         if (def == NULL)
             return (NULL);
         def->type = XML_RELAXNG_GROUP;
         if (node->children == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
                        "Element %s is empty\n", node->name, NULL);
         } else {
             def->content =
                 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
         }
     } else if (IS_RELAXNG(node, "ref")) {
         def = xmlRelaxNGNewDefine(ctxt, node);
         if (def == NULL)
             return (NULL);
         def->type = XML_RELAXNG_REF;
         def->name = xmlGetProp(node, BAD_CAST "name");
         if (def->name == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_REF_NO_NAME, "ref has no name\n",
                        NULL, NULL);
         } else {
             xmlRelaxNGNormExtSpace(def->name);
             if (xmlValidateNCName(def->name, 0)) {
                 xmlRngPErr(ctxt, node, XML_RNGP_REF_NAME_INVALID,
                            "ref name '%s' is not an NCName\n", def->name,
                            NULL);
             }
         }
         if (node->children != NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_REF_NOT_EMPTY, "ref is not empty\n",
                        NULL, NULL);
         }
         if (ctxt->grammar->refs == NULL)
             ctxt->grammar->refs = xmlHashCreate(10);
         if (ctxt->grammar->refs == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
                        "Could not create references hash\n", NULL, NULL);
             def = NULL;
         } else {
             int tmp;

             tmp = xmlHashAddEntry(ctxt->grammar->refs, def->name, def);
             if (tmp < 0) {
                 xmlRelaxNGDefinePtr prev;

                 prev = (xmlRelaxNGDefinePtr)
                     xmlHashLookup(ctxt->grammar->refs, def->name);
                 if (prev == NULL) {
                     if (def->name != NULL) {
 		        xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
 				   "Error refs definitions '%s'\n",
 				   def->name, NULL);
                     } else {
 		        xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
 				   "Error refs definitions\n",
 				   NULL, NULL);
                     }
                     def = NULL;
                 } else {
                     def->nextHash = prev->nextHash;
                     prev->nextHash = def;
                 }
             }
         }
     } else if (IS_RELAXNG(node, "data")) {
         def = xmlRelaxNGParseData(ctxt, node);
     } else if (IS_RELAXNG(node, "value")) {
         def = xmlRelaxNGParseValue(ctxt, node);
     } else if (IS_RELAXNG(node, "list")) {
         def = xmlRelaxNGNewDefine(ctxt, node);
         if (def == NULL)
             return (NULL);
         def->type = XML_RELAXNG_LIST;
         if (node->children == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
                        "Element %s is empty\n", node->name, NULL);
         } else {
             def->content =
                 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
         }
     } else if (IS_RELAXNG(node, "interleave")) {
         def = xmlRelaxNGParseInterleave(ctxt, node);
     } else if (IS_RELAXNG(node, "externalRef")) {
         def = xmlRelaxNGProcessExternalRef(ctxt, node);
     } else if (IS_RELAXNG(node, "notAllowed")) {
         def = xmlRelaxNGNewDefine(ctxt, node);
         if (def == NULL)
             return (NULL);
         def->type = XML_RELAXNG_NOT_ALLOWED;
         if (node->children != NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_NOTALLOWED_NOT_EMPTY,
                        "xmlRelaxNGParse: notAllowed element is not empty\n",
                        NULL, NULL);
         }
     } else if (IS_RELAXNG(node, "grammar")) {
         xmlRelaxNGGrammarPtr grammar, old;
         xmlRelaxNGGrammarPtr oldparent;

 #ifdef DEBUG_GRAMMAR
         xmlGenericError(xmlGenericErrorContext,
                         "Found <grammar> pattern\n");
 #endif

         oldparent = ctxt->parentgrammar;
         old = ctxt->grammar;
         ctxt->parentgrammar = old;
         grammar = xmlRelaxNGParseGrammar(ctxt, node->children);
         if (old != NULL) {
             ctxt->grammar = old;
             ctxt->parentgrammar = oldparent;
 #if 0
             if (grammar != NULL) {
                 grammar->next = old->next;
                 old->next = grammar;
             }
 #endif
         }
         if (grammar != NULL)
             def = grammar->start;
         else
             def = NULL;
     } else if (IS_RELAXNG(node, "parentRef")) {
         if (ctxt->parentgrammar == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_PARENT,
                        "Use of parentRef without a parent grammar\n", NULL,
                        NULL);
             return (NULL);
         }
         def = xmlRelaxNGNewDefine(ctxt, node);
         if (def == NULL)
             return (NULL);
         def->type = XML_RELAXNG_PARENTREF;
         def->name = xmlGetProp(node, BAD_CAST "name");
         if (def->name == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_NAME,
                        "parentRef has no name\n", NULL, NULL);
         } else {
             xmlRelaxNGNormExtSpace(def->name);
             if (xmlValidateNCName(def->name, 0)) {
                 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NAME_INVALID,
                            "parentRef name '%s' is not an NCName\n",
                            def->name, NULL);
             }
         }
         if (node->children != NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NOT_EMPTY,
                        "parentRef is not empty\n", NULL, NULL);
         }
         if (ctxt->parentgrammar->refs == NULL)
             ctxt->parentgrammar->refs = xmlHashCreate(10);
         if (ctxt->parentgrammar->refs == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED,
                        "Could not create references hash\n", NULL, NULL);
             def = NULL;
         } else if (def->name != NULL) {
             int tmp;

             tmp =
                 xmlHashAddEntry(ctxt->parentgrammar->refs, def->name, def);
             if (tmp < 0) {
                 xmlRelaxNGDefinePtr prev;

                 prev = (xmlRelaxNGDefinePtr)
                     xmlHashLookup(ctxt->parentgrammar->refs, def->name);
                 if (prev == NULL) {
                     xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED,
                                "Internal error parentRef definitions '%s'\n",
                                def->name, NULL);
                     def = NULL;
                 } else {
                     def->nextHash = prev->nextHash;
                     prev->nextHash = def;
                 }
             }
         }
     } else if (IS_RELAXNG(node, "mixed")) {
         if (node->children == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT, "Mixed is empty\n",
                        NULL, NULL);
             def = NULL;
         } else {
             def = xmlRelaxNGParseInterleave(ctxt, node);
             if (def != NULL) {
                 xmlRelaxNGDefinePtr tmp;

                 if ((def->content != NULL) && (def->content->next != NULL)) {
                     tmp = xmlRelaxNGNewDefine(ctxt, node);
                     if (tmp != NULL) {
                         tmp->type = XML_RELAXNG_GROUP;
                         tmp->content = def->content;
                         def->content = tmp;
                     }
                 }

                 tmp = xmlRelaxNGNewDefine(ctxt, node);
                 if (tmp == NULL)
                     return (def);
                 tmp->type = XML_RELAXNG_TEXT;
                 tmp->next = def->content;
                 def->content = tmp;
             }
         }
     } else {
         xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_CONSTRUCT,
                    "Unexpected node %s is not a pattern\n", node->name,
                    NULL);
         def = NULL;
     }
     return (def);
 }

 /**
  * xmlRelaxNGParseAttribute:
  * @ctxt:  a Relax-NG parser context
  * @node:  the element node
  *
  * parse the content of a RelaxNG attribute node.
  *
  * Returns the definition pointer or NULL in case of error.
  */
 static xmlRelaxNGDefinePtr
 xmlRelaxNGParseAttribute(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
 {
     xmlRelaxNGDefinePtr ret, cur;
     xmlNodePtr child;
     int old_flags;

     ret = xmlRelaxNGNewDefine(ctxt, node);
     if (ret == NULL)
         return (NULL);
     ret->type = XML_RELAXNG_ATTRIBUTE;
     ret->parent = ctxt->def;
     child = node->children;
     if (child == NULL) {
         xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_EMPTY,
                    "xmlRelaxNGParseattribute: attribute has no children\n",
                    NULL, NULL);
         return (ret);
     }
     old_flags = ctxt->flags;
     ctxt->flags |= XML_RELAXNG_IN_ATTRIBUTE;
     cur = xmlRelaxNGParseNameClass(ctxt, child, ret);
     if (cur != NULL)
         child = child->next;

     if (child != NULL) {
         cur = xmlRelaxNGParsePattern(ctxt, child);
         if (cur != NULL) {
             switch (cur->type) {
                 case XML_RELAXNG_EMPTY:
                 case XML_RELAXNG_NOT_ALLOWED:
                 case XML_RELAXNG_TEXT:
                 case XML_RELAXNG_ELEMENT:
                 case XML_RELAXNG_DATATYPE:
                 case XML_RELAXNG_VALUE:
                 case XML_RELAXNG_LIST:
                 case XML_RELAXNG_REF:
                 case XML_RELAXNG_PARENTREF:
                 case XML_RELAXNG_EXTERNALREF:
                 case XML_RELAXNG_DEF:
                 case XML_RELAXNG_ONEORMORE:
                 case XML_RELAXNG_ZEROORMORE:
                 case XML_RELAXNG_OPTIONAL:
                 case XML_RELAXNG_CHOICE:
                 case XML_RELAXNG_GROUP:
                 case XML_RELAXNG_INTERLEAVE:
                 case XML_RELAXNG_ATTRIBUTE:
                     ret->content = cur;
                     cur->parent = ret;
                     break;
                 case XML_RELAXNG_START:
                 case XML_RELAXNG_PARAM:
                 case XML_RELAXNG_EXCEPT:
                     xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CONTENT,
                                "attribute has invalid content\n", NULL,
                                NULL);
                     break;
                 case XML_RELAXNG_NOOP:
                     xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_NOOP,
                                "RNG Internal error, noop found in attribute\n",
                                NULL, NULL);
                     break;
             }
         }
         child = child->next;
     }
     if (child != NULL) {
         xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CHILDREN,
                    "attribute has multiple children\n", NULL, NULL);
     }
     ctxt->flags = old_flags;
     return (ret);
 }

 /**
  * xmlRelaxNGParseExceptNameClass:
  * @ctxt:  a Relax-NG parser context
  * @node:  the except node
  * @attr:  1 if within an attribute, 0 if within an element
  *
  * parse the content of a RelaxNG nameClass node.
  *
  * Returns the definition pointer or NULL in case of error.
  */
 static xmlRelaxNGDefinePtr
 xmlRelaxNGParseExceptNameClass(xmlRelaxNGParserCtxtPtr ctxt,
                                xmlNodePtr node, int attr)
 {
     xmlRelaxNGDefinePtr ret, cur, last = NULL;
     xmlNodePtr child;

     if (!IS_RELAXNG(node, "except")) {
         xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MISSING,
                    "Expecting an except node\n", NULL, NULL);
         return (NULL);
     }
     if (node->next != NULL) {
         xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MULTIPLE,
                    "exceptNameClass allows only a single except node\n",
                    NULL, NULL);
     }
     if (node->children == NULL) {
         xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_EMPTY, "except has no content\n",
                    NULL, NULL);
         return (NULL);
     }

     ret = xmlRelaxNGNewDefine(ctxt, node);
     if (ret == NULL)
         return (NULL);
     ret->type = XML_RELAXNG_EXCEPT;
     child = node->children;
     while (child != NULL) {
         cur = xmlRelaxNGNewDefine(ctxt, child);
         if (cur == NULL)
             break;
         if (attr)
             cur->type = XML_RELAXNG_ATTRIBUTE;
         else
             cur->type = XML_RELAXNG_ELEMENT;

         if (xmlRelaxNGParseNameClass(ctxt, child, cur) != NULL) {
             if (last == NULL) {
                 ret->content = cur;
             } else {
                 last->next = cur;
             }
             last = cur;
         }
         child = child->next;
     }

     return (ret);
 }

 /**
  * xmlRelaxNGParseNameClass:
  * @ctxt:  a Relax-NG parser context
  * @node:  the nameClass node
  * @def:  the current definition
  *
  * parse the content of a RelaxNG nameClass node.
  *
  * Returns the definition pointer or NULL in case of error.
  */
 static xmlRelaxNGDefinePtr
 xmlRelaxNGParseNameClass(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node,
                          xmlRelaxNGDefinePtr def)
 {
     xmlRelaxNGDefinePtr ret, tmp;
     xmlChar *val;

     ret = def;
     if ((IS_RELAXNG(node, "name")) || (IS_RELAXNG(node, "anyName")) ||
         (IS_RELAXNG(node, "nsName"))) {
         if ((def->type != XML_RELAXNG_ELEMENT) &&
             (def->type != XML_RELAXNG_ATTRIBUTE)) {
             ret = xmlRelaxNGNewDefine(ctxt, node);
             if (ret == NULL)
                 return (NULL);
             ret->parent = def;
             if (ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE)
                 ret->type = XML_RELAXNG_ATTRIBUTE;
             else
                 ret->type = XML_RELAXNG_ELEMENT;
         }
     }
     if (IS_RELAXNG(node, "name")) {
         val = xmlNodeGetContent(node);
         xmlRelaxNGNormExtSpace(val);
         if (xmlValidateNCName(val, 0)) {
 	    if (node->parent != NULL)
 		xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME,
 			   "Element %s name '%s' is not an NCName\n",
 			   node->parent->name, val);
 	    else
 		xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME,
 			   "name '%s' is not an NCName\n",
 			   val, NULL);
         }
         ret->name = val;
         val = xmlGetProp(node, BAD_CAST "ns");
         ret->ns = val;
         if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
             (val != NULL) &&
             (xmlStrEqual(val, BAD_CAST "http://www.w3.org/2000/xmlns"))) {
 	    xmlRngPErr(ctxt, node, XML_RNGP_XML_NS,
                         "Attribute with namespace '%s' is not allowed\n",
                         val, NULL);
         }
         if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
             (val != NULL) &&
             (val[0] == 0) && (xmlStrEqual(ret->name, BAD_CAST "xmlns"))) {
 	    xmlRngPErr(ctxt, node, XML_RNGP_XMLNS_NAME,
                        "Attribute with QName 'xmlns' is not allowed\n",
                        val, NULL);
         }
     } else if (IS_RELAXNG(node, "anyName")) {
         ret->name = NULL;
         ret->ns = NULL;
         if (node->children != NULL) {
             ret->nameClass =
                 xmlRelaxNGParseExceptNameClass(ctxt, node->children,
                                                (def->type ==
                                                 XML_RELAXNG_ATTRIBUTE));
         }
     } else if (IS_RELAXNG(node, "nsName")) {
         ret->name = NULL;
         ret->ns = xmlGetProp(node, BAD_CAST "ns");
         if (ret->ns == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_NSNAME_NO_NS,
                        "nsName has no ns attribute\n", NULL, NULL);
         }
         if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
             (ret->ns != NULL) &&
             (xmlStrEqual
              (ret->ns, BAD_CAST "http://www.w3.org/2000/xmlns"))) {
             xmlRngPErr(ctxt, node, XML_RNGP_XML_NS,
                        "Attribute with namespace '%s' is not allowed\n",
                        ret->ns, NULL);
         }
         if (node->children != NULL) {
             ret->nameClass =
                 xmlRelaxNGParseExceptNameClass(ctxt, node->children,
                                                (def->type ==
                                                 XML_RELAXNG_ATTRIBUTE));
         }
     } else if (IS_RELAXNG(node, "choice")) {
         xmlNodePtr child;
         xmlRelaxNGDefinePtr last = NULL;

         ret = xmlRelaxNGNewDefine(ctxt, node);
         if (ret == NULL)
             return (NULL);
         ret->parent = def;
         ret->type = XML_RELAXNG_CHOICE;

         if (node->children == NULL) {
             xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_EMPTY,
                        "Element choice is empty\n", NULL, NULL);
         } else {

             child = node->children;
             while (child != NULL) {
                 tmp = xmlRelaxNGParseNameClass(ctxt, child, ret);
                 if (tmp != NULL) {
                     if (last == NULL) {
                         last = ret->nameClass = tmp;
                     } else {
                         last->next = tmp;
                         last = tmp;
                     }
                 }
                 child = child->next;
             }
         }
     } else {
         xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_CONTENT,
                    "expecting name, anyName, nsName or choice : got %s\n",
                    node->name, NULL);
         return (NULL);
     }
     if (ret != def) {
         if (def->nameClass == NULL) {
             def->nameClass = ret;
         } else {
             tmp = def->nameClass;
             while (tmp->next != NULL) {
                 tmp = tmp->next;
             }
             tmp->next = ret;
         }
     }
     return (ret);
 }

 /**
  * xmlRelaxNGParseElement:
  * @ctxt:  a Relax-NG parser context
  * @node:  the element node
  *
  * parse the content of a RelaxNG element node.
  *
  * Returns the definition pointer or NULL in case of error.
  */
 static xmlRelaxNGDefinePtr
 xmlRelaxNGParseElement(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
 {
     xmlRelaxNGDefinePtr ret, cur, last;
     xmlNodePtr child;
     const xmlChar *olddefine;

     ret = xmlRelaxNGNewDefine(ctxt, node);
     if (ret == NULL)
         return (NULL);
     ret->type = XML_RELAXNG_ELEMENT;
     ret->parent = ctxt->def;
     child = node->children;
     if (child == NULL) {
         xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_EMPTY,
                    "xmlRelaxNGParseElement: element has no children\n",
                    NULL, NULL);
         return (ret);
     }
     cur = xmlRelaxNGParseNameClass(ctxt, child, ret);
     if (cur != NULL)
         child = child->next;

     if (child == NULL) {
         xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NO_CONTENT,
                    "xmlRelaxNGParseElement: element has no content\n",
                    NULL, NULL);
         return (ret);
     }
     olddefine = ctxt->define;
     ctxt->define = NULL;
     last = NULL;
     while (child != NULL) {
         cur = xmlRelaxNGParsePattern(ctxt, child);
         if (cur != NULL) {
             cur->parent = ret;
             switch (cur->type) {
                 case XML_RELAXNG_EMPTY:
                 case XML_RELAXNG_NOT_ALLOWED:
                 case XML_RELAXNG_TEXT:
                 case XML_RELAXNG_ELEMENT:
                 case XML_RELAXNG_DATATYPE:
                 case XML_RELAXNG_VALUE:
                 case XML_RELAXNG_LIST:
                 case XML_RELAXNG_REF:
                 case XML_RELAXNG_PARENTREF:
                 case XML_RELAXNG_EXTERNALREF:
                 case XML_RELAXNG_DEF:
                 case XML_RELAXNG_ZEROORMORE:
                 case XML_RELAXNG_ONEORMORE:
                 case XML_RELAXNG_OPTIONAL:
                 case XML_RELAXNG_CHOICE:
                 case XML_RELAXNG_GROUP:
                 case XML_RELAXNG_INTERLEAVE:
                     if (last == NULL) {
                         ret->content = last = cur;
                     } else {
                         if ((last->type == XML_RELAXNG_ELEMENT) &&
                             (ret->content == last)) {
                             ret->content = xmlRelaxNGNewDefine(ctxt, node);
                             if (ret->content != NULL) {
                                 ret->content->type = XML_RELAXNG_GROUP;
                                 ret->content->content = last;
                             } else {
                                 ret->content = last;
                             }
                         }
                         last->next = cur;
                         last = cur;
                     }
                     break;
                 case XML_RELAXNG_ATTRIBUTE:
                     cur->next = ret->attrs;
                     ret->attrs = cur;
                     break;
                 case XML_RELAXNG_START:
                     xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
                                "RNG Internal error, start found in element\n",
                                NULL, NULL);
                     break;
                 case XML_RELAXNG_PARAM:
                     xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
                                "RNG Internal error, param found in element\n",
                                NULL, NULL);
                     break;
                 case XML_RELAXNG_EXCEPT:
                     xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
                                "RNG Internal error, except found in element\n",
                                NULL, NULL);
                     break;
                 case XML_RELAXNG_NOOP:
                     xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
                                "RNG Internal error, noop found in element\n",
                                NULL, NULL);
                     break;
             }
         }
         child = child->next;
     }
     ctxt->define = olddefine;
     return (ret);
 }

 /**
  * xmlRelaxNGParsePatterns:
  * @ctxt:  a Relax-NG parser context
  * @nodes:  list of nodes
  * @group:  use an implicit <group> for elements
  *
  * parse the content of a RelaxNG start node.
  *
  * Returns the definition pointer or NULL in case of error.
  */
 static xmlRelaxNGDefinePtr
 xmlRelaxNGParsePatterns(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes,
                         int group)
 {
     xmlRelaxNGDefinePtr def = NULL, last = NULL, cur, parent;

     parent = ctxt->def;
     while (nodes != NULL) {
         if (IS_RELAXNG(nodes, "element")) {
             cur = xmlRelaxNGParseElement(ctxt, nodes);
             if (def == NULL) {
                 def = last = cur;
             } else {
                 if ((group == 1) && (def->type == XML_RELAXNG_ELEMENT) &&
                     (def == last)) {
                     def = xmlRelaxNGNewDefine(ctxt, nodes);
                     def->type = XML_RELAXNG_GROUP;
                     def->content = last;
                 }
                 last->next = cur;
                 last = cur;
             }
             cur->parent = parent;
         } else {
             cur = xmlRelaxNGParsePattern(ctxt, nodes);
             if (cur != NULL) {
                 if (def == NULL) {
                     def = last = cur;
                 } else {
                     last->next = cur;
                     last = cur;
                 }
             }
         }
         nodes = nodes->next;
     }
     return (def);
 }

 /**
  * xmlRelaxNGParseStart:
  * @ctxt:  a Relax-NG parser context
  * @nodes:  start children nodes
  *
  * parse the content of a RelaxNG start node.
  *
  * Returns 0 in case of success, -1 in case of error
  */
 static int
 xmlRelaxNGParseStart(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes)
 {
     int ret = 0;
     xmlRelaxNGDefinePtr def = NULL, last;

     if (nodes == NULL) {
         xmlRngPErr(ctxt, nodes, XML_RNGP_START_EMPTY, "start has no children\n",
                    NULL, NULL);
         return (-1);
     }
     if (IS_RELAXNG(nodes, "empty")) {
         def = xmlRelaxNGNewDefine(ctxt, nodes);
         if (def == NULL)
             return (-1);
         def->type = XML_RELAXNG_EMPTY;
         if (nodes->children != NULL) {
             xmlRngPErr(ctxt, nodes, XML_RNGP_EMPTY_CONTENT,
                        "element empty is not empty\n", NULL, NULL);
         }
     } else if (IS_RELAXNG(nodes, "notAllowed")) {
         def = xmlRelaxNGNewDefine(ctxt, nodes);
         if (def == NULL)
             return (-1);
         def->type = XML_RELAXNG_NOT_ALLOWED;
         if (nodes->children != NULL) {
             xmlRngPErr(ctxt, nodes, XML_RNGP_NOTALLOWED_NOT_EMPTY,
                        "element notAllowed is not empty\n", NULL, NULL);
         }
     } else {
         def = xmlRelaxNGParsePatterns(ctxt, nodes, 1);
     }
     if (ctxt->grammar->start != NULL) {
         last = ctxt->grammar->start;
         while (last->next != NULL)
             last = last->next;
         last->next = def;
     } else {
         ctxt->grammar->start = def;
     }
     nodes = nodes->next;
     if (nodes != NULL) {
         xmlRngPErr(ctxt, nodes, XML_RNGP_START_CONTENT,
                    "start more than one children\n", NULL, NULL);
         return (-1);
     }
     return (ret);
 }

 /**
  * xmlRelaxNGParseGrammarContent:
  * @ctxt:  a Relax-NG parser context
  * @nodes:  grammar children nodes
  *
  * parse the content of a RelaxNG grammar node.
  *
  * Returns 0 in case of success, -1 in case of error
  */
 static int
 xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt,
                               xmlNodePtr nodes)
 {
     int ret = 0, tmp;

     if (nodes == NULL) {
         xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_EMPTY,
                    "grammar has no children\n", NULL, NULL);
         return (-1);
     }
     while (nodes != NULL) {
         if (IS_RELAXNG(nodes, "start")) {
             if (nodes->children == NULL) {
                 xmlRngPErr(ctxt, nodes, XML_RNGP_START_EMPTY,
                            "start has no children\n", NULL, NULL);
             } else {
                 tmp = xmlRelaxNGParseStart(ctxt, nodes->children);
                 if (tmp != 0)
                     ret = -1;
             }
         } else if (IS_RELAXNG(nodes, "define")) {
             tmp = xmlRelaxNGParseDefine(ctxt, nodes);
             if (tmp != 0)
                 ret = -1;
         } else if (IS_RELAXNG(nodes, "include")) {
             tmp = xmlRelaxNGParseInclude(ctxt, nodes);
             if (tmp != 0)
                 ret = -1;
         } else {
             xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_CONTENT,
                        "grammar has unexpected child %s\n", nodes->name,
                        NULL);
             ret = -1;
         }
         nodes = nodes->next;
     }
     return (ret);
 }

 /**
  * xmlRelaxNGCheckReference:
  * @ref:  the ref
  * @ctxt:  a Relax-NG parser context
  * @name:  the name associated to the defines
  *
  * Applies the 4.17. combine attribute rule for all the define
  * element of a given grammar using the same name.
  */
 static void
 xmlRelaxNGCheckReference(xmlRelaxNGDefinePtr ref,
                          xmlRelaxNGParserCtxtPtr ctxt,
                          const xmlChar * name)
 {
     xmlRelaxNGGrammarPtr grammar;
     xmlRelaxNGDefinePtr def, cur;

     grammar = ctxt->grammar;
     if (grammar == NULL) {
         xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
                    "Internal error: no grammar in CheckReference %s\n",
                    name, NULL);
         return;
     }
     if (ref->content != NULL) {
         xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
                    "Internal error: reference has content in CheckReference %s\n",
                    name, NULL);
         return;
     }
     if (grammar->defs != NULL) {
         def = xmlHashLookup(grammar->defs, name);
         if (def != NULL) {
             cur = ref;
             while (cur != NULL) {
                 cur->content = def;
                 cur = cur->nextHash;
             }
         } else {
             xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
                        "Reference %s has no matching definition\n", name,
                        NULL);
         }
     } else {
         xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
                    "Reference %s has no matching definition\n", name,
                    NULL);
     }
 }

 /**
  * xmlRelaxNGCheckCombine:
  * @define:  the define(s) list
  * @ctxt:  a Relax-NG parser context
  * @name:  the name associated to the defines
  *
  * Applies the 4.17. combine attribute rule for all the define
  * element of a given grammar using the same name.
  */
 static void
 xmlRelaxNGCheckCombine(xmlRelaxNGDefinePtr define,
                        xmlRelaxNGParserCtxtPtr ctxt, const xmlChar * name)
 {
     xmlChar *combine;
     int choiceOrInterleave = -1;
     int missing = 0;
     xmlRelaxNGDefinePtr cur, last, tmp, tmp2;

     if (define->nextHash == NULL)
         return;
     cur = define;
     while (cur != NULL) {
         combine = xmlGetProp(cur->node, BAD_CAST "combine");
         if (combine != NULL) {
             if (xmlStrEqual(combine, BAD_CAST "choice")) {
                 if (choiceOrInterleave == -1)
                     choiceOrInterleave = 1;
                 else if (choiceOrInterleave == 0) {
                     xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
                                "Defines for %s use both 'choice' and 'interleave'\n",
                                name, NULL);
                 }
             } else if (xmlStrEqual(combine, BAD_CAST "interleave")) {
                 if (choiceOrInterleave == -1)
                     choiceOrInterleave = 0;
                 else if (choiceOrInterleave == 1) {
                     xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
                                "Defines for %s use both 'choice' and 'interleave'\n",
                                name, NULL);
                 }
             } else {
                 xmlRngPErr(ctxt, define->node, XML_RNGP_UNKNOWN_COMBINE,
                            "Defines for %s use unknown combine value '%s''\n",
                            name, combine);
             }
             xmlFree(combine);
         } else {
             if (missing == 0)
                 missing = 1;
             else {
                 xmlRngPErr(ctxt, define->node, XML_RNGP_NEED_COMBINE,
                            "Some defines for %s needs the combine attribute\n",
                            name, NULL);
             }
         }

         cur = cur->nextHash;
     }
 #ifdef DEBUG
     xmlGenericError(xmlGenericErrorContext,
                     "xmlRelaxNGCheckCombine(): merging %s defines: %d\n",
                     name, choiceOrInterleave);
 #endif
     if (choiceOrInterleave == -1)
         choiceOrInterleave = 0;
     cur = xmlRelaxNGNewDefine(ctxt, define->node);
     if (cur == NULL)
         return;
     if (choiceOrInterleave == 0)
         cur->type = XML_RELAXNG_INTERLEAVE;
     else
         cur->type = XML_RELAXNG_CHOICE;
     tmp = define;
     last = NULL;
     while (tmp != NULL) {
         if (tmp->content != NULL) {
             if (tmp->content->next != NULL) {
                 /*
                  * we need first to create a wrapper.
                  */
                 tmp2 = xmlRelaxNGNewDefine(ctxt, tmp->content->node);
                 if (tmp2 == NULL)
                     break;
                 tmp2->type = XML_RELAXNG_GROUP;
                 tmp2->content = tmp->content;
             } else {
                 tmp2 = tmp->content;
             }
             if (last == NULL) {
                 cur->content = tmp2;
             } else {
                 last->next = tmp2;
             }
             last = tmp2;
         }
         tmp->content = cur;
         tmp = tmp->nextHash;
     }
     define->content = cur;
     if (choiceOrInterleave == 0) {
         if (ctxt->interleaves == NULL)
             ctxt->interleaves = xmlHashCreate(10);
         if (ctxt->interleaves == NULL) {
             xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
                        "Failed to create interleaves hash table\n", NULL,
                        NULL);
         } else {
             char tmpname[32];

             snprintf(tmpname, 32, "interleave%d", ctxt->nbInterleaves++);
             if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST tmpname, cur) <
                 0) {
                 xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
                            "Failed to add %s to hash table\n",
 			   (const xmlChar *) tmpname, NULL);
             }
         }
     }
 }

 /**
  * xmlRelaxNGCombineStart:
  * @ctxt:  a Relax-NG parser context
  * @grammar:  the grammar
  *
  * Applies the 4.17. combine rule for all the start
  * element of a given grammar.
  */
 static void
 xmlRelaxNGCombineStart(xmlRelaxNGParserCtxtPtr ctxt,
                        xmlRelaxNGGrammarPtr grammar)
 {
     xmlRelaxNGDefinePtr starts;
     xmlChar *combine;
     int choiceOrInterleave = -1;
     int missing = 0;
     xmlRelaxNGDefinePtr cur;

     starts = grammar->start;
     if ((starts == NULL) || (starts->next == NULL))
         return;
     cur = starts;
     while (cur != NULL) {
         if ((cur->node == NULL) || (cur->node->parent == NULL) ||
             (!xmlStrEqual(cur->node->parent->name, BAD_CAST "start"))) {
             combine = NULL;
             xmlRngPErr(ctxt, cur->node, XML_RNGP_START_MISSING,
                        "Internal error: start element not found\n", NULL,
                        NULL);
         } else {
             combine = xmlGetProp(cur->node->parent, BAD_CAST "combine");
         }

         if (combine != NULL) {
             if (xmlStrEqual(combine, BAD_CAST "choice")) {
                 if (choiceOrInterleave == -1)
                     choiceOrInterleave = 1;
                 else if (choiceOrInterleave == 0) {
                     xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
                                "<start> use both 'choice' and 'interleave'\n",
                                NULL, NULL);
                 }
             } else if (xmlStrEqual(combine, BAD_CAST "interleave")) {
                 if (choiceOrInterleave == -1)
                     choiceOrInterleave = 0;
                 else if (choiceOrInterleave == 1) {
                     xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
                                "<start> use both 'choice' and 'interleave'\n",
                                NULL, NULL);
                 }
             } else {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_UNKNOWN_COMBINE,
                            "<start> uses unknown combine value '%s''\n",
                            combine, NULL);
             }
             xmlFree(combine);
         } else {
             if (missing == 0)
                 missing = 1;
             else {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_NEED_COMBINE,
                            "Some <start> element miss the combine attribute\n",
                            NULL, NULL);
             }
         }

         cur = cur->next;
     }
 #ifdef DEBUG
     xmlGenericError(xmlGenericErrorContext,
                     "xmlRelaxNGCombineStart(): merging <start>: %d\n",
                     choiceOrInterleave);
 #endif
     if (choiceOrInterleave == -1)
         choiceOrInterleave = 0;
     cur = xmlRelaxNGNewDefine(ctxt, starts->node);
     if (cur == NULL)
         return;
     if (choiceOrInterleave == 0)
         cur->type = XML_RELAXNG_INTERLEAVE;
     else
         cur->type = XML_RELAXNG_CHOICE;
     cur->content = grammar->start;
     grammar->start = cur;
     if (choiceOrInterleave == 0) {
         if (ctxt->interleaves == NULL)
             ctxt->interleaves = xmlHashCreate(10);
         if (ctxt->interleaves == NULL) {
             xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
                        "Failed to create interleaves hash table\n", NULL,
                        NULL);
         } else {
             char tmpname[32];

             snprintf(tmpname, 32, "interleave%d", ctxt->nbInterleaves++);
             if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST tmpname, cur) <
                 0) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
                            "Failed to add %s to hash table\n",
 			   (const xmlChar *) tmpname, NULL);
             }
         }
     }
 }

 /**
  * xmlRelaxNGCheckCycles:
  * @ctxt:  a Relax-NG parser context
  * @nodes:  grammar children nodes
  * @depth:  the counter
  *
  * Check for cycles.
  *
  * Returns 0 if check passed, and -1 in case of error
  */
 static int
 xmlRelaxNGCheckCycles(xmlRelaxNGParserCtxtPtr ctxt,
                       xmlRelaxNGDefinePtr cur, int depth)
 {
     int ret = 0;

     while ((ret == 0) && (cur != NULL)) {
         if ((cur->type == XML_RELAXNG_REF) ||
             (cur->type == XML_RELAXNG_PARENTREF)) {
             if (cur->depth == -1) {
                 cur->depth = depth;
                 ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth);
                 cur->depth = -2;
             } else if (depth == cur->depth) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_CYCLE,
                            "Detected a cycle in %s references\n",
                            cur->name, NULL);
                 return (-1);
             }
         } else if (cur->type == XML_RELAXNG_ELEMENT) {
             ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth + 1);
         } else {
             ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth);
         }
         cur = cur->next;
     }
     return (ret);
 }

 /**
  * xmlRelaxNGTryUnlink:
  * @ctxt:  a Relax-NG parser context
  * @cur:  the definition to unlink
  * @parent:  the parent definition
  * @prev:  the previous sibling definition
  *
  * Try to unlink a definition. If not possble make it a NOOP
  *
  * Returns the new prev definition
  */
 static xmlRelaxNGDefinePtr
 xmlRelaxNGTryUnlink(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
                     xmlRelaxNGDefinePtr cur,
                     xmlRelaxNGDefinePtr parent, xmlRelaxNGDefinePtr prev)
 {
     if (prev != NULL) {
         prev->next = cur->next;
     } else {
         if (parent != NULL) {
             if (parent->content == cur)
                 parent->content = cur->next;
             else if (parent->attrs == cur)
                 parent->attrs = cur->next;
             else if (parent->nameClass == cur)
                 parent->nameClass = cur->next;
         } else {
             cur->type = XML_RELAXNG_NOOP;
             prev = cur;
         }
     }
     return (prev);
 }

 /**
  * xmlRelaxNGSimplify:
  * @ctxt:  a Relax-NG parser context
  * @nodes:  grammar children nodes
  *
  * Check for simplification of empty and notAllowed
  */
 static void
 xmlRelaxNGSimplify(xmlRelaxNGParserCtxtPtr ctxt,
                    xmlRelaxNGDefinePtr cur, xmlRelaxNGDefinePtr parent)
 {
     xmlRelaxNGDefinePtr prev = NULL;

     while (cur != NULL) {
         if ((cur->type == XML_RELAXNG_REF) ||
             (cur->type == XML_RELAXNG_PARENTREF)) {
             if (cur->depth != -3) {
                 cur->depth = -3;
                 xmlRelaxNGSimplify(ctxt, cur->content, cur);
             }
         } else if (cur->type == XML_RELAXNG_NOT_ALLOWED) {
             cur->parent = parent;
             if ((parent != NULL) &&
                 ((parent->type == XML_RELAXNG_ATTRIBUTE) ||
                  (parent->type == XML_RELAXNG_LIST) ||
                  (parent->type == XML_RELAXNG_GROUP) ||
                  (parent->type == XML_RELAXNG_INTERLEAVE) ||
                  (parent->type == XML_RELAXNG_ONEORMORE) ||
                  (parent->type == XML_RELAXNG_ZEROORMORE))) {
                 parent->type = XML_RELAXNG_NOT_ALLOWED;
                 break;
             }
             if ((parent != NULL) && (parent->type == XML_RELAXNG_CHOICE)) {
                 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
             } else
                 prev = cur;
         } else if (cur->type == XML_RELAXNG_EMPTY) {
             cur->parent = parent;
             if ((parent != NULL) &&
                 ((parent->type == XML_RELAXNG_ONEORMORE) ||
                  (parent->type == XML_RELAXNG_ZEROORMORE))) {
                 parent->type = XML_RELAXNG_EMPTY;
                 break;
             }
             if ((parent != NULL) &&
                 ((parent->type == XML_RELAXNG_GROUP) ||
                  (parent->type == XML_RELAXNG_INTERLEAVE))) {
                 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
             } else
                 prev = cur;
         } else {
             cur->parent = parent;
             if (cur->content != NULL)
                 xmlRelaxNGSimplify(ctxt, cur->content, cur);
             if ((cur->type != XML_RELAXNG_VALUE) && (cur->attrs != NULL))
                 xmlRelaxNGSimplify(ctxt, cur->attrs, cur);
             if (cur->nameClass != NULL)
                 xmlRelaxNGSimplify(ctxt, cur->nameClass, cur);
             /*
              * On Elements, try to move attribute only generating rules on
              * the attrs rules.
              */
             if (cur->type == XML_RELAXNG_ELEMENT) {
                 int attronly;
                 xmlRelaxNGDefinePtr tmp, pre;

                 while (cur->content != NULL) {
                     attronly =
                         xmlRelaxNGGenerateAttributes(ctxt, cur->content);
                     if (attronly == 1) {
                         /*
                          * migrate cur->content to attrs
                          */
                         tmp = cur->content;
                         cur->content = tmp->next;
                         tmp->next = cur->attrs;
                         cur->attrs = tmp;
                     } else {
                         /*
                          * cur->content can generate elements or text
                          */
                         break;
                     }
                 }
                 pre = cur->content;
                 while ((pre != NULL) && (pre->next != NULL)) {
                     tmp = pre->next;
                     attronly = xmlRelaxNGGenerateAttributes(ctxt, tmp);
                     if (attronly == 1) {
                         /*
                          * migrate tmp to attrs
                          */
                         pre->next = tmp->next;
                         tmp->next = cur->attrs;
                         cur->attrs = tmp;
                     } else {
                         pre = tmp;
                     }
                 }
             }
             /*
              * This may result in a simplification
              */
             if ((cur->type == XML_RELAXNG_GROUP) ||
                 (cur->type == XML_RELAXNG_INTERLEAVE)) {
                 if (cur->content == NULL)
                     cur->type = XML_RELAXNG_EMPTY;
                 else if (cur->content->next == NULL) {
                     if ((parent == NULL) && (prev == NULL)) {
                         cur->type = XML_RELAXNG_NOOP;
                     } else if (prev == NULL) {
                         parent->content = cur->content;
                         cur->content->next = cur->next;
                         cur = cur->content;
                     } else {
                         cur->content->next = cur->next;
                         prev->next = cur->content;
                         cur = cur->content;
                     }
                 }
             }
             /*
              * the current node may have been transformed back
              */
             if ((cur->type == XML_RELAXNG_EXCEPT) &&
                 (cur->content != NULL) &&
                 (cur->content->type == XML_RELAXNG_NOT_ALLOWED)) {
                 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
             } else if (cur->type == XML_RELAXNG_NOT_ALLOWED) {
                 if ((parent != NULL) &&
                     ((parent->type == XML_RELAXNG_ATTRIBUTE) ||
                      (parent->type == XML_RELAXNG_LIST) ||
                      (parent->type == XML_RELAXNG_GROUP) ||
                      (parent->type == XML_RELAXNG_INTERLEAVE) ||
                      (parent->type == XML_RELAXNG_ONEORMORE) ||
                      (parent->type == XML_RELAXNG_ZEROORMORE))) {
                     parent->type = XML_RELAXNG_NOT_ALLOWED;
                     break;
                 }
                 if ((parent != NULL) &&
                     (parent->type == XML_RELAXNG_CHOICE)) {
                     prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
                 } else
                     prev = cur;
             } else if (cur->type == XML_RELAXNG_EMPTY) {
                 if ((parent != NULL) &&
                     ((parent->type == XML_RELAXNG_ONEORMORE) ||
                      (parent->type == XML_RELAXNG_ZEROORMORE))) {
                     parent->type = XML_RELAXNG_EMPTY;
                     break;
                 }
                 if ((parent != NULL) &&
                     ((parent->type == XML_RELAXNG_GROUP) ||
                      (parent->type == XML_RELAXNG_INTERLEAVE) ||
                      (parent->type == XML_RELAXNG_CHOICE))) {
                     prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
                 } else
                     prev = cur;
             } else {
                 prev = cur;
             }
         }
         cur = cur->next;
     }
 }

 /**
  * xmlRelaxNGGroupContentType:
  * @ct1:  the first content type
  * @ct2:  the second content type
  *
  * Try to group 2 content types
  *
  * Returns the content type
  */
 static xmlRelaxNGContentType
 xmlRelaxNGGroupContentType(xmlRelaxNGContentType ct1,
                            xmlRelaxNGContentType ct2)
 {
     if ((ct1 == XML_RELAXNG_CONTENT_ERROR) ||
         (ct2 == XML_RELAXNG_CONTENT_ERROR))
         return (XML_RELAXNG_CONTENT_ERROR);
     if (ct1 == XML_RELAXNG_CONTENT_EMPTY)
         return (ct2);
     if (ct2 == XML_RELAXNG_CONTENT_EMPTY)
         return (ct1);
     if ((ct1 == XML_RELAXNG_CONTENT_COMPLEX) &&
         (ct2 == XML_RELAXNG_CONTENT_COMPLEX))
         return (XML_RELAXNG_CONTENT_COMPLEX);
     return (XML_RELAXNG_CONTENT_ERROR);
 }

 /**
  * xmlRelaxNGMaxContentType:
  * @ct1:  the first content type
  * @ct2:  the second content type
  *
  * Compute the max content-type
  *
  * Returns the content type
  */
 static xmlRelaxNGContentType
 xmlRelaxNGMaxContentType(xmlRelaxNGContentType ct1,
                          xmlRelaxNGContentType ct2)
 {
     if ((ct1 == XML_RELAXNG_CONTENT_ERROR) ||
         (ct2 == XML_RELAXNG_CONTENT_ERROR))
         return (XML_RELAXNG_CONTENT_ERROR);
     if ((ct1 == XML_RELAXNG_CONTENT_SIMPLE) ||
         (ct2 == XML_RELAXNG_CONTENT_SIMPLE))
         return (XML_RELAXNG_CONTENT_SIMPLE);
     if ((ct1 == XML_RELAXNG_CONTENT_COMPLEX) ||
         (ct2 == XML_RELAXNG_CONTENT_COMPLEX))
         return (XML_RELAXNG_CONTENT_COMPLEX);
     return (XML_RELAXNG_CONTENT_EMPTY);
 }

 /**
  * xmlRelaxNGCheckRules:
  * @ctxt:  a Relax-NG parser context
  * @cur:  the current definition
  * @flags:  some accumulated flags
  * @ptype:  the parent type
  *
  * Check for rules in section 7.1 and 7.2
  *
  * Returns the content type of @cur
  */
 static xmlRelaxNGContentType
 xmlRelaxNGCheckRules(xmlRelaxNGParserCtxtPtr ctxt,
                      xmlRelaxNGDefinePtr cur, int flags,
                      xmlRelaxNGType ptype)
 {
     int nflags = flags;
     xmlRelaxNGContentType ret, tmp, val = XML_RELAXNG_CONTENT_EMPTY;

     while (cur != NULL) {
         ret = XML_RELAXNG_CONTENT_EMPTY;
         if ((cur->type == XML_RELAXNG_REF) ||
             (cur->type == XML_RELAXNG_PARENTREF)) {
            /*
             * This should actually be caught by list//element(ref) at the
             * element boundaries, c.f. Bug #159968 local refs are dropped
             * in step 4.19.
             */
 #if 0
             if (flags & XML_RELAXNG_IN_LIST) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_REF,
                            "Found forbidden pattern list//ref\n", NULL,
                            NULL);
             }
 #endif
             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_REF,
                            "Found forbidden pattern data/except//ref\n",
                            NULL, NULL);
             }
             if (cur->depth > -4) {
                 cur->depth = -4;
                 ret = xmlRelaxNGCheckRules(ctxt, cur->content,
                                            flags, cur->type);
                 cur->depth = ret - 15;
             } else if (cur->depth == -4) {
                 ret = XML_RELAXNG_CONTENT_COMPLEX;
             } else {
                 ret = (xmlRelaxNGContentType) (cur->depth + 15);
             }
         } else if (cur->type == XML_RELAXNG_ELEMENT) {
             /*
              * The 7.3 Attribute derivation rule for groups is plugged there
              */
             xmlRelaxNGCheckGroupAttrs(ctxt, cur);
             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ELEM,
                            "Found forbidden pattern data/except//element(ref)\n",
                            NULL, NULL);
             }
             if (flags & XML_RELAXNG_IN_LIST) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ELEM,
                            "Found forbidden pattern list//element(ref)\n",
                            NULL, NULL);
             }
             if (flags & XML_RELAXNG_IN_ATTRIBUTE) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM,
                            "Found forbidden pattern attribute//element(ref)\n",
                            NULL, NULL);
             }
             if (flags & XML_RELAXNG_IN_ATTRIBUTE) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM,
                            "Found forbidden pattern attribute//element(ref)\n",
                            NULL, NULL);
             }
             /*
              * reset since in the simple form elements are only child
              * of grammar/define
              */
             nflags = 0;
             ret =
                 xmlRelaxNGCheckRules(ctxt, cur->attrs, nflags, cur->type);
             if (ret != XML_RELAXNG_CONTENT_EMPTY) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_EMPTY,
                            "Element %s attributes have a content type error\n",
                            cur->name, NULL);
             }
             ret =
                 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
                                      cur->type);
             if (ret == XML_RELAXNG_CONTENT_ERROR) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_ERROR,
                            "Element %s has a content type error\n",
                            cur->name, NULL);
             } else {
                 ret = XML_RELAXNG_CONTENT_COMPLEX;
             }
         } else if (cur->type == XML_RELAXNG_ATTRIBUTE) {
             if (flags & XML_RELAXNG_IN_ATTRIBUTE) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ATTR,
                            "Found forbidden pattern attribute//attribute\n",
                            NULL, NULL);
             }
             if (flags & XML_RELAXNG_IN_LIST) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ATTR,
                            "Found forbidden pattern list//attribute\n",
                            NULL, NULL);
             }
             if (flags & XML_RELAXNG_IN_OOMGROUP) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_GROUP_ATTR,
                            "Found forbidden pattern oneOrMore//group//attribute\n",
                            NULL, NULL);
             }
             if (flags & XML_RELAXNG_IN_OOMINTERLEAVE) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR,
                            "Found forbidden pattern oneOrMore//interleave//attribute\n",
                            NULL, NULL);
             }
             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ATTR,
                            "Found forbidden pattern data/except//attribute\n",
                            NULL, NULL);
             }
             if (flags & XML_RELAXNG_IN_START) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ATTR,
                            "Found forbidden pattern start//attribute\n",
                            NULL, NULL);
             }
             if ((!(flags & XML_RELAXNG_IN_ONEORMORE))
                 && (cur->name == NULL)) {
                 if (cur->ns == NULL) {
                     xmlRngPErr(ctxt, cur->node, XML_RNGP_ANYNAME_ATTR_ANCESTOR,
                                "Found anyName attribute without oneOrMore ancestor\n",
                                NULL, NULL);
                 } else {
                     xmlRngPErr(ctxt, cur->node, XML_RNGP_NSNAME_ATTR_ANCESTOR,
                                "Found nsName attribute without oneOrMore ancestor\n",
                                NULL, NULL);
                 }
             }
             nflags = flags | XML_RELAXNG_IN_ATTRIBUTE;
             xmlRelaxNGCheckRules(ctxt, cur->content, nflags, cur->type);
             ret = XML_RELAXNG_CONTENT_EMPTY;
         } else if ((cur->type == XML_RELAXNG_ONEORMORE) ||
                    (cur->type == XML_RELAXNG_ZEROORMORE)) {
             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ONEMORE,
                            "Found forbidden pattern data/except//oneOrMore\n",
                            NULL, NULL);
             }
             if (flags & XML_RELAXNG_IN_START) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ONEMORE,
                            "Found forbidden pattern start//oneOrMore\n",
                            NULL, NULL);
             }
             nflags = flags | XML_RELAXNG_IN_ONEORMORE;
             ret =
                 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
                                      cur->type);
             ret = xmlRelaxNGGroupContentType(ret, ret);
         } else if (cur->type == XML_RELAXNG_LIST) {
             if (flags & XML_RELAXNG_IN_LIST) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_LIST,
                            "Found forbidden pattern list//list\n", NULL,
                            NULL);
             }
             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_LIST,
                            "Found forbidden pattern data/except//list\n",
                            NULL, NULL);
             }
             if (flags & XML_RELAXNG_IN_START) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_LIST,
                            "Found forbidden pattern start//list\n", NULL,
                            NULL);
             }
             nflags = flags | XML_RELAXNG_IN_LIST;
             ret =
                 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
                                      cur->type);
         } else if (cur->type == XML_RELAXNG_GROUP) {
             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_GROUP,
                            "Found forbidden pattern data/except//group\n",
                            NULL, NULL);
             }
             if (flags & XML_RELAXNG_IN_START) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_GROUP,
                            "Found forbidden pattern start//group\n", NULL,
                            NULL);
             }
             if (flags & XML_RELAXNG_IN_ONEORMORE)
                 nflags = flags | XML_RELAXNG_IN_OOMGROUP;
             else
                 nflags = flags;
             ret =
                 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
                                      cur->type);
             /*
              * The 7.3 Attribute derivation rule for groups is plugged there
              */
             xmlRelaxNGCheckGroupAttrs(ctxt, cur);
         } else if (cur->type == XML_RELAXNG_INTERLEAVE) {
             if (flags & XML_RELAXNG_IN_LIST) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_INTERLEAVE,
                            "Found forbidden pattern list//interleave\n",
                            NULL, NULL);
             }
             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
                            "Found forbidden pattern data/except//interleave\n",
                            NULL, NULL);
             }
             if (flags & XML_RELAXNG_IN_START) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
                            "Found forbidden pattern start//interleave\n",
                            NULL, NULL);
             }
             if (flags & XML_RELAXNG_IN_ONEORMORE)
                 nflags = flags | XML_RELAXNG_IN_OOMINTERLEAVE;
             else
                 nflags = flags;
             ret =
                 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
                                      cur->type);
         } else if (cur->type == XML_RELAXNG_EXCEPT) {
             if ((cur->parent != NULL) &&
                 (cur->parent->type == XML_RELAXNG_DATATYPE))
                 nflags = flags | XML_RELAXNG_IN_DATAEXCEPT;
             else
                 nflags = flags;
             ret =
                 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
                                      cur->type);
         } else if (cur->type == XML_RELAXNG_DATATYPE) {
             if (flags & XML_RELAXNG_IN_START) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_DATA,
                            "Found forbidden pattern start//data\n", NULL,
                            NULL);
             }
             xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
             ret = XML_RELAXNG_CONTENT_SIMPLE;
         } else if (cur->type == XML_RELAXNG_VALUE) {
             if (flags & XML_RELAXNG_IN_START) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_VALUE,
                            "Found forbidden pattern start//value\n", NULL,
                            NULL);
             }
             xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
             ret = XML_RELAXNG_CONTENT_SIMPLE;
         } else if (cur->type == XML_RELAXNG_TEXT) {
             if (flags & XML_RELAXNG_IN_LIST) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_TEXT,
                            "Found forbidden pattern list//text\n", NULL,
                            NULL);
             }
             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_TEXT,
                            "Found forbidden pattern data/except//text\n",
                            NULL, NULL);
             }
             if (flags & XML_RELAXNG_IN_START) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_TEXT,
                            "Found forbidden pattern start//text\n", NULL,
                            NULL);
             }
             ret = XML_RELAXNG_CONTENT_COMPLEX;
         } else if (cur->type == XML_RELAXNG_EMPTY) {
             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_EMPTY,
                            "Found forbidden pattern data/except//empty\n",
                            NULL, NULL);
             }
             if (flags & XML_RELAXNG_IN_START) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_EMPTY,
                            "Found forbidden pattern start//empty\n", NULL,
                            NULL);
             }
             ret = XML_RELAXNG_CONTENT_EMPTY;
         } else if (cur->type == XML_RELAXNG_CHOICE) {
             xmlRelaxNGCheckChoiceDeterminism(ctxt, cur);
             ret =
                 xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
         } else {
             ret =
                 xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
         }
         cur = cur->next;
         if (ptype == XML_RELAXNG_GROUP) {
             val = xmlRelaxNGGroupContentType(val, ret);
         } else if (ptype == XML_RELAXNG_INTERLEAVE) {
             tmp = xmlRelaxNGGroupContentType(val, ret);
             if (tmp != XML_RELAXNG_CONTENT_ERROR)
                 tmp = xmlRelaxNGMaxContentType(val, ret);
         } else if (ptype == XML_RELAXNG_CHOICE) {
             val = xmlRelaxNGMaxContentType(val, ret);
         } else if (ptype == XML_RELAXNG_LIST) {
             val = XML_RELAXNG_CONTENT_SIMPLE;
         } else if (ptype == XML_RELAXNG_EXCEPT) {
             if (ret == XML_RELAXNG_CONTENT_ERROR)
                 val = XML_RELAXNG_CONTENT_ERROR;
             else
                 val = XML_RELAXNG_CONTENT_SIMPLE;
         } else {
             val = xmlRelaxNGGroupContentType(val, ret);
         }

     }
     return (val);
 }

 /**
  * xmlRelaxNGParseGrammar:
  * @ctxt:  a Relax-NG parser context
  * @nodes:  grammar children nodes
  *
  * parse a Relax-NG <grammar> node
  *
  * Returns the internal xmlRelaxNGGrammarPtr built or
  *         NULL in case of error
  */
 static xmlRelaxNGGrammarPtr
 xmlRelaxNGParseGrammar(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes)
 {
     xmlRelaxNGGrammarPtr ret, tmp, old;

 #ifdef DEBUG_GRAMMAR
     xmlGenericError(xmlGenericErrorContext, "Parsing a new grammar\n");
 #endif

     ret = xmlRelaxNGNewGrammar(ctxt);
     if (ret == NULL)
         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 {
             while (tmp->next != NULL)
                 tmp = tmp->next;
             tmp->next = ret;
         }
     }

     old = ctxt->grammar;
     ctxt->grammar = ret;
     xmlRelaxNGParseGrammarContent(ctxt, nodes);
     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
      */
     xmlRelaxNGCombineStart(ctxt, ret);
     if (ret->defs != NULL) {
         xmlHashScan(ret->defs, (xmlHashScanner) xmlRelaxNGCheckCombine,
                     ctxt);
     }

     /*
      * link together defines and refs in this grammar
      */
     if (ret->refs != NULL) {
         xmlHashScan(ret->refs, (xmlHashScanner) xmlRelaxNGCheckReference,
                     ctxt);
     }

     ctxt->grammar = old;
     return (ret);
 }

 /**
  * xmlRelaxNGParseDocument:
  * @ctxt:  a Relax-NG parser context
  * @node:  the root node of the RelaxNG schema
  *
  * parse a Relax-NG definition resource and build an internal
  * xmlRelaxNG struture which can be used to validate instances.
  *
  * Returns the internal XML RelaxNG structure built or
  *         NULL in case of error
  */
 static xmlRelaxNGPtr
 xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
 {
     xmlRelaxNGPtr schema = NULL;
     const xmlChar *olddefine;
     xmlRelaxNGGrammarPtr old;

     if ((ctxt == NULL) || (node == NULL))
         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);
     } else {
         xmlRelaxNGGrammarPtr tmp, ret;

         schema->topgrammar = ret = xmlRelaxNGNewGrammar(ctxt);
         if (schema->topgrammar == NULL) {
             return (schema);
         }
         /*
          * 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 {
                 while (tmp->next != NULL)
                     tmp = tmp->next;
                 tmp->next = ret;
             }
         }
         old = ctxt->grammar;
         ctxt->grammar = ret;
         xmlRelaxNGParseStart(ctxt, node);
         if (old != NULL)
             ctxt->grammar = old;
     }
     ctxt->define = olddefine;
     if (schema->topgrammar->start != NULL) {
         xmlRelaxNGCheckCycles(ctxt, schema->topgrammar->start, 0);
         if ((ctxt->flags & XML_RELAXNG_IN_EXTERNALREF) == 0) {
             xmlRelaxNGSimplify(ctxt, schema->topgrammar->start, NULL);
             while ((schema->topgrammar->start != NULL) &&
                    (schema->topgrammar->start->type == XML_RELAXNG_NOOP) &&
                    (schema->topgrammar->start->next != NULL))
                 schema->topgrammar->start =
                     schema->topgrammar->start->content;
             xmlRelaxNGCheckRules(ctxt, schema->topgrammar->start,
                                  XML_RELAXNG_IN_START, XML_RELAXNG_NOOP);
         }
     }
 #ifdef DEBUG
     if (schema == NULL)
         xmlGenericError(xmlGenericErrorContext,
                         "xmlRelaxNGParseDocument() failed\n");
 #endif

     return (schema);
 }

 /************************************************************************
  * 									*
  * 			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
  */
 xmlRelaxNGParserCtxtPtr
 xmlRelaxNGNewParserCtxt(const char *URL)
 {
     xmlRelaxNGParserCtxtPtr ret;

     if (URL == NULL)
         return (NULL);

     ret =
         (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
     if (ret == NULL) {
         xmlRngPErrMemory(NULL, "building parser\n");
         return (NULL);
     }
     memset(ret, 0, sizeof(xmlRelaxNGParserCtxt));
     ret->URL = xmlStrdup((const xmlChar *) URL);
     ret->error = xmlGenericError;
     ret->userData = xmlGenericErrorContext;
     return (ret);
 }

 /**
  * xmlRelaxNGNewMemParserCtxt:
  * @buffer:  a pointer to a char array containing the schemas
  * @size:  the size of the array
  *
  * Create an XML RelaxNGs parse context for that memory buffer expected
  * to contain an XML RelaxNGs file.
  *
  * Returns the parser context or NULL in case of error
  */
 xmlRelaxNGParserCtxtPtr
 xmlRelaxNGNewMemParserCtxt(const char *buffer, int size)
 {
     xmlRelaxNGParserCtxtPtr ret;

     if ((buffer == NULL) || (size <= 0))
         return (NULL);

     ret =
         (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
     if (ret == NULL) {
         xmlRngPErrMemory(NULL, "building parser\n");
         return (NULL);
     }
     memset(ret, 0, sizeof(xmlRelaxNGParserCtxt));
     ret->buffer = buffer;
     ret->size = size;
     ret->error = xmlGenericError;
     ret->userData = xmlGenericErrorContext;
     return (ret);
 }

 /**
  * xmlRelaxNGNewDocParserCtxt:
  * @doc:  a preparsed document tree
  *
  * Create an XML RelaxNGs parser context for that document.
  * Note: since the process of compiling a RelaxNG schemas modifies the
  *       document, the @doc parameter is duplicated internally.
  *
  * Returns the parser context or NULL in case of error
  */
 xmlRelaxNGParserCtxtPtr
 xmlRelaxNGNewDocParserCtxt(xmlDocPtr doc)
 {
     xmlRelaxNGParserCtxtPtr ret;
     xmlDocPtr copy;

     if (doc == NULL)
         return (NULL);
     copy = xmlCopyDoc(doc, 1);
     if (copy == NULL)
         return (NULL);

     ret =
         (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
     if (ret == NULL) {
         xmlRngPErrMemory(NULL, "building parser\n");
         return (NULL);
     }
     memset(ret, 0, sizeof(xmlRelaxNGParserCtxt));
     ret->document = copy;
     ret->freedoc = 1;
     ret->userData = xmlGenericErrorContext;
     return (ret);
 }

 /**
  * xmlRelaxNGFreeParserCtxt:
  * @ctxt:  the schema parser context
  *
  * Free the resources associated to the schema parser context
  */
 void
 xmlRelaxNGFreeParserCtxt(xmlRelaxNGParserCtxtPtr ctxt)
 {
     if (ctxt == NULL)
         return;
     if (ctxt->URL != NULL)
         xmlFree(ctxt->URL);
     if (ctxt->doc != NULL)
         xmlRelaxNGFreeDocument(ctxt->doc);
     if (ctxt->interleaves != NULL)
         xmlHashFree(ctxt->interleaves, NULL);
     if (ctxt->documents != NULL)
         xmlRelaxNGFreeDocumentList(ctxt->documents);
     if (ctxt->includes != NULL)
         xmlRelaxNGFreeIncludeList(ctxt->includes);
     if (ctxt->docTab != NULL)
         xmlFree(ctxt->docTab);
     if (ctxt->incTab != NULL)
         xmlFree(ctxt->incTab);
     if (ctxt->defTab != NULL) {
         int i;

         for (i = 0; i < ctxt->defNr; i++)
             xmlRelaxNGFreeDefine(ctxt->defTab[i]);
         xmlFree(ctxt->defTab);
     }
     if ((ctxt->document != NULL) && (ctxt->freedoc))
         xmlFreeDoc(ctxt->document);
     xmlFree(ctxt);
 }

 /**
  * xmlRelaxNGNormExtSpace:
  * @value:  a value
  *
  * Removes the leading and ending spaces of the value
  * The string is modified "in situ"
  */
 static void
 xmlRelaxNGNormExtSpace(xmlChar * value)
 {
     xmlChar *start = value;
     xmlChar *cur = value;

     if (value == NULL)
         return;

     while (IS_BLANK_CH(*cur))
         cur++;
     if (cur == start) {
         do {
             while ((*cur != 0) && (!IS_BLANK_CH(*cur)))
                 cur++;
             if (*cur == 0)
                 return;
             start = cur;
             while (IS_BLANK_CH(*cur))
                 cur++;
             if (*cur == 0) {
                 *start = 0;
                 return;
             }
         } while (1);
     } else {
         do {
             while ((*cur != 0) && (!IS_BLANK_CH(*cur)))
                 *start++ = *cur++;
             if (*cur == 0) {
                 *start = 0;
                 return;
             }
             /* don't try to normalize the inner spaces */
             while (IS_BLANK_CH(*cur))
                 cur++;
             if (*cur == 0) {
                 *start = 0;
                 return;
             }
             *start++ = *cur++;
         } while (1);
     }
 }

 /**
  * xmlRelaxNGCleanupAttributes:
  * @ctxt:  a Relax-NG parser context
  * @node:  a Relax-NG node
  *
  * Check all the attributes on the given node
  */
 static void
 xmlRelaxNGCleanupAttributes(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
 {
     xmlAttrPtr cur, next;

     cur = node->properties;
     while (cur != NULL) {
         next = cur->next;
         if ((cur->ns == NULL) ||
             (xmlStrEqual(cur->ns->href, xmlRelaxNGNs))) {
             if (xmlStrEqual(cur->name, BAD_CAST "name")) {
                 if ((!xmlStrEqual(node->name, BAD_CAST "element")) &&
                     (!xmlStrEqual(node->name, BAD_CAST "attribute")) &&
                     (!xmlStrEqual(node->name, BAD_CAST "ref")) &&
                     (!xmlStrEqual(node->name, BAD_CAST "parentRef")) &&
                     (!xmlStrEqual(node->name, BAD_CAST "param")) &&
                     (!xmlStrEqual(node->name, BAD_CAST "define"))) {
                     xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
                                "Attribute %s is not allowed on %s\n",
                                cur->name, node->name);
                 }
             } else if (xmlStrEqual(cur->name, BAD_CAST "type")) {
                 if ((!xmlStrEqual(node->name, BAD_CAST "value")) &&
                     (!xmlStrEqual(node->name, BAD_CAST "data"))) {
                     xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
                                "Attribute %s is not allowed on %s\n",
                                cur->name, node->name);
                 }
             } else if (xmlStrEqual(cur->name, BAD_CAST "href")) {
                 if ((!xmlStrEqual(node->name, BAD_CAST "externalRef")) &&
                     (!xmlStrEqual(node->name, BAD_CAST "include"))) {
                     xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
                                "Attribute %s is not allowed on %s\n",
                                cur->name, node->name);
                 }
             } else if (xmlStrEqual(cur->name, BAD_CAST "combine")) {
                 if ((!xmlStrEqual(node->name, BAD_CAST "start")) &&
                     (!xmlStrEqual(node->name, BAD_CAST "define"))) {
                     xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
                                "Attribute %s is not allowed on %s\n",
                                cur->name, node->name);
                 }
             } else if (xmlStrEqual(cur->name, BAD_CAST "datatypeLibrary")) {
                 xmlChar *val;
                 xmlURIPtr uri;

                 val = xmlNodeListGetString(node->doc, cur->children, 1);
                 if (val != NULL) {
                     if (val[0] != 0) {
                         uri = xmlParseURI((const char *) val);
                         if (uri == NULL) {
                             xmlRngPErr(ctxt, node, XML_RNGP_INVALID_URI,
                                        "Attribute %s contains invalid URI %s\n",
                                        cur->name, val);
                         } else {
                             if (uri->scheme == NULL) {
                                 xmlRngPErr(ctxt, node, XML_RNGP_URI_NOT_ABSOLUTE,
                                            "Attribute %s URI %s is not absolute\n",
                                            cur->name, val);
                             }
                             if (uri->fragment != NULL) {
                                 xmlRngPErr(ctxt, node, XML_RNGP_URI_FRAGMENT,
                                            "Attribute %s URI %s has a fragment ID\n",
                                            cur->name, val);
                             }
                             xmlFreeURI(uri);
                         }
                     }
                     xmlFree(val);
                 }
             } else if (!xmlStrEqual(cur->name, BAD_CAST "ns")) {
                 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_ATTRIBUTE,
                            "Unknown attribute %s on %s\n", cur->name,
                            node->name);
             }
         }
         cur = next;
     }
 }

 /**
  * xmlRelaxNGCleanupTree:
  * @ctxt:  a Relax-NG parser context
  * @root:  an xmlNodePtr subtree
  *
  * Cleanup the subtree from unwanted nodes for parsing, resolve
  * Include and externalRef lookups.
  */
 static void
 xmlRelaxNGCleanupTree(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr root)
 {
     xmlNodePtr cur, delete;

     delete = NULL;
     cur = root;
     while (cur != NULL) {
         if (delete != NULL) {
             xmlUnlinkNode(delete);
             xmlFreeNode(delete);
             delete = NULL;
         }
         if (cur->type == XML_ELEMENT_NODE) {
             /*
              * Simplification 4.1. Annotations
              */
             if ((cur->ns == NULL) ||
                 (!xmlStrEqual(cur->ns->href, xmlRelaxNGNs))) {
                 if ((cur->parent != NULL) &&
                     (cur->parent->type == XML_ELEMENT_NODE) &&
                     ((xmlStrEqual(cur->parent->name, BAD_CAST "name")) ||
                      (xmlStrEqual(cur->parent->name, BAD_CAST "value")) ||
                      (xmlStrEqual(cur->parent->name, BAD_CAST "param")))) {
                     xmlRngPErr(ctxt, cur, XML_RNGP_FOREIGN_ELEMENT,
                                "element %s doesn't allow foreign elements\n",
                                cur->parent->name, NULL);
                 }
                 delete = cur;
                 goto skip_children;
             } else {
                 xmlRelaxNGCleanupAttributes(ctxt, cur);
                 if (xmlStrEqual(cur->name, BAD_CAST "externalRef")) {
                     xmlChar *href, *ns, *base, *URL;
                     xmlRelaxNGDocumentPtr docu;
                     xmlNodePtr tmp;
 		    xmlURIPtr uri;

                     ns = xmlGetProp(cur, BAD_CAST "ns");
                     if (ns == NULL) {
                         tmp = cur->parent;
                         while ((tmp != NULL) &&
                                (tmp->type == XML_ELEMENT_NODE)) {
                             ns = xmlGetProp(tmp, BAD_CAST "ns");
                             if (ns != NULL)
                                 break;
                             tmp = tmp->parent;
                         }
                     }
                     href = xmlGetProp(cur, BAD_CAST "href");
                     if (href == NULL) {
                         xmlRngPErr(ctxt, cur, XML_RNGP_MISSING_HREF,
                                    "xmlRelaxNGParse: externalRef has no href attribute\n",
                                    NULL, NULL);
                         if (ns != NULL)
                             xmlFree(ns);
                         delete = cur;
                         goto skip_children;
                     }
 		    uri = xmlParseURI((const char *) href);
 		    if (uri == NULL) {
                         xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
                                    "Incorrect URI for externalRef %s\n",
                                    href, NULL);
                         if (ns != NULL)
                             xmlFree(ns);
                         if (href != NULL)
                             xmlFree(href);
                         delete = cur;
                         goto skip_children;
 		    }
 		    if (uri->fragment != NULL) {
                         xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
 			       "Fragment forbidden in URI for externalRef %s\n",
                                    href, NULL);
                         if (ns != NULL)
                             xmlFree(ns);
 		        xmlFreeURI(uri);
                         if (href != NULL)
                             xmlFree(href);
                         delete = cur;
                         goto skip_children;
 		    }
 		    xmlFreeURI(uri);
                     base = xmlNodeGetBase(cur->doc, cur);
                     URL = xmlBuildURI(href, base);
                     if (URL == NULL) {
                         xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
                                    "Failed to compute URL for externalRef %s\n",
                                    href, NULL);
                         if (ns != NULL)
                             xmlFree(ns);
                         if (href != NULL)
                             xmlFree(href);
                         if (base != NULL)
                             xmlFree(base);
                         delete = cur;
                         goto skip_children;
                     }
                     if (href != NULL)
                         xmlFree(href);
                     if (base != NULL)
                         xmlFree(base);
                     docu = xmlRelaxNGLoadExternalRef(ctxt, URL, ns);
                     if (docu == NULL) {
                         xmlRngPErr(ctxt, cur, XML_RNGP_EXTERNAL_REF_FAILURE,
                                    "Failed to load externalRef %s\n", URL,
                                    NULL);
                         if (ns != NULL)
                             xmlFree(ns);
                         xmlFree(URL);
                         delete = cur;
                         goto skip_children;
                     }
                     if (ns != NULL)
                         xmlFree(ns);
                     xmlFree(URL);
                     cur->psvi = docu;
                 } else if (xmlStrEqual(cur->name, BAD_CAST "include")) {
                     xmlChar *href, *ns, *base, *URL;
                     xmlRelaxNGIncludePtr incl;
                     xmlNodePtr tmp;

                     href = xmlGetProp(cur, BAD_CAST "href");
                     if (href == NULL) {
                         xmlRngPErr(ctxt, cur, XML_RNGP_MISSING_HREF,
                                    "xmlRelaxNGParse: include has no href attribute\n",
                                    NULL, NULL);
                         delete = cur;
                         goto skip_children;
                     }
                     base = xmlNodeGetBase(cur->doc, cur);
                     URL = xmlBuildURI(href, base);
                     if (URL == NULL) {
                         xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
                                    "Failed to compute URL for include %s\n",
                                    href, NULL);
                         if (href != NULL)
                             xmlFree(href);
                         if (base != NULL)
                             xmlFree(base);
                         delete = cur;
                         goto skip_children;
                     }
                     if (href != NULL)
                         xmlFree(href);
                     if (base != NULL)
                         xmlFree(base);
                     ns = xmlGetProp(cur, BAD_CAST "ns");
                     if (ns == NULL) {
                         tmp = cur->parent;
                         while ((tmp != NULL) &&
                                (tmp->type == XML_ELEMENT_NODE)) {
                             ns = xmlGetProp(tmp, BAD_CAST "ns");
                             if (ns != NULL)
                                 break;
                             tmp = tmp->parent;
                         }
                     }
                     incl = xmlRelaxNGLoadInclude(ctxt, URL, cur, ns);
                     if (ns != NULL)
                         xmlFree(ns);
                     if (incl == NULL) {
                         xmlRngPErr(ctxt, cur, XML_RNGP_INCLUDE_FAILURE,
                                    "Failed to load include %s\n", URL,
                                    NULL);
                         xmlFree(URL);
                         delete = cur;
                         goto skip_children;
                     }
                     xmlFree(URL);
                     cur->psvi = incl;
                 } else if ((xmlStrEqual(cur->name, BAD_CAST "element")) ||
                            (xmlStrEqual(cur->name, BAD_CAST "attribute")))
                 {
                     xmlChar *name, *ns;
                     xmlNodePtr text = NULL;

                     /*
                      * Simplification 4.8. name attribute of element
                      * and attribute elements
                      */
                     name = xmlGetProp(cur, BAD_CAST "name");
                     if (name != NULL) {
                         if (cur->children == NULL) {
                             text =
                                 xmlNewChild(cur, cur->ns, BAD_CAST "name",
                                             name);
                         } else {
                             xmlNodePtr node;

                             node = xmlNewDocNode(cur->doc, cur->ns,
 			                         BAD_CAST "name", NULL);
                             if (node != NULL) {
                                 xmlAddPrevSibling(cur->children, node);
                                 text = xmlNewText(name);
                                 xmlAddChild(node, text);
                                 text = node;
                             }
                         }
                         if (text == NULL) {
                             xmlRngPErr(ctxt, cur, XML_RNGP_CREATE_FAILURE,
                                        "Failed to create a name %s element\n",
                                        name, NULL);
                         }
                         xmlUnsetProp(cur, BAD_CAST "name");
                         xmlFree(name);
                         ns = xmlGetProp(cur, BAD_CAST "ns");
                         if (ns != NULL) {
                             if (text != NULL) {
                                 xmlSetProp(text, BAD_CAST "ns", ns);
                                 /* xmlUnsetProp(cur, BAD_CAST "ns"); */
                             }
                             xmlFree(ns);
                         } else if (xmlStrEqual(cur->name,
                                                BAD_CAST "attribute")) {
                             xmlSetProp(text, BAD_CAST "ns", BAD_CAST "");
                         }
                     }
                 } else if ((xmlStrEqual(cur->name, BAD_CAST "name")) ||
                            (xmlStrEqual(cur->name, BAD_CAST "nsName")) ||
                            (xmlStrEqual(cur->name, BAD_CAST "value"))) {
                     /*
                      * Simplification 4.8. name attribute of element
                      * and attribute elements
                      */
                     if (xmlHasProp(cur, BAD_CAST "ns") == NULL) {
                         xmlNodePtr node;
                         xmlChar *ns = NULL;

                         node = cur->parent;
                         while ((node != NULL) &&
                                (node->type == XML_ELEMENT_NODE)) {
                             ns = xmlGetProp(node, BAD_CAST "ns");
                             if (ns != NULL) {
                                 break;
                             }
                             node = node->parent;
                         }
                         if (ns == NULL) {
                             xmlSetProp(cur, BAD_CAST "ns", BAD_CAST "");
                         } else {
                             xmlSetProp(cur, BAD_CAST "ns", ns);
                             xmlFree(ns);
                         }
                     }
                     if (xmlStrEqual(cur->name, BAD_CAST "name")) {
                         xmlChar *name, *local, *prefix;

                         /*
                          * Simplification: 4.10. QNames
                          */
                         name = xmlNodeGetContent(cur);
                         if (name != NULL) {
                             local = xmlSplitQName2(name, &prefix);
                             if (local != NULL) {
                                 xmlNsPtr ns;

                                 ns = xmlSearchNs(cur->doc, cur, prefix);
                                 if (ns == NULL) {
                                     xmlRngPErr(ctxt, cur,
                                                XML_RNGP_PREFIX_UNDEFINED,
                                                "xmlRelaxNGParse: no namespace for prefix %s\n",
                                                prefix, NULL);
                                 } else {
                                     xmlSetProp(cur, BAD_CAST "ns",
                                                ns->href);
                                     xmlNodeSetContent(cur, local);
                                 }
                                 xmlFree(local);
                                 xmlFree(prefix);
                             }
                             xmlFree(name);
                         }
                     }
                     /*
                      * 4.16
                      */
                     if (xmlStrEqual(cur->name, BAD_CAST "nsName")) {
                         if (ctxt->flags & XML_RELAXNG_IN_NSEXCEPT) {
                             xmlRngPErr(ctxt, cur,
                                        XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME,
                                        "Found nsName/except//nsName forbidden construct\n",
                                        NULL, NULL);
                         }
                     }
                 } else if ((xmlStrEqual(cur->name, BAD_CAST "except")) &&
                            (cur != root)) {
                     int oldflags = ctxt->flags;

                     /*
                      * 4.16
                      */
                     if ((cur->parent != NULL) &&
                         (xmlStrEqual
                          (cur->parent->name, BAD_CAST "anyName"))) {
                         ctxt->flags |= XML_RELAXNG_IN_ANYEXCEPT;
                         xmlRelaxNGCleanupTree(ctxt, cur);
                         ctxt->flags = oldflags;
                         goto skip_children;
                     } else if ((cur->parent != NULL) &&
                                (xmlStrEqual
                                 (cur->parent->name, BAD_CAST "nsName"))) {
                         ctxt->flags |= XML_RELAXNG_IN_NSEXCEPT;
                         xmlRelaxNGCleanupTree(ctxt, cur);
                         ctxt->flags = oldflags;
                         goto skip_children;
                     }
                 } else if (xmlStrEqual(cur->name, BAD_CAST "anyName")) {
                     /*
                      * 4.16
                      */
                     if (ctxt->flags & XML_RELAXNG_IN_ANYEXCEPT) {
                         xmlRngPErr(ctxt, cur,
                                    XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME,
                                    "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
                  * 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
 		     * 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) {
 			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 ((!xmlStrEqual(cur->parent->name, BAD_CAST "value"))
                         &&
                         (!xmlStrEqual
                          (cur->parent->name, BAD_CAST "param")))
                         delete = cur;
                 } else {
                     delete = cur;
                     goto skip_children;
                 }
             }
         } else {
             delete = cur;
             goto skip_children;
         }

         /*
          * Skip to next node
          */
         if (cur->children != NULL) {
             if ((cur->children->type != XML_ENTITY_DECL) &&
                 (cur->children->type != XML_ENTITY_REF_NODE) &&
                 (cur->children->type != XML_ENTITY_NODE)) {
                 cur = cur->children;
                 continue;
             }
         }
       skip_children:
         if (cur->next != NULL) {
             cur = cur->next;
             continue;
         }

         do {
             cur = cur->parent;
             if (cur == NULL)
                 break;
             if (cur == root) {
                 cur = NULL;
                 break;
             }
             if (cur->next != NULL) {
                 cur = cur->next;
                 break;
             }
         } while (cur != NULL);
     }
     if (delete != NULL) {
         xmlUnlinkNode(delete);
         xmlFreeNode(delete);
         delete = NULL;
     }
 }

 /**
  * xmlRelaxNGCleanupDoc:
  * @ctxt:  a Relax-NG parser context
  * @doc:  an xmldocPtr document pointer
  *
  * Cleanup the document from unwanted nodes for parsing, resolve
  * Include and externalRef lookups.
  *
  * Returns the cleaned up document or NULL in case of error
  */
 static xmlDocPtr
 xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt, xmlDocPtr doc)
 {
     xmlNodePtr root;

     /*
      * Extract the root
      */
     root = xmlDocGetRootElement(doc);
     if (root == NULL) {
         xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_RNGP_EMPTY, "xmlRelaxNGParse: %s is empty\n",
                    ctxt->URL, NULL);
         return (NULL);
     }
     xmlRelaxNGCleanupTree(ctxt, root);
     return (doc);
 }

 /**
  * xmlRelaxNGParse:
  * @ctxt:  a Relax-NG parser context
  *
  * parse a schema definition resource and build an internal
  * XML Shema struture which can be used to validate instances.
  * *WARNING* this interface is highly subject to change
  *
  * Returns the internal XML RelaxNG structure built from the resource or
  *         NULL in case of error
  */
 xmlRelaxNGPtr
 xmlRelaxNGParse(xmlRelaxNGParserCtxtPtr ctxt)
 {
     xmlRelaxNGPtr ret = NULL;
     xmlDocPtr doc;
     xmlNodePtr root;

     xmlRelaxNGInitTypes();

     if (ctxt == NULL)
         return (NULL);

     /*
      * First step is to parse the input document into an DOM/Infoset
      */
     if (ctxt->URL != NULL) {
         doc = xmlReadFile((const char *) ctxt->URL,NULL,0);
         if (doc == NULL) {
             xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
                        "xmlRelaxNGParse: could not load %s\n", ctxt->URL,
                        NULL);
             return (NULL);
         }
     } else if (ctxt->buffer != NULL) {
         doc = xmlReadMemory(ctxt->buffer, ctxt->size,NULL,NULL,0);
         if (doc == NULL) {
             xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
                        "xmlRelaxNGParse: could not parse schemas\n", NULL,
                        NULL);
             return (NULL);
         }
         doc->URL = xmlStrdup(BAD_CAST "in_memory_buffer");
         ctxt->URL = xmlStrdup(BAD_CAST "in_memory_buffer");
     } else if (ctxt->document != NULL) {
         doc = ctxt->document;
     } else {
         xmlRngPErr(ctxt, NULL, XML_RNGP_EMPTY,
                    "xmlRelaxNGParse: nothing to parse\n", NULL, NULL);
         return (NULL);
     }
     ctxt->document = doc;

     /*
      * Some preprocessing of the document content
      */
     doc = xmlRelaxNGCleanupDoc(ctxt, doc);
     if (doc == NULL) {
         xmlFreeDoc(ctxt->document);
         ctxt->document = NULL;
         return (NULL);
     }

     /*
      * 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, NULL);
         xmlFreeDoc(doc);
         return (NULL);
     }
     ret = xmlRelaxNGParseDocument(ctxt, root);
     if (ret == NULL) {
         xmlFreeDoc(doc);
         return (NULL);
     }

     /*
      * Check the ref/defines links
      */
     /*
      * try to preprocess interleaves
      */
     if (ctxt->interleaves != NULL) {
         xmlHashScan(ctxt->interleaves,
                     (xmlHashScanner) xmlRelaxNGComputeInterleaves, ctxt);
     }

     /*
      * if there was a parsing error return NULL
      */
     if (ctxt->nbErrors > 0) {
         xmlRelaxNGFree(ret);
         ctxt->document = NULL;
         xmlFreeDoc(doc);
         return (NULL);
     }

     /*
      * try to compile (parts of) the schemas
      */
     if ((ret->topgrammar != NULL) && (ret->topgrammar->start != NULL)) {
         if (ret->topgrammar->start->type != XML_RELAXNG_START) {
             xmlRelaxNGDefinePtr def;

             def = xmlRelaxNGNewDefine(ctxt, NULL);
             if (def != NULL) {
                 def->type = XML_RELAXNG_START;
                 def->content = ret->topgrammar->start;
                 ret->topgrammar->start = def;
             }
         }
         xmlRelaxNGTryCompile(ctxt, ret->topgrammar->start);
     }

     /*
      * Transfer the pointer for cleanup at the schema level.
      */
     ret->doc = doc;
     ctxt->document = NULL;
     ret->documents = ctxt->documents;
     ctxt->documents = NULL;

     ret->includes = ctxt->includes;
     ctxt->includes = NULL;
     ret->defNr = ctxt->defNr;
     ret->defTab = ctxt->defTab;
     ctxt->defTab = NULL;
     if (ctxt->idref == 1)
         ret->idref = 1;

     return (ret);
 }

 /**
  * xmlRelaxNGSetParserErrors:
  * @ctxt:  a Relax-NG validation context
  * @err:  the error callback
  * @warn:  the warning callback
  * @ctx:  contextual data for the callbacks
  *
  * Set the callback functions used to handle errors for a validation context
  */
 void
 xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
                           xmlRelaxNGValidityErrorFunc err,
                           xmlRelaxNGValidityWarningFunc warn, void *ctx)
 {
     if (ctxt == NULL)
         return;
     ctxt->error = err;
     ctxt->warning = warn;
     ctxt->serror = NULL;
     ctxt->userData = ctx;
 }

 /**
  * xmlRelaxNGGetParserErrors:
  * @ctxt:  a Relax-NG validation context
  * @err:  the error callback result
  * @warn:  the warning callback result
  * @ctx:  contextual data for the callbacks result
  *
  * Get the callback information used to handle errors for a validation context
  *
  * Returns -1 in case of failure, 0 otherwise.
  */
 int
 xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
                           xmlRelaxNGValidityErrorFunc * err,
                           xmlRelaxNGValidityWarningFunc * warn, void **ctx)
 {
     if (ctxt == NULL)
         return (-1);
     if (err != NULL)
         *err = ctxt->error;
     if (warn != NULL)
         *warn = ctxt->warning;
     if (ctx != NULL)
         *ctx = ctxt->userData;
     return (0);
 }

 #ifdef LIBXML_OUTPUT_ENABLED

 /************************************************************************
  * 									*
  * 			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
  */
 static void
 xmlRelaxNGDumpDefines(FILE * output, xmlRelaxNGDefinePtr defines)
 {
     while (defines != NULL) {
         xmlRelaxNGDumpDefine(output, defines);
         defines = defines->next;
     }
 }

 /**
  * xmlRelaxNGDumpDefine:
  * @output:  the file output
  * @define:  a define structure
  *
  * Dump a RelaxNG structure back
  */
 static void
 xmlRelaxNGDumpDefine(FILE * output, xmlRelaxNGDefinePtr define)
 {
     if (define == NULL)
         return;
     switch (define->type) {
         case XML_RELAXNG_EMPTY:
             fprintf(output, "<empty/>\n");
             break;
         case XML_RELAXNG_NOT_ALLOWED:
             fprintf(output, "<notAllowed/>\n");
             break;
         case XML_RELAXNG_TEXT:
             fprintf(output, "<text/>\n");
             break;
         case XML_RELAXNG_ELEMENT:
             fprintf(output, "<element>\n");
             if (define->name != NULL) {
                 fprintf(output, "<name");
                 if (define->ns != NULL)
                     fprintf(output, " ns=\"%s\"", define->ns);
                 fprintf(output, ">%s</name>\n", define->name);
             }
             xmlRelaxNGDumpDefines(output, define->attrs);
             xmlRelaxNGDumpDefines(output, define->content);
             fprintf(output, "</element>\n");
             break;
         case XML_RELAXNG_LIST:
             fprintf(output, "<list>\n");
             xmlRelaxNGDumpDefines(output, define->content);
             fprintf(output, "</list>\n");
             break;
         case XML_RELAXNG_ONEORMORE:
             fprintf(output, "<oneOrMore>\n");
             xmlRelaxNGDumpDefines(output, define->content);
             fprintf(output, "</oneOrMore>\n");
             break;
         case XML_RELAXNG_ZEROORMORE:
             fprintf(output, "<zeroOrMore>\n");
             xmlRelaxNGDumpDefines(output, define->content);
             fprintf(output, "</zeroOrMore>\n");
             break;
         case XML_RELAXNG_CHOICE:
             fprintf(output, "<choice>\n");
             xmlRelaxNGDumpDefines(output, define->content);
             fprintf(output, "</choice>\n");
             break;
         case XML_RELAXNG_GROUP:
             fprintf(output, "<group>\n");
             xmlRelaxNGDumpDefines(output, define->content);
             fprintf(output, "</group>\n");
             break;
         case XML_RELAXNG_INTERLEAVE:
             fprintf(output, "<interleave>\n");
             xmlRelaxNGDumpDefines(output, define->content);
             fprintf(output, "</interleave>\n");
             break;
         case XML_RELAXNG_OPTIONAL:
             fprintf(output, "<optional>\n");
             xmlRelaxNGDumpDefines(output, define->content);
             fprintf(output, "</optional>\n");
             break;
         case XML_RELAXNG_ATTRIBUTE:
             fprintf(output, "<attribute>\n");
             xmlRelaxNGDumpDefines(output, define->content);
             fprintf(output, "</attribute>\n");
             break;
         case XML_RELAXNG_DEF:
             fprintf(output, "<define");
             if (define->name != NULL)
                 fprintf(output, " name=\"%s\"", define->name);
             fprintf(output, ">\n");
             xmlRelaxNGDumpDefines(output, define->content);
             fprintf(output, "</define>\n");
             break;
         case XML_RELAXNG_REF:
             fprintf(output, "<ref");
             if (define->name != NULL)
                 fprintf(output, " name=\"%s\"", define->name);
             fprintf(output, ">\n");
             xmlRelaxNGDumpDefines(output, define->content);
             fprintf(output, "</ref>\n");
             break;
         case XML_RELAXNG_PARENTREF:
             fprintf(output, "<parentRef");
             if (define->name != NULL)
                 fprintf(output, " name=\"%s\"", define->name);
             fprintf(output, ">\n");
             xmlRelaxNGDumpDefines(output, define->content);
             fprintf(output, "</parentRef>\n");
             break;
         case XML_RELAXNG_EXTERNALREF:
             fprintf(output, "<externalRef>");
             xmlRelaxNGDumpDefines(output, define->content);
             fprintf(output, "</externalRef>\n");
             break;
         case XML_RELAXNG_DATATYPE:
         case XML_RELAXNG_VALUE:
             TODO break;
         case XML_RELAXNG_START:
         case XML_RELAXNG_EXCEPT:
         case XML_RELAXNG_PARAM:
             TODO break;
         case XML_RELAXNG_NOOP:
             xmlRelaxNGDumpDefines(output, define->content);
             break;
     }
 }

 /**
  * xmlRelaxNGDumpGrammar:
  * @output:  the file output
  * @grammar:  a grammar structure
  * @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");
     if (top)
         fprintf(output, " xmlns=\"http://relaxng.org/ns/structure/1.0\"");
     switch (grammar->combine) {
         case XML_RELAXNG_COMBINE_UNDEFINED:
             break;
         case XML_RELAXNG_COMBINE_CHOICE:
             fprintf(output, " combine=\"choice\"");
             break;
         case XML_RELAXNG_COMBINE_INTERLEAVE:
             fprintf(output, " combine=\"interleave\"");
             break;
         default:
             fprintf(output, " <!-- invalid combine value -->");
     }
     fprintf(output, ">\n");
     if (grammar->start == NULL) {
         fprintf(output, " <!-- grammar had no start -->");
     } else {
         fprintf(output, "<start>\n");
         xmlRelaxNGDumpDefine(output, grammar->start);
         fprintf(output, "</start>\n");
     }
     /* TODO ? Dump the defines ? */
     fprintf(output, "</grammar>\n");
 }

 /**
  * xmlRelaxNGDump:
  * @output:  the file output
  * @schema:  a schema structure
  *
  * Dump a RelaxNG structure back
  */
 void
 xmlRelaxNGDump(FILE * output, xmlRelaxNGPtr schema)
 {
     if (output == NULL)
         return;
     if (schema == NULL) {
         fprintf(output, "RelaxNG empty or failed to compile\n");
         return;
     }
     fprintf(output, "RelaxNG: ");
     if (schema->doc == NULL) {
         fprintf(output, "no document\n");
     } else if (schema->doc->URL != NULL) {
         fprintf(output, "%s\n", schema->doc->URL);
     } else {
         fprintf(output, "\n");
     }
     if (schema->topgrammar == NULL) {
         fprintf(output, "RelaxNG has no top grammar\n");
         return;
     }
     xmlRelaxNGDumpGrammar(output, schema->topgrammar, 1);
 }

 /**
  * xmlRelaxNGDumpTree:
  * @output:  the file output
  * @schema:  a schema structure
  *
  * Dump the transformed RelaxNG tree.
  */
 void
 xmlRelaxNGDumpTree(FILE * output, xmlRelaxNGPtr schema)
 {
     if (output == NULL)
         return;
     if (schema == NULL) {
         fprintf(output, "RelaxNG empty or failed to compile\n");
         return;
     }
     if (schema->doc == NULL) {
         fprintf(output, "no document\n");
     } else {
         xmlDocDump(output, schema->doc);
     }
 }
 #endif /* LIBXML_OUTPUT_ENABLED */

 /************************************************************************
  * 									*
  * 		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
  *
  * Handle the callback and if needed validate the element children.
  */
 static void
 xmlRelaxNGValidateCompiledCallback(xmlRegExecCtxtPtr exec ATTRIBUTE_UNUSED,
                                    const xmlChar * token,
                                    void *transdata, void *inputdata)
 {
     xmlRelaxNGValidCtxtPtr ctxt = (xmlRelaxNGValidCtxtPtr) inputdata;
     xmlRelaxNGDefinePtr define = (xmlRelaxNGDefinePtr) transdata;
     int ret;

 #ifdef DEBUG_COMPILE
     xmlGenericError(xmlGenericErrorContext,
                     "Compiled callback for: '%s'\n", token);
 #endif
     if (ctxt == NULL) {
         fprintf(stderr, "callback on %s missing context\n", token);
         if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
             ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
         return;
     }
     if (define == NULL) {
         if (token[0] == '#')
             return;
         fprintf(stderr, "callback on %s missing define\n", token);
         if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
             ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
         return;
     }
     if ((ctxt == NULL) || (define == NULL)) {
         fprintf(stderr, "callback on %s missing info\n", token);
         if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
             ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
         return;
     } else if (define->type != XML_RELAXNG_ELEMENT) {
         fprintf(stderr, "callback on %s define is not element\n", token);
         if (ctxt->errNo == XML_RELAXNG_OK)
             ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
         return;
     }
     ret = xmlRelaxNGValidateDefinition(ctxt, define);
     if (ret != 0)
         ctxt->perr = ret;
 }

 /**
  * xmlRelaxNGValidateCompiledContent:
  * @ctxt:  the RelaxNG validation context
  * @regexp:  the regular expression as compiled
  * @content:  list of children to test against the regexp
  *
  * Validate the content model of an element or start using the regexp
  *
  * Returns 0 in case of success, -1 in case of error.
  */
 static int
 xmlRelaxNGValidateCompiledContent(xmlRelaxNGValidCtxtPtr ctxt,
                                   xmlRegexpPtr regexp, xmlNodePtr content)
 {
     xmlRegExecCtxtPtr exec;
     xmlNodePtr cur;
     int ret = 0;
     int oldperr = ctxt->perr;

     if ((ctxt == NULL) || (regexp == NULL))
         return (-1);
     exec = xmlRegNewExecCtxt(regexp,
                              xmlRelaxNGValidateCompiledCallback, ctxt);
     ctxt->perr = 0;
     cur = content;
     while (cur != NULL) {
         ctxt->state->seq = cur;
         switch (cur->type) {
             case XML_TEXT_NODE:
             case XML_CDATA_SECTION_NODE:
                 if (xmlIsBlankNode(cur))
                     break;
                 ret = xmlRegExecPushString(exec, BAD_CAST "#text", ctxt);
                 if (ret < 0) {
                     VALID_ERR2(XML_RELAXNG_ERR_TEXTWRONG,
                                cur->parent->name);
                 }
                 break;
             case XML_ELEMENT_NODE:
                 if (cur->ns != NULL) {
                     ret = xmlRegExecPushString2(exec, cur->name,
                                                 cur->ns->href, ctxt);
                 } else {
                     ret = xmlRegExecPushString(exec, cur->name, ctxt);
                 }
                 if (ret < 0) {
                     VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, cur->name);
                 }
                 break;
             default:
                 break;
         }
         if (ret < 0)
             break;
         /*
          * Switch to next element
          */
         cur = cur->next;
     }
     ret = xmlRegExecPushString(exec, NULL, NULL);
     if (ret == 1) {
         ret = 0;
         ctxt->state->seq = NULL;
     } else if (ret == 0) {
         /*
          * TODO: get some of the names needed to exit the current state of exec
          */
         VALID_ERR2(XML_RELAXNG_ERR_NOELEM, BAD_CAST "");
         ret = -1;
         if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
             xmlRelaxNGDumpValidError(ctxt);
     } else {
         ret = -1;
     }
     xmlRegFreeExecCtxt(exec);
     /*
      * There might be content model errors outside of the pure
      * 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			*
  * 									*
  ************************************************************************/
 static int xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
                                            xmlRelaxNGDefinePtr defines);
 static int xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt,
                                         int dolog);
 static void xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt);

 /**
  * xmlRelaxNGElemPush:
  * @ctxt:  the validation context
  * @exec:  the regexp runtime for the new content model
  *
  * Push a new regexp for the current node content model on the stack
  *
  * Returns 0 in case of success and -1 in case of error.
  */
 static int
 xmlRelaxNGElemPush(xmlRelaxNGValidCtxtPtr ctxt, xmlRegExecCtxtPtr exec)
 {
     if (ctxt->elemTab == NULL) {
         ctxt->elemMax = 10;
         ctxt->elemTab = (xmlRegExecCtxtPtr *) xmlMalloc(ctxt->elemMax *
                                                         sizeof
                                                         (xmlRegExecCtxtPtr));
         if (ctxt->elemTab == NULL) {
             xmlRngVErrMemory(ctxt, "validating\n");
             return (-1);
         }
     }
     if (ctxt->elemNr >= ctxt->elemMax) {
         ctxt->elemMax *= 2;
         ctxt->elemTab = (xmlRegExecCtxtPtr *) xmlRealloc(ctxt->elemTab,
                                                          ctxt->elemMax *
                                                          sizeof
                                                          (xmlRegExecCtxtPtr));
         if (ctxt->elemTab == NULL) {
             xmlRngVErrMemory(ctxt, "validating\n");
             return (-1);
         }
     }
     ctxt->elemTab[ctxt->elemNr++] = exec;
     ctxt->elem = exec;
     return (0);
 }

 /**
  * xmlRelaxNGElemPop:
  * @ctxt:  the validation context
  *
  * Pop the regexp of the current node content model from the stack
  *
  * Returns the exec or NULL if empty
  */
 static xmlRegExecCtxtPtr
 xmlRelaxNGElemPop(xmlRelaxNGValidCtxtPtr ctxt)
 {
     xmlRegExecCtxtPtr ret;

     if (ctxt->elemNr <= 0)
         return (NULL);
     ctxt->elemNr--;
     ret = ctxt->elemTab[ctxt->elemNr];
     ctxt->elemTab[ctxt->elemNr] = NULL;
     if (ctxt->elemNr > 0)
         ctxt->elem = ctxt->elemTab[ctxt->elemNr - 1];
     else
         ctxt->elem = NULL;
     return (ret);
 }

 /**
  * xmlRelaxNGValidateProgressiveCallback:
  * @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
  *
  * Handle the callback and if needed validate the element children.
  * some of the in/out informations are passed via the context in @inputdata.
  */
 static void
 xmlRelaxNGValidateProgressiveCallback(xmlRegExecCtxtPtr exec
                                       ATTRIBUTE_UNUSED,
                                       const xmlChar * token,
                                       void *transdata, void *inputdata)
 {
     xmlRelaxNGValidCtxtPtr ctxt = (xmlRelaxNGValidCtxtPtr) inputdata;
     xmlRelaxNGDefinePtr define = (xmlRelaxNGDefinePtr) transdata;
     xmlRelaxNGValidStatePtr state, oldstate;
     xmlNodePtr node = ctxt->pnode;
     int ret = 0, oldflags;

 #ifdef DEBUG_PROGRESSIVE
     xmlGenericError(xmlGenericErrorContext,
                     "Progressive callback for: '%s'\n", token);
 #endif
     if (ctxt == NULL) {
         fprintf(stderr, "callback on %s missing context\n", token);
         return;
     }
     ctxt->pstate = 1;
     if (define == NULL) {
         if (token[0] == '#')
             return;
         fprintf(stderr, "callback on %s missing define\n", token);
         if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
             ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
         ctxt->pstate = -1;
         return;
     }
     if ((ctxt == NULL) || (define == NULL)) {
         fprintf(stderr, "callback on %s missing info\n", token);
         if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
             ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
         ctxt->pstate = -1;
         return;
     } else if (define->type != XML_RELAXNG_ELEMENT) {
         fprintf(stderr, "callback on %s define is not element\n", token);
         if (ctxt->errNo == XML_RELAXNG_OK)
             ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
         ctxt->pstate = -1;
         return;
     }
     if (node->type != XML_ELEMENT_NODE) {
         VALID_ERR(XML_RELAXNG_ERR_NOTELEM);
         if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
             xmlRelaxNGDumpValidError(ctxt);
         ctxt->pstate = -1;
         return;
     }
     if (define->contModel == NULL) {
         /*
          * this node cannot be validated in a streamable fashion
          */
 #ifdef DEBUG_PROGRESSIVE
         xmlGenericError(xmlGenericErrorContext,
                         "Element '%s' validation is not streamable\n",
                         token);
 #endif
         ctxt->pstate = 0;
         ctxt->pdef = define;
         return;
     }
     exec = xmlRegNewExecCtxt(define->contModel,
                              xmlRelaxNGValidateProgressiveCallback, ctxt);
     if (exec == NULL) {
         ctxt->pstate = -1;
         return;
     }
     xmlRelaxNGElemPush(ctxt, exec);

     /*
      * Validate the attributes part of the content.
      */
     state = xmlRelaxNGNewValidState(ctxt, node);
     if (state == NULL) {
         ctxt->pstate = -1;
         return;
     }
     oldstate = ctxt->state;
     ctxt->state = state;
     if (define->attrs != NULL) {
         ret = xmlRelaxNGValidateAttributeList(ctxt, define->attrs);
         if (ret != 0) {
             ctxt->pstate = -1;
             VALID_ERR2(XML_RELAXNG_ERR_ATTRVALID, node->name);
         }
     }
     if (ctxt->state != NULL) {
         ctxt->state->seq = NULL;
         ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
         if (ret != 0) {
             ctxt->pstate = -1;
         }
         xmlRelaxNGFreeValidState(ctxt, ctxt->state);
     } else if (ctxt->states != NULL) {
         int tmp = -1, i;

         oldflags = ctxt->flags;

         for (i = 0; i < ctxt->states->nbState; i++) {
             state = ctxt->states->tabState[i];
             ctxt->state = state;
             ctxt->state->seq = NULL;

             if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
                 tmp = 0;
                 break;
             }
         }
         if (tmp != 0) {
             /*
              * validation error, log the message for the "best" one
              */
             ctxt->flags |= FLAGS_IGNORABLE;
             xmlRelaxNGLogBestError(ctxt);
         }
         for (i = 0; i < ctxt->states->nbState; i++) {
             xmlRelaxNGFreeValidState(ctxt, ctxt->states->tabState[i]);
         }
         xmlRelaxNGFreeStates(ctxt, ctxt->states);
         ctxt->states = NULL;
         if ((ret == 0) && (tmp == -1))
             ctxt->pstate = -1;
         ctxt->flags = oldflags;
     }
     if (ctxt->pstate == -1) {
         if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
             xmlRelaxNGDumpValidError(ctxt);
         }
     }
     ctxt->state = oldstate;
 }

 /**
  * xmlRelaxNGValidatePushElement:
  * @ctxt:  the validation context
  * @doc:  a document instance
  * @elem:  an element instance
  *
  * Push a new element start on the RelaxNG validation stack.
  *
  * returns 1 if no validation problem was found or 0 if validating the
  *         element requires a full node, and -1 in case of error.
  */
 int
 xmlRelaxNGValidatePushElement(xmlRelaxNGValidCtxtPtr ctxt,
                               xmlDocPtr doc ATTRIBUTE_UNUSED,
                               xmlNodePtr elem)
 {
     int ret = 1;

     if ((ctxt == NULL) || (elem == NULL))
         return (-1);

 #ifdef DEBUG_PROGRESSIVE
     xmlGenericError(xmlGenericErrorContext, "PushElem %s\n", elem->name);
 #endif
     if (ctxt->elem == 0) {
         xmlRelaxNGPtr schema;
         xmlRelaxNGGrammarPtr grammar;
         xmlRegExecCtxtPtr exec;
         xmlRelaxNGDefinePtr define;

         schema = ctxt->schema;
         if (schema == NULL) {
             VALID_ERR(XML_RELAXNG_ERR_NOGRAMMAR);
             return (-1);
         }
         grammar = schema->topgrammar;
         if ((grammar == NULL) || (grammar->start == NULL)) {
             VALID_ERR(XML_RELAXNG_ERR_NOGRAMMAR);
             return (-1);
         }
         define = grammar->start;
         if (define->contModel == NULL) {
             ctxt->pdef = define;
             return (0);
         }
         exec = xmlRegNewExecCtxt(define->contModel,
                                  xmlRelaxNGValidateProgressiveCallback,
                                  ctxt);
         if (exec == NULL) {
             return (-1);
         }
         xmlRelaxNGElemPush(ctxt, exec);
     }
     ctxt->pnode = elem;
     ctxt->pstate = 0;
     if (elem->ns != NULL) {
         ret =
             xmlRegExecPushString2(ctxt->elem, elem->name, elem->ns->href,
                                   ctxt);
     } else {
         ret = xmlRegExecPushString(ctxt->elem, elem->name, ctxt);
     }
     if (ret < 0) {
         VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, elem->name);
     } else {
         if (ctxt->pstate == 0)
             ret = 0;
         else if (ctxt->pstate < 0)
             ret = -1;
         else
             ret = 1;
     }
 #ifdef DEBUG_PROGRESSIVE
     if (ret < 0)
         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
  *
  * 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;

     if ((ctxt == NULL) || (ctxt->elem == NULL) || (data == NULL))
         return (-1);

 #ifdef DEBUG_PROGRESSIVE
     xmlGenericError(xmlGenericErrorContext, "CDATA %s %d\n", data, len);
 #endif

     while (*data != 0) {
         if (!IS_BLANK_CH(*data))
             break;
         data++;
     }
     if (*data == 0)
         return (1);

     ret = xmlRegExecPushString(ctxt->elem, BAD_CAST "#text", ctxt);
     if (ret < 0) {
         VALID_ERR2(XML_RELAXNG_ERR_TEXTWRONG, BAD_CAST " TODO ");
 #ifdef DEBUG_PROGRESSIVE
         xmlGenericError(xmlGenericErrorContext, "CDATA failed\n");
 #endif

         return (-1);
     }
     return (1);
 }

 /**
  * xmlRelaxNGValidatePopElement:
  * @ctxt:  the RelaxNG validation context
  * @doc:  a document instance
  * @elem:  an element instance
  *
  * Pop the element end from the RelaxNG validation stack.
  *
  * returns 1 if no validation problem was found or 0 otherwise
  */
 int
 xmlRelaxNGValidatePopElement(xmlRelaxNGValidCtxtPtr ctxt,
                              xmlDocPtr doc ATTRIBUTE_UNUSED,
                              xmlNodePtr elem)
 {
     int ret;
     xmlRegExecCtxtPtr exec;

     if ((ctxt == NULL) || (ctxt->elem == NULL) || (elem == NULL))
         return (-1);
 #ifdef DEBUG_PROGRESSIVE
     xmlGenericError(xmlGenericErrorContext, "PopElem %s\n", elem->name);
 #endif
     /*
      * verify that we reached a terminal state of the content model.
      */
     exec = xmlRelaxNGElemPop(ctxt);
     ret = xmlRegExecPushString(exec, NULL, NULL);
     if (ret == 0) {
         /*
          * TODO: get some of the names needed to exit the current state of exec
          */
         VALID_ERR2(XML_RELAXNG_ERR_NOELEM, BAD_CAST "");
         ret = -1;
     } else if (ret < 0) {
         ret = -1;
     } else {
         ret = 1;
     }
     xmlRegFreeExecCtxt(exec);
 #ifdef DEBUG_PROGRESSIVE
     if (ret < 0)
         xmlGenericError(xmlGenericErrorContext, "PopElem %s failed\n",
                         elem->name);
 #endif
     return (ret);
 }

 /**
  * xmlRelaxNGValidateFullElement:
  * @ctxt:  the validation context
  * @doc:  a document instance
  * @elem:  an element instance
  *
  * Validate a full subtree when xmlRelaxNGValidatePushElement() returned
  * 0 and the content of the node has been expanded.
  *
  * returns 1 if no validation problem was found or -1 in case of error.
  */
 int
 xmlRelaxNGValidateFullElement(xmlRelaxNGValidCtxtPtr ctxt,
                               xmlDocPtr doc ATTRIBUTE_UNUSED,
                               xmlNodePtr elem)
 {
     int ret;
     xmlRelaxNGValidStatePtr state;

     if ((ctxt == NULL) || (ctxt->pdef == NULL) || (elem == NULL))
         return (-1);
 #ifdef DEBUG_PROGRESSIVE
     xmlGenericError(xmlGenericErrorContext, "FullElem %s\n", elem->name);
 #endif
     state = xmlRelaxNGNewValidState(ctxt, elem->parent);
     if (state == NULL) {
         return (-1);
     }
     state->seq = elem;
     ctxt->state = state;
     ctxt->errNo = XML_RELAXNG_OK;
     ret = xmlRelaxNGValidateDefinition(ctxt, ctxt->pdef);
     if ((ret != 0) || (ctxt->errNo != XML_RELAXNG_OK))
         ret = -1;
     else
         ret = 1;
     xmlRelaxNGFreeValidState(ctxt, state);
     ctxt->state = NULL;
 #ifdef DEBUG_PROGRESSIVE
     if (ret < 0)
         xmlGenericError(xmlGenericErrorContext, "FullElem %s failed\n",
                         elem->name);
 #endif
     return (ret);
 }

 /************************************************************************
  * 									*
  * 		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
  *
  * Returns the new sibling or NULL in case of error.
  */
 static xmlNodePtr
 xmlRelaxNGSkipIgnored(xmlRelaxNGValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
                       xmlNodePtr node)
 {
     /*
      * TODO complete and handle entities
      */
     while ((node != NULL) &&
            ((node->type == XML_COMMENT_NODE) ||
             (node->type == XML_PI_NODE) ||
 	    (node->type == XML_XINCLUDE_START) ||
 	    (node->type == XML_XINCLUDE_END) ||
             (((node->type == XML_TEXT_NODE) ||
               (node->type == XML_CDATA_SECTION_NODE)) &&
              ((ctxt->flags & FLAGS_MIXED_CONTENT) ||
               (IS_BLANK_NODE(node)))))) {
         node = node->next;
     }
     return (node);
 }

 /**
  * xmlRelaxNGNormalize:
  * @ctxt:  a schema validation context
  * @str:  the string to normalize
  *
  * Implements the  normalizeWhiteSpace( s ) function from
  * section 6.2.9 of the spec
  *
  * Returns the new string or NULL in case of error.
  */
 static xmlChar *
 xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt, const xmlChar * str)
 {
     xmlChar *ret, *p;
     const xmlChar *tmp;
     int len;

     if (str == NULL)
         return (NULL);
     tmp = str;
     while (*tmp != 0)
         tmp++;
     len = tmp - str;

     ret = (xmlChar *) xmlMallocAtomic((len + 1) * sizeof(xmlChar));
     if (ret == NULL) {
         xmlRngVErrMemory(ctxt, "validating\n");
         return (NULL);
     }
     p = ret;
     while (IS_BLANK_CH(*str))
         str++;
     while (*str != 0) {
         if (IS_BLANK_CH(*str)) {
             while (IS_BLANK_CH(*str))
                 str++;
             if (*str == 0)
                 break;
             *p++ = ' ';
         } else
             *p++ = *str++;
     }
     *p = 0;
     return (ret);
 }

 /**
  * xmlRelaxNGValidateDatatype:
  * @ctxt:  a Relax-NG validation context
  * @value:  the string value
  * @type:  the datatype definition
  * @node:  the node
  *
  * Validate the given value against the dataype
  *
  * Returns 0 if the validation succeeded or an error code.
  */
 static int
 xmlRelaxNGValidateDatatype(xmlRelaxNGValidCtxtPtr ctxt,
                            const xmlChar * value,
                            xmlRelaxNGDefinePtr define, xmlNodePtr node)
 {
     int ret, tmp;
     xmlRelaxNGTypeLibraryPtr lib;
     void *result = NULL;
     xmlRelaxNGDefinePtr cur;

     if ((define == NULL) || (define->data == NULL)) {
         return (-1);
     }
     lib = (xmlRelaxNGTypeLibraryPtr) define->data;
     if (lib->check != NULL) {
         if ((define->attrs != NULL) &&
             (define->attrs->type == XML_RELAXNG_PARAM)) {
             ret =
                 lib->check(lib->data, define->name, value, &result, node);
         } else {
             ret = lib->check(lib->data, define->name, value, NULL, node);
         }
     } else
         ret = -1;
     if (ret < 0) {
         VALID_ERR2(XML_RELAXNG_ERR_TYPE, define->name);
         if ((result != NULL) && (lib != NULL) && (lib->freef != NULL))
             lib->freef(lib->data, result);
         return (-1);
     } else if (ret == 1) {
         ret = 0;
     } else if (ret == 2) {
         VALID_ERR2P(XML_RELAXNG_ERR_DUPID, value);
     } else {
         VALID_ERR3P(XML_RELAXNG_ERR_TYPEVAL, define->name, value);
         ret = -1;
     }
     cur = define->attrs;
     while ((ret == 0) && (cur != NULL) && (cur->type == XML_RELAXNG_PARAM)) {
         if (lib->facet != NULL) {
             tmp = lib->facet(lib->data, define->name, cur->name,
                              cur->value, value, result);
             if (tmp != 0)
                 ret = -1;
         }
         cur = cur->next;
     }
     if ((ret == 0) && (define->content != NULL)) {
         const xmlChar *oldvalue, *oldendvalue;

         oldvalue = ctxt->state->value;
         oldendvalue = ctxt->state->endvalue;
         ctxt->state->value = (xmlChar *) value;
         ctxt->state->endvalue = NULL;
         ret = xmlRelaxNGValidateValue(ctxt, define->content);
         ctxt->state->value = (xmlChar *) oldvalue;
         ctxt->state->endvalue = (xmlChar *) oldendvalue;
     }
     if ((result != NULL) && (lib != NULL) && (lib->freef != NULL))
         lib->freef(lib->data, result);
     return (ret);
 }

 /**
  * xmlRelaxNGNextValue:
  * @ctxt:  a Relax-NG validation context
  *
  * Skip to the next value when validating within a list
  *
  * Returns 0 if the operation succeeded or an error code.
  */
 static int
 xmlRelaxNGNextValue(xmlRelaxNGValidCtxtPtr ctxt)
 {
     xmlChar *cur;

     cur = ctxt->state->value;
     if ((cur == NULL) || (ctxt->state->endvalue == NULL)) {
         ctxt->state->value = NULL;
         ctxt->state->endvalue = NULL;
         return (0);
     }
     while (*cur != 0)
         cur++;
     while ((cur != ctxt->state->endvalue) && (*cur == 0))
         cur++;
     if (cur == ctxt->state->endvalue)
         ctxt->state->value = NULL;
     else
         ctxt->state->value = cur;
     return (0);
 }

 /**
  * xmlRelaxNGValidateValueList:
  * @ctxt:  a Relax-NG validation context
  * @defines:  the list of definitions to verify
  *
  * Validate the given set of definitions for the current value
  *
  * Returns 0 if the validation succeeded or an error code.
  */
 static int
 xmlRelaxNGValidateValueList(xmlRelaxNGValidCtxtPtr ctxt,
                             xmlRelaxNGDefinePtr defines)
 {
     int ret = 0;

     while (defines != NULL) {
         ret = xmlRelaxNGValidateValue(ctxt, defines);
         if (ret != 0)
             break;
         defines = defines->next;
     }
     return (ret);
 }

 /**
  * xmlRelaxNGValidateValue:
  * @ctxt:  a Relax-NG validation context
  * @define:  the definition to verify
  *
  * Validate the given definition for the current value
  *
  * Returns 0 if the validation succeeded or an error code.
  */
 static int
 xmlRelaxNGValidateValue(xmlRelaxNGValidCtxtPtr ctxt,
                         xmlRelaxNGDefinePtr define)
 {
     int ret = 0, oldflags;
     xmlChar *value;

     value = ctxt->state->value;
     switch (define->type) {
         case XML_RELAXNG_EMPTY:{
                 if ((value != NULL) && (value[0] != 0)) {
                     int idx = 0;

                     while (IS_BLANK_CH(value[idx]))
                         idx++;
                     if (value[idx] != 0)
                         ret = -1;
                 }
                 break;
             }
         case XML_RELAXNG_TEXT:
             break;
         case XML_RELAXNG_VALUE:{
                 if (!xmlStrEqual(value, define->value)) {
                     if (define->name != NULL) {
                         xmlRelaxNGTypeLibraryPtr lib;

                         lib = (xmlRelaxNGTypeLibraryPtr) define->data;
                         if ((lib != NULL) && (lib->comp != NULL)) {
                             ret = lib->comp(lib->data, define->name,
                                             define->value, define->node,
                                             (void *) define->attrs,
                                             value, ctxt->state->node);
                         } else
                             ret = -1;
                         if (ret < 0) {
                             VALID_ERR2(XML_RELAXNG_ERR_TYPECMP,
                                        define->name);
                             return (-1);
                         } else if (ret == 1) {
                             ret = 0;
                         } else {
                             ret = -1;
                         }
                     } else {
                         xmlChar *nval, *nvalue;

                         /*
                          * TODO: trivial optimizations are possible by
                          * computing at compile-time
                          */
                         nval = xmlRelaxNGNormalize(ctxt, define->value);
                         nvalue = xmlRelaxNGNormalize(ctxt, value);

                         if ((nval == NULL) || (nvalue == NULL) ||
                             (!xmlStrEqual(nval, nvalue)))
                             ret = -1;
                         if (nval != NULL)
                             xmlFree(nval);
                         if (nvalue != NULL)
                             xmlFree(nvalue);
                     }
                 }
                 if (ret == 0)
                     xmlRelaxNGNextValue(ctxt);
                 break;
             }
         case XML_RELAXNG_DATATYPE:{
                 ret = xmlRelaxNGValidateDatatype(ctxt, value, define,
                                                  ctxt->state->seq);
                 if (ret == 0)
                     xmlRelaxNGNextValue(ctxt);

                 break;
             }
         case XML_RELAXNG_CHOICE:{
                 xmlRelaxNGDefinePtr list = define->content;
                 xmlChar *oldvalue;

                 oldflags = ctxt->flags;
                 ctxt->flags |= FLAGS_IGNORABLE;

                 oldvalue = ctxt->state->value;
                 while (list != NULL) {
                     ret = xmlRelaxNGValidateValue(ctxt, list);
                     if (ret == 0) {
                         break;
                     }
                     ctxt->state->value = oldvalue;
                     list = list->next;
                 }
                 ctxt->flags = oldflags;
                 if (ret != 0) {
                     if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
                         xmlRelaxNGDumpValidError(ctxt);
                 } else {
                     if (ctxt->errNr > 0)
                         xmlRelaxNGPopErrors(ctxt, 0);
                 }
                 break;
             }
         case XML_RELAXNG_LIST:{
                 xmlRelaxNGDefinePtr list = define->content;
                 xmlChar *oldvalue, *oldend, *val, *cur;

 #ifdef DEBUG_LIST
                 int nb_values = 0;
 #endif

                 oldvalue = ctxt->state->value;
                 oldend = ctxt->state->endvalue;

                 val = xmlStrdup(oldvalue);
                 if (val == NULL) {
                     val = xmlStrdup(BAD_CAST "");
                 }
                 if (val == NULL) {
                     VALID_ERR(XML_RELAXNG_ERR_NOSTATE);
                     return (-1);
                 }
                 cur = val;
                 while (*cur != 0) {
                     if (IS_BLANK_CH(*cur)) {
                         *cur = 0;
                         cur++;
 #ifdef DEBUG_LIST
                         nb_values++;
 #endif
                         while (IS_BLANK_CH(*cur))
                             *cur++ = 0;
                     } else
                         cur++;
                 }
 #ifdef DEBUG_LIST
                 xmlGenericError(xmlGenericErrorContext,
                                 "list value: '%s' found %d items\n",
                                 oldvalue, nb_values);
                 nb_values = 0;
 #endif
                 ctxt->state->endvalue = cur;
                 cur = val;
                 while ((*cur == 0) && (cur != ctxt->state->endvalue))
                     cur++;

                 ctxt->state->value = cur;

                 while (list != NULL) {
                     if (ctxt->state->value == ctxt->state->endvalue)
                         ctxt->state->value = NULL;
                     ret = xmlRelaxNGValidateValue(ctxt, list);
                     if (ret != 0) {
 #ifdef DEBUG_LIST
                         xmlGenericError(xmlGenericErrorContext,
                                         "Failed to validate value: '%s' with %d rule\n",
                                         ctxt->state->value, nb_values);
 #endif
                         break;
                     }
 #ifdef DEBUG_LIST
                     nb_values++;
 #endif
                     list = list->next;
                 }

                 if ((ret == 0) && (ctxt->state->value != NULL) &&
                     (ctxt->state->value != ctxt->state->endvalue)) {
                     VALID_ERR2(XML_RELAXNG_ERR_LISTEXTRA,
                                ctxt->state->value);
                     ret = -1;
                 }
                 xmlFree(val);
                 ctxt->state->value = oldvalue;
                 ctxt->state->endvalue = oldend;
                 break;
             }
         case XML_RELAXNG_ONEORMORE:
             ret = xmlRelaxNGValidateValueList(ctxt, define->content);
             if (ret != 0) {
                 break;
             }
             /* no break on purpose */
         case XML_RELAXNG_ZEROORMORE:{
                 xmlChar *cur, *temp;

                 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 (ret != 0) {
                     if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
                         xmlRelaxNGDumpValidError(ctxt);
                 } else {
                     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
                         ret = 0;
                     list = list->next;
                 }
                 break;
             }
         case XML_RELAXNG_DEF:
         case XML_RELAXNG_GROUP:{
                 xmlRelaxNGDefinePtr list;

                 list = define->content;
                 while (list != NULL) {
                     ret = xmlRelaxNGValidateValue(ctxt, list);
                     if (ret != 0) {
                         ret = -1;
                         break;
                     } else
                         ret = 0;
                     list = list->next;
                 }
                 break;
             }
         case XML_RELAXNG_REF:
         case XML_RELAXNG_PARENTREF:
             ret = xmlRelaxNGValidateValue(ctxt, define->content);
             break;
         default:
             TODO ret = -1;
     }
     return (ret);
 }

 /**
  * xmlRelaxNGValidateValueContent:
  * @ctxt:  a Relax-NG validation context
  * @defines:  the list of definitions to verify
  *
  * Validate the given definitions for the current value
  *
  * Returns 0 if the validation succeeded or an error code.
  */
 static int
 xmlRelaxNGValidateValueContent(xmlRelaxNGValidCtxtPtr ctxt,
                                xmlRelaxNGDefinePtr defines)
 {
     int ret = 0;

     while (defines != NULL) {
         ret = xmlRelaxNGValidateValue(ctxt, defines);
         if (ret != 0)
             break;
         defines = defines->next;
     }
     return (ret);
 }

 /**
  * xmlRelaxNGAttributeMatch:
  * @ctxt:  a Relax-NG validation context
  * @define:  the definition to check
  * @prop:  the attribute
  *
  * Check if the attribute matches the definition nameClass
  *
  * Returns 1 if the attribute matches, 0 if no, or -1 in case of error
  */
 static int
 xmlRelaxNGAttributeMatch(xmlRelaxNGValidCtxtPtr ctxt,
                          xmlRelaxNGDefinePtr define, xmlAttrPtr prop)
 {
     int ret;

     if (define->name != NULL) {
         if (!xmlStrEqual(define->name, prop->name))
             return (0);
     }
     if (define->ns != NULL) {
         if (define->ns[0] == 0) {
             if (prop->ns != NULL)
                 return (0);
         } else {
             if ((prop->ns == NULL) ||
                 (!xmlStrEqual(define->ns, prop->ns->href)))
                 return (0);
         }
     }
     if (define->nameClass == NULL)
         return (1);
     define = define->nameClass;
     if (define->type == XML_RELAXNG_EXCEPT) {
         xmlRelaxNGDefinePtr list;

         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 {
     TODO}
     return (1);
 }

 /**
  * xmlRelaxNGValidateAttribute:
  * @ctxt:  a Relax-NG validation context
  * @define:  the definition to verify
  *
  * Validate the given attribute definition for that node
  *
  * Returns 0 if the validation succeeded or an error code.
  */
 static int
 xmlRelaxNGValidateAttribute(xmlRelaxNGValidCtxtPtr ctxt,
                             xmlRelaxNGDefinePtr define)
 {
     int ret = 0, i;
     xmlChar *value, *oldvalue;
     xmlAttrPtr prop = NULL, tmp;
     xmlNodePtr oldseq;

     if (ctxt->state->nbAttrLeft <= 0)
         return (-1);
     if (define->name != NULL) {
         for (i = 0; i < ctxt->state->nbAttrs; i++) {
             tmp = ctxt->state->attrs[i];
             if ((tmp != NULL) && (xmlStrEqual(define->name, tmp->name))) {
                 if ((((define->ns == NULL) || (define->ns[0] == 0)) &&
                      (tmp->ns == NULL)) ||
                     ((tmp->ns != NULL) &&
                      (xmlStrEqual(define->ns, tmp->ns->href)))) {
                     prop = tmp;
                     break;
                 }
             }
         }
         if (prop != NULL) {
             value = xmlNodeListGetString(prop->doc, prop->children, 1);
             oldvalue = ctxt->state->value;
             oldseq = ctxt->state->seq;
             ctxt->state->seq = (xmlNodePtr) prop;
             ctxt->state->value = value;
             ctxt->state->endvalue = NULL;
             ret = xmlRelaxNGValidateValueContent(ctxt, define->content);
             if (ctxt->state->value != NULL)
                 value = ctxt->state->value;
             if (value != NULL)
                 xmlFree(value);
             ctxt->state->value = oldvalue;
             ctxt->state->seq = oldseq;
             if (ret == 0) {
                 /*
                  * flag the attribute as processed
                  */
                 ctxt->state->attrs[i] = NULL;
                 ctxt->state->nbAttrLeft--;
             }
         } else {
             ret = -1;
         }
 #ifdef DEBUG
         xmlGenericError(xmlGenericErrorContext,
                         "xmlRelaxNGValidateAttribute(%s): %d\n",
                         define->name, ret);
 #endif
     } else {
         for (i = 0; i < ctxt->state->nbAttrs; i++) {
             tmp = ctxt->state->attrs[i];
             if ((tmp != NULL) &&
                 (xmlRelaxNGAttributeMatch(ctxt, define, tmp) == 1)) {
                 prop = tmp;
                 break;
             }
         }
         if (prop != NULL) {
             value = xmlNodeListGetString(prop->doc, prop->children, 1);
             oldvalue = ctxt->state->value;
             oldseq = ctxt->state->seq;
             ctxt->state->seq = (xmlNodePtr) prop;
             ctxt->state->value = value;
             ret = xmlRelaxNGValidateValueContent(ctxt, define->content);
             if (ctxt->state->value != NULL)
                 value = ctxt->state->value;
             if (value != NULL)
                 xmlFree(value);
             ctxt->state->value = oldvalue;
             ctxt->state->seq = oldseq;
             if (ret == 0) {
                 /*
                  * flag the attribute as processed
                  */
                 ctxt->state->attrs[i] = NULL;
                 ctxt->state->nbAttrLeft--;
             }
         } else {
             ret = -1;
         }
 #ifdef DEBUG
         if (define->ns != NULL) {
             xmlGenericError(xmlGenericErrorContext,
                             "xmlRelaxNGValidateAttribute(nsName ns = %s): %d\n",
                             define->ns, ret);
         } else {
             xmlGenericError(xmlGenericErrorContext,
                             "xmlRelaxNGValidateAttribute(anyName): %d\n",
                             ret);
         }
 #endif
     }

     return (ret);
 }

 /**
  * xmlRelaxNGValidateAttributeList:
  * @ctxt:  a Relax-NG validation context
  * @define:  the list of definition to verify
  *
  * Validate the given node against the list of attribute definitions
  *
  * Returns 0 if the validation succeeded or an error code.
  */
 static int
 xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
                                 xmlRelaxNGDefinePtr defines)
 {
     int ret = 0, res;
     int needmore = 0;
     xmlRelaxNGDefinePtr cur;

     cur = defines;
     while (cur != NULL) {
         if (cur->type == XML_RELAXNG_ATTRIBUTE) {
             if (xmlRelaxNGValidateAttribute(ctxt, cur) != 0)
                 ret = -1;
         } else
             needmore = 1;
         cur = cur->next;
     }
     if (!needmore)
         return (ret);
     cur = defines;
     while (cur != NULL) {
         if (cur->type != XML_RELAXNG_ATTRIBUTE) {
             if ((ctxt->state != NULL) || (ctxt->states != NULL)) {
                 res = xmlRelaxNGValidateDefinition(ctxt, cur);
                 if (res < 0)
                     ret = -1;
             } else {
                 VALID_ERR(XML_RELAXNG_ERR_NOSTATE);
                 return (-1);
             }
             if (res == -1)      /* continues on -2 */
                 break;
         }
         cur = cur->next;
     }

     return (ret);
 }

 /**
  * xmlRelaxNGNodeMatchesList:
  * @node:  the node
  * @list:  a NULL terminated array of definitions
  *
  * Check if a node can be matched by one of the definitions
  *
  * Returns 1 if matches 0 otherwise
  */
 static int
 xmlRelaxNGNodeMatchesList(xmlNodePtr node, xmlRelaxNGDefinePtr * list)
 {
     xmlRelaxNGDefinePtr cur;
     int i = 0, tmp;

     if ((node == NULL) || (list == NULL))
         return (0);

     cur = list[i++];
     while (cur != NULL) {
         if ((node->type == XML_ELEMENT_NODE) &&
             (cur->type == XML_RELAXNG_ELEMENT)) {
             tmp = xmlRelaxNGElementMatch(NULL, cur, node);
             if (tmp == 1)
                 return (1);
         } else if (((node->type == XML_TEXT_NODE) ||
                     (node->type == XML_CDATA_SECTION_NODE)) &&
                    (cur->type == XML_RELAXNG_TEXT)) {
             return (1);
         }
         cur = list[i++];
     }
     return (0);
 }

 /**
  * xmlRelaxNGValidateInterleave:
  * @ctxt:  a Relax-NG validation context
  * @define:  the definition to verify
  *
  * Validate an interleave definition for a node.
  *
  * Returns 0 if the validation succeeded or an error code.
  */
 static int
 xmlRelaxNGValidateInterleave(xmlRelaxNGValidCtxtPtr ctxt,
                              xmlRelaxNGDefinePtr define)
 {
     int ret = 0, i, nbgroups;
     int errNr = ctxt->errNr;
     int oldflags;

     xmlRelaxNGValidStatePtr oldstate;
     xmlRelaxNGPartitionPtr partitions;
     xmlRelaxNGInterleaveGroupPtr group = NULL;
     xmlNodePtr cur, start, last = NULL, lastchg = NULL, lastelem;
     xmlNodePtr *list = NULL, *lasts = NULL;

     if (define->data != NULL) {
         partitions = (xmlRelaxNGPartitionPtr) define->data;
         nbgroups = partitions->nbgroups;
     } else {
         VALID_ERR(XML_RELAXNG_ERR_INTERNODATA);
         return (-1);
     }
     /*
      * Optimizations for MIXED
      */
     oldflags = ctxt->flags;
     if (define->dflags & IS_MIXED) {
         ctxt->flags |= FLAGS_MIXED_CONTENT;
         if (nbgroups == 2) {
             /*
              * this is a pure <mixed> case
              */
             if (ctxt->state != NULL)
                 ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt,
                                                          ctxt->state->seq);
             if (partitions->groups[0]->rule->type == XML_RELAXNG_TEXT)
                 ret = xmlRelaxNGValidateDefinition(ctxt,
                                                    partitions->groups[1]->
                                                    rule);
             else
                 ret = xmlRelaxNGValidateDefinition(ctxt,
                                                    partitions->groups[0]->
                                                    rule);
             if (ret == 0) {
                 if (ctxt->state != NULL)
                     ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt,
                                                              ctxt->state->
                                                              seq);
             }
             ctxt->flags = oldflags;
             return (ret);
         }
     }

     /*
      * Build arrays to store the first and last node of the chain
      * pertaining to each group
      */
     list = (xmlNodePtr *) xmlMalloc(nbgroups * sizeof(xmlNodePtr));
     if (list == NULL) {
         xmlRngVErrMemory(ctxt, "validating\n");
         return (-1);
     }
     memset(list, 0, nbgroups * sizeof(xmlNodePtr));
     lasts = (xmlNodePtr *) xmlMalloc(nbgroups * sizeof(xmlNodePtr));
     if (lasts == NULL) {
         xmlRngVErrMemory(ctxt, "validating\n");
         return (-1);
     }
     memset(lasts, 0, nbgroups * sizeof(xmlNodePtr));

     /*
      * Walk the sequence of children finding the right group and
      * sorting them in sequences.
      */
     cur = ctxt->state->seq;
     cur = xmlRelaxNGSkipIgnored(ctxt, cur);
     start = cur;
     while (cur != NULL) {
         ctxt->state->seq = cur;
         if ((partitions->triage != NULL) &&
             (partitions->flags & IS_DETERMINIST)) {
             void *tmp = NULL;

             if ((cur->type == XML_TEXT_NODE) ||
                 (cur->type == XML_CDATA_SECTION_NODE)) {
                 tmp = xmlHashLookup2(partitions->triage, BAD_CAST "#text",
                                      NULL);
             } else if (cur->type == XML_ELEMENT_NODE) {
                 if (cur->ns != NULL) {
                     tmp = xmlHashLookup2(partitions->triage, cur->name,
                                          cur->ns->href);
                     if (tmp == NULL)
                         tmp = xmlHashLookup2(partitions->triage,
                                              BAD_CAST "#any",
                                              cur->ns->href);
                 } else
                     tmp =
                         xmlHashLookup2(partitions->triage, cur->name,
                                        NULL);
                 if (tmp == NULL)
                     tmp =
                         xmlHashLookup2(partitions->triage, BAD_CAST "#any",
                                        NULL);
             }

             if (tmp == NULL) {
                 i = nbgroups;
             } else {
                 i = ((long) tmp) - 1;
                 if (partitions->flags & IS_NEEDCHECK) {
                     group = partitions->groups[i];
                     if (!xmlRelaxNGNodeMatchesList(cur, group->defs))
                         i = nbgroups;
                 }
             }
         } else {
             for (i = 0; i < nbgroups; i++) {
                 group = partitions->groups[i];
                 if (group == NULL)
                     continue;
                 if (xmlRelaxNGNodeMatchesList(cur, group->defs))
                     break;
             }
         }
         /*
          * We break as soon as an element not matched is found
          */
         if (i >= nbgroups) {
             break;
         }
         if (lasts[i] != NULL) {
             lasts[i]->next = cur;
             lasts[i] = cur;
         } else {
             list[i] = cur;
             lasts[i] = cur;
         }
         if (cur->next != NULL)
             lastchg = cur->next;
         else
             lastchg = cur;
         cur = xmlRelaxNGSkipIgnored(ctxt, cur->next);
     }
     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);
         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) {
             cur = ctxt->state->seq;
             cur = xmlRelaxNGSkipIgnored(ctxt, cur);
             xmlRelaxNGFreeValidState(ctxt, oldstate);
             oldstate = ctxt->state;
             ctxt->state = NULL;
             if (cur != NULL) {
                 VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA, cur->name);
                 ret = -1;
                 ctxt->state = oldstate;
                 goto done;
             }
         } else if (ctxt->states != NULL) {
             int j;
             int found = 0;

             for (j = 0; j < ctxt->states->nbState; j++) {
                 cur = ctxt->states->tabState[j]->seq;
                 cur = xmlRelaxNGSkipIgnored(ctxt, cur);
                 if (cur == NULL) {
                     found = 1;
                     break;
                 }
             }
             if (ctxt->states->nbState > 0) {
                 xmlRelaxNGFreeValidState(ctxt, oldstate);
                 oldstate =
                     ctxt->states->tabState[ctxt->states->nbState - 1];
             }
             for (j = 0; j < ctxt->states->nbState - 1; j++) {
                 xmlRelaxNGFreeValidState(ctxt, ctxt->states->tabState[j]);
             }
             xmlRelaxNGFreeStates(ctxt, ctxt->states);
             ctxt->states = NULL;
             if (found == 0) {
                 VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA, cur->name);
                 ret = -1;
                 ctxt->state = oldstate;
                 goto done;
             }
         } else {
             ret = -1;
             break;
         }
         if (lasts[i] != NULL) {
             lasts[i]->next = last;
         }
     }
     if (ctxt->state != NULL)
         xmlRelaxNGFreeValidState(ctxt, ctxt->state);
     ctxt->state = oldstate;
     ctxt->state->seq = lastelem;
     if (ret != 0) {
         VALID_ERR(XML_RELAXNG_ERR_INTERSEQ);
         ret = -1;
         goto done;
     }

   done:
     ctxt->flags = oldflags;
     /*
      * builds the next links chain from the prev one
      */
     cur = lastchg;
     while (cur != NULL) {
         if ((cur == start) || (cur->prev == NULL))
             break;
         cur->prev->next = cur;
         cur = cur->prev;
     }
     if (ret == 0) {
         if (ctxt->errNr > errNr)
             xmlRelaxNGPopErrors(ctxt, errNr);
     }

     xmlFree(list);
     xmlFree(lasts);
     return (ret);
 }

 /**
  * xmlRelaxNGValidateDefinitionList:
  * @ctxt:  a Relax-NG validation context
  * @define:  the list of definition to verify
  *
  * Validate the given node content against the (list) of definitions
  *
  * Returns 0 if the validation succeeded or an error code.
  */
 static int
 xmlRelaxNGValidateDefinitionList(xmlRelaxNGValidCtxtPtr ctxt,
                                  xmlRelaxNGDefinePtr defines)
 {
     int ret = 0, res;


     if (defines == NULL) {
         VALID_ERR2(XML_RELAXNG_ERR_INTERNAL,
                    BAD_CAST "NULL definition list");
         return (-1);
     }
     while (defines != NULL) {
         if ((ctxt->state != NULL) || (ctxt->states != NULL)) {
             res = xmlRelaxNGValidateDefinition(ctxt, defines);
             if (res < 0)
                 ret = -1;
         } else {
             VALID_ERR(XML_RELAXNG_ERR_NOSTATE);
             return (-1);
         }
         if (res == -1)          /* continues on -2 */
             break;
         defines = defines->next;
     }

     return (ret);
 }

 /**
  * xmlRelaxNGElementMatch:
  * @ctxt:  a Relax-NG validation context
  * @define:  the definition to check
  * @elem:  the element
  *
  * Check if the element matches the definition nameClass
  *
  * Returns 1 if the element matches, 0 if no, or -1 in case of error
  */
 static int
 xmlRelaxNGElementMatch(xmlRelaxNGValidCtxtPtr ctxt,
                        xmlRelaxNGDefinePtr define, xmlNodePtr elem)
 {
     int ret = 0, oldflags = 0;

     if (define->name != NULL) {
         if (!xmlStrEqual(elem->name, define->name)) {
             VALID_ERR3(XML_RELAXNG_ERR_ELEMNAME, define->name, elem->name);
             return (0);
         }
     }
     if ((define->ns != NULL) && (define->ns[0] != 0)) {
         if (elem->ns == NULL) {
             VALID_ERR2(XML_RELAXNG_ERR_ELEMNONS, elem->name);
             return (0);
         } else if (!xmlStrEqual(elem->ns->href, define->ns)) {
             VALID_ERR3(XML_RELAXNG_ERR_ELEMWRONGNS,
                        elem->name, define->ns);
             return (0);
         }
     } else if ((elem->ns != NULL) && (define->ns != NULL) &&
                (define->name == NULL)) {
         VALID_ERR2(XML_RELAXNG_ERR_ELEMEXTRANS, elem->name);
         return (0);
     } else if ((elem->ns != NULL) && (define->name != NULL)) {
         VALID_ERR2(XML_RELAXNG_ERR_ELEMEXTRANS, define->name);
         return (0);
     }

     if (define->nameClass == NULL)
         return (1);

     define = define->nameClass;
     if (define->type == XML_RELAXNG_EXCEPT) {
         xmlRelaxNGDefinePtr list;

         if (ctxt != NULL) {
             oldflags = ctxt->flags;
             ctxt->flags |= FLAGS_IGNORABLE;
         }

         list = define->content;
         while (list != NULL) {
             ret = xmlRelaxNGElementMatch(ctxt, list, elem);
             if (ret == 1) {
                 if (ctxt != NULL)
                     ctxt->flags = oldflags;
                 return (0);
             }
             if (ret < 0) {
                 if (ctxt != NULL)
                     ctxt->flags = oldflags;
                 return (ret);
             }
             list = list->next;
         }
         ret = 1;
         if (ctxt != NULL) {
             ctxt->flags = oldflags;
         }
     } else if (define->type == XML_RELAXNG_CHOICE) {
         xmlRelaxNGDefinePtr list;

         if (ctxt != NULL) {
             oldflags = ctxt->flags;
             ctxt->flags |= FLAGS_IGNORABLE;
         }

         list = define->nameClass;
         while (list != NULL) {
             ret = xmlRelaxNGElementMatch(ctxt, list, elem);
             if (ret == 1) {
                 if (ctxt != NULL)
                     ctxt->flags = oldflags;
                 return (1);
             }
             if (ret < 0) {
                 if (ctxt != NULL)
                     ctxt->flags = oldflags;
                 return (ret);
             }
             list = list->next;
         }
         if (ctxt != NULL) {
             if (ret != 0) {
                 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
                     xmlRelaxNGDumpValidError(ctxt);
             } else {
                 if (ctxt->errNr > 0)
                     xmlRelaxNGPopErrors(ctxt, 0);
             }
         }
         ret = 0;
         if (ctxt != NULL) {
             ctxt->flags = oldflags;
         }
     } else {
         TODO ret = -1;
     }
     return (ret);
 }

 /**
  * xmlRelaxNGBestState:
  * @ctxt:  a Relax-NG validation context
  *
  * Find the "best" state in the ctxt->states list of states to report
  * errors about. I.e. a state with no element left in the child list
  * or the one with the less attributes left.
  * This is called only if a falidation error was detected
  *
  * Returns the index of the "best" state or -1 in case of error
  */
 static int
 xmlRelaxNGBestState(xmlRelaxNGValidCtxtPtr ctxt)
 {
     xmlRelaxNGValidStatePtr state;
     int i, tmp;
     int best = -1;
     int value = 1000000;

     if ((ctxt == NULL) || (ctxt->states == NULL) ||
         (ctxt->states->nbState <= 0))
         return (-1);

     for (i = 0; i < ctxt->states->nbState; i++) {
         state = ctxt->states->tabState[i];
         if (state == NULL)
             continue;
         if (state->seq != NULL) {
             if ((best == -1) || (value > 100000)) {
                 value = 100000;
                 best = i;
             }
         } else {
             tmp = state->nbAttrLeft;
             if ((best == -1) || (value > tmp)) {
                 value = tmp;
                 best = i;
             }
         }
     }
     return (best);
 }

 /**
  * xmlRelaxNGLogBestError:
  * @ctxt:  a Relax-NG validation context
  *
  * Find the "best" state in the ctxt->states list of states to report
  * errors about and log it.
  */
 static void
 xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt)
 {
     int best;

     if ((ctxt == NULL) || (ctxt->states == NULL) ||
         (ctxt->states->nbState <= 0))
         return;

     best = xmlRelaxNGBestState(ctxt);
     if ((best >= 0) && (best < ctxt->states->nbState)) {
         ctxt->state = ctxt->states->tabState[best];

         xmlRelaxNGValidateElementEnd(ctxt, 1);
     }
 }

 /**
  * xmlRelaxNGValidateElementEnd:
  * @ctxt:  a Relax-NG validation context
  * @dolog:  indicate that error logging should be done
  *
  * Validate the end of the element, implements check that
  * there is nothing left not consumed in the element content
  * or in the attribute list.
  *
  * Returns 0 if the validation succeeded or an error code.
  */
 static int
 xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt, int dolog)
 {
     int i;
     xmlRelaxNGValidStatePtr state;

     state = ctxt->state;
     if (state->seq != NULL) {
         state->seq = xmlRelaxNGSkipIgnored(ctxt, state->seq);
         if (state->seq != NULL) {
             if (dolog) {
                 VALID_ERR3(XML_RELAXNG_ERR_EXTRACONTENT,
                            state->node->name, state->seq->name);
             }
             return (-1);
         }
     }
     for (i = 0; i < state->nbAttrs; i++) {
         if (state->attrs[i] != NULL) {
             if (dolog) {
                 VALID_ERR3(XML_RELAXNG_ERR_INVALIDATTR,
                            state->attrs[i]->name, state->node->name);
             }
             return (-1 - i);
         }
     }
     return (0);
 }

 /**
  * xmlRelaxNGValidateState:
  * @ctxt:  a Relax-NG validation context
  * @define:  the definition to verify
  *
  * Validate the current state against the definition
  *
  * Returns 0 if the validation succeeded or an error code.
  */
 static int
 xmlRelaxNGValidateState(xmlRelaxNGValidCtxtPtr ctxt,
                         xmlRelaxNGDefinePtr define)
 {
     xmlNodePtr node;
     int ret = 0, i, tmp, oldflags, errNr;
     xmlRelaxNGValidStatePtr oldstate = NULL, state;

     if (define == NULL) {
         VALID_ERR(XML_RELAXNG_ERR_NODEFINE);
         return (-1);
     }

     if (ctxt->state != NULL) {
         node = ctxt->state->seq;
     } else {
         node = NULL;
     }
 #ifdef DEBUG
     for (i = 0; i < ctxt->depth; i++)
         xmlGenericError(xmlGenericErrorContext, " ");
     xmlGenericError(xmlGenericErrorContext,
                     "Start validating %s ", xmlRelaxNGDefName(define));
     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);
             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) ||
                     (node->type == XML_CDATA_SECTION_NODE)))
                 node = node->next;
             ctxt->state->seq = node;
             break;
         case XML_RELAXNG_ELEMENT:
             errNr = ctxt->errNr;
             node = xmlRelaxNGSkipIgnored(ctxt, node);
             if (node == NULL) {
                 VALID_ERR2(XML_RELAXNG_ERR_NOELEM, define->name);
                 ret = -1;
                 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
                     xmlRelaxNGDumpValidError(ctxt);
                 break;
             }
             if (node->type != XML_ELEMENT_NODE) {
                 VALID_ERR(XML_RELAXNG_ERR_NOTELEM);
                 ret = -1;
                 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
                     xmlRelaxNGDumpValidError(ctxt);
                 break;
             }
             /*
              * This node was already validated successfully against
              * this definition.
              */
             if (node->psvi == define) {
                 ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt, node->next);
                 if (ctxt->errNr > errNr)
                     xmlRelaxNGPopErrors(ctxt, errNr);
                 if (ctxt->errNr != 0) {
                     while ((ctxt->err != NULL) &&
                            (((ctxt->err->err == XML_RELAXNG_ERR_ELEMNAME)
                              && (xmlStrEqual(ctxt->err->arg2, node->name)))
                             ||
                             ((ctxt->err->err ==
                               XML_RELAXNG_ERR_ELEMEXTRANS)
                              && (xmlStrEqual(ctxt->err->arg1, node->name)))
                             || (ctxt->err->err == XML_RELAXNG_ERR_NOELEM)
                             || (ctxt->err->err ==
                                 XML_RELAXNG_ERR_NOTELEM)))
                         xmlRelaxNGValidErrorPop(ctxt);
                 }
                 break;
             }

             ret = xmlRelaxNGElementMatch(ctxt, define, node);
             if (ret <= 0) {
                 ret = -1;
                 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
                     xmlRelaxNGDumpValidError(ctxt);
                 break;
             }
             ret = 0;
             if (ctxt->errNr != 0) {
                 if (ctxt->errNr > errNr)
                     xmlRelaxNGPopErrors(ctxt, errNr);
                 while ((ctxt->err != NULL) &&
                        (((ctxt->err->err == XML_RELAXNG_ERR_ELEMNAME) &&
                          (xmlStrEqual(ctxt->err->arg2, node->name))) ||
                         ((ctxt->err->err == XML_RELAXNG_ERR_ELEMEXTRANS) &&
                          (xmlStrEqual(ctxt->err->arg1, node->name))) ||
                         (ctxt->err->err == XML_RELAXNG_ERR_NOELEM) ||
                         (ctxt->err->err == XML_RELAXNG_ERR_NOTELEM)))
                     xmlRelaxNGValidErrorPop(ctxt);
             }
             errNr = ctxt->errNr;

             oldflags = ctxt->flags;
             if (ctxt->flags & FLAGS_MIXED_CONTENT) {
                 ctxt->flags -= FLAGS_MIXED_CONTENT;
             }
             state = xmlRelaxNGNewValidState(ctxt, node);
             if (state == NULL) {
                 ret = -1;
                 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
                     xmlRelaxNGDumpValidError(ctxt);
                 break;
             }

             oldstate = ctxt->state;
             ctxt->state = state;
             if (define->attrs != NULL) {
                 tmp = xmlRelaxNGValidateAttributeList(ctxt, define->attrs);
                 if (tmp != 0) {
                     ret = -1;
                     VALID_ERR2(XML_RELAXNG_ERR_ATTRVALID, node->name);
                 }
             }
             if (define->contModel != NULL) {
                 xmlRelaxNGValidStatePtr nstate, tmpstate = ctxt->state;
                 xmlRelaxNGStatesPtr tmpstates = ctxt->states;
                 xmlNodePtr nseq;

                 nstate = xmlRelaxNGNewValidState(ctxt, node);
                 ctxt->state = nstate;
                 ctxt->states = NULL;

                 tmp = xmlRelaxNGValidateCompiledContent(ctxt,
                                                         define->contModel,
                                                         ctxt->state->seq);
                 nseq = ctxt->state->seq;
                 ctxt->state = tmpstate;
                 ctxt->states = tmpstates;
                 xmlRelaxNGFreeValidState(ctxt, nstate);

 #ifdef DEBUG_COMPILE
                 xmlGenericError(xmlGenericErrorContext,
                                 "Validating content of '%s' : %d\n",
                                 define->name, tmp);
 #endif
                 if (tmp != 0)
                     ret = -1;

                 if (ctxt->states != NULL) {
                     tmp = -1;

                     for (i = 0; i < ctxt->states->nbState; i++) {
                         state = ctxt->states->tabState[i];
                         ctxt->state = state;
                         ctxt->state->seq = nseq;

                         if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
                             tmp = 0;
                             break;
                         }
                     }
                     if (tmp != 0) {
                         /*
                          * validation error, log the message for the "best" one
                          */
                         ctxt->flags |= FLAGS_IGNORABLE;
                         xmlRelaxNGLogBestError(ctxt);
                     }
                     for (i = 0; i < ctxt->states->nbState; i++) {
                         xmlRelaxNGFreeValidState(ctxt,
                                                  ctxt->states->
                                                  tabState[i]);
                     }
                     xmlRelaxNGFreeStates(ctxt, ctxt->states);
                     ctxt->flags = oldflags;
                     ctxt->states = NULL;
                     if ((ret == 0) && (tmp == -1))
                         ret = -1;
                 } else {
                     state = ctxt->state;
                     ctxt->state->seq = nseq;
                     if (ret == 0)
                         ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
                     xmlRelaxNGFreeValidState(ctxt, state);
                 }
             } else {
                 if (define->content != NULL) {
                     tmp = xmlRelaxNGValidateDefinitionList(ctxt,
                                                            define->
                                                            content);
                     if (tmp != 0) {
                         ret = -1;
                         if (ctxt->state == NULL) {
                             ctxt->state = oldstate;
                             VALID_ERR2(XML_RELAXNG_ERR_CONTENTVALID,
                                        node->name);
                             ctxt->state = NULL;
                         } else {
                             VALID_ERR2(XML_RELAXNG_ERR_CONTENTVALID,
                                        node->name);
                         }

                     }
                 }
                 if (ctxt->states != NULL) {
                     tmp = -1;

                     for (i = 0; i < ctxt->states->nbState; i++) {
                         state = ctxt->states->tabState[i];
                         ctxt->state = state;

                         if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
                             tmp = 0;
                             break;
                         }
                     }
                     if (tmp != 0) {
                         /*
                          * validation error, log the message for the "best" one
                          */
                         ctxt->flags |= FLAGS_IGNORABLE;
                         xmlRelaxNGLogBestError(ctxt);
                     }
                     for (i = 0; i < ctxt->states->nbState; i++) {
                         xmlRelaxNGFreeValidState(ctxt,
                                                  ctxt->states->
                                                  tabState[i]);
                     }
                     xmlRelaxNGFreeStates(ctxt, ctxt->states);
                     ctxt->flags = oldflags;
                     ctxt->states = NULL;
                     if ((ret == 0) && (tmp == -1))
                         ret = -1;
                 } else {
                     state = ctxt->state;
                     if (ret == 0)
                         ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
                     xmlRelaxNGFreeValidState(ctxt, state);
                 }
             }
             if (ret == 0) {
                 node->psvi = define;
             }
             ctxt->flags = oldflags;
             ctxt->state = oldstate;
             if (oldstate != NULL)
                 oldstate->seq = xmlRelaxNGSkipIgnored(ctxt, node->next);
             if (ret != 0) {
                 if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
                     xmlRelaxNGDumpValidError(ctxt);
                     ret = 0;
                 } else {
                     ret = -2;
                 }
             } else {
                 if (ctxt->errNr > errNr)
                     xmlRelaxNGPopErrors(ctxt, errNr);
             }

 #ifdef DEBUG
             xmlGenericError(xmlGenericErrorContext,
                             "xmlRelaxNGValidateDefinition(): validated %s : %d",
                             node->name, ret);
             if (oldstate == NULL)
                 xmlGenericError(xmlGenericErrorContext, ": no state\n");
             else if (oldstate->seq == NULL)
                 xmlGenericError(xmlGenericErrorContext, ": done\n");
             else if (oldstate->seq->type == XML_ELEMENT_NODE)
                 xmlGenericError(xmlGenericErrorContext, ": next elem %s\n",
                                 oldstate->seq->name);
             else
                 xmlGenericError(xmlGenericErrorContext, ": next %s %d\n",
                                 oldstate->seq->name, oldstate->seq->type);
 #endif
             break;
         case XML_RELAXNG_OPTIONAL:{
                 errNr = ctxt->errNr;
                 oldflags = ctxt->flags;
                 ctxt->flags |= FLAGS_IGNORABLE;
                 oldstate = xmlRelaxNGCopyValidState(ctxt, ctxt->state);
                 ret =
                     xmlRelaxNGValidateDefinitionList(ctxt,
                                                      define->content);
                 if (ret != 0) {
                     if (ctxt->state != NULL)
                         xmlRelaxNGFreeValidState(ctxt, ctxt->state);
                     ctxt->state = oldstate;
                     ctxt->flags = oldflags;
                     ret = 0;
                     if (ctxt->errNr > errNr)
                         xmlRelaxNGPopErrors(ctxt, errNr);
                     break;
                 }
                 if (ctxt->states != NULL) {
                     xmlRelaxNGAddStates(ctxt, ctxt->states, oldstate);
                 } else {
                     ctxt->states = xmlRelaxNGNewStates(ctxt, 1);
                     if (ctxt->states == NULL) {
                         xmlRelaxNGFreeValidState(ctxt, oldstate);
                         ctxt->flags = oldflags;
                         ret = -1;
                         if (ctxt->errNr > errNr)
                             xmlRelaxNGPopErrors(ctxt, errNr);
                         break;
                     }
                     xmlRelaxNGAddStates(ctxt, ctxt->states, oldstate);
                     xmlRelaxNGAddStates(ctxt, ctxt->states, ctxt->state);
                     ctxt->state = NULL;
                 }
                 ctxt->flags = oldflags;
                 ret = 0;
                 if (ctxt->errNr > errNr)
                     xmlRelaxNGPopErrors(ctxt, errNr);
                 break;
             }
         case XML_RELAXNG_ONEORMORE:
             errNr = ctxt->errNr;
             ret = xmlRelaxNGValidateDefinitionList(ctxt, define->content);
             if (ret != 0) {
                 break;
             }
             if (ctxt->errNr > errNr)
                 xmlRelaxNGPopErrors(ctxt, errNr);
             /* no break on purpose */
         case XML_RELAXNG_ZEROORMORE:{
                 int progress;
                 xmlRelaxNGStatesPtr states = NULL, res = NULL;
                 int base, j;

                 errNr = ctxt->errNr;
                 res = xmlRelaxNGNewStates(ctxt, 1);
                 if (res == NULL) {
                     ret = -1;
                     break;
                 }
                 /*
                  * All the input states are also exit states
                  */
                 if (ctxt->state != NULL) {
                     xmlRelaxNGAddStates(ctxt, res,
                                         xmlRelaxNGCopyValidState(ctxt,
                                                                  ctxt->
                                                                  state));
                 } else {
                     for (j = 0; j < ctxt->states->nbState; j++) {
                         xmlRelaxNGAddStates(ctxt, res,
                                             xmlRelaxNGCopyValidState(ctxt,
                                                                      ctxt->
                                                                      states->
                                                                      tabState
                                                                      [j]));
                     }
                 }
                 oldflags = ctxt->flags;
                 ctxt->flags |= FLAGS_IGNORABLE;
                 do {
                     progress = 0;
                     base = res->nbState;

                     if (ctxt->states != NULL) {
                         states = ctxt->states;
                         for (i = 0; i < states->nbState; i++) {
                             ctxt->state = states->tabState[i];
                             ctxt->states = NULL;
                             ret = xmlRelaxNGValidateDefinitionList(ctxt,
                                                                    define->
                                                                    content);
                             if (ret == 0) {
                                 if (ctxt->state != NULL) {
                                     tmp = xmlRelaxNGAddStates(ctxt, res,
                                                               ctxt->state);
                                     ctxt->state = NULL;
                                     if (tmp == 1)
                                         progress = 1;
                                 } else if (ctxt->states != NULL) {
                                     for (j = 0; j < ctxt->states->nbState;
                                          j++) {
                                         tmp =
                                             xmlRelaxNGAddStates(ctxt, res,
                                                                 ctxt->
                                                                 states->
                                                                 tabState
                                                                 [j]);
                                         if (tmp == 1)
                                             progress = 1;
                                     }
                                     xmlRelaxNGFreeStates(ctxt,
                                                          ctxt->states);
                                     ctxt->states = NULL;
                                 }
                             } else {
                                 if (ctxt->state != NULL) {
                                     xmlRelaxNGFreeValidState(ctxt,
                                                              ctxt->state);
                                     ctxt->state = NULL;
                                 }
                             }
                         }
                     } else {
                         ret = xmlRelaxNGValidateDefinitionList(ctxt,
                                                                define->
                                                                content);
                         if (ret != 0) {
                             xmlRelaxNGFreeValidState(ctxt, ctxt->state);
                             ctxt->state = NULL;
                         } else {
                             base = res->nbState;
                             if (ctxt->state != NULL) {
                                 tmp = xmlRelaxNGAddStates(ctxt, res,
                                                           ctxt->state);
                                 ctxt->state = NULL;
                                 if (tmp == 1)
                                     progress = 1;
                             } else if (ctxt->states != NULL) {
                                 for (j = 0; j < ctxt->states->nbState; j++) {
                                     tmp = xmlRelaxNGAddStates(ctxt, res,
                                                               ctxt->
                                                               states->
                                                               tabState[j]);
                                     if (tmp == 1)
                                         progress = 1;
                                 }
                                 if (states == NULL) {
                                     states = ctxt->states;
                                 } else {
                                     xmlRelaxNGFreeStates(ctxt,
                                                          ctxt->states);
                                 }
                                 ctxt->states = NULL;
                             }
                         }
                     }
                     if (progress) {
                         /*
                          * Collect all the new nodes added at that step
                          * and make them the new node set
                          */
                         if (res->nbState - base == 1) {
                             ctxt->state = xmlRelaxNGCopyValidState(ctxt,
                                                                    res->
                                                                    tabState
                                                                    [base]);
                         } else {
                             if (states == NULL) {
                                 xmlRelaxNGNewStates(ctxt,
                                                     res->nbState - base);
                             }
                             states->nbState = 0;
                             for (i = base; i < res->nbState; i++)
                                 xmlRelaxNGAddStates(ctxt, states,
                                                     xmlRelaxNGCopyValidState
                                                     (ctxt,
                                                      res->tabState[i]));
                             ctxt->states = states;
                         }
                     }
                 } while (progress == 1);
                 if (states != NULL) {
                     xmlRelaxNGFreeStates(ctxt, states);
                 }
                 ctxt->states = res;
                 ctxt->flags = oldflags;
 #if 0
                 /*
                  * errors may have to be propagated back...
                  */
                 if (ctxt->errNr > errNr)
                     xmlRelaxNGPopErrors(ctxt, errNr);
 #endif
                 ret = 0;
                 break;
             }
         case XML_RELAXNG_CHOICE:{
                 xmlRelaxNGDefinePtr list = NULL;
                 xmlRelaxNGStatesPtr states = NULL;

                 node = xmlRelaxNGSkipIgnored(ctxt, node);

                 errNr = ctxt->errNr;
                 if ((define->dflags & IS_TRIABLE) && (define->data != NULL) &&
 		    (node != NULL)) {
 		    /*
 		     * node == NULL can't be optimized since IS_TRIABLE
 		     * doesn't account for choice which may lead to
 		     * only attributes.
 		     */
                     xmlHashTablePtr triage =
                         (xmlHashTablePtr) define->data;

                     /*
                      * Something we can optimize cleanly there is only one
                      * possble branch out !
                      */
                     if ((node->type == XML_TEXT_NODE) ||
                         (node->type == XML_CDATA_SECTION_NODE)) {
                         list =
                             xmlHashLookup2(triage, BAD_CAST "#text", NULL);
                     } else if (node->type == XML_ELEMENT_NODE) {
                         if (node->ns != NULL) {
                             list = xmlHashLookup2(triage, node->name,
                                                   node->ns->href);
                             if (list == NULL)
                                 list =
                                     xmlHashLookup2(triage, BAD_CAST "#any",
                                                    node->ns->href);
                         } else
                             list =
                                 xmlHashLookup2(triage, node->name, NULL);
                         if (list == NULL)
                             list =
                                 xmlHashLookup2(triage, BAD_CAST "#any",
                                                NULL);
                     }
                     if (list == NULL) {
                         ret = -1;
 			VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, node->name);
                         break;
                     }
                     ret = xmlRelaxNGValidateDefinition(ctxt, list);
                     if (ret == 0) {
                     }
                     break;
                 }

                 list = define->content;
                 oldflags = ctxt->flags;
                 ctxt->flags |= FLAGS_IGNORABLE;

                 while (list != NULL) {
                     oldstate = xmlRelaxNGCopyValidState(ctxt, ctxt->state);
                     ret = xmlRelaxNGValidateDefinition(ctxt, list);
                     if (ret == 0) {
                         if (states == NULL) {
                             states = xmlRelaxNGNewStates(ctxt, 1);
                         }
                         if (ctxt->state != NULL) {
                             xmlRelaxNGAddStates(ctxt, states, ctxt->state);
                         } else if (ctxt->states != NULL) {
                             for (i = 0; i < ctxt->states->nbState; i++) {
                                 xmlRelaxNGAddStates(ctxt, states,
                                                     ctxt->states->
                                                     tabState[i]);
                             }
                             xmlRelaxNGFreeStates(ctxt, ctxt->states);
                             ctxt->states = NULL;
                         }
                     } else {
                         xmlRelaxNGFreeValidState(ctxt, ctxt->state);
                     }
                     ctxt->state = oldstate;
                     list = list->next;
                 }
                 if (states != NULL) {
                     xmlRelaxNGFreeValidState(ctxt, oldstate);
                     ctxt->states = states;
                     ctxt->state = NULL;
                     ret = 0;
                 } else {
                     ctxt->states = NULL;
                 }
                 ctxt->flags = oldflags;
                 if (ret != 0) {
                     if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
                         xmlRelaxNGDumpValidError(ctxt);
                     }
                 } else {
                     if (ctxt->errNr > errNr)
                         xmlRelaxNGPopErrors(ctxt, errNr);
                 }
                 break;
             }
         case XML_RELAXNG_DEF:
         case XML_RELAXNG_GROUP:
             ret = xmlRelaxNGValidateDefinitionList(ctxt, define->content);
             break;
         case XML_RELAXNG_INTERLEAVE:
             ret = xmlRelaxNGValidateInterleave(ctxt, define);
             break;
         case XML_RELAXNG_ATTRIBUTE:
             ret = xmlRelaxNGValidateAttribute(ctxt, define);
             break;
         case XML_RELAXNG_START:
         case XML_RELAXNG_NOOP:
         case XML_RELAXNG_REF:
         case XML_RELAXNG_EXTERNALREF:
         case XML_RELAXNG_PARENTREF:
             ret = xmlRelaxNGValidateDefinition(ctxt, define->content);
             break;
         case XML_RELAXNG_DATATYPE:{
                 xmlNodePtr child;
                 xmlChar *content = NULL;

                 child = node;
                 while (child != NULL) {
                     if (child->type == XML_ELEMENT_NODE) {
                         VALID_ERR2(XML_RELAXNG_ERR_DATAELEM,
                                    node->parent->name);
                         ret = -1;
                         break;
                     } else if ((child->type == XML_TEXT_NODE) ||
                                (child->type == XML_CDATA_SECTION_NODE)) {
                         content = xmlStrcat(content, child->content);
                     }
                     /* TODO: handle entities ... */
                     child = child->next;
                 }
                 if (ret == -1) {
                     if (content != NULL)
                         xmlFree(content);
                     break;
                 }
                 if (content == NULL) {
                     content = xmlStrdup(BAD_CAST "");
                     if (content == NULL) {
                         xmlRngVErrMemory(ctxt, "validating\n");
                         ret = -1;
                         break;
                     }
                 }
                 ret = xmlRelaxNGValidateDatatype(ctxt, content, define,
                                                  ctxt->state->seq);
                 if (ret == -1) {
                     VALID_ERR2(XML_RELAXNG_ERR_DATATYPE, define->name);
                 } else if (ret == 0) {
                     ctxt->state->seq = NULL;
                 }
                 if (content != NULL)
                     xmlFree(content);
                 break;
             }
         case XML_RELAXNG_VALUE:{
                 xmlChar *content = NULL;
                 xmlChar *oldvalue;
                 xmlNodePtr child;

                 child = node;
                 while (child != NULL) {
                     if (child->type == XML_ELEMENT_NODE) {
                         VALID_ERR2(XML_RELAXNG_ERR_VALELEM,
                                    node->parent->name);
                         ret = -1;
                         break;
                     } else if ((child->type == XML_TEXT_NODE) ||
                                (child->type == XML_CDATA_SECTION_NODE)) {
                         content = xmlStrcat(content, child->content);
                     }
                     /* TODO: handle entities ... */
                     child = child->next;
                 }
                 if (ret == -1) {
                     if (content != NULL)
                         xmlFree(content);
                     break;
                 }
                 if (content == NULL) {
                     content = xmlStrdup(BAD_CAST "");
                     if (content == NULL) {
                         xmlRngVErrMemory(ctxt, "validating\n");
                         ret = -1;
                         break;
                     }
                 }
                 oldvalue = ctxt->state->value;
                 ctxt->state->value = content;
                 ret = xmlRelaxNGValidateValue(ctxt, define);
                 ctxt->state->value = oldvalue;
                 if (ret == -1) {
                     VALID_ERR2(XML_RELAXNG_ERR_VALUE, define->name);
                 } else if (ret == 0) {
                     ctxt->state->seq = NULL;
                 }
                 if (content != NULL)
                     xmlFree(content);
                 break;
             }
         case XML_RELAXNG_LIST:{
                 xmlChar *content;
                 xmlNodePtr child;
                 xmlChar *oldvalue, *oldendvalue;
                 int len;

                 /*
                  * Make sure it's only text nodes
                  */

                 content = NULL;
                 child = node;
                 while (child != NULL) {
                     if (child->type == XML_ELEMENT_NODE) {
                         VALID_ERR2(XML_RELAXNG_ERR_LISTELEM,
                                    node->parent->name);
                         ret = -1;
                         break;
                     } else if ((child->type == XML_TEXT_NODE) ||
                                (child->type == XML_CDATA_SECTION_NODE)) {
                         content = xmlStrcat(content, child->content);
                     }
                     /* TODO: handle entities ... */
                     child = child->next;
                 }
                 if (ret == -1) {
                     if (content != NULL)
                         xmlFree(content);
                     break;
                 }
                 if (content == NULL) {
                     content = xmlStrdup(BAD_CAST "");
                     if (content == NULL) {
                         xmlRngVErrMemory(ctxt, "validating\n");
                         ret = -1;
                         break;
                     }
                 }
                 len = xmlStrlen(content);
                 oldvalue = ctxt->state->value;
                 oldendvalue = ctxt->state->endvalue;
                 ctxt->state->value = content;
                 ctxt->state->endvalue = content + len;
                 ret = xmlRelaxNGValidateValue(ctxt, define);
                 ctxt->state->value = oldvalue;
                 ctxt->state->endvalue = oldendvalue;
                 if (ret == -1) {
                     VALID_ERR(XML_RELAXNG_ERR_LIST);
                 } else if ((ret == 0) && (node != NULL)) {
                     ctxt->state->seq = node->next;
                 }
                 if (content != NULL)
                     xmlFree(content);
                 break;
             }
         case XML_RELAXNG_EXCEPT:
         case XML_RELAXNG_PARAM:
             TODO ret = -1;
             break;
     }
     ctxt->depth--;
 #ifdef DEBUG
     for (i = 0; i < ctxt->depth; i++)
         xmlGenericError(xmlGenericErrorContext, " ");
     xmlGenericError(xmlGenericErrorContext,
                     "Validating %s ", xmlRelaxNGDefName(define));
     if (define->name != NULL)
         xmlGenericError(xmlGenericErrorContext, "%s ", define->name);
     if (ret == 0)
         xmlGenericError(xmlGenericErrorContext, "suceeded\n");
     else
         xmlGenericError(xmlGenericErrorContext, "failed\n");
 #endif
     return (ret);
 }

 /**
  * xmlRelaxNGValidateDefinition:
  * @ctxt:  a Relax-NG validation context
  * @define:  the definition to verify
  *
  * Validate the current node lists against the definition
  *
  * Returns 0 if the validation succeeded or an error code.
  */
 static int
 xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt,
                              xmlRelaxNGDefinePtr define)
 {
     xmlRelaxNGStatesPtr states, res;
     int i, j, k, ret, oldflags;

     /*
      * We should NOT have both ctxt->state and ctxt->states
      */
     if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
         TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
         ctxt->state = NULL;
     }

     if ((ctxt->states == NULL) || (ctxt->states->nbState == 1)) {
         if (ctxt->states != NULL) {
             ctxt->state = ctxt->states->tabState[0];
             xmlRelaxNGFreeStates(ctxt, ctxt->states);
             ctxt->states = NULL;
         }
         ret = xmlRelaxNGValidateState(ctxt, define);
         if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
             TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
             ctxt->state = NULL;
         }
         if ((ctxt->states != NULL) && (ctxt->states->nbState == 1)) {
             ctxt->state = ctxt->states->tabState[0];
             xmlRelaxNGFreeStates(ctxt, ctxt->states);
             ctxt->states = NULL;
         }
         return (ret);
     }

     states = ctxt->states;
     ctxt->states = NULL;
     res = NULL;
     j = 0;
     oldflags = ctxt->flags;
     ctxt->flags |= FLAGS_IGNORABLE;
     for (i = 0; i < states->nbState; i++) {
         ctxt->state = states->tabState[i];
         ctxt->states = NULL;
         ret = xmlRelaxNGValidateState(ctxt, define);
         /*
          * We should NOT have both ctxt->state and ctxt->states
          */
         if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
             TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
             ctxt->state = NULL;
         }
         if (ret == 0) {
             if (ctxt->states == NULL) {
                 if (res != NULL) {
                     /* add the state to the container */
                     xmlRelaxNGAddStates(ctxt, res, ctxt->state);
                     ctxt->state = NULL;
                 } else {
                     /* add the state directly in states */
                     states->tabState[j++] = ctxt->state;
                     ctxt->state = NULL;
                 }
             } else {
                 if (res == NULL) {
                     /* make it the new container and copy other results */
                     res = ctxt->states;
                     ctxt->states = NULL;
                     for (k = 0; k < j; k++)
                         xmlRelaxNGAddStates(ctxt, res,
                                             states->tabState[k]);
                 } else {
                     /* add all the new results to res and reff the container */
                     for (k = 0; k < ctxt->states->nbState; k++)
                         xmlRelaxNGAddStates(ctxt, res,
                                             ctxt->states->tabState[k]);
                     xmlRelaxNGFreeStates(ctxt, ctxt->states);
                     ctxt->states = NULL;
                 }
             }
         } else {
             if (ctxt->state != NULL) {
                 xmlRelaxNGFreeValidState(ctxt, ctxt->state);
                 ctxt->state = NULL;
             } else if (ctxt->states != NULL) {
                 for (k = 0; k < ctxt->states->nbState; k++)
                     xmlRelaxNGFreeValidState(ctxt,
                                              ctxt->states->tabState[k]);
                 xmlRelaxNGFreeStates(ctxt, ctxt->states);
                 ctxt->states = NULL;
             }
         }
     }
     ctxt->flags = oldflags;
     if (res != NULL) {
         xmlRelaxNGFreeStates(ctxt, states);
         ctxt->states = res;
         ret = 0;
     } else if (j > 1) {
         states->nbState = j;
         ctxt->states = states;
         ret = 0;
     } else if (j == 1) {
         ctxt->state = states->tabState[0];
         xmlRelaxNGFreeStates(ctxt, states);
         ret = 0;
     } else {
         ret = -1;
         xmlRelaxNGFreeStates(ctxt, states);
         if (ctxt->states != NULL) {
             xmlRelaxNGFreeStates(ctxt, ctxt->states);
             ctxt->states = NULL;
         }
     }
     if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
         TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
         ctxt->state = NULL;
     }
     return (ret);
 }

 /**
  * xmlRelaxNGValidateDocument:
  * @ctxt:  a Relax-NG validation context
  * @doc:  the document
  *
  * Validate the given document
  *
  * Returns 0 if the validation succeeded or an error code.
  */
 static int
 xmlRelaxNGValidateDocument(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc)
 {
     int ret;
     xmlRelaxNGPtr schema;
     xmlRelaxNGGrammarPtr grammar;
     xmlRelaxNGValidStatePtr state;
     xmlNodePtr node;

     if ((ctxt == NULL) || (ctxt->schema == NULL) || (doc == NULL))
         return (-1);

     ctxt->errNo = XML_RELAXNG_OK;
     schema = ctxt->schema;
     grammar = schema->topgrammar;
     if (grammar == NULL) {
         VALID_ERR(XML_RELAXNG_ERR_NOGRAMMAR);
         return (-1);
     }
     state = xmlRelaxNGNewValidState(ctxt, NULL);
     ctxt->state = state;
     ret = xmlRelaxNGValidateDefinition(ctxt, grammar->start);
     if ((ctxt->state != NULL) && (state->seq != NULL)) {
         state = ctxt->state;
         node = state->seq;
         node = xmlRelaxNGSkipIgnored(ctxt, node);
         if (node != NULL) {
             if (ret != -1) {
                 VALID_ERR(XML_RELAXNG_ERR_EXTRADATA);
                 ret = -1;
             }
         }
     } else if (ctxt->states != NULL) {
         int i;
         int tmp = -1;

         for (i = 0; i < ctxt->states->nbState; i++) {
             state = ctxt->states->tabState[i];
             node = state->seq;
             node = xmlRelaxNGSkipIgnored(ctxt, node);
             if (node == NULL)
                 tmp = 0;
             xmlRelaxNGFreeValidState(ctxt, state);
         }
         if (tmp == -1) {
             if (ret != -1) {
                 VALID_ERR(XML_RELAXNG_ERR_EXTRADATA);
                 ret = -1;
             }
         }
     }
     if (ctxt->state != NULL) {
         xmlRelaxNGFreeValidState(ctxt, ctxt->state);
         ctxt->state = NULL;
     }
     if (ret != 0)
         xmlRelaxNGDumpValidError(ctxt);
 #ifdef DEBUG
     else if (ctxt->errNr != 0) {
         ctxt->error(ctxt->userData,
                     "%d Extra error messages left on stack !\n",
                     ctxt->errNr);
         xmlRelaxNGDumpValidError(ctxt);
     }
 #endif
 #ifdef LIBXML_VALID_ENABLED
     if (ctxt->idref == 1) {
         xmlValidCtxt vctxt;

         memset(&vctxt, 0, sizeof(xmlValidCtxt));
         vctxt.valid = 1;
         vctxt.error = ctxt->error;
         vctxt.warning = ctxt->warning;
         vctxt.userData = ctxt->userData;

         if (xmlValidateDocumentFinal(&vctxt, doc) != 1)
             ret = -1;
     }
 #endif /* LIBXML_VALID_ENABLED */
     if ((ret == 0) && (ctxt->errNo != XML_RELAXNG_OK))
         ret = -1;

     return (ret);
 }

 /************************************************************************
  * 									*
  * 			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
  */
 xmlRelaxNGValidCtxtPtr
 xmlRelaxNGNewValidCtxt(xmlRelaxNGPtr schema)
 {
     xmlRelaxNGValidCtxtPtr ret;

     ret = (xmlRelaxNGValidCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGValidCtxt));
     if (ret == NULL) {
         xmlRngVErrMemory(NULL, "building context\n");
         return (NULL);
     }
     memset(ret, 0, sizeof(xmlRelaxNGValidCtxt));
     ret->schema = schema;
     ret->error = xmlGenericError;
     ret->userData = xmlGenericErrorContext;
     ret->errNr = 0;
     ret->errMax = 0;
     ret->err = NULL;
     ret->errTab = NULL;
     if (schema != NULL)
 	ret->idref = schema->idref;
     ret->states = NULL;
     ret->freeState = NULL;
     ret->freeStates = NULL;
     ret->errNo = XML_RELAXNG_OK;
     return (ret);
 }

 /**
  * xmlRelaxNGFreeValidCtxt:
  * @ctxt:  the schema validation context
  *
  * Free the resources associated to the schema validation context
  */
 void
 xmlRelaxNGFreeValidCtxt(xmlRelaxNGValidCtxtPtr ctxt)
 {
     int k;

     if (ctxt == NULL)
         return;
     if (ctxt->states != NULL)
         xmlRelaxNGFreeStates(NULL, ctxt->states);
     if (ctxt->freeState != NULL) {
         for (k = 0; k < ctxt->freeState->nbState; k++) {
             xmlRelaxNGFreeValidState(NULL, ctxt->freeState->tabState[k]);
         }
         xmlRelaxNGFreeStates(NULL, ctxt->freeState);
     }
     if (ctxt->freeStates != NULL) {
         for (k = 0; k < ctxt->freeStatesNr; k++) {
             xmlRelaxNGFreeStates(NULL, ctxt->freeStates[k]);
         }
         xmlFree(ctxt->freeStates);
     }
     if (ctxt->errTab != NULL)
         xmlFree(ctxt->errTab);
     if (ctxt->elemTab != NULL) {
         xmlRegExecCtxtPtr exec;

         exec = xmlRelaxNGElemPop(ctxt);
         while (exec != NULL) {
             xmlRegFreeExecCtxt(exec);
             exec = xmlRelaxNGElemPop(ctxt);
         }
         xmlFree(ctxt->elemTab);
     }
     xmlFree(ctxt);
 }

 /**
  * xmlRelaxNGSetValidErrors:
  * @ctxt:  a Relax-NG validation context
  * @err:  the error function
  * @warn: the warning function
  * @ctx: the functions context
  *
  * Set the error and warning callback informations
  */
 void
 xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
                          xmlRelaxNGValidityErrorFunc err,
                          xmlRelaxNGValidityWarningFunc warn, void *ctx)
 {
     if (ctxt == NULL)
         return;
     ctxt->error = err;
     ctxt->warning = warn;
     ctxt->userData = ctx;
     ctxt->serror = NULL;
 }

 /**
  * xmlRelaxNGSetValidStructuredErrors:
  * @ctxt:  a Relax-NG validation context
  * @serror:  the structured error function
  * @ctx: the functions context
  *
  * Set the structured error callback
  */
 void
 xmlRelaxNGSetValidStructuredErrors(xmlRelaxNGValidCtxtPtr ctxt,
                                    xmlStructuredErrorFunc serror, void *ctx)
 {
     if (ctxt == NULL)
         return;
     ctxt->serror = serror;
     ctxt->error = NULL;
     ctxt->warning = NULL;
     ctxt->userData = ctx;
 }

 /**
  * xmlRelaxNGGetValidErrors:
  * @ctxt:  a Relax-NG validation context
  * @err:  the error function result
  * @warn: the warning function result
  * @ctx: the functions context result
  *
  * Get the error and warning callback informations
  *
  * Returns -1 in case of error and 0 otherwise
  */
 int
 xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
                          xmlRelaxNGValidityErrorFunc * err,
                          xmlRelaxNGValidityWarningFunc * warn, void **ctx)
 {
     if (ctxt == NULL)
         return (-1);
     if (err != NULL)
         *err = ctxt->error;
     if (warn != NULL)
         *warn = ctxt->warning;
     if (ctx != NULL)
         *ctx = ctxt->userData;
     return (0);
 }

 /**
  * xmlRelaxNGValidateDoc:
  * @ctxt:  a Relax-NG validation context
  * @doc:  a parsed document tree
  *
  * Validate a document tree in memory.
  *
  * Returns 0 if the document is valid, a positive error code
  *     number otherwise and -1 in case of internal or API error.
  */
 int
 xmlRelaxNGValidateDoc(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc)
 {
     int ret;

     if ((ctxt == NULL) || (doc == NULL))
         return (-1);

     ctxt->doc = doc;

     ret = xmlRelaxNGValidateDocument(ctxt, doc);
     /*
      * TODO: build error codes
      */
     if (ret == -1)
         return (1);
     return (ret);
 }

 #define bottom_relaxng
 #include "elfgcchack.h"
 #endif /* LIBXML_SCHEMAS_ENABLED */