Annotation of embedaddon/libxml2/relaxng.c, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * relaxng.c : implementation of the Relax-NG handling and validity checking
                      3:  *
                      4:  * See Copyright for the status of this software.
                      5:  *
                      6:  * Daniel Veillard <veillard@redhat.com>
                      7:  */
                      8: 
                      9: /**
                     10:  * TODO:
                     11:  * - add support for DTD compatibility spec
                     12:  *   http://www.oasis-open.org/committees/relax-ng/compatibility-20011203.html
                     13:  * - report better mem allocations pbms at runtime and abort immediately.
                     14:  */
                     15: 
                     16: #define IN_LIBXML
                     17: #include "libxml.h"
                     18: 
                     19: #ifdef LIBXML_SCHEMAS_ENABLED
                     20: 
                     21: #include <string.h>
                     22: #include <stdio.h>
                     23: #include <libxml/xmlmemory.h>
                     24: #include <libxml/parser.h>
                     25: #include <libxml/parserInternals.h>
                     26: #include <libxml/hash.h>
                     27: #include <libxml/uri.h>
                     28: 
                     29: #include <libxml/relaxng.h>
                     30: 
                     31: #include <libxml/xmlschemastypes.h>
                     32: #include <libxml/xmlautomata.h>
                     33: #include <libxml/xmlregexp.h>
                     34: #include <libxml/xmlschemastypes.h>
                     35: 
                     36: /*
                     37:  * The Relax-NG namespace
                     38:  */
                     39: static const xmlChar *xmlRelaxNGNs = (const xmlChar *)
                     40:     "http://relaxng.org/ns/structure/1.0";
                     41: 
                     42: #define IS_RELAXNG(node, type)                                         \
                     43:    ((node != NULL) && (node->ns != NULL) &&                            \
                     44:     (xmlStrEqual(node->name, (const xmlChar *) type)) &&               \
                     45:     (xmlStrEqual(node->ns->href, xmlRelaxNGNs)))
                     46: 
                     47: 
                     48: #if 0
                     49: #define DEBUG 1
                     50: 
                     51: #define DEBUG_GRAMMAR 1
                     52: 
                     53: #define DEBUG_CONTENT 1
                     54: 
                     55: #define DEBUG_TYPE 1
                     56: 
                     57: #define DEBUG_VALID 1
                     58: 
                     59: #define DEBUG_INTERLEAVE 1
                     60: 
                     61: #define DEBUG_LIST 1
                     62: 
                     63: #define DEBUG_INCLUDE 1 
                     64: 
                     65: #define DEBUG_ERROR 1
                     66: 
                     67: #define DEBUG_COMPILE 1
                     68: 
                     69: #define DEBUG_PROGRESSIVE 1
                     70: #endif
                     71: 
                     72: #define MAX_ERROR 5
                     73: 
                     74: #define TODO                                                           \
                     75:     xmlGenericError(xmlGenericErrorContext,                            \
                     76:            "Unimplemented block at %s:%d\n",                           \
                     77:             __FILE__, __LINE__);
                     78: 
                     79: typedef struct _xmlRelaxNGSchema xmlRelaxNGSchema;
                     80: typedef xmlRelaxNGSchema *xmlRelaxNGSchemaPtr;
                     81: 
                     82: typedef struct _xmlRelaxNGDefine xmlRelaxNGDefine;
                     83: typedef xmlRelaxNGDefine *xmlRelaxNGDefinePtr;
                     84: 
                     85: typedef struct _xmlRelaxNGDocument xmlRelaxNGDocument;
                     86: typedef xmlRelaxNGDocument *xmlRelaxNGDocumentPtr;
                     87: 
                     88: typedef struct _xmlRelaxNGInclude xmlRelaxNGInclude;
                     89: typedef xmlRelaxNGInclude *xmlRelaxNGIncludePtr;
                     90: 
                     91: typedef enum {
                     92:     XML_RELAXNG_COMBINE_UNDEFINED = 0,  /* undefined */
                     93:     XML_RELAXNG_COMBINE_CHOICE, /* choice */
                     94:     XML_RELAXNG_COMBINE_INTERLEAVE      /* interleave */
                     95: } xmlRelaxNGCombine;
                     96: 
                     97: typedef enum {
                     98:     XML_RELAXNG_CONTENT_ERROR = -1,
                     99:     XML_RELAXNG_CONTENT_EMPTY = 0,
                    100:     XML_RELAXNG_CONTENT_SIMPLE,
                    101:     XML_RELAXNG_CONTENT_COMPLEX
                    102: } xmlRelaxNGContentType;
                    103: 
                    104: typedef struct _xmlRelaxNGGrammar xmlRelaxNGGrammar;
                    105: typedef xmlRelaxNGGrammar *xmlRelaxNGGrammarPtr;
                    106: 
                    107: struct _xmlRelaxNGGrammar {
                    108:     xmlRelaxNGGrammarPtr parent;        /* the parent grammar if any */
                    109:     xmlRelaxNGGrammarPtr children;      /* the children grammar if any */
                    110:     xmlRelaxNGGrammarPtr next;  /* the next grammar if any */
                    111:     xmlRelaxNGDefinePtr start;  /* <start> content */
                    112:     xmlRelaxNGCombine combine;  /* the default combine value */
                    113:     xmlRelaxNGDefinePtr startList;      /* list of <start> definitions */
                    114:     xmlHashTablePtr defs;       /* define* */
                    115:     xmlHashTablePtr refs;       /* references */
                    116: };
                    117: 
                    118: 
                    119: typedef enum {
                    120:     XML_RELAXNG_NOOP = -1,      /* a no operation from simplification  */
                    121:     XML_RELAXNG_EMPTY = 0,      /* an empty pattern */
                    122:     XML_RELAXNG_NOT_ALLOWED,    /* not allowed top */
                    123:     XML_RELAXNG_EXCEPT,         /* except present in nameclass defs */
                    124:     XML_RELAXNG_TEXT,           /* textual content */
                    125:     XML_RELAXNG_ELEMENT,        /* an element */
                    126:     XML_RELAXNG_DATATYPE,       /* extenal data type definition */
                    127:     XML_RELAXNG_PARAM,          /* extenal data type parameter */
                    128:     XML_RELAXNG_VALUE,          /* value from an extenal data type definition */
                    129:     XML_RELAXNG_LIST,           /* a list of patterns */
                    130:     XML_RELAXNG_ATTRIBUTE,      /* an attrbute following a pattern */
                    131:     XML_RELAXNG_DEF,            /* a definition */
                    132:     XML_RELAXNG_REF,            /* reference to a definition */
                    133:     XML_RELAXNG_EXTERNALREF,    /* reference to an external def */
                    134:     XML_RELAXNG_PARENTREF,      /* reference to a def in the parent grammar */
                    135:     XML_RELAXNG_OPTIONAL,       /* optional patterns */
                    136:     XML_RELAXNG_ZEROORMORE,     /* zero or more non empty patterns */
                    137:     XML_RELAXNG_ONEORMORE,      /* one or more non empty patterns */
                    138:     XML_RELAXNG_CHOICE,         /* a choice between non empty patterns */
                    139:     XML_RELAXNG_GROUP,          /* a pair/group of non empty patterns */
                    140:     XML_RELAXNG_INTERLEAVE,     /* interleaving choice of non-empty patterns */
                    141:     XML_RELAXNG_START           /* Used to keep track of starts on grammars */
                    142: } xmlRelaxNGType;
                    143: 
                    144: #define IS_NULLABLE            (1 << 0)
                    145: #define IS_NOT_NULLABLE                (1 << 1)
                    146: #define IS_INDETERMINIST       (1 << 2)
                    147: #define IS_MIXED               (1 << 3)
                    148: #define IS_TRIABLE             (1 << 4)
                    149: #define IS_PROCESSED           (1 << 5)
                    150: #define IS_COMPILABLE          (1 << 6)
                    151: #define IS_NOT_COMPILABLE      (1 << 7)
                    152: #define IS_EXTERNAL_REF                (1 << 8)
                    153: 
                    154: struct _xmlRelaxNGDefine {
                    155:     xmlRelaxNGType type;        /* the type of definition */
                    156:     xmlNodePtr node;            /* the node in the source */
                    157:     xmlChar *name;              /* the element local name if present */
                    158:     xmlChar *ns;                /* the namespace local name if present */
                    159:     xmlChar *value;             /* value when available */
                    160:     void *data;                 /* data lib or specific pointer */
                    161:     xmlRelaxNGDefinePtr content;        /* the expected content */
                    162:     xmlRelaxNGDefinePtr parent; /* the parent definition, if any */
                    163:     xmlRelaxNGDefinePtr next;   /* list within grouping sequences */
                    164:     xmlRelaxNGDefinePtr attrs;  /* list of attributes for elements */
                    165:     xmlRelaxNGDefinePtr nameClass;      /* the nameClass definition if any */
                    166:     xmlRelaxNGDefinePtr nextHash;       /* next define in defs/refs hash tables */
                    167:     short depth;                /* used for the cycle detection */
                    168:     short dflags;               /* define related flags */
                    169:     xmlRegexpPtr contModel;     /* a compiled content model if available */
                    170: };
                    171: 
                    172: /**
                    173:  * _xmlRelaxNG:
                    174:  *
                    175:  * A RelaxNGs definition
                    176:  */
                    177: struct _xmlRelaxNG {
                    178:     void *_private;             /* unused by the library for users or bindings */
                    179:     xmlRelaxNGGrammarPtr topgrammar;
                    180:     xmlDocPtr doc;
                    181: 
                    182:     int idref;                  /* requires idref checking */
                    183: 
                    184:     xmlHashTablePtr defs;       /* define */
                    185:     xmlHashTablePtr refs;       /* references */
                    186:     xmlRelaxNGDocumentPtr documents;    /* all the documents loaded */
                    187:     xmlRelaxNGIncludePtr includes;      /* all the includes loaded */
                    188:     int defNr;                  /* number of defines used */
                    189:     xmlRelaxNGDefinePtr *defTab;        /* pointer to the allocated definitions */
                    190: 
                    191: };
                    192: 
                    193: #define XML_RELAXNG_IN_ATTRIBUTE       (1 << 0)
                    194: #define XML_RELAXNG_IN_ONEORMORE       (1 << 1)
                    195: #define XML_RELAXNG_IN_LIST            (1 << 2)
                    196: #define XML_RELAXNG_IN_DATAEXCEPT      (1 << 3)
                    197: #define XML_RELAXNG_IN_START           (1 << 4)
                    198: #define XML_RELAXNG_IN_OOMGROUP                (1 << 5)
                    199: #define XML_RELAXNG_IN_OOMINTERLEAVE   (1 << 6)
                    200: #define XML_RELAXNG_IN_EXTERNALREF     (1 << 7)
                    201: #define XML_RELAXNG_IN_ANYEXCEPT       (1 << 8)
                    202: #define XML_RELAXNG_IN_NSEXCEPT                (1 << 9)
                    203: 
                    204: struct _xmlRelaxNGParserCtxt {
                    205:     void *userData;             /* user specific data block */
                    206:     xmlRelaxNGValidityErrorFunc error;  /* the callback in case of errors */
                    207:     xmlRelaxNGValidityWarningFunc warning;      /* the callback in case of warning */
                    208:     xmlStructuredErrorFunc serror;
                    209:     xmlRelaxNGValidErr err;
                    210: 
                    211:     xmlRelaxNGPtr schema;       /* The schema in use */
                    212:     xmlRelaxNGGrammarPtr grammar;       /* the current grammar */
                    213:     xmlRelaxNGGrammarPtr parentgrammar; /* the parent grammar */
                    214:     int flags;                  /* parser flags */
                    215:     int nbErrors;               /* number of errors at parse time */
                    216:     int nbWarnings;             /* number of warnings at parse time */
                    217:     const xmlChar *define;      /* the current define scope */
                    218:     xmlRelaxNGDefinePtr def;    /* the current define */
                    219: 
                    220:     int nbInterleaves;
                    221:     xmlHashTablePtr interleaves;        /* keep track of all the interleaves */
                    222: 
                    223:     xmlRelaxNGDocumentPtr documents;    /* all the documents loaded */
                    224:     xmlRelaxNGIncludePtr includes;      /* all the includes loaded */
                    225:     xmlChar *URL;
                    226:     xmlDocPtr document;
                    227: 
                    228:     int defNr;                  /* number of defines used */
                    229:     int defMax;                 /* number of defines aloocated */
                    230:     xmlRelaxNGDefinePtr *defTab;        /* pointer to the allocated definitions */
                    231: 
                    232:     const char *buffer;
                    233:     int size;
                    234: 
                    235:     /* the document stack */
                    236:     xmlRelaxNGDocumentPtr doc;  /* Current parsed external ref */
                    237:     int docNr;                  /* Depth of the parsing stack */
                    238:     int docMax;                 /* Max depth of the parsing stack */
                    239:     xmlRelaxNGDocumentPtr *docTab;      /* array of docs */
                    240: 
                    241:     /* the include stack */
                    242:     xmlRelaxNGIncludePtr inc;   /* Current parsed include */
                    243:     int incNr;                  /* Depth of the include parsing stack */
                    244:     int incMax;                 /* Max depth of the parsing stack */
                    245:     xmlRelaxNGIncludePtr *incTab;       /* array of incs */
                    246: 
                    247:     int idref;                  /* requires idref checking */
                    248: 
                    249:     /* used to compile content models */
                    250:     xmlAutomataPtr am;          /* the automata */
                    251:     xmlAutomataStatePtr state;  /* used to build the automata */
                    252: 
                    253:     int crng;                  /* compact syntax and other flags */
                    254:     int freedoc;               /* need to free the document */
                    255: };
                    256: 
                    257: #define FLAGS_IGNORABLE                1
                    258: #define FLAGS_NEGATIVE         2
                    259: #define FLAGS_MIXED_CONTENT    4
                    260: #define FLAGS_NOERROR          8
                    261: 
                    262: /**
                    263:  * xmlRelaxNGInterleaveGroup:
                    264:  *
                    265:  * A RelaxNGs partition set associated to lists of definitions
                    266:  */
                    267: typedef struct _xmlRelaxNGInterleaveGroup xmlRelaxNGInterleaveGroup;
                    268: typedef xmlRelaxNGInterleaveGroup *xmlRelaxNGInterleaveGroupPtr;
                    269: struct _xmlRelaxNGInterleaveGroup {
                    270:     xmlRelaxNGDefinePtr rule;   /* the rule to satisfy */
                    271:     xmlRelaxNGDefinePtr *defs;  /* the array of element definitions */
                    272:     xmlRelaxNGDefinePtr *attrs; /* the array of attributes definitions */
                    273: };
                    274: 
                    275: #define IS_DETERMINIST         1
                    276: #define IS_NEEDCHECK           2
                    277: 
                    278: /**
                    279:  * xmlRelaxNGPartitions:
                    280:  *
                    281:  * A RelaxNGs partition associated to an interleave group
                    282:  */
                    283: typedef struct _xmlRelaxNGPartition xmlRelaxNGPartition;
                    284: typedef xmlRelaxNGPartition *xmlRelaxNGPartitionPtr;
                    285: struct _xmlRelaxNGPartition {
                    286:     int nbgroups;               /* number of groups in the partitions */
                    287:     xmlHashTablePtr triage;     /* hash table used to direct nodes to the
                    288:                                  * right group when possible */
                    289:     int flags;                  /* determinist ? */
                    290:     xmlRelaxNGInterleaveGroupPtr *groups;
                    291: };
                    292: 
                    293: /**
                    294:  * xmlRelaxNGValidState:
                    295:  *
                    296:  * A RelaxNGs validation state
                    297:  */
                    298: #define MAX_ATTR 20
                    299: typedef struct _xmlRelaxNGValidState xmlRelaxNGValidState;
                    300: typedef xmlRelaxNGValidState *xmlRelaxNGValidStatePtr;
                    301: struct _xmlRelaxNGValidState {
                    302:     xmlNodePtr node;            /* the current node */
                    303:     xmlNodePtr seq;             /* the sequence of children left to validate */
                    304:     int nbAttrs;                /* the number of attributes */
                    305:     int maxAttrs;               /* the size of attrs */
                    306:     int nbAttrLeft;             /* the number of attributes left to validate */
                    307:     xmlChar *value;             /* the value when operating on string */
                    308:     xmlChar *endvalue;          /* the end value when operating on string */
                    309:     xmlAttrPtr *attrs;          /* the array of attributes */
                    310: };
                    311: 
                    312: /**
                    313:  * xmlRelaxNGStates:
                    314:  *
                    315:  * A RelaxNGs container for validation state
                    316:  */
                    317: typedef struct _xmlRelaxNGStates xmlRelaxNGStates;
                    318: typedef xmlRelaxNGStates *xmlRelaxNGStatesPtr;
                    319: struct _xmlRelaxNGStates {
                    320:     int nbState;                /* the number of states */
                    321:     int maxState;               /* the size of the array */
                    322:     xmlRelaxNGValidStatePtr *tabState;
                    323: };
                    324: 
                    325: #define ERROR_IS_DUP   1
                    326: 
                    327: /**
                    328:  * xmlRelaxNGValidError:
                    329:  *
                    330:  * A RelaxNGs validation error
                    331:  */
                    332: typedef struct _xmlRelaxNGValidError xmlRelaxNGValidError;
                    333: typedef xmlRelaxNGValidError *xmlRelaxNGValidErrorPtr;
                    334: struct _xmlRelaxNGValidError {
                    335:     xmlRelaxNGValidErr err;     /* the error number */
                    336:     int flags;                  /* flags */
                    337:     xmlNodePtr node;            /* the current node */
                    338:     xmlNodePtr seq;             /* the current child */
                    339:     const xmlChar *arg1;        /* first arg */
                    340:     const xmlChar *arg2;        /* second arg */
                    341: };
                    342: 
                    343: /**
                    344:  * xmlRelaxNGValidCtxt:
                    345:  *
                    346:  * A RelaxNGs validation context
                    347:  */
                    348: 
                    349: struct _xmlRelaxNGValidCtxt {
                    350:     void *userData;             /* user specific data block */
                    351:     xmlRelaxNGValidityErrorFunc error;  /* the callback in case of errors */
                    352:     xmlRelaxNGValidityWarningFunc warning;      /* the callback in case of warning */
                    353:     xmlStructuredErrorFunc serror;
                    354:     int nbErrors;               /* number of errors in validation */
                    355: 
                    356:     xmlRelaxNGPtr schema;       /* The schema in use */
                    357:     xmlDocPtr doc;              /* the document being validated */
                    358:     int flags;                  /* validation flags */
                    359:     int depth;                  /* validation depth */
                    360:     int idref;                  /* requires idref checking */
                    361:     int errNo;                  /* the first error found */
                    362: 
                    363:     /*
                    364:      * Errors accumulated in branches may have to be stacked to be
                    365:      * provided back when it's sure they affect validation.
                    366:      */
                    367:     xmlRelaxNGValidErrorPtr err;        /* Last error */
                    368:     int errNr;                  /* Depth of the error stack */
                    369:     int errMax;                 /* Max depth of the error stack */
                    370:     xmlRelaxNGValidErrorPtr errTab;     /* stack of errors */
                    371: 
                    372:     xmlRelaxNGValidStatePtr state;      /* the current validation state */
                    373:     xmlRelaxNGStatesPtr states; /* the accumulated state list */
                    374: 
                    375:     xmlRelaxNGStatesPtr freeState;      /* the pool of free valid states */
                    376:     int freeStatesNr;
                    377:     int freeStatesMax;
                    378:     xmlRelaxNGStatesPtr *freeStates;    /* the pool of free state groups */
                    379: 
                    380:     /*
                    381:      * This is used for "progressive" validation
                    382:      */
                    383:     xmlRegExecCtxtPtr elem;     /* the current element regexp */
                    384:     int elemNr;                 /* the number of element validated */
                    385:     int elemMax;                /* the max depth of elements */
                    386:     xmlRegExecCtxtPtr *elemTab; /* the stack of regexp runtime */
                    387:     int pstate;                 /* progressive state */
                    388:     xmlNodePtr pnode;           /* the current node */
                    389:     xmlRelaxNGDefinePtr pdef;   /* the non-streamable definition */
                    390:     int perr;                   /* signal error in content model
                    391:                                  * outside the regexp */
                    392: };
                    393: 
                    394: /**
                    395:  * xmlRelaxNGInclude:
                    396:  *
                    397:  * Structure associated to a RelaxNGs document element
                    398:  */
                    399: struct _xmlRelaxNGInclude {
                    400:     xmlRelaxNGIncludePtr next;  /* keep a chain of includes */
                    401:     xmlChar *href;              /* the normalized href value */
                    402:     xmlDocPtr doc;              /* the associated XML document */
                    403:     xmlRelaxNGDefinePtr content;        /* the definitions */
                    404:     xmlRelaxNGPtr schema;       /* the schema */
                    405: };
                    406: 
                    407: /**
                    408:  * xmlRelaxNGDocument:
                    409:  *
                    410:  * Structure associated to a RelaxNGs document element
                    411:  */
                    412: struct _xmlRelaxNGDocument {
                    413:     xmlRelaxNGDocumentPtr next; /* keep a chain of documents */
                    414:     xmlChar *href;              /* the normalized href value */
                    415:     xmlDocPtr doc;              /* the associated XML document */
                    416:     xmlRelaxNGDefinePtr content;        /* the definitions */
                    417:     xmlRelaxNGPtr schema;       /* the schema */
                    418:     int externalRef;            /* 1 if an external ref */
                    419: };
                    420: 
                    421: 
                    422: /************************************************************************
                    423:  *                                                                     *
                    424:  *             Some factorized error routines                          *
                    425:  *                                                                     *
                    426:  ************************************************************************/
                    427: 
                    428: /**
                    429:  * xmlRngPErrMemory:
                    430:  * @ctxt:  an Relax-NG parser context
                    431:  * @extra:  extra informations
                    432:  *
                    433:  * Handle a redefinition of attribute error
                    434:  */
                    435: static void
                    436: xmlRngPErrMemory(xmlRelaxNGParserCtxtPtr ctxt, const char *extra)
                    437: {
                    438:     xmlStructuredErrorFunc schannel = NULL;
                    439:     xmlGenericErrorFunc channel = NULL;
                    440:     void *data = NULL;
                    441: 
                    442:     if (ctxt != NULL) {
                    443:         if (ctxt->serror != NULL)
                    444:            schannel = ctxt->serror;
                    445:        else
                    446:            channel = ctxt->error;
                    447:         data = ctxt->userData;
                    448:         ctxt->nbErrors++;
                    449:     }
                    450:     if (extra)
                    451:         __xmlRaiseError(schannel, channel, data,
                    452:                         NULL, NULL, XML_FROM_RELAXNGP,
                    453:                         XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
                    454:                         NULL, NULL, 0, 0,
                    455:                         "Memory allocation failed : %s\n", extra);
                    456:     else
                    457:         __xmlRaiseError(schannel, channel, data,
                    458:                         NULL, NULL, XML_FROM_RELAXNGP,
                    459:                         XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
                    460:                         NULL, NULL, 0, 0, "Memory allocation failed\n");
                    461: }
                    462: 
                    463: /**
                    464:  * xmlRngVErrMemory:
                    465:  * @ctxt:  a Relax-NG validation context
                    466:  * @extra:  extra informations
                    467:  *
                    468:  * Handle a redefinition of attribute error
                    469:  */
                    470: static void
                    471: xmlRngVErrMemory(xmlRelaxNGValidCtxtPtr ctxt, const char *extra)
                    472: {
                    473:     xmlStructuredErrorFunc schannel = NULL;
                    474:     xmlGenericErrorFunc channel = NULL;
                    475:     void *data = NULL;
                    476: 
                    477:     if (ctxt != NULL) {
                    478:         if (ctxt->serror != NULL)
                    479:            schannel = ctxt->serror;
                    480:        else
                    481:            channel = ctxt->error;
                    482:         data = ctxt->userData;
                    483:         ctxt->nbErrors++;
                    484:     }
                    485:     if (extra)
                    486:         __xmlRaiseError(schannel, channel, data,
                    487:                         NULL, NULL, XML_FROM_RELAXNGV,
                    488:                         XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
                    489:                         NULL, NULL, 0, 0,
                    490:                         "Memory allocation failed : %s\n", extra);
                    491:     else
                    492:         __xmlRaiseError(schannel, channel, data,
                    493:                         NULL, NULL, XML_FROM_RELAXNGV,
                    494:                         XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
                    495:                         NULL, NULL, 0, 0, "Memory allocation failed\n");
                    496: }
                    497: 
                    498: /**
                    499:  * xmlRngPErr:
                    500:  * @ctxt:  a Relax-NG parser context
                    501:  * @node:  the node raising the error
                    502:  * @error:  the error code
                    503:  * @msg:  message
                    504:  * @str1:  extra info
                    505:  * @str2:  extra info
                    506:  *
                    507:  * Handle a Relax NG Parsing error
                    508:  */
                    509: static void
                    510: xmlRngPErr(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node, int error,
                    511:            const char *msg, const xmlChar * str1, const xmlChar * str2)
                    512: {
                    513:     xmlStructuredErrorFunc schannel = NULL;
                    514:     xmlGenericErrorFunc channel = NULL;
                    515:     void *data = NULL;
                    516: 
                    517:     if (ctxt != NULL) {
                    518:         if (ctxt->serror != NULL)
                    519:            schannel = ctxt->serror;
                    520:        else
                    521:            channel = ctxt->error;
                    522:         data = ctxt->userData;
                    523:         ctxt->nbErrors++;
                    524:     }
                    525:     __xmlRaiseError(schannel, channel, data,
                    526:                     NULL, node, XML_FROM_RELAXNGP,
                    527:                     error, XML_ERR_ERROR, NULL, 0,
                    528:                     (const char *) str1, (const char *) str2, NULL, 0, 0,
                    529:                     msg, str1, str2);
                    530: }
                    531: 
                    532: /**
                    533:  * xmlRngVErr:
                    534:  * @ctxt:  a Relax-NG validation context
                    535:  * @node:  the node raising the error
                    536:  * @error:  the error code
                    537:  * @msg:  message
                    538:  * @str1:  extra info
                    539:  * @str2:  extra info
                    540:  *
                    541:  * Handle a Relax NG Validation error
                    542:  */
                    543: static void
                    544: xmlRngVErr(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node, int error,
                    545:            const char *msg, const xmlChar * str1, const xmlChar * str2)
                    546: {
                    547:     xmlStructuredErrorFunc schannel = NULL;
                    548:     xmlGenericErrorFunc channel = NULL;
                    549:     void *data = NULL;
                    550: 
                    551:     if (ctxt != NULL) {
                    552:         if (ctxt->serror != NULL)
                    553:            schannel = ctxt->serror;
                    554:        else
                    555:            channel = ctxt->error;
                    556:         data = ctxt->userData;
                    557:         ctxt->nbErrors++;
                    558:     }
                    559:     __xmlRaiseError(schannel, channel, data,
                    560:                     NULL, node, XML_FROM_RELAXNGV,
                    561:                     error, XML_ERR_ERROR, NULL, 0,
                    562:                     (const char *) str1, (const char *) str2, NULL, 0, 0,
                    563:                     msg, str1, str2);
                    564: }
                    565: 
                    566: /************************************************************************
                    567:  *                                                                     *
                    568:  *             Preliminary type checking interfaces                    *
                    569:  *                                                                     *
                    570:  ************************************************************************/
                    571: 
                    572: /**
                    573:  * xmlRelaxNGTypeHave:
                    574:  * @data:  data needed for the library
                    575:  * @type:  the type name
                    576:  * @value:  the value to check
                    577:  *
                    578:  * Function provided by a type library to check if a type is exported
                    579:  *
                    580:  * Returns 1 if yes, 0 if no and -1 in case of error.
                    581:  */
                    582: typedef int (*xmlRelaxNGTypeHave) (void *data, const xmlChar * type);
                    583: 
                    584: /**
                    585:  * xmlRelaxNGTypeCheck:
                    586:  * @data:  data needed for the library
                    587:  * @type:  the type name
                    588:  * @value:  the value to check
                    589:  * @result:  place to store the result if needed
                    590:  *
                    591:  * Function provided by a type library to check if a value match a type
                    592:  *
                    593:  * Returns 1 if yes, 0 if no and -1 in case of error.
                    594:  */
                    595: typedef int (*xmlRelaxNGTypeCheck) (void *data, const xmlChar * type,
                    596:                                     const xmlChar * value, void **result,
                    597:                                     xmlNodePtr node);
                    598: 
                    599: /**
                    600:  * xmlRelaxNGFacetCheck:
                    601:  * @data:  data needed for the library
                    602:  * @type:  the type name
                    603:  * @facet:  the facet name
                    604:  * @val:  the facet value
                    605:  * @strval:  the string value
                    606:  * @value:  the value to check
                    607:  *
                    608:  * Function provided by a type library to check a value facet
                    609:  *
                    610:  * Returns 1 if yes, 0 if no and -1 in case of error.
                    611:  */
                    612: typedef int (*xmlRelaxNGFacetCheck) (void *data, const xmlChar * type,
                    613:                                      const xmlChar * facet,
                    614:                                      const xmlChar * val,
                    615:                                      const xmlChar * strval, void *value);
                    616: 
                    617: /**
                    618:  * xmlRelaxNGTypeFree:
                    619:  * @data:  data needed for the library
                    620:  * @result:  the value to free
                    621:  *
                    622:  * Function provided by a type library to free a returned result
                    623:  */
                    624: typedef void (*xmlRelaxNGTypeFree) (void *data, void *result);
                    625: 
                    626: /**
                    627:  * xmlRelaxNGTypeCompare:
                    628:  * @data:  data needed for the library
                    629:  * @type:  the type name
                    630:  * @value1:  the first value
                    631:  * @value2:  the second value
                    632:  *
                    633:  * Function provided by a type library to compare two values accordingly
                    634:  * to a type.
                    635:  *
                    636:  * Returns 1 if yes, 0 if no and -1 in case of error.
                    637:  */
                    638: typedef int (*xmlRelaxNGTypeCompare) (void *data, const xmlChar * type,
                    639:                                       const xmlChar * value1,
                    640:                                       xmlNodePtr ctxt1,
                    641:                                       void *comp1,
                    642:                                       const xmlChar * value2,
                    643:                                       xmlNodePtr ctxt2);
                    644: typedef struct _xmlRelaxNGTypeLibrary xmlRelaxNGTypeLibrary;
                    645: typedef xmlRelaxNGTypeLibrary *xmlRelaxNGTypeLibraryPtr;
                    646: struct _xmlRelaxNGTypeLibrary {
                    647:     const xmlChar *namespace;   /* the datatypeLibrary value */
                    648:     void *data;                 /* data needed for the library */
                    649:     xmlRelaxNGTypeHave have;    /* the export function */
                    650:     xmlRelaxNGTypeCheck check;  /* the checking function */
                    651:     xmlRelaxNGTypeCompare comp; /* the compare function */
                    652:     xmlRelaxNGFacetCheck facet; /* the facet check function */
                    653:     xmlRelaxNGTypeFree freef;   /* the freeing function */
                    654: };
                    655: 
                    656: /************************************************************************
                    657:  *                                                                     *
                    658:  *                     Allocation functions                            *
                    659:  *                                                                     *
                    660:  ************************************************************************/
                    661: static void xmlRelaxNGFreeGrammar(xmlRelaxNGGrammarPtr grammar);
                    662: static void xmlRelaxNGFreeDefine(xmlRelaxNGDefinePtr define);
                    663: static void xmlRelaxNGNormExtSpace(xmlChar * value);
                    664: static void xmlRelaxNGFreeInnerSchema(xmlRelaxNGPtr schema);
                    665: static int xmlRelaxNGEqualValidState(xmlRelaxNGValidCtxtPtr ctxt
                    666:                                      ATTRIBUTE_UNUSED,
                    667:                                      xmlRelaxNGValidStatePtr state1,
                    668:                                      xmlRelaxNGValidStatePtr state2);
                    669: static void xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt,
                    670:                                      xmlRelaxNGValidStatePtr state);
                    671: 
                    672: /**
                    673:  * xmlRelaxNGFreeDocument:
                    674:  * @docu:  a document structure
                    675:  *
                    676:  * Deallocate a RelaxNG document structure.
                    677:  */
                    678: static void
                    679: xmlRelaxNGFreeDocument(xmlRelaxNGDocumentPtr docu)
                    680: {
                    681:     if (docu == NULL)
                    682:         return;
                    683: 
                    684:     if (docu->href != NULL)
                    685:         xmlFree(docu->href);
                    686:     if (docu->doc != NULL)
                    687:         xmlFreeDoc(docu->doc);
                    688:     if (docu->schema != NULL)
                    689:         xmlRelaxNGFreeInnerSchema(docu->schema);
                    690:     xmlFree(docu);
                    691: }
                    692: 
                    693: /**
                    694:  * xmlRelaxNGFreeDocumentList:
                    695:  * @docu:  a list of  document structure
                    696:  *
                    697:  * Deallocate a RelaxNG document structures.
                    698:  */
                    699: static void
                    700: xmlRelaxNGFreeDocumentList(xmlRelaxNGDocumentPtr docu)
                    701: {
                    702:     xmlRelaxNGDocumentPtr next;
                    703: 
                    704:     while (docu != NULL) {
                    705:         next = docu->next;
                    706:         xmlRelaxNGFreeDocument(docu);
                    707:         docu = next;
                    708:     }
                    709: }
                    710: 
                    711: /**
                    712:  * xmlRelaxNGFreeInclude:
                    713:  * @incl:  a include structure
                    714:  *
                    715:  * Deallocate a RelaxNG include structure.
                    716:  */
                    717: static void
                    718: xmlRelaxNGFreeInclude(xmlRelaxNGIncludePtr incl)
                    719: {
                    720:     if (incl == NULL)
                    721:         return;
                    722: 
                    723:     if (incl->href != NULL)
                    724:         xmlFree(incl->href);
                    725:     if (incl->doc != NULL)
                    726:         xmlFreeDoc(incl->doc);
                    727:     if (incl->schema != NULL)
                    728:         xmlRelaxNGFree(incl->schema);
                    729:     xmlFree(incl);
                    730: }
                    731: 
                    732: /**
                    733:  * xmlRelaxNGFreeIncludeList:
                    734:  * @incl:  a include structure list
                    735:  *
                    736:  * Deallocate a RelaxNG include structure.
                    737:  */
                    738: static void
                    739: xmlRelaxNGFreeIncludeList(xmlRelaxNGIncludePtr incl)
                    740: {
                    741:     xmlRelaxNGIncludePtr next;
                    742: 
                    743:     while (incl != NULL) {
                    744:         next = incl->next;
                    745:         xmlRelaxNGFreeInclude(incl);
                    746:         incl = next;
                    747:     }
                    748: }
                    749: 
                    750: /**
                    751:  * xmlRelaxNGNewRelaxNG:
                    752:  * @ctxt:  a Relax-NG validation context (optional)
                    753:  *
                    754:  * Allocate a new RelaxNG structure.
                    755:  *
                    756:  * Returns the newly allocated structure or NULL in case or error
                    757:  */
                    758: static xmlRelaxNGPtr
                    759: xmlRelaxNGNewRelaxNG(xmlRelaxNGParserCtxtPtr ctxt)
                    760: {
                    761:     xmlRelaxNGPtr ret;
                    762: 
                    763:     ret = (xmlRelaxNGPtr) xmlMalloc(sizeof(xmlRelaxNG));
                    764:     if (ret == NULL) {
                    765:         xmlRngPErrMemory(ctxt, NULL);
                    766:         return (NULL);
                    767:     }
                    768:     memset(ret, 0, sizeof(xmlRelaxNG));
                    769: 
                    770:     return (ret);
                    771: }
                    772: 
                    773: /**
                    774:  * xmlRelaxNGFreeInnerSchema:
                    775:  * @schema:  a schema structure
                    776:  *
                    777:  * Deallocate a RelaxNG schema structure.
                    778:  */
                    779: static void
                    780: xmlRelaxNGFreeInnerSchema(xmlRelaxNGPtr schema)
                    781: {
                    782:     if (schema == NULL)
                    783:         return;
                    784: 
                    785:     if (schema->doc != NULL)
                    786:         xmlFreeDoc(schema->doc);
                    787:     if (schema->defTab != NULL) {
                    788:         int i;
                    789: 
                    790:         for (i = 0; i < schema->defNr; i++)
                    791:             xmlRelaxNGFreeDefine(schema->defTab[i]);
                    792:         xmlFree(schema->defTab);
                    793:     }
                    794: 
                    795:     xmlFree(schema);
                    796: }
                    797: 
                    798: /**
                    799:  * xmlRelaxNGFree:
                    800:  * @schema:  a schema structure
                    801:  *
                    802:  * Deallocate a RelaxNG structure.
                    803:  */
                    804: void
                    805: xmlRelaxNGFree(xmlRelaxNGPtr schema)
                    806: {
                    807:     if (schema == NULL)
                    808:         return;
                    809: 
                    810:     if (schema->topgrammar != NULL)
                    811:         xmlRelaxNGFreeGrammar(schema->topgrammar);
                    812:     if (schema->doc != NULL)
                    813:         xmlFreeDoc(schema->doc);
                    814:     if (schema->documents != NULL)
                    815:         xmlRelaxNGFreeDocumentList(schema->documents);
                    816:     if (schema->includes != NULL)
                    817:         xmlRelaxNGFreeIncludeList(schema->includes);
                    818:     if (schema->defTab != NULL) {
                    819:         int i;
                    820: 
                    821:         for (i = 0; i < schema->defNr; i++)
                    822:             xmlRelaxNGFreeDefine(schema->defTab[i]);
                    823:         xmlFree(schema->defTab);
                    824:     }
                    825: 
                    826:     xmlFree(schema);
                    827: }
                    828: 
                    829: /**
                    830:  * xmlRelaxNGNewGrammar:
                    831:  * @ctxt:  a Relax-NG validation context (optional)
                    832:  *
                    833:  * Allocate a new RelaxNG grammar.
                    834:  *
                    835:  * Returns the newly allocated structure or NULL in case or error
                    836:  */
                    837: static xmlRelaxNGGrammarPtr
                    838: xmlRelaxNGNewGrammar(xmlRelaxNGParserCtxtPtr ctxt)
                    839: {
                    840:     xmlRelaxNGGrammarPtr ret;
                    841: 
                    842:     ret = (xmlRelaxNGGrammarPtr) xmlMalloc(sizeof(xmlRelaxNGGrammar));
                    843:     if (ret == NULL) {
                    844:         xmlRngPErrMemory(ctxt, NULL);
                    845:         return (NULL);
                    846:     }
                    847:     memset(ret, 0, sizeof(xmlRelaxNGGrammar));
                    848: 
                    849:     return (ret);
                    850: }
                    851: 
                    852: /**
                    853:  * xmlRelaxNGFreeGrammar:
                    854:  * @grammar:  a grammar structure
                    855:  *
                    856:  * Deallocate a RelaxNG grammar structure.
                    857:  */
                    858: static void
                    859: xmlRelaxNGFreeGrammar(xmlRelaxNGGrammarPtr grammar)
                    860: {
                    861:     if (grammar == NULL)
                    862:         return;
                    863: 
                    864:     if (grammar->children != NULL) {
                    865:         xmlRelaxNGFreeGrammar(grammar->children);
                    866:     }
                    867:     if (grammar->next != NULL) {
                    868:         xmlRelaxNGFreeGrammar(grammar->next);
                    869:     }
                    870:     if (grammar->refs != NULL) {
                    871:         xmlHashFree(grammar->refs, NULL);
                    872:     }
                    873:     if (grammar->defs != NULL) {
                    874:         xmlHashFree(grammar->defs, NULL);
                    875:     }
                    876: 
                    877:     xmlFree(grammar);
                    878: }
                    879: 
                    880: /**
                    881:  * xmlRelaxNGNewDefine:
                    882:  * @ctxt:  a Relax-NG validation context
                    883:  * @node:  the node in the input document.
                    884:  *
                    885:  * Allocate a new RelaxNG define.
                    886:  *
                    887:  * Returns the newly allocated structure or NULL in case or error
                    888:  */
                    889: static xmlRelaxNGDefinePtr
                    890: xmlRelaxNGNewDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
                    891: {
                    892:     xmlRelaxNGDefinePtr ret;
                    893: 
                    894:     if (ctxt->defMax == 0) {
                    895:         ctxt->defMax = 16;
                    896:         ctxt->defNr = 0;
                    897:         ctxt->defTab = (xmlRelaxNGDefinePtr *)
                    898:             xmlMalloc(ctxt->defMax * sizeof(xmlRelaxNGDefinePtr));
                    899:         if (ctxt->defTab == NULL) {
                    900:             xmlRngPErrMemory(ctxt, "allocating define\n");
                    901:             return (NULL);
                    902:         }
                    903:     } else if (ctxt->defMax <= ctxt->defNr) {
                    904:         xmlRelaxNGDefinePtr *tmp;
                    905: 
                    906:         ctxt->defMax *= 2;
                    907:         tmp = (xmlRelaxNGDefinePtr *) xmlRealloc(ctxt->defTab,
                    908:                                                  ctxt->defMax *
                    909:                                                  sizeof
                    910:                                                  (xmlRelaxNGDefinePtr));
                    911:         if (tmp == NULL) {
                    912:             xmlRngPErrMemory(ctxt, "allocating define\n");
                    913:             return (NULL);
                    914:         }
                    915:         ctxt->defTab = tmp;
                    916:     }
                    917:     ret = (xmlRelaxNGDefinePtr) xmlMalloc(sizeof(xmlRelaxNGDefine));
                    918:     if (ret == NULL) {
                    919:         xmlRngPErrMemory(ctxt, "allocating define\n");
                    920:         return (NULL);
                    921:     }
                    922:     memset(ret, 0, sizeof(xmlRelaxNGDefine));
                    923:     ctxt->defTab[ctxt->defNr++] = ret;
                    924:     ret->node = node;
                    925:     ret->depth = -1;
                    926:     return (ret);
                    927: }
                    928: 
                    929: /**
                    930:  * xmlRelaxNGFreePartition:
                    931:  * @partitions:  a partition set structure
                    932:  *
                    933:  * Deallocate RelaxNG partition set structures.
                    934:  */
                    935: static void
                    936: xmlRelaxNGFreePartition(xmlRelaxNGPartitionPtr partitions)
                    937: {
                    938:     xmlRelaxNGInterleaveGroupPtr group;
                    939:     int j;
                    940: 
                    941:     if (partitions != NULL) {
                    942:         if (partitions->groups != NULL) {
                    943:             for (j = 0; j < partitions->nbgroups; j++) {
                    944:                 group = partitions->groups[j];
                    945:                 if (group != NULL) {
                    946:                     if (group->defs != NULL)
                    947:                         xmlFree(group->defs);
                    948:                     if (group->attrs != NULL)
                    949:                         xmlFree(group->attrs);
                    950:                     xmlFree(group);
                    951:                 }
                    952:             }
                    953:             xmlFree(partitions->groups);
                    954:         }
                    955:         if (partitions->triage != NULL) {
                    956:             xmlHashFree(partitions->triage, NULL);
                    957:         }
                    958:         xmlFree(partitions);
                    959:     }
                    960: }
                    961: 
                    962: /**
                    963:  * xmlRelaxNGFreeDefine:
                    964:  * @define:  a define structure
                    965:  *
                    966:  * Deallocate a RelaxNG define structure.
                    967:  */
                    968: static void
                    969: xmlRelaxNGFreeDefine(xmlRelaxNGDefinePtr define)
                    970: {
                    971:     if (define == NULL)
                    972:         return;
                    973: 
                    974:     if ((define->type == XML_RELAXNG_VALUE) && (define->attrs != NULL)) {
                    975:         xmlRelaxNGTypeLibraryPtr lib;
                    976: 
                    977:         lib = (xmlRelaxNGTypeLibraryPtr) define->data;
                    978:         if ((lib != NULL) && (lib->freef != NULL))
                    979:             lib->freef(lib->data, (void *) define->attrs);
                    980:     }
                    981:     if ((define->data != NULL) && (define->type == XML_RELAXNG_INTERLEAVE))
                    982:         xmlRelaxNGFreePartition((xmlRelaxNGPartitionPtr) define->data);
                    983:     if ((define->data != NULL) && (define->type == XML_RELAXNG_CHOICE))
                    984:         xmlHashFree((xmlHashTablePtr) define->data, NULL);
                    985:     if (define->name != NULL)
                    986:         xmlFree(define->name);
                    987:     if (define->ns != NULL)
                    988:         xmlFree(define->ns);
                    989:     if (define->value != NULL)
                    990:         xmlFree(define->value);
                    991:     if (define->contModel != NULL)
                    992:         xmlRegFreeRegexp(define->contModel);
                    993:     xmlFree(define);
                    994: }
                    995: 
                    996: /**
                    997:  * xmlRelaxNGNewStates:
                    998:  * @ctxt:  a Relax-NG validation context
                    999:  * @size:  the default size for the container
                   1000:  *
                   1001:  * Allocate a new RelaxNG validation state container
                   1002:  *
                   1003:  * Returns the newly allocated structure or NULL in case or error
                   1004:  */
                   1005: static xmlRelaxNGStatesPtr
                   1006: xmlRelaxNGNewStates(xmlRelaxNGValidCtxtPtr ctxt, int size)
                   1007: {
                   1008:     xmlRelaxNGStatesPtr ret;
                   1009: 
                   1010:     if ((ctxt != NULL) &&
                   1011:         (ctxt->freeStates != NULL) && (ctxt->freeStatesNr > 0)) {
                   1012:         ctxt->freeStatesNr--;
                   1013:         ret = ctxt->freeStates[ctxt->freeStatesNr];
                   1014:         ret->nbState = 0;
                   1015:         return (ret);
                   1016:     }
                   1017:     if (size < 16)
                   1018:         size = 16;
                   1019: 
                   1020:     ret = (xmlRelaxNGStatesPtr) xmlMalloc(sizeof(xmlRelaxNGStates) +
                   1021:                                           (size -
                   1022:                                            1) *
                   1023:                                           sizeof(xmlRelaxNGValidStatePtr));
                   1024:     if (ret == NULL) {
                   1025:         xmlRngVErrMemory(ctxt, "allocating states\n");
                   1026:         return (NULL);
                   1027:     }
                   1028:     ret->nbState = 0;
                   1029:     ret->maxState = size;
                   1030:     ret->tabState = (xmlRelaxNGValidStatePtr *) xmlMalloc((size) *
                   1031:                                                           sizeof
                   1032:                                                           (xmlRelaxNGValidStatePtr));
                   1033:     if (ret->tabState == NULL) {
                   1034:         xmlRngVErrMemory(ctxt, "allocating states\n");
                   1035:         xmlFree(ret);
                   1036:         return (NULL);
                   1037:     }
                   1038:     return (ret);
                   1039: }
                   1040: 
                   1041: /**
                   1042:  * xmlRelaxNGAddStateUniq:
                   1043:  * @ctxt:  a Relax-NG validation context
                   1044:  * @states:  the states container
                   1045:  * @state:  the validation state
                   1046:  *
                   1047:  * Add a RelaxNG validation state to the container without checking
                   1048:  * for unicity.
                   1049:  *
                   1050:  * Return 1 in case of success and 0 if this is a duplicate and -1 on error
                   1051:  */
                   1052: static int
                   1053: xmlRelaxNGAddStatesUniq(xmlRelaxNGValidCtxtPtr ctxt,
                   1054:                         xmlRelaxNGStatesPtr states,
                   1055:                         xmlRelaxNGValidStatePtr state)
                   1056: {
                   1057:     if (state == NULL) {
                   1058:         return (-1);
                   1059:     }
                   1060:     if (states->nbState >= states->maxState) {
                   1061:         xmlRelaxNGValidStatePtr *tmp;
                   1062:         int size;
                   1063: 
                   1064:         size = states->maxState * 2;
                   1065:         tmp = (xmlRelaxNGValidStatePtr *) xmlRealloc(states->tabState,
                   1066:                                                      (size) *
                   1067:                                                      sizeof
                   1068:                                                      (xmlRelaxNGValidStatePtr));
                   1069:         if (tmp == NULL) {
                   1070:             xmlRngVErrMemory(ctxt, "adding states\n");
                   1071:             return (-1);
                   1072:         }
                   1073:         states->tabState = tmp;
                   1074:         states->maxState = size;
                   1075:     }
                   1076:     states->tabState[states->nbState++] = state;
                   1077:     return (1);
                   1078: }
                   1079: 
                   1080: /**
                   1081:  * xmlRelaxNGAddState:
                   1082:  * @ctxt:  a Relax-NG validation context
                   1083:  * @states:  the states container
                   1084:  * @state:  the validation state
                   1085:  *
                   1086:  * Add a RelaxNG validation state to the container
                   1087:  *
                   1088:  * Return 1 in case of success and 0 if this is a duplicate and -1 on error
                   1089:  */
                   1090: static int
                   1091: xmlRelaxNGAddStates(xmlRelaxNGValidCtxtPtr ctxt,
                   1092:                     xmlRelaxNGStatesPtr states,
                   1093:                     xmlRelaxNGValidStatePtr state)
                   1094: {
                   1095:     int i;
                   1096: 
                   1097:     if (state == NULL) {
                   1098:         return (-1);
                   1099:     }
                   1100:     if (states->nbState >= states->maxState) {
                   1101:         xmlRelaxNGValidStatePtr *tmp;
                   1102:         int size;
                   1103: 
                   1104:         size = states->maxState * 2;
                   1105:         tmp = (xmlRelaxNGValidStatePtr *) xmlRealloc(states->tabState,
                   1106:                                                      (size) *
                   1107:                                                      sizeof
                   1108:                                                      (xmlRelaxNGValidStatePtr));
                   1109:         if (tmp == NULL) {
                   1110:             xmlRngVErrMemory(ctxt, "adding states\n");
                   1111:             return (-1);
                   1112:         }
                   1113:         states->tabState = tmp;
                   1114:         states->maxState = size;
                   1115:     }
                   1116:     for (i = 0; i < states->nbState; i++) {
                   1117:         if (xmlRelaxNGEqualValidState(ctxt, state, states->tabState[i])) {
                   1118:             xmlRelaxNGFreeValidState(ctxt, state);
                   1119:             return (0);
                   1120:         }
                   1121:     }
                   1122:     states->tabState[states->nbState++] = state;
                   1123:     return (1);
                   1124: }
                   1125: 
                   1126: /**
                   1127:  * xmlRelaxNGFreeStates:
                   1128:  * @ctxt:  a Relax-NG validation context
                   1129:  * @states:  teh container
                   1130:  *
                   1131:  * Free a RelaxNG validation state container
                   1132:  */
                   1133: static void
                   1134: xmlRelaxNGFreeStates(xmlRelaxNGValidCtxtPtr ctxt,
                   1135:                      xmlRelaxNGStatesPtr states)
                   1136: {
                   1137:     if (states == NULL)
                   1138:         return;
                   1139:     if ((ctxt != NULL) && (ctxt->freeStates == NULL)) {
                   1140:         ctxt->freeStatesMax = 40;
                   1141:         ctxt->freeStatesNr = 0;
                   1142:         ctxt->freeStates = (xmlRelaxNGStatesPtr *)
                   1143:             xmlMalloc(ctxt->freeStatesMax * sizeof(xmlRelaxNGStatesPtr));
                   1144:         if (ctxt->freeStates == NULL) {
                   1145:             xmlRngVErrMemory(ctxt, "storing states\n");
                   1146:         }
                   1147:     } else if ((ctxt != NULL)
                   1148:                && (ctxt->freeStatesNr >= ctxt->freeStatesMax)) {
                   1149:         xmlRelaxNGStatesPtr *tmp;
                   1150: 
                   1151:         tmp = (xmlRelaxNGStatesPtr *) xmlRealloc(ctxt->freeStates,
                   1152:                                                  2 * ctxt->freeStatesMax *
                   1153:                                                  sizeof
                   1154:                                                  (xmlRelaxNGStatesPtr));
                   1155:         if (tmp == NULL) {
                   1156:             xmlRngVErrMemory(ctxt, "storing states\n");
                   1157:             xmlFree(states->tabState);
                   1158:             xmlFree(states);
                   1159:             return;
                   1160:         }
                   1161:         ctxt->freeStates = tmp;
                   1162:         ctxt->freeStatesMax *= 2;
                   1163:     }
                   1164:     if ((ctxt == NULL) || (ctxt->freeStates == NULL)) {
                   1165:         xmlFree(states->tabState);
                   1166:         xmlFree(states);
                   1167:     } else {
                   1168:         ctxt->freeStates[ctxt->freeStatesNr++] = states;
                   1169:     }
                   1170: }
                   1171: 
                   1172: /**
                   1173:  * xmlRelaxNGNewValidState:
                   1174:  * @ctxt:  a Relax-NG validation context
                   1175:  * @node:  the current node or NULL for the document
                   1176:  *
                   1177:  * Allocate a new RelaxNG validation state
                   1178:  *
                   1179:  * Returns the newly allocated structure or NULL in case or error
                   1180:  */
                   1181: static xmlRelaxNGValidStatePtr
                   1182: xmlRelaxNGNewValidState(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node)
                   1183: {
                   1184:     xmlRelaxNGValidStatePtr ret;
                   1185:     xmlAttrPtr attr;
                   1186:     xmlAttrPtr attrs[MAX_ATTR];
                   1187:     int nbAttrs = 0;
                   1188:     xmlNodePtr root = NULL;
                   1189: 
                   1190:     if (node == NULL) {
                   1191:         root = xmlDocGetRootElement(ctxt->doc);
                   1192:         if (root == NULL)
                   1193:             return (NULL);
                   1194:     } else {
                   1195:         attr = node->properties;
                   1196:         while (attr != NULL) {
                   1197:             if (nbAttrs < MAX_ATTR)
                   1198:                 attrs[nbAttrs++] = attr;
                   1199:             else
                   1200:                 nbAttrs++;
                   1201:             attr = attr->next;
                   1202:         }
                   1203:     }
                   1204:     if ((ctxt->freeState != NULL) && (ctxt->freeState->nbState > 0)) {
                   1205:         ctxt->freeState->nbState--;
                   1206:         ret = ctxt->freeState->tabState[ctxt->freeState->nbState];
                   1207:     } else {
                   1208:         ret =
                   1209:             (xmlRelaxNGValidStatePtr)
                   1210:             xmlMalloc(sizeof(xmlRelaxNGValidState));
                   1211:         if (ret == NULL) {
                   1212:             xmlRngVErrMemory(ctxt, "allocating states\n");
                   1213:             return (NULL);
                   1214:         }
                   1215:         memset(ret, 0, sizeof(xmlRelaxNGValidState));
                   1216:     }
                   1217:     ret->value = NULL;
                   1218:     ret->endvalue = NULL;
                   1219:     if (node == NULL) {
                   1220:         ret->node = (xmlNodePtr) ctxt->doc;
                   1221:         ret->seq = root;
                   1222:     } else {
                   1223:         ret->node = node;
                   1224:         ret->seq = node->children;
                   1225:     }
                   1226:     ret->nbAttrs = 0;
                   1227:     if (nbAttrs > 0) {
                   1228:         if (ret->attrs == NULL) {
                   1229:             if (nbAttrs < 4)
                   1230:                 ret->maxAttrs = 4;
                   1231:             else
                   1232:                 ret->maxAttrs = nbAttrs;
                   1233:             ret->attrs = (xmlAttrPtr *) xmlMalloc(ret->maxAttrs *
                   1234:                                                   sizeof(xmlAttrPtr));
                   1235:             if (ret->attrs == NULL) {
                   1236:                 xmlRngVErrMemory(ctxt, "allocating states\n");
                   1237:                 return (ret);
                   1238:             }
                   1239:         } else if (ret->maxAttrs < nbAttrs) {
                   1240:             xmlAttrPtr *tmp;
                   1241: 
                   1242:             tmp = (xmlAttrPtr *) xmlRealloc(ret->attrs, nbAttrs *
                   1243:                                             sizeof(xmlAttrPtr));
                   1244:             if (tmp == NULL) {
                   1245:                 xmlRngVErrMemory(ctxt, "allocating states\n");
                   1246:                 return (ret);
                   1247:             }
                   1248:             ret->attrs = tmp;
                   1249:             ret->maxAttrs = nbAttrs;
                   1250:         }
                   1251:         ret->nbAttrs = nbAttrs;
                   1252:         if (nbAttrs < MAX_ATTR) {
                   1253:             memcpy(ret->attrs, attrs, sizeof(xmlAttrPtr) * nbAttrs);
                   1254:         } else {
                   1255:             attr = node->properties;
                   1256:             nbAttrs = 0;
                   1257:             while (attr != NULL) {
                   1258:                 ret->attrs[nbAttrs++] = attr;
                   1259:                 attr = attr->next;
                   1260:             }
                   1261:         }
                   1262:     }
                   1263:     ret->nbAttrLeft = ret->nbAttrs;
                   1264:     return (ret);
                   1265: }
                   1266: 
                   1267: /**
                   1268:  * xmlRelaxNGCopyValidState:
                   1269:  * @ctxt:  a Relax-NG validation context
                   1270:  * @state:  a validation state
                   1271:  *
                   1272:  * Copy the validation state
                   1273:  *
                   1274:  * Returns the newly allocated structure or NULL in case or error
                   1275:  */
                   1276: static xmlRelaxNGValidStatePtr
                   1277: xmlRelaxNGCopyValidState(xmlRelaxNGValidCtxtPtr ctxt,
                   1278:                          xmlRelaxNGValidStatePtr state)
                   1279: {
                   1280:     xmlRelaxNGValidStatePtr ret;
                   1281:     unsigned int maxAttrs;
                   1282:     xmlAttrPtr *attrs;
                   1283: 
                   1284:     if (state == NULL)
                   1285:         return (NULL);
                   1286:     if ((ctxt->freeState != NULL) && (ctxt->freeState->nbState > 0)) {
                   1287:         ctxt->freeState->nbState--;
                   1288:         ret = ctxt->freeState->tabState[ctxt->freeState->nbState];
                   1289:     } else {
                   1290:         ret =
                   1291:             (xmlRelaxNGValidStatePtr)
                   1292:             xmlMalloc(sizeof(xmlRelaxNGValidState));
                   1293:         if (ret == NULL) {
                   1294:             xmlRngVErrMemory(ctxt, "allocating states\n");
                   1295:             return (NULL);
                   1296:         }
                   1297:         memset(ret, 0, sizeof(xmlRelaxNGValidState));
                   1298:     }
                   1299:     attrs = ret->attrs;
                   1300:     maxAttrs = ret->maxAttrs;
                   1301:     memcpy(ret, state, sizeof(xmlRelaxNGValidState));
                   1302:     ret->attrs = attrs;
                   1303:     ret->maxAttrs = maxAttrs;
                   1304:     if (state->nbAttrs > 0) {
                   1305:         if (ret->attrs == NULL) {
                   1306:             ret->maxAttrs = state->maxAttrs;
                   1307:             ret->attrs = (xmlAttrPtr *) xmlMalloc(ret->maxAttrs *
                   1308:                                                   sizeof(xmlAttrPtr));
                   1309:             if (ret->attrs == NULL) {
                   1310:                 xmlRngVErrMemory(ctxt, "allocating states\n");
                   1311:                 ret->nbAttrs = 0;
                   1312:                 return (ret);
                   1313:             }
                   1314:         } else if (ret->maxAttrs < state->nbAttrs) {
                   1315:             xmlAttrPtr *tmp;
                   1316: 
                   1317:             tmp = (xmlAttrPtr *) xmlRealloc(ret->attrs, state->maxAttrs *
                   1318:                                             sizeof(xmlAttrPtr));
                   1319:             if (tmp == NULL) {
                   1320:                 xmlRngVErrMemory(ctxt, "allocating states\n");
                   1321:                 ret->nbAttrs = 0;
                   1322:                 return (ret);
                   1323:             }
                   1324:             ret->maxAttrs = state->maxAttrs;
                   1325:             ret->attrs = tmp;
                   1326:         }
                   1327:         memcpy(ret->attrs, state->attrs,
                   1328:                state->nbAttrs * sizeof(xmlAttrPtr));
                   1329:     }
                   1330:     return (ret);
                   1331: }
                   1332: 
                   1333: /**
                   1334:  * xmlRelaxNGEqualValidState:
                   1335:  * @ctxt:  a Relax-NG validation context
                   1336:  * @state1:  a validation state
                   1337:  * @state2:  a validation state
                   1338:  *
                   1339:  * Compare the validation states for equality
                   1340:  *
                   1341:  * Returns 1 if equald, 0 otherwise
                   1342:  */
                   1343: static int
                   1344: xmlRelaxNGEqualValidState(xmlRelaxNGValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
                   1345:                           xmlRelaxNGValidStatePtr state1,
                   1346:                           xmlRelaxNGValidStatePtr state2)
                   1347: {
                   1348:     int i;
                   1349: 
                   1350:     if ((state1 == NULL) || (state2 == NULL))
                   1351:         return (0);
                   1352:     if (state1 == state2)
                   1353:         return (1);
                   1354:     if (state1->node != state2->node)
                   1355:         return (0);
                   1356:     if (state1->seq != state2->seq)
                   1357:         return (0);
                   1358:     if (state1->nbAttrLeft != state2->nbAttrLeft)
                   1359:         return (0);
                   1360:     if (state1->nbAttrs != state2->nbAttrs)
                   1361:         return (0);
                   1362:     if (state1->endvalue != state2->endvalue)
                   1363:         return (0);
                   1364:     if ((state1->value != state2->value) &&
                   1365:         (!xmlStrEqual(state1->value, state2->value)))
                   1366:         return (0);
                   1367:     for (i = 0; i < state1->nbAttrs; i++) {
                   1368:         if (state1->attrs[i] != state2->attrs[i])
                   1369:             return (0);
                   1370:     }
                   1371:     return (1);
                   1372: }
                   1373: 
                   1374: /**
                   1375:  * xmlRelaxNGFreeValidState:
                   1376:  * @state:  a validation state structure
                   1377:  *
                   1378:  * Deallocate a RelaxNG validation state structure.
                   1379:  */
                   1380: static void
                   1381: xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt,
                   1382:                          xmlRelaxNGValidStatePtr state)
                   1383: {
                   1384:     if (state == NULL)
                   1385:         return;
                   1386: 
                   1387:     if ((ctxt != NULL) && (ctxt->freeState == NULL)) {
                   1388:         ctxt->freeState = xmlRelaxNGNewStates(ctxt, 40);
                   1389:     }
                   1390:     if ((ctxt == NULL) || (ctxt->freeState == NULL)) {
                   1391:         if (state->attrs != NULL)
                   1392:             xmlFree(state->attrs);
                   1393:         xmlFree(state);
                   1394:     } else {
                   1395:         xmlRelaxNGAddStatesUniq(ctxt, ctxt->freeState, state);
                   1396:     }
                   1397: }
                   1398: 
                   1399: /************************************************************************
                   1400:  *                                                                     *
                   1401:  *                     Semi internal functions                         *
                   1402:  *                                                                     *
                   1403:  ************************************************************************/
                   1404: 
                   1405: /**
                   1406:  * xmlRelaxParserSetFlag:
                   1407:  * @ctxt: a RelaxNG parser context
                   1408:  * @flags: a set of flags values
                   1409:  *
                   1410:  * Semi private function used to pass informations to a parser context
                   1411:  * which are a combination of xmlRelaxNGParserFlag .
                   1412:  *
                   1413:  * Returns 0 if success and -1 in case of error
                   1414:  */
                   1415: int
                   1416: xmlRelaxParserSetFlag(xmlRelaxNGParserCtxtPtr ctxt, int flags)
                   1417: {
                   1418:     if (ctxt == NULL) return(-1);
                   1419:     if (flags & XML_RELAXNGP_FREE_DOC) {
                   1420:         ctxt->crng |= XML_RELAXNGP_FREE_DOC;
                   1421:        flags -= XML_RELAXNGP_FREE_DOC;
                   1422:     }
                   1423:     if (flags & XML_RELAXNGP_CRNG) {
                   1424:         ctxt->crng |= XML_RELAXNGP_CRNG;
                   1425:        flags -= XML_RELAXNGP_CRNG;
                   1426:     }
                   1427:     if (flags != 0) return(-1);
                   1428:     return(0);
                   1429: }
                   1430: 
                   1431: /************************************************************************
                   1432:  *                                                                     *
                   1433:  *                     Document functions                              *
                   1434:  *                                                                     *
                   1435:  ************************************************************************/
                   1436: static xmlDocPtr xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt,
                   1437:                                       xmlDocPtr doc);
                   1438: 
                   1439: /**
                   1440:  * xmlRelaxNGIncludePush:
                   1441:  * @ctxt:  the parser context
                   1442:  * @value:  the element doc
                   1443:  *
                   1444:  * Pushes a new include on top of the include stack
                   1445:  *
                   1446:  * Returns 0 in case of error, the index in the stack otherwise
                   1447:  */
                   1448: static int
                   1449: xmlRelaxNGIncludePush(xmlRelaxNGParserCtxtPtr ctxt,
                   1450:                       xmlRelaxNGIncludePtr value)
                   1451: {
                   1452:     if (ctxt->incTab == NULL) {
                   1453:         ctxt->incMax = 4;
                   1454:         ctxt->incNr = 0;
                   1455:         ctxt->incTab =
                   1456:             (xmlRelaxNGIncludePtr *) xmlMalloc(ctxt->incMax *
                   1457:                                                sizeof(ctxt->incTab[0]));
                   1458:         if (ctxt->incTab == NULL) {
                   1459:             xmlRngPErrMemory(ctxt, "allocating include\n");
                   1460:             return (0);
                   1461:         }
                   1462:     }
                   1463:     if (ctxt->incNr >= ctxt->incMax) {
                   1464:         ctxt->incMax *= 2;
                   1465:         ctxt->incTab =
                   1466:             (xmlRelaxNGIncludePtr *) xmlRealloc(ctxt->incTab,
                   1467:                                                 ctxt->incMax *
                   1468:                                                 sizeof(ctxt->incTab[0]));
                   1469:         if (ctxt->incTab == NULL) {
                   1470:             xmlRngPErrMemory(ctxt, "allocating include\n");
                   1471:             return (0);
                   1472:         }
                   1473:     }
                   1474:     ctxt->incTab[ctxt->incNr] = value;
                   1475:     ctxt->inc = value;
                   1476:     return (ctxt->incNr++);
                   1477: }
                   1478: 
                   1479: /**
                   1480:  * xmlRelaxNGIncludePop:
                   1481:  * @ctxt: the parser context
                   1482:  *
                   1483:  * Pops the top include from the include stack
                   1484:  *
                   1485:  * Returns the include just removed
                   1486:  */
                   1487: static xmlRelaxNGIncludePtr
                   1488: xmlRelaxNGIncludePop(xmlRelaxNGParserCtxtPtr ctxt)
                   1489: {
                   1490:     xmlRelaxNGIncludePtr ret;
                   1491: 
                   1492:     if (ctxt->incNr <= 0)
                   1493:         return (NULL);
                   1494:     ctxt->incNr--;
                   1495:     if (ctxt->incNr > 0)
                   1496:         ctxt->inc = ctxt->incTab[ctxt->incNr - 1];
                   1497:     else
                   1498:         ctxt->inc = NULL;
                   1499:     ret = ctxt->incTab[ctxt->incNr];
                   1500:     ctxt->incTab[ctxt->incNr] = NULL;
                   1501:     return (ret);
                   1502: }
                   1503: 
                   1504: /**
                   1505:  * xmlRelaxNGRemoveRedefine:
                   1506:  * @ctxt: the parser context
                   1507:  * @URL:  the normalized URL
                   1508:  * @target:  the included target
                   1509:  * @name:  the define name to eliminate
                   1510:  *
                   1511:  * Applies the elimination algorithm of 4.7
                   1512:  *
                   1513:  * Returns 0 in case of error, 1 in case of success.
                   1514:  */
                   1515: static int
                   1516: xmlRelaxNGRemoveRedefine(xmlRelaxNGParserCtxtPtr ctxt,
                   1517:                          const xmlChar * URL ATTRIBUTE_UNUSED,
                   1518:                          xmlNodePtr target, const xmlChar * name)
                   1519: {
                   1520:     int found = 0;
                   1521:     xmlNodePtr tmp, tmp2;
                   1522:     xmlChar *name2;
                   1523: 
                   1524: #ifdef DEBUG_INCLUDE
                   1525:     if (name == NULL)
                   1526:         xmlGenericError(xmlGenericErrorContext,
                   1527:                         "Elimination of <include> start from %s\n", URL);
                   1528:     else
                   1529:         xmlGenericError(xmlGenericErrorContext,
                   1530:                         "Elimination of <include> define %s from %s\n",
                   1531:                         name, URL);
                   1532: #endif
                   1533:     tmp = target;
                   1534:     while (tmp != NULL) {
                   1535:         tmp2 = tmp->next;
                   1536:         if ((name == NULL) && (IS_RELAXNG(tmp, "start"))) {
                   1537:             found = 1;
                   1538:             xmlUnlinkNode(tmp);
                   1539:             xmlFreeNode(tmp);
                   1540:         } else if ((name != NULL) && (IS_RELAXNG(tmp, "define"))) {
                   1541:             name2 = xmlGetProp(tmp, BAD_CAST "name");
                   1542:             xmlRelaxNGNormExtSpace(name2);
                   1543:             if (name2 != NULL) {
                   1544:                 if (xmlStrEqual(name, name2)) {
                   1545:                     found = 1;
                   1546:                     xmlUnlinkNode(tmp);
                   1547:                     xmlFreeNode(tmp);
                   1548:                 }
                   1549:                 xmlFree(name2);
                   1550:             }
                   1551:         } else if (IS_RELAXNG(tmp, "include")) {
                   1552:             xmlChar *href = NULL;
                   1553:             xmlRelaxNGDocumentPtr inc = tmp->psvi;
                   1554: 
                   1555:             if ((inc != NULL) && (inc->doc != NULL) &&
                   1556:                 (inc->doc->children != NULL)) {
                   1557: 
                   1558:                 if (xmlStrEqual
                   1559:                     (inc->doc->children->name, BAD_CAST "grammar")) {
                   1560: #ifdef DEBUG_INCLUDE
                   1561:                     href = xmlGetProp(tmp, BAD_CAST "href");
                   1562: #endif
                   1563:                     if (xmlRelaxNGRemoveRedefine(ctxt, href,
                   1564:                                                  inc->doc->children->
                   1565:                                                  children, name) == 1) {
                   1566:                         found = 1;
                   1567:                     }
                   1568: #ifdef DEBUG_INCLUDE
                   1569:                     if (href != NULL)
                   1570:                         xmlFree(href);
                   1571: #endif
                   1572:                 }
                   1573:             }
                   1574:         }
                   1575:         tmp = tmp2;
                   1576:     }
                   1577:     return (found);
                   1578: }
                   1579: 
                   1580: /**
                   1581:  * xmlRelaxNGLoadInclude:
                   1582:  * @ctxt: the parser context
                   1583:  * @URL:  the normalized URL
                   1584:  * @node: the include node.
                   1585:  * @ns:  the namespace passed from the context.
                   1586:  *
                   1587:  * First lookup if the document is already loaded into the parser context,
                   1588:  * check against recursion. If not found the resource is loaded and
                   1589:  * the content is preprocessed before being returned back to the caller.
                   1590:  *
                   1591:  * Returns the xmlRelaxNGIncludePtr or NULL in case of error
                   1592:  */
                   1593: static xmlRelaxNGIncludePtr
                   1594: xmlRelaxNGLoadInclude(xmlRelaxNGParserCtxtPtr ctxt, const xmlChar * URL,
                   1595:                       xmlNodePtr node, const xmlChar * ns)
                   1596: {
                   1597:     xmlRelaxNGIncludePtr ret = NULL;
                   1598:     xmlDocPtr doc;
                   1599:     int i;
                   1600:     xmlNodePtr root, cur;
                   1601: 
                   1602: #ifdef DEBUG_INCLUDE
                   1603:     xmlGenericError(xmlGenericErrorContext,
                   1604:                     "xmlRelaxNGLoadInclude(%s)\n", URL);
                   1605: #endif
                   1606: 
                   1607:     /*
                   1608:      * check against recursion in the stack
                   1609:      */
                   1610:     for (i = 0; i < ctxt->incNr; i++) {
                   1611:         if (xmlStrEqual(ctxt->incTab[i]->href, URL)) {
                   1612:             xmlRngPErr(ctxt, NULL, XML_RNGP_INCLUDE_RECURSE,
                   1613:                        "Detected an Include recursion for %s\n", URL,
                   1614:                        NULL);
                   1615:             return (NULL);
                   1616:         }
                   1617:     }
                   1618: 
                   1619:     /*
                   1620:      * load the document
                   1621:      */
                   1622:     doc = xmlReadFile((const char *) URL,NULL,0);
                   1623:     if (doc == NULL) {
                   1624:         xmlRngPErr(ctxt, node, XML_RNGP_PARSE_ERROR,
                   1625:                    "xmlRelaxNG: could not load %s\n", URL, NULL);
                   1626:         return (NULL);
                   1627:     }
                   1628: #ifdef DEBUG_INCLUDE
                   1629:     xmlGenericError(xmlGenericErrorContext, "Parsed %s Okay\n", URL);
                   1630: #endif
                   1631: 
                   1632:     /*
                   1633:      * Allocate the document structures and register it first.
                   1634:      */
                   1635:     ret = (xmlRelaxNGIncludePtr) xmlMalloc(sizeof(xmlRelaxNGInclude));
                   1636:     if (ret == NULL) {
                   1637:         xmlRngPErrMemory(ctxt, "allocating include\n");
                   1638:         xmlFreeDoc(doc);
                   1639:         return (NULL);
                   1640:     }
                   1641:     memset(ret, 0, sizeof(xmlRelaxNGInclude));
                   1642:     ret->doc = doc;
                   1643:     ret->href = xmlStrdup(URL);
                   1644:     ret->next = ctxt->includes;
                   1645:     ctxt->includes = ret;
                   1646: 
                   1647:     /*
                   1648:      * transmit the ns if needed
                   1649:      */
                   1650:     if (ns != NULL) {
                   1651:         root = xmlDocGetRootElement(doc);
                   1652:         if (root != NULL) {
                   1653:             if (xmlHasProp(root, BAD_CAST "ns") == NULL) {
                   1654:                 xmlSetProp(root, BAD_CAST "ns", ns);
                   1655:             }
                   1656:         }
                   1657:     }
                   1658: 
                   1659:     /*
                   1660:      * push it on the stack
                   1661:      */
                   1662:     xmlRelaxNGIncludePush(ctxt, ret);
                   1663: 
                   1664:     /*
                   1665:      * Some preprocessing of the document content, this include recursing
                   1666:      * in the include stack.
                   1667:      */
                   1668: #ifdef DEBUG_INCLUDE
                   1669:     xmlGenericError(xmlGenericErrorContext, "cleanup of %s\n", URL);
                   1670: #endif
                   1671: 
                   1672:     doc = xmlRelaxNGCleanupDoc(ctxt, doc);
                   1673:     if (doc == NULL) {
                   1674:         ctxt->inc = NULL;
                   1675:         return (NULL);
                   1676:     }
                   1677: 
                   1678:     /*
                   1679:      * Pop up the include from the stack
                   1680:      */
                   1681:     xmlRelaxNGIncludePop(ctxt);
                   1682: 
                   1683: #ifdef DEBUG_INCLUDE
                   1684:     xmlGenericError(xmlGenericErrorContext, "Checking of %s\n", URL);
                   1685: #endif
                   1686:     /*
                   1687:      * Check that the top element is a grammar
                   1688:      */
                   1689:     root = xmlDocGetRootElement(doc);
                   1690:     if (root == NULL) {
                   1691:         xmlRngPErr(ctxt, node, XML_RNGP_EMPTY,
                   1692:                    "xmlRelaxNG: included document is empty %s\n", URL,
                   1693:                    NULL);
                   1694:         return (NULL);
                   1695:     }
                   1696:     if (!IS_RELAXNG(root, "grammar")) {
                   1697:         xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
                   1698:                    "xmlRelaxNG: included document %s root is not a grammar\n",
                   1699:                    URL, NULL);
                   1700:         return (NULL);
                   1701:     }
                   1702: 
                   1703:     /*
                   1704:      * Elimination of redefined rules in the include.
                   1705:      */
                   1706:     cur = node->children;
                   1707:     while (cur != NULL) {
                   1708:         if (IS_RELAXNG(cur, "start")) {
                   1709:             int found = 0;
                   1710: 
                   1711:             found =
                   1712:                 xmlRelaxNGRemoveRedefine(ctxt, URL, root->children, NULL);
                   1713:             if (!found) {
                   1714:                 xmlRngPErr(ctxt, node, XML_RNGP_START_MISSING,
                   1715:                            "xmlRelaxNG: include %s has a start but not the included grammar\n",
                   1716:                            URL, NULL);
                   1717:             }
                   1718:         } else if (IS_RELAXNG(cur, "define")) {
                   1719:             xmlChar *name;
                   1720: 
                   1721:             name = xmlGetProp(cur, BAD_CAST "name");
                   1722:             if (name == NULL) {
                   1723:                 xmlRngPErr(ctxt, node, XML_RNGP_NAME_MISSING,
                   1724:                            "xmlRelaxNG: include %s has define without name\n",
                   1725:                            URL, NULL);
                   1726:             } else {
                   1727:                 int found;
                   1728: 
                   1729:                 xmlRelaxNGNormExtSpace(name);
                   1730:                 found = xmlRelaxNGRemoveRedefine(ctxt, URL,
                   1731:                                                  root->children, name);
                   1732:                 if (!found) {
                   1733:                     xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_MISSING,
                   1734:                                "xmlRelaxNG: include %s has a define %s but not the included grammar\n",
                   1735:                                URL, name);
                   1736:                 }
                   1737:                 xmlFree(name);
                   1738:             }
                   1739:         }
                   1740:         cur = cur->next;
                   1741:     }
                   1742: 
                   1743: 
                   1744:     return (ret);
                   1745: }
                   1746: 
                   1747: /**
                   1748:  * xmlRelaxNGValidErrorPush:
                   1749:  * @ctxt:  the validation context
                   1750:  * @err:  the error code
                   1751:  * @arg1:  the first string argument
                   1752:  * @arg2:  the second string argument
                   1753:  * @dup:  arg need to be duplicated
                   1754:  *
                   1755:  * Pushes a new error on top of the error stack
                   1756:  *
                   1757:  * Returns 0 in case of error, the index in the stack otherwise
                   1758:  */
                   1759: static int
                   1760: xmlRelaxNGValidErrorPush(xmlRelaxNGValidCtxtPtr ctxt,
                   1761:                          xmlRelaxNGValidErr err, const xmlChar * arg1,
                   1762:                          const xmlChar * arg2, int dup)
                   1763: {
                   1764:     xmlRelaxNGValidErrorPtr cur;
                   1765: 
                   1766: #ifdef DEBUG_ERROR
                   1767:     xmlGenericError(xmlGenericErrorContext,
                   1768:                     "Pushing error %d at %d on stack\n", err, ctxt->errNr);
                   1769: #endif
                   1770:     if (ctxt->errTab == NULL) {
                   1771:         ctxt->errMax = 8;
                   1772:         ctxt->errNr = 0;
                   1773:         ctxt->errTab =
                   1774:             (xmlRelaxNGValidErrorPtr) xmlMalloc(ctxt->errMax *
                   1775:                                                 sizeof
                   1776:                                                 (xmlRelaxNGValidError));
                   1777:         if (ctxt->errTab == NULL) {
                   1778:             xmlRngVErrMemory(ctxt, "pushing error\n");
                   1779:             return (0);
                   1780:         }
                   1781:         ctxt->err = NULL;
                   1782:     }
                   1783:     if (ctxt->errNr >= ctxt->errMax) {
                   1784:         ctxt->errMax *= 2;
                   1785:         ctxt->errTab =
                   1786:             (xmlRelaxNGValidErrorPtr) xmlRealloc(ctxt->errTab,
                   1787:                                                  ctxt->errMax *
                   1788:                                                  sizeof
                   1789:                                                  (xmlRelaxNGValidError));
                   1790:         if (ctxt->errTab == NULL) {
                   1791:             xmlRngVErrMemory(ctxt, "pushing error\n");
                   1792:             return (0);
                   1793:         }
                   1794:         ctxt->err = &ctxt->errTab[ctxt->errNr - 1];
                   1795:     }
                   1796:     if ((ctxt->err != NULL) && (ctxt->state != NULL) &&
                   1797:         (ctxt->err->node == ctxt->state->node) && (ctxt->err->err == err))
                   1798:         return (ctxt->errNr);
                   1799:     cur = &ctxt->errTab[ctxt->errNr];
                   1800:     cur->err = err;
                   1801:     if (dup) {
                   1802:         cur->arg1 = xmlStrdup(arg1);
                   1803:         cur->arg2 = xmlStrdup(arg2);
                   1804:         cur->flags = ERROR_IS_DUP;
                   1805:     } else {
                   1806:         cur->arg1 = arg1;
                   1807:         cur->arg2 = arg2;
                   1808:         cur->flags = 0;
                   1809:     }
                   1810:     if (ctxt->state != NULL) {
                   1811:         cur->node = ctxt->state->node;
                   1812:         cur->seq = ctxt->state->seq;
                   1813:     } else {
                   1814:         cur->node = NULL;
                   1815:         cur->seq = NULL;
                   1816:     }
                   1817:     ctxt->err = cur;
                   1818:     return (ctxt->errNr++);
                   1819: }
                   1820: 
                   1821: /**
                   1822:  * xmlRelaxNGValidErrorPop:
                   1823:  * @ctxt: the validation context
                   1824:  *
                   1825:  * Pops the top error from the error stack
                   1826:  */
                   1827: static void
                   1828: xmlRelaxNGValidErrorPop(xmlRelaxNGValidCtxtPtr ctxt)
                   1829: {
                   1830:     xmlRelaxNGValidErrorPtr cur;
                   1831: 
                   1832:     if (ctxt->errNr <= 0) {
                   1833:         ctxt->err = NULL;
                   1834:         return;
                   1835:     }
                   1836:     ctxt->errNr--;
                   1837:     if (ctxt->errNr > 0)
                   1838:         ctxt->err = &ctxt->errTab[ctxt->errNr - 1];
                   1839:     else
                   1840:         ctxt->err = NULL;
                   1841:     cur = &ctxt->errTab[ctxt->errNr];
                   1842:     if (cur->flags & ERROR_IS_DUP) {
                   1843:         if (cur->arg1 != NULL)
                   1844:             xmlFree((xmlChar *) cur->arg1);
                   1845:         cur->arg1 = NULL;
                   1846:         if (cur->arg2 != NULL)
                   1847:             xmlFree((xmlChar *) cur->arg2);
                   1848:         cur->arg2 = NULL;
                   1849:         cur->flags = 0;
                   1850:     }
                   1851: }
                   1852: 
                   1853: /**
                   1854:  * xmlRelaxNGDocumentPush:
                   1855:  * @ctxt:  the parser context
                   1856:  * @value:  the element doc
                   1857:  *
                   1858:  * Pushes a new doc on top of the doc stack
                   1859:  *
                   1860:  * Returns 0 in case of error, the index in the stack otherwise
                   1861:  */
                   1862: static int
                   1863: xmlRelaxNGDocumentPush(xmlRelaxNGParserCtxtPtr ctxt,
                   1864:                        xmlRelaxNGDocumentPtr value)
                   1865: {
                   1866:     if (ctxt->docTab == NULL) {
                   1867:         ctxt->docMax = 4;
                   1868:         ctxt->docNr = 0;
                   1869:         ctxt->docTab =
                   1870:             (xmlRelaxNGDocumentPtr *) xmlMalloc(ctxt->docMax *
                   1871:                                                 sizeof(ctxt->docTab[0]));
                   1872:         if (ctxt->docTab == NULL) {
                   1873:             xmlRngPErrMemory(ctxt, "adding document\n");
                   1874:             return (0);
                   1875:         }
                   1876:     }
                   1877:     if (ctxt->docNr >= ctxt->docMax) {
                   1878:         ctxt->docMax *= 2;
                   1879:         ctxt->docTab =
                   1880:             (xmlRelaxNGDocumentPtr *) xmlRealloc(ctxt->docTab,
                   1881:                                                  ctxt->docMax *
                   1882:                                                  sizeof(ctxt->docTab[0]));
                   1883:         if (ctxt->docTab == NULL) {
                   1884:             xmlRngPErrMemory(ctxt, "adding document\n");
                   1885:             return (0);
                   1886:         }
                   1887:     }
                   1888:     ctxt->docTab[ctxt->docNr] = value;
                   1889:     ctxt->doc = value;
                   1890:     return (ctxt->docNr++);
                   1891: }
                   1892: 
                   1893: /**
                   1894:  * xmlRelaxNGDocumentPop:
                   1895:  * @ctxt: the parser context
                   1896:  *
                   1897:  * Pops the top doc from the doc stack
                   1898:  *
                   1899:  * Returns the doc just removed
                   1900:  */
                   1901: static xmlRelaxNGDocumentPtr
                   1902: xmlRelaxNGDocumentPop(xmlRelaxNGParserCtxtPtr ctxt)
                   1903: {
                   1904:     xmlRelaxNGDocumentPtr ret;
                   1905: 
                   1906:     if (ctxt->docNr <= 0)
                   1907:         return (NULL);
                   1908:     ctxt->docNr--;
                   1909:     if (ctxt->docNr > 0)
                   1910:         ctxt->doc = ctxt->docTab[ctxt->docNr - 1];
                   1911:     else
                   1912:         ctxt->doc = NULL;
                   1913:     ret = ctxt->docTab[ctxt->docNr];
                   1914:     ctxt->docTab[ctxt->docNr] = NULL;
                   1915:     return (ret);
                   1916: }
                   1917: 
                   1918: /**
                   1919:  * xmlRelaxNGLoadExternalRef:
                   1920:  * @ctxt: the parser context
                   1921:  * @URL:  the normalized URL
                   1922:  * @ns:  the inherited ns if any
                   1923:  *
                   1924:  * First lookup if the document is already loaded into the parser context,
                   1925:  * check against recursion. If not found the resource is loaded and
                   1926:  * the content is preprocessed before being returned back to the caller.
                   1927:  *
                   1928:  * Returns the xmlRelaxNGDocumentPtr or NULL in case of error
                   1929:  */
                   1930: static xmlRelaxNGDocumentPtr
                   1931: xmlRelaxNGLoadExternalRef(xmlRelaxNGParserCtxtPtr ctxt,
                   1932:                           const xmlChar * URL, const xmlChar * ns)
                   1933: {
                   1934:     xmlRelaxNGDocumentPtr ret = NULL;
                   1935:     xmlDocPtr doc;
                   1936:     xmlNodePtr root;
                   1937:     int i;
                   1938: 
                   1939:     /*
                   1940:      * check against recursion in the stack
                   1941:      */
                   1942:     for (i = 0; i < ctxt->docNr; i++) {
                   1943:         if (xmlStrEqual(ctxt->docTab[i]->href, URL)) {
                   1944:             xmlRngPErr(ctxt, NULL, XML_RNGP_EXTERNALREF_RECURSE,
                   1945:                        "Detected an externalRef recursion for %s\n", URL,
                   1946:                        NULL);
                   1947:             return (NULL);
                   1948:         }
                   1949:     }
                   1950: 
                   1951:     /*
                   1952:      * load the document
                   1953:      */
                   1954:     doc = xmlReadFile((const char *) URL,NULL,0);
                   1955:     if (doc == NULL) {
                   1956:         xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
                   1957:                    "xmlRelaxNG: could not load %s\n", URL, NULL);
                   1958:         return (NULL);
                   1959:     }
                   1960: 
                   1961:     /*
                   1962:      * Allocate the document structures and register it first.
                   1963:      */
                   1964:     ret = (xmlRelaxNGDocumentPtr) xmlMalloc(sizeof(xmlRelaxNGDocument));
                   1965:     if (ret == NULL) {
                   1966:         xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_ERR_NO_MEMORY,
                   1967:                    "xmlRelaxNG: allocate memory for doc %s\n", URL, NULL);
                   1968:         xmlFreeDoc(doc);
                   1969:         return (NULL);
                   1970:     }
                   1971:     memset(ret, 0, sizeof(xmlRelaxNGDocument));
                   1972:     ret->doc = doc;
                   1973:     ret->href = xmlStrdup(URL);
                   1974:     ret->next = ctxt->documents;
                   1975:     ret->externalRef = 1;
                   1976:     ctxt->documents = ret;
                   1977: 
                   1978:     /*
                   1979:      * transmit the ns if needed
                   1980:      */
                   1981:     if (ns != NULL) {
                   1982:         root = xmlDocGetRootElement(doc);
                   1983:         if (root != NULL) {
                   1984:             if (xmlHasProp(root, BAD_CAST "ns") == NULL) {
                   1985:                 xmlSetProp(root, BAD_CAST "ns", ns);
                   1986:             }
                   1987:         }
                   1988:     }
                   1989: 
                   1990:     /*
                   1991:      * push it on the stack and register it in the hash table
                   1992:      */
                   1993:     xmlRelaxNGDocumentPush(ctxt, ret);
                   1994: 
                   1995:     /*
                   1996:      * Some preprocessing of the document content
                   1997:      */
                   1998:     doc = xmlRelaxNGCleanupDoc(ctxt, doc);
                   1999:     if (doc == NULL) {
                   2000:         ctxt->doc = NULL;
                   2001:         return (NULL);
                   2002:     }
                   2003: 
                   2004:     xmlRelaxNGDocumentPop(ctxt);
                   2005: 
                   2006:     return (ret);
                   2007: }
                   2008: 
                   2009: /************************************************************************
                   2010:  *                                                                     *
                   2011:  *                     Error functions                                 *
                   2012:  *                                                                     *
                   2013:  ************************************************************************/
                   2014: 
                   2015: #define VALID_ERR(a) xmlRelaxNGAddValidError(ctxt, a, NULL, NULL, 0);
                   2016: #define VALID_ERR2(a, b) xmlRelaxNGAddValidError(ctxt, a, b, NULL, 0);
                   2017: #define VALID_ERR3(a, b, c) xmlRelaxNGAddValidError(ctxt, a, b, c, 0);
                   2018: #define VALID_ERR2P(a, b) xmlRelaxNGAddValidError(ctxt, a, b, NULL, 1);
                   2019: #define VALID_ERR3P(a, b, c) xmlRelaxNGAddValidError(ctxt, a, b, c, 1);
                   2020: 
                   2021: static const char *
                   2022: xmlRelaxNGDefName(xmlRelaxNGDefinePtr def)
                   2023: {
                   2024:     if (def == NULL)
                   2025:         return ("none");
                   2026:     switch (def->type) {
                   2027:         case XML_RELAXNG_EMPTY:
                   2028:             return ("empty");
                   2029:         case XML_RELAXNG_NOT_ALLOWED:
                   2030:             return ("notAllowed");
                   2031:         case XML_RELAXNG_EXCEPT:
                   2032:             return ("except");
                   2033:         case XML_RELAXNG_TEXT:
                   2034:             return ("text");
                   2035:         case XML_RELAXNG_ELEMENT:
                   2036:             return ("element");
                   2037:         case XML_RELAXNG_DATATYPE:
                   2038:             return ("datatype");
                   2039:         case XML_RELAXNG_VALUE:
                   2040:             return ("value");
                   2041:         case XML_RELAXNG_LIST:
                   2042:             return ("list");
                   2043:         case XML_RELAXNG_ATTRIBUTE:
                   2044:             return ("attribute");
                   2045:         case XML_RELAXNG_DEF:
                   2046:             return ("def");
                   2047:         case XML_RELAXNG_REF:
                   2048:             return ("ref");
                   2049:         case XML_RELAXNG_EXTERNALREF:
                   2050:             return ("externalRef");
                   2051:         case XML_RELAXNG_PARENTREF:
                   2052:             return ("parentRef");
                   2053:         case XML_RELAXNG_OPTIONAL:
                   2054:             return ("optional");
                   2055:         case XML_RELAXNG_ZEROORMORE:
                   2056:             return ("zeroOrMore");
                   2057:         case XML_RELAXNG_ONEORMORE:
                   2058:             return ("oneOrMore");
                   2059:         case XML_RELAXNG_CHOICE:
                   2060:             return ("choice");
                   2061:         case XML_RELAXNG_GROUP:
                   2062:             return ("group");
                   2063:         case XML_RELAXNG_INTERLEAVE:
                   2064:             return ("interleave");
                   2065:         case XML_RELAXNG_START:
                   2066:             return ("start");
                   2067:         case XML_RELAXNG_NOOP:
                   2068:             return ("noop");
                   2069:         case XML_RELAXNG_PARAM:
                   2070:             return ("param");
                   2071:     }
                   2072:     return ("unknown");
                   2073: }
                   2074: 
                   2075: /**
                   2076:  * xmlRelaxNGGetErrorString:
                   2077:  * @err:  the error code
                   2078:  * @arg1:  the first string argument
                   2079:  * @arg2:  the second string argument
                   2080:  *
                   2081:  * computes a formatted error string for the given error code and args
                   2082:  *
                   2083:  * Returns the error string, it must be deallocated by the caller
                   2084:  */
                   2085: static xmlChar *
                   2086: xmlRelaxNGGetErrorString(xmlRelaxNGValidErr err, const xmlChar * arg1,
                   2087:                          const xmlChar * arg2)
                   2088: {
                   2089:     char msg[1000];
                   2090: 
                   2091:     if (arg1 == NULL)
                   2092:         arg1 = BAD_CAST "";
                   2093:     if (arg2 == NULL)
                   2094:         arg2 = BAD_CAST "";
                   2095: 
                   2096:     msg[0] = 0;
                   2097:     switch (err) {
                   2098:         case XML_RELAXNG_OK:
                   2099:             return (NULL);
                   2100:         case XML_RELAXNG_ERR_MEMORY:
                   2101:             return (xmlCharStrdup("out of memory\n"));
                   2102:         case XML_RELAXNG_ERR_TYPE:
                   2103:             snprintf(msg, 1000, "failed to validate type %s\n", arg1);
                   2104:             break;
                   2105:         case XML_RELAXNG_ERR_TYPEVAL:
                   2106:             snprintf(msg, 1000, "Type %s doesn't allow value '%s'\n", arg1,
                   2107:                      arg2);
                   2108:             break;
                   2109:         case XML_RELAXNG_ERR_DUPID:
                   2110:             snprintf(msg, 1000, "ID %s redefined\n", arg1);
                   2111:             break;
                   2112:         case XML_RELAXNG_ERR_TYPECMP:
                   2113:             snprintf(msg, 1000, "failed to compare type %s\n", arg1);
                   2114:             break;
                   2115:         case XML_RELAXNG_ERR_NOSTATE:
                   2116:             return (xmlCharStrdup("Internal error: no state\n"));
                   2117:         case XML_RELAXNG_ERR_NODEFINE:
                   2118:             return (xmlCharStrdup("Internal error: no define\n"));
                   2119:         case XML_RELAXNG_ERR_INTERNAL:
                   2120:             snprintf(msg, 1000, "Internal error: %s\n", arg1);
                   2121:             break;
                   2122:         case XML_RELAXNG_ERR_LISTEXTRA:
                   2123:             snprintf(msg, 1000, "Extra data in list: %s\n", arg1);
                   2124:             break;
                   2125:         case XML_RELAXNG_ERR_INTERNODATA:
                   2126:             return (xmlCharStrdup
                   2127:                     ("Internal: interleave block has no data\n"));
                   2128:         case XML_RELAXNG_ERR_INTERSEQ:
                   2129:             return (xmlCharStrdup("Invalid sequence in interleave\n"));
                   2130:         case XML_RELAXNG_ERR_INTEREXTRA:
                   2131:             snprintf(msg, 1000, "Extra element %s in interleave\n", arg1);
                   2132:             break;
                   2133:         case XML_RELAXNG_ERR_ELEMNAME:
                   2134:             snprintf(msg, 1000, "Expecting element %s, got %s\n", arg1,
                   2135:                      arg2);
                   2136:             break;
                   2137:         case XML_RELAXNG_ERR_ELEMNONS:
                   2138:             snprintf(msg, 1000, "Expecting a namespace for element %s\n",
                   2139:                      arg1);
                   2140:             break;
                   2141:         case XML_RELAXNG_ERR_ELEMWRONGNS:
                   2142:             snprintf(msg, 1000,
                   2143:                      "Element %s has wrong namespace: expecting %s\n", arg1,
                   2144:                      arg2);
                   2145:             break;
                   2146:         case XML_RELAXNG_ERR_ELEMWRONG:
                   2147:             snprintf(msg, 1000, "Did not expect element %s there\n", arg1);
                   2148:             break;
                   2149:         case XML_RELAXNG_ERR_TEXTWRONG:
                   2150:             snprintf(msg, 1000,
                   2151:                      "Did not expect text in element %s content\n", arg1);
                   2152:             break;
                   2153:         case XML_RELAXNG_ERR_ELEMEXTRANS:
                   2154:             snprintf(msg, 1000, "Expecting no namespace for element %s\n",
                   2155:                      arg1);
                   2156:             break;
                   2157:         case XML_RELAXNG_ERR_ELEMNOTEMPTY:
                   2158:             snprintf(msg, 1000, "Expecting element %s to be empty\n", arg1);
                   2159:             break;
                   2160:         case XML_RELAXNG_ERR_NOELEM:
                   2161:             snprintf(msg, 1000, "Expecting an element %s, got nothing\n",
                   2162:                      arg1);
                   2163:             break;
                   2164:         case XML_RELAXNG_ERR_NOTELEM:
                   2165:             return (xmlCharStrdup("Expecting an element got text\n"));
                   2166:         case XML_RELAXNG_ERR_ATTRVALID:
                   2167:             snprintf(msg, 1000, "Element %s failed to validate attributes\n",
                   2168:                      arg1);
                   2169:             break;
                   2170:         case XML_RELAXNG_ERR_CONTENTVALID:
                   2171:             snprintf(msg, 1000, "Element %s failed to validate content\n",
                   2172:                      arg1);
                   2173:             break;
                   2174:         case XML_RELAXNG_ERR_EXTRACONTENT:
                   2175:             snprintf(msg, 1000, "Element %s has extra content: %s\n",
                   2176:                      arg1, arg2);
                   2177:             break;
                   2178:         case XML_RELAXNG_ERR_INVALIDATTR:
                   2179:             snprintf(msg, 1000, "Invalid attribute %s for element %s\n",
                   2180:                      arg1, arg2);
                   2181:             break;
                   2182:         case XML_RELAXNG_ERR_LACKDATA:
                   2183:             snprintf(msg, 1000, "Datatype element %s contains no data\n",
                   2184:                      arg1);
                   2185:             break;
                   2186:         case XML_RELAXNG_ERR_DATAELEM:
                   2187:             snprintf(msg, 1000, "Datatype element %s has child elements\n",
                   2188:                      arg1);
                   2189:             break;
                   2190:         case XML_RELAXNG_ERR_VALELEM:
                   2191:             snprintf(msg, 1000, "Value element %s has child elements\n",
                   2192:                      arg1);
                   2193:             break;
                   2194:         case XML_RELAXNG_ERR_LISTELEM:
                   2195:             snprintf(msg, 1000, "List element %s has child elements\n",
                   2196:                      arg1);
                   2197:             break;
                   2198:         case XML_RELAXNG_ERR_DATATYPE:
                   2199:             snprintf(msg, 1000, "Error validating datatype %s\n", arg1);
                   2200:             break;
                   2201:         case XML_RELAXNG_ERR_VALUE:
                   2202:             snprintf(msg, 1000, "Error validating value %s\n", arg1);
                   2203:             break;
                   2204:         case XML_RELAXNG_ERR_LIST:
                   2205:             return (xmlCharStrdup("Error validating list\n"));
                   2206:         case XML_RELAXNG_ERR_NOGRAMMAR:
                   2207:             return (xmlCharStrdup("No top grammar defined\n"));
                   2208:         case XML_RELAXNG_ERR_EXTRADATA:
                   2209:             return (xmlCharStrdup("Extra data in the document\n"));
                   2210:         default:
                   2211:             return (xmlCharStrdup("Unknown error !\n"));
                   2212:     }
                   2213:     if (msg[0] == 0) {
                   2214:         snprintf(msg, 1000, "Unknown error code %d\n", err);
                   2215:     }
                   2216:     msg[1000 - 1] = 0;
                   2217:     return (xmlStrdup((xmlChar *) msg));
                   2218: }
                   2219: 
                   2220: /**
                   2221:  * xmlRelaxNGShowValidError:
                   2222:  * @ctxt:  the validation context
                   2223:  * @err:  the error number
                   2224:  * @node:  the node
                   2225:  * @child:  the node child generating the problem.
                   2226:  * @arg1:  the first argument
                   2227:  * @arg2:  the second argument
                   2228:  *
                   2229:  * Show a validation error.
                   2230:  */
                   2231: static void
                   2232: xmlRelaxNGShowValidError(xmlRelaxNGValidCtxtPtr ctxt,
                   2233:                          xmlRelaxNGValidErr err, xmlNodePtr node,
                   2234:                          xmlNodePtr child, const xmlChar * arg1,
                   2235:                          const xmlChar * arg2)
                   2236: {
                   2237:     xmlChar *msg;
                   2238: 
                   2239:     if (ctxt->flags & FLAGS_NOERROR)
                   2240:         return;
                   2241: 
                   2242: #ifdef DEBUG_ERROR
                   2243:     xmlGenericError(xmlGenericErrorContext, "Show error %d\n", err);
                   2244: #endif
                   2245:     msg = xmlRelaxNGGetErrorString(err, arg1, arg2);
                   2246:     if (msg == NULL)
                   2247:         return;
                   2248: 
                   2249:     if (ctxt->errNo == XML_RELAXNG_OK)
                   2250:         ctxt->errNo = err;
                   2251:     xmlRngVErr(ctxt, (child == NULL ? node : child), err,
                   2252:                (const char *) msg, arg1, arg2);
                   2253:     xmlFree(msg);
                   2254: }
                   2255: 
                   2256: /**
                   2257:  * xmlRelaxNGPopErrors:
                   2258:  * @ctxt:  the validation context
                   2259:  * @level:  the error level in the stack
                   2260:  *
                   2261:  * pop and discard all errors until the given level is reached
                   2262:  */
                   2263: static void
                   2264: xmlRelaxNGPopErrors(xmlRelaxNGValidCtxtPtr ctxt, int level)
                   2265: {
                   2266:     int i;
                   2267:     xmlRelaxNGValidErrorPtr err;
                   2268: 
                   2269: #ifdef DEBUG_ERROR
                   2270:     xmlGenericError(xmlGenericErrorContext,
                   2271:                     "Pop errors till level %d\n", level);
                   2272: #endif
                   2273:     for (i = level; i < ctxt->errNr; i++) {
                   2274:         err = &ctxt->errTab[i];
                   2275:         if (err->flags & ERROR_IS_DUP) {
                   2276:             if (err->arg1 != NULL)
                   2277:                 xmlFree((xmlChar *) err->arg1);
                   2278:             err->arg1 = NULL;
                   2279:             if (err->arg2 != NULL)
                   2280:                 xmlFree((xmlChar *) err->arg2);
                   2281:             err->arg2 = NULL;
                   2282:             err->flags = 0;
                   2283:         }
                   2284:     }
                   2285:     ctxt->errNr = level;
                   2286:     if (ctxt->errNr <= 0)
                   2287:         ctxt->err = NULL;
                   2288: }
                   2289: 
                   2290: /**
                   2291:  * xmlRelaxNGDumpValidError:
                   2292:  * @ctxt:  the validation context
                   2293:  *
                   2294:  * Show all validation error over a given index.
                   2295:  */
                   2296: static void
                   2297: xmlRelaxNGDumpValidError(xmlRelaxNGValidCtxtPtr ctxt)
                   2298: {
                   2299:     int i, j, k;
                   2300:     xmlRelaxNGValidErrorPtr err, dup;
                   2301: 
                   2302: #ifdef DEBUG_ERROR
                   2303:     xmlGenericError(xmlGenericErrorContext,
                   2304:                     "Dumping error stack %d errors\n", ctxt->errNr);
                   2305: #endif
                   2306:     for (i = 0, k = 0; i < ctxt->errNr; i++) {
                   2307:         err = &ctxt->errTab[i];
                   2308:         if (k < MAX_ERROR) {
                   2309:             for (j = 0; j < i; j++) {
                   2310:                 dup = &ctxt->errTab[j];
                   2311:                 if ((err->err == dup->err) && (err->node == dup->node) &&
                   2312:                     (xmlStrEqual(err->arg1, dup->arg1)) &&
                   2313:                     (xmlStrEqual(err->arg2, dup->arg2))) {
                   2314:                     goto skip;
                   2315:                 }
                   2316:             }
                   2317:             xmlRelaxNGShowValidError(ctxt, err->err, err->node, err->seq,
                   2318:                                      err->arg1, err->arg2);
                   2319:             k++;
                   2320:         }
                   2321:       skip:
                   2322:         if (err->flags & ERROR_IS_DUP) {
                   2323:             if (err->arg1 != NULL)
                   2324:                 xmlFree((xmlChar *) err->arg1);
                   2325:             err->arg1 = NULL;
                   2326:             if (err->arg2 != NULL)
                   2327:                 xmlFree((xmlChar *) err->arg2);
                   2328:             err->arg2 = NULL;
                   2329:             err->flags = 0;
                   2330:         }
                   2331:     }
                   2332:     ctxt->errNr = 0;
                   2333: }
                   2334: 
                   2335: /**
                   2336:  * xmlRelaxNGAddValidError:
                   2337:  * @ctxt:  the validation context
                   2338:  * @err:  the error number
                   2339:  * @arg1:  the first argument
                   2340:  * @arg2:  the second argument
                   2341:  * @dup:  need to dup the args
                   2342:  *
                   2343:  * Register a validation error, either generating it if it's sure
                   2344:  * or stacking it for later handling if unsure.
                   2345:  */
                   2346: static void
                   2347: xmlRelaxNGAddValidError(xmlRelaxNGValidCtxtPtr ctxt,
                   2348:                         xmlRelaxNGValidErr err, const xmlChar * arg1,
                   2349:                         const xmlChar * arg2, int dup)
                   2350: {
                   2351:     if (ctxt == NULL)
                   2352:         return;
                   2353:     if (ctxt->flags & FLAGS_NOERROR)
                   2354:         return;
                   2355: 
                   2356: #ifdef DEBUG_ERROR
                   2357:     xmlGenericError(xmlGenericErrorContext, "Adding error %d\n", err);
                   2358: #endif
                   2359:     /*
                   2360:      * generate the error directly
                   2361:      */
                   2362:     if (((ctxt->flags & FLAGS_IGNORABLE) == 0) ||
                   2363:         (ctxt->flags & FLAGS_NEGATIVE)) {
                   2364:         xmlNodePtr node, seq;
                   2365: 
                   2366:         /*
                   2367:          * Flush first any stacked error which might be the
                   2368:          * real cause of the problem.
                   2369:          */
                   2370:         if (ctxt->errNr != 0)
                   2371:             xmlRelaxNGDumpValidError(ctxt);
                   2372:         if (ctxt->state != NULL) {
                   2373:             node = ctxt->state->node;
                   2374:             seq = ctxt->state->seq;
                   2375:         } else {
                   2376:             node = seq = NULL;
                   2377:         }
                   2378:         if ((node == NULL) && (seq == NULL)) {
                   2379:             node = ctxt->pnode;
                   2380:         }
                   2381:         xmlRelaxNGShowValidError(ctxt, err, node, seq, arg1, arg2);
                   2382:     }
                   2383:     /*
                   2384:      * Stack the error for later processing if needed
                   2385:      */
                   2386:     else {
                   2387:         xmlRelaxNGValidErrorPush(ctxt, err, arg1, arg2, dup);
                   2388:     }
                   2389: }
                   2390: 
                   2391: 
                   2392: /************************************************************************
                   2393:  *                                                                     *
                   2394:  *                     Type library hooks                              *
                   2395:  *                                                                     *
                   2396:  ************************************************************************/
                   2397: static xmlChar *xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt,
                   2398:                                     const xmlChar * str);
                   2399: 
                   2400: /**
                   2401:  * xmlRelaxNGSchemaTypeHave:
                   2402:  * @data:  data needed for the library
                   2403:  * @type:  the type name
                   2404:  *
                   2405:  * Check if the given type is provided by
                   2406:  * the W3C XMLSchema Datatype library.
                   2407:  *
                   2408:  * Returns 1 if yes, 0 if no and -1 in case of error.
                   2409:  */
                   2410: static int
                   2411: xmlRelaxNGSchemaTypeHave(void *data ATTRIBUTE_UNUSED, const xmlChar * type)
                   2412: {
                   2413:     xmlSchemaTypePtr typ;
                   2414: 
                   2415:     if (type == NULL)
                   2416:         return (-1);
                   2417:     typ = xmlSchemaGetPredefinedType(type,
                   2418:                                      BAD_CAST
                   2419:                                      "http://www.w3.org/2001/XMLSchema");
                   2420:     if (typ == NULL)
                   2421:         return (0);
                   2422:     return (1);
                   2423: }
                   2424: 
                   2425: /**
                   2426:  * xmlRelaxNGSchemaTypeCheck:
                   2427:  * @data:  data needed for the library
                   2428:  * @type:  the type name
                   2429:  * @value:  the value to check
                   2430:  * @node:  the node
                   2431:  *
                   2432:  * Check if the given type and value are validated by
                   2433:  * the W3C XMLSchema Datatype library.
                   2434:  *
                   2435:  * Returns 1 if yes, 0 if no and -1 in case of error.
                   2436:  */
                   2437: static int
                   2438: xmlRelaxNGSchemaTypeCheck(void *data ATTRIBUTE_UNUSED,
                   2439:                           const xmlChar * type,
                   2440:                           const xmlChar * value,
                   2441:                           void **result, xmlNodePtr node)
                   2442: {
                   2443:     xmlSchemaTypePtr typ;
                   2444:     int ret;
                   2445: 
                   2446:     if ((type == NULL) || (value == NULL))
                   2447:         return (-1);
                   2448:     typ = xmlSchemaGetPredefinedType(type,
                   2449:                                      BAD_CAST
                   2450:                                      "http://www.w3.org/2001/XMLSchema");
                   2451:     if (typ == NULL)
                   2452:         return (-1);
                   2453:     ret = xmlSchemaValPredefTypeNode(typ, value,
                   2454:                                      (xmlSchemaValPtr *) result, node);
                   2455:     if (ret == 2)               /* special ID error code */
                   2456:         return (2);
                   2457:     if (ret == 0)
                   2458:         return (1);
                   2459:     if (ret > 0)
                   2460:         return (0);
                   2461:     return (-1);
                   2462: }
                   2463: 
                   2464: /**
                   2465:  * xmlRelaxNGSchemaFacetCheck:
                   2466:  * @data:  data needed for the library
                   2467:  * @type:  the type name
                   2468:  * @facet:  the facet name
                   2469:  * @val:  the facet value
                   2470:  * @strval:  the string value
                   2471:  * @value:  the value to check
                   2472:  *
                   2473:  * Function provided by a type library to check a value facet
                   2474:  *
                   2475:  * Returns 1 if yes, 0 if no and -1 in case of error.
                   2476:  */
                   2477: static int
                   2478: xmlRelaxNGSchemaFacetCheck(void *data ATTRIBUTE_UNUSED,
                   2479:                            const xmlChar * type, const xmlChar * facetname,
                   2480:                            const xmlChar * val, const xmlChar * strval,
                   2481:                            void *value)
                   2482: {
                   2483:     xmlSchemaFacetPtr facet;
                   2484:     xmlSchemaTypePtr typ;
                   2485:     int ret;
                   2486: 
                   2487:     if ((type == NULL) || (strval == NULL))
                   2488:         return (-1);
                   2489:     typ = xmlSchemaGetPredefinedType(type,
                   2490:                                      BAD_CAST
                   2491:                                      "http://www.w3.org/2001/XMLSchema");
                   2492:     if (typ == NULL)
                   2493:         return (-1);
                   2494: 
                   2495:     facet = xmlSchemaNewFacet();
                   2496:     if (facet == NULL)
                   2497:         return (-1);
                   2498: 
                   2499:     if (xmlStrEqual(facetname, BAD_CAST "minInclusive")) {
                   2500:         facet->type = XML_SCHEMA_FACET_MININCLUSIVE;
                   2501:     } else if (xmlStrEqual(facetname, BAD_CAST "minExclusive")) {
                   2502:         facet->type = XML_SCHEMA_FACET_MINEXCLUSIVE;
                   2503:     } else if (xmlStrEqual(facetname, BAD_CAST "maxInclusive")) {
                   2504:         facet->type = XML_SCHEMA_FACET_MAXINCLUSIVE;
                   2505:     } else if (xmlStrEqual(facetname, BAD_CAST "maxExclusive")) {
                   2506:         facet->type = XML_SCHEMA_FACET_MAXEXCLUSIVE;
                   2507:     } else if (xmlStrEqual(facetname, BAD_CAST "totalDigits")) {
                   2508:         facet->type = XML_SCHEMA_FACET_TOTALDIGITS;
                   2509:     } else if (xmlStrEqual(facetname, BAD_CAST "fractionDigits")) {
                   2510:         facet->type = XML_SCHEMA_FACET_FRACTIONDIGITS;
                   2511:     } else if (xmlStrEqual(facetname, BAD_CAST "pattern")) {
                   2512:         facet->type = XML_SCHEMA_FACET_PATTERN;
                   2513:     } else if (xmlStrEqual(facetname, BAD_CAST "enumeration")) {
                   2514:         facet->type = XML_SCHEMA_FACET_ENUMERATION;
                   2515:     } else if (xmlStrEqual(facetname, BAD_CAST "whiteSpace")) {
                   2516:         facet->type = XML_SCHEMA_FACET_WHITESPACE;
                   2517:     } else if (xmlStrEqual(facetname, BAD_CAST "length")) {
                   2518:         facet->type = XML_SCHEMA_FACET_LENGTH;
                   2519:     } else if (xmlStrEqual(facetname, BAD_CAST "maxLength")) {
                   2520:         facet->type = XML_SCHEMA_FACET_MAXLENGTH;
                   2521:     } else if (xmlStrEqual(facetname, BAD_CAST "minLength")) {
                   2522:         facet->type = XML_SCHEMA_FACET_MINLENGTH;
                   2523:     } else {
                   2524:         xmlSchemaFreeFacet(facet);
                   2525:         return (-1);
                   2526:     }
                   2527:     facet->value = val;
                   2528:     ret = xmlSchemaCheckFacet(facet, typ, NULL, type);
                   2529:     if (ret != 0) {
                   2530:         xmlSchemaFreeFacet(facet);
                   2531:         return (-1);
                   2532:     }
                   2533:     ret = xmlSchemaValidateFacet(typ, facet, strval, value);
                   2534:     xmlSchemaFreeFacet(facet);
                   2535:     if (ret != 0)
                   2536:         return (-1);
                   2537:     return (0);
                   2538: }
                   2539: 
                   2540: /**
                   2541:  * xmlRelaxNGSchemaFreeValue:
                   2542:  * @data:  data needed for the library
                   2543:  * @value:  the value to free
                   2544:  *
                   2545:  * Function provided by a type library to free a Schemas value
                   2546:  *
                   2547:  * Returns 1 if yes, 0 if no and -1 in case of error.
                   2548:  */
                   2549: static void
                   2550: xmlRelaxNGSchemaFreeValue(void *data ATTRIBUTE_UNUSED, void *value)
                   2551: {
                   2552:     xmlSchemaFreeValue(value);
                   2553: }
                   2554: 
                   2555: /**
                   2556:  * xmlRelaxNGSchemaTypeCompare:
                   2557:  * @data:  data needed for the library
                   2558:  * @type:  the type name
                   2559:  * @value1:  the first value
                   2560:  * @value2:  the second value
                   2561:  *
                   2562:  * Compare two values for equality accordingly a type from the W3C XMLSchema
                   2563:  * Datatype library.
                   2564:  *
                   2565:  * Returns 1 if equal, 0 if no and -1 in case of error.
                   2566:  */
                   2567: static int
                   2568: xmlRelaxNGSchemaTypeCompare(void *data ATTRIBUTE_UNUSED,
                   2569:                             const xmlChar * type,
                   2570:                             const xmlChar * value1,
                   2571:                             xmlNodePtr ctxt1,
                   2572:                             void *comp1,
                   2573:                             const xmlChar * value2, xmlNodePtr ctxt2)
                   2574: {
                   2575:     int ret;
                   2576:     xmlSchemaTypePtr typ;
                   2577:     xmlSchemaValPtr res1 = NULL, res2 = NULL;
                   2578: 
                   2579:     if ((type == NULL) || (value1 == NULL) || (value2 == NULL))
                   2580:         return (-1);
                   2581:     typ = xmlSchemaGetPredefinedType(type,
                   2582:                                      BAD_CAST
                   2583:                                      "http://www.w3.org/2001/XMLSchema");
                   2584:     if (typ == NULL)
                   2585:         return (-1);
                   2586:     if (comp1 == NULL) {
                   2587:         ret = xmlSchemaValPredefTypeNode(typ, value1, &res1, ctxt1);
                   2588:         if (ret != 0)
                   2589:             return (-1);
                   2590:         if (res1 == NULL)
                   2591:             return (-1);
                   2592:     } else {
                   2593:         res1 = (xmlSchemaValPtr) comp1;
                   2594:     }
                   2595:     ret = xmlSchemaValPredefTypeNode(typ, value2, &res2, ctxt2);
                   2596:     if (ret != 0) {
                   2597:        if ((comp1 == NULL) && (res1 != NULL))
                   2598:            xmlSchemaFreeValue(res1);
                   2599:         return (-1);
                   2600:     }
                   2601:     if (res1 == NULL) {
                   2602:         return (-1);
                   2603:     }
                   2604:     ret = xmlSchemaCompareValues(res1, res2);
                   2605:     if (res1 != (xmlSchemaValPtr) comp1)
                   2606:         xmlSchemaFreeValue(res1);
                   2607:     xmlSchemaFreeValue(res2);
                   2608:     if (ret == -2)
                   2609:         return (-1);
                   2610:     if (ret == 0)
                   2611:         return (1);
                   2612:     return (0);
                   2613: }
                   2614: 
                   2615: /**
                   2616:  * xmlRelaxNGDefaultTypeHave:
                   2617:  * @data:  data needed for the library
                   2618:  * @type:  the type name
                   2619:  *
                   2620:  * Check if the given type is provided by
                   2621:  * the default datatype library.
                   2622:  *
                   2623:  * Returns 1 if yes, 0 if no and -1 in case of error.
                   2624:  */
                   2625: static int
                   2626: xmlRelaxNGDefaultTypeHave(void *data ATTRIBUTE_UNUSED,
                   2627:                           const xmlChar * type)
                   2628: {
                   2629:     if (type == NULL)
                   2630:         return (-1);
                   2631:     if (xmlStrEqual(type, BAD_CAST "string"))
                   2632:         return (1);
                   2633:     if (xmlStrEqual(type, BAD_CAST "token"))
                   2634:         return (1);
                   2635:     return (0);
                   2636: }
                   2637: 
                   2638: /**
                   2639:  * xmlRelaxNGDefaultTypeCheck:
                   2640:  * @data:  data needed for the library
                   2641:  * @type:  the type name
                   2642:  * @value:  the value to check
                   2643:  * @node:  the node
                   2644:  *
                   2645:  * Check if the given type and value are validated by
                   2646:  * the default datatype library.
                   2647:  *
                   2648:  * Returns 1 if yes, 0 if no and -1 in case of error.
                   2649:  */
                   2650: static int
                   2651: xmlRelaxNGDefaultTypeCheck(void *data ATTRIBUTE_UNUSED,
                   2652:                            const xmlChar * type ATTRIBUTE_UNUSED,
                   2653:                            const xmlChar * value ATTRIBUTE_UNUSED,
                   2654:                            void **result ATTRIBUTE_UNUSED,
                   2655:                            xmlNodePtr node ATTRIBUTE_UNUSED)
                   2656: {
                   2657:     if (value == NULL)
                   2658:         return (-1);
                   2659:     if (xmlStrEqual(type, BAD_CAST "string"))
                   2660:         return (1);
                   2661:     if (xmlStrEqual(type, BAD_CAST "token")) {
                   2662:         return (1);
                   2663:     }
                   2664: 
                   2665:     return (0);
                   2666: }
                   2667: 
                   2668: /**
                   2669:  * xmlRelaxNGDefaultTypeCompare:
                   2670:  * @data:  data needed for the library
                   2671:  * @type:  the type name
                   2672:  * @value1:  the first value
                   2673:  * @value2:  the second value
                   2674:  *
                   2675:  * Compare two values accordingly a type from the default
                   2676:  * datatype library.
                   2677:  *
                   2678:  * Returns 1 if yes, 0 if no and -1 in case of error.
                   2679:  */
                   2680: static int
                   2681: xmlRelaxNGDefaultTypeCompare(void *data ATTRIBUTE_UNUSED,
                   2682:                              const xmlChar * type,
                   2683:                              const xmlChar * value1,
                   2684:                              xmlNodePtr ctxt1 ATTRIBUTE_UNUSED,
                   2685:                              void *comp1 ATTRIBUTE_UNUSED,
                   2686:                              const xmlChar * value2,
                   2687:                              xmlNodePtr ctxt2 ATTRIBUTE_UNUSED)
                   2688: {
                   2689:     int ret = -1;
                   2690: 
                   2691:     if (xmlStrEqual(type, BAD_CAST "string")) {
                   2692:         ret = xmlStrEqual(value1, value2);
                   2693:     } else if (xmlStrEqual(type, BAD_CAST "token")) {
                   2694:         if (!xmlStrEqual(value1, value2)) {
                   2695:             xmlChar *nval, *nvalue;
                   2696: 
                   2697:             /*
                   2698:              * TODO: trivial optimizations are possible by
                   2699:              * computing at compile-time
                   2700:              */
                   2701:             nval = xmlRelaxNGNormalize(NULL, value1);
                   2702:             nvalue = xmlRelaxNGNormalize(NULL, value2);
                   2703: 
                   2704:             if ((nval == NULL) || (nvalue == NULL))
                   2705:                 ret = -1;
                   2706:             else if (xmlStrEqual(nval, nvalue))
                   2707:                 ret = 1;
                   2708:             else
                   2709:                 ret = 0;
                   2710:             if (nval != NULL)
                   2711:                 xmlFree(nval);
                   2712:             if (nvalue != NULL)
                   2713:                 xmlFree(nvalue);
                   2714:         } else
                   2715:             ret = 1;
                   2716:     }
                   2717:     return (ret);
                   2718: }
                   2719: 
                   2720: static int xmlRelaxNGTypeInitialized = 0;
                   2721: static xmlHashTablePtr xmlRelaxNGRegisteredTypes = NULL;
                   2722: 
                   2723: /**
                   2724:  * xmlRelaxNGFreeTypeLibrary:
                   2725:  * @lib:  the type library structure
                   2726:  * @namespace:  the URI bound to the library
                   2727:  *
                   2728:  * Free the structure associated to the type library
                   2729:  */
                   2730: static void
                   2731: xmlRelaxNGFreeTypeLibrary(xmlRelaxNGTypeLibraryPtr lib,
                   2732:                           const xmlChar * namespace ATTRIBUTE_UNUSED)
                   2733: {
                   2734:     if (lib == NULL)
                   2735:         return;
                   2736:     if (lib->namespace != NULL)
                   2737:         xmlFree((xmlChar *) lib->namespace);
                   2738:     xmlFree(lib);
                   2739: }
                   2740: 
                   2741: /**
                   2742:  * xmlRelaxNGRegisterTypeLibrary:
                   2743:  * @namespace:  the URI bound to the library
                   2744:  * @data:  data associated to the library
                   2745:  * @have:  the provide function
                   2746:  * @check:  the checking function
                   2747:  * @comp:  the comparison function
                   2748:  *
                   2749:  * Register a new type library
                   2750:  *
                   2751:  * Returns 0 in case of success and -1 in case of error.
                   2752:  */
                   2753: static int
                   2754: xmlRelaxNGRegisterTypeLibrary(const xmlChar * namespace, void *data,
                   2755:                               xmlRelaxNGTypeHave have,
                   2756:                               xmlRelaxNGTypeCheck check,
                   2757:                               xmlRelaxNGTypeCompare comp,
                   2758:                               xmlRelaxNGFacetCheck facet,
                   2759:                               xmlRelaxNGTypeFree freef)
                   2760: {
                   2761:     xmlRelaxNGTypeLibraryPtr lib;
                   2762:     int ret;
                   2763: 
                   2764:     if ((xmlRelaxNGRegisteredTypes == NULL) || (namespace == NULL) ||
                   2765:         (check == NULL) || (comp == NULL))
                   2766:         return (-1);
                   2767:     if (xmlHashLookup(xmlRelaxNGRegisteredTypes, namespace) != NULL) {
                   2768:         xmlGenericError(xmlGenericErrorContext,
                   2769:                         "Relax-NG types library '%s' already registered\n",
                   2770:                         namespace);
                   2771:         return (-1);
                   2772:     }
                   2773:     lib =
                   2774:         (xmlRelaxNGTypeLibraryPtr)
                   2775:         xmlMalloc(sizeof(xmlRelaxNGTypeLibrary));
                   2776:     if (lib == NULL) {
                   2777:         xmlRngVErrMemory(NULL, "adding types library\n");
                   2778:         return (-1);
                   2779:     }
                   2780:     memset(lib, 0, sizeof(xmlRelaxNGTypeLibrary));
                   2781:     lib->namespace = xmlStrdup(namespace);
                   2782:     lib->data = data;
                   2783:     lib->have = have;
                   2784:     lib->comp = comp;
                   2785:     lib->check = check;
                   2786:     lib->facet = facet;
                   2787:     lib->freef = freef;
                   2788:     ret = xmlHashAddEntry(xmlRelaxNGRegisteredTypes, namespace, lib);
                   2789:     if (ret < 0) {
                   2790:         xmlGenericError(xmlGenericErrorContext,
                   2791:                         "Relax-NG types library failed to register '%s'\n",
                   2792:                         namespace);
                   2793:         xmlRelaxNGFreeTypeLibrary(lib, namespace);
                   2794:         return (-1);
                   2795:     }
                   2796:     return (0);
                   2797: }
                   2798: 
                   2799: /**
                   2800:  * xmlRelaxNGInitTypes:
                   2801:  *
                   2802:  * Initilize the default type libraries.
                   2803:  *
                   2804:  * Returns 0 in case of success and -1 in case of error.
                   2805:  */
                   2806: int
                   2807: xmlRelaxNGInitTypes(void)
                   2808: {
                   2809:     if (xmlRelaxNGTypeInitialized != 0)
                   2810:         return (0);
                   2811:     xmlRelaxNGRegisteredTypes = xmlHashCreate(10);
                   2812:     if (xmlRelaxNGRegisteredTypes == NULL) {
                   2813:         xmlGenericError(xmlGenericErrorContext,
                   2814:                         "Failed to allocate sh table for Relax-NG types\n");
                   2815:         return (-1);
                   2816:     }
                   2817:     xmlRelaxNGRegisterTypeLibrary(BAD_CAST
                   2818:                                   "http://www.w3.org/2001/XMLSchema-datatypes",
                   2819:                                   NULL, xmlRelaxNGSchemaTypeHave,
                   2820:                                   xmlRelaxNGSchemaTypeCheck,
                   2821:                                   xmlRelaxNGSchemaTypeCompare,
                   2822:                                   xmlRelaxNGSchemaFacetCheck,
                   2823:                                   xmlRelaxNGSchemaFreeValue);
                   2824:     xmlRelaxNGRegisterTypeLibrary(xmlRelaxNGNs, NULL,
                   2825:                                   xmlRelaxNGDefaultTypeHave,
                   2826:                                   xmlRelaxNGDefaultTypeCheck,
                   2827:                                   xmlRelaxNGDefaultTypeCompare, NULL,
                   2828:                                   NULL);
                   2829:     xmlRelaxNGTypeInitialized = 1;
                   2830:     return (0);
                   2831: }
                   2832: 
                   2833: /**
                   2834:  * xmlRelaxNGCleanupTypes:
                   2835:  *
                   2836:  * Cleanup the default Schemas type library associated to RelaxNG
                   2837:  */
                   2838: void
                   2839: xmlRelaxNGCleanupTypes(void)
                   2840: {
                   2841:     xmlSchemaCleanupTypes();
                   2842:     if (xmlRelaxNGTypeInitialized == 0)
                   2843:         return;
                   2844:     xmlHashFree(xmlRelaxNGRegisteredTypes, (xmlHashDeallocator)
                   2845:                 xmlRelaxNGFreeTypeLibrary);
                   2846:     xmlRelaxNGTypeInitialized = 0;
                   2847: }
                   2848: 
                   2849: /************************************************************************
                   2850:  *                                                                     *
                   2851:  *             Compiling element content into regexp                   *
                   2852:  *                                                                     *
                   2853:  * Sometime the element content can be compiled into a pure regexp,    *
                   2854:  * This allows a faster execution and streamability at that level      *
                   2855:  *                                                                     *
                   2856:  ************************************************************************/
                   2857: 
                   2858: /* from automata.c but not exported */
                   2859: void xmlAutomataSetFlags(xmlAutomataPtr am, int flags);
                   2860: 
                   2861: 
                   2862: static int xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt,
                   2863:                                 xmlRelaxNGDefinePtr def);
                   2864: 
                   2865: /**
                   2866:  * xmlRelaxNGIsCompileable:
                   2867:  * @define:  the definition to check
                   2868:  *
                   2869:  * Check if a definition is nullable.
                   2870:  *
                   2871:  * Returns 1 if yes, 0 if no and -1 in case of error
                   2872:  */
                   2873: static int
                   2874: xmlRelaxNGIsCompileable(xmlRelaxNGDefinePtr def)
                   2875: {
                   2876:     int ret = -1;
                   2877: 
                   2878:     if (def == NULL) {
                   2879:         return (-1);
                   2880:     }
                   2881:     if ((def->type != XML_RELAXNG_ELEMENT) &&
                   2882:         (def->dflags & IS_COMPILABLE))
                   2883:         return (1);
                   2884:     if ((def->type != XML_RELAXNG_ELEMENT) &&
                   2885:         (def->dflags & IS_NOT_COMPILABLE))
                   2886:         return (0);
                   2887:     switch (def->type) {
                   2888:         case XML_RELAXNG_NOOP:
                   2889:             ret = xmlRelaxNGIsCompileable(def->content);
                   2890:             break;
                   2891:         case XML_RELAXNG_TEXT:
                   2892:         case XML_RELAXNG_EMPTY:
                   2893:             ret = 1;
                   2894:             break;
                   2895:         case XML_RELAXNG_ELEMENT:
                   2896:             /*
                   2897:              * Check if the element content is compileable
                   2898:              */
                   2899:             if (((def->dflags & IS_NOT_COMPILABLE) == 0) &&
                   2900:                 ((def->dflags & IS_COMPILABLE) == 0)) {
                   2901:                 xmlRelaxNGDefinePtr list;
                   2902: 
                   2903:                 list = def->content;
                   2904:                 while (list != NULL) {
                   2905:                     ret = xmlRelaxNGIsCompileable(list);
                   2906:                     if (ret != 1)
                   2907:                         break;
                   2908:                     list = list->next;
                   2909:                 }
                   2910:                /*
                   2911:                 * Because the routine is recursive, we must guard against
                   2912:                 * discovering both COMPILABLE and NOT_COMPILABLE
                   2913:                 */
                   2914:                 if (ret == 0) {
                   2915:                    def->dflags &= ~IS_COMPILABLE;
                   2916:                     def->dflags |= IS_NOT_COMPILABLE;
                   2917:                }
                   2918:                 if ((ret == 1) && !(def->dflags &= IS_NOT_COMPILABLE))
                   2919:                     def->dflags |= IS_COMPILABLE;
                   2920: #ifdef DEBUG_COMPILE
                   2921:                 if (ret == 1) {
                   2922:                     xmlGenericError(xmlGenericErrorContext,
                   2923:                                     "element content for %s is compilable\n",
                   2924:                                     def->name);
                   2925:                 } else if (ret == 0) {
                   2926:                     xmlGenericError(xmlGenericErrorContext,
                   2927:                                     "element content for %s is not compilable\n",
                   2928:                                     def->name);
                   2929:                 } else {
                   2930:                     xmlGenericError(xmlGenericErrorContext,
                   2931:                                     "Problem in RelaxNGIsCompileable for element %s\n",
                   2932:                                     def->name);
                   2933:                 }
                   2934: #endif
                   2935:             }
                   2936:             /*
                   2937:              * All elements return a compileable status unless they
                   2938:              * are generic like anyName
                   2939:              */
                   2940:             if ((def->nameClass != NULL) || (def->name == NULL))
                   2941:                 ret = 0;
                   2942:             else
                   2943:                 ret = 1;
                   2944:             return (ret);
                   2945:         case XML_RELAXNG_REF:
                   2946:         case XML_RELAXNG_EXTERNALREF:
                   2947:         case XML_RELAXNG_PARENTREF:
                   2948:             if (def->depth == -20) {
                   2949:                 return (1);
                   2950:             } else {
                   2951:                 xmlRelaxNGDefinePtr list;
                   2952: 
                   2953:                 def->depth = -20;
                   2954:                 list = def->content;
                   2955:                 while (list != NULL) {
                   2956:                     ret = xmlRelaxNGIsCompileable(list);
                   2957:                     if (ret != 1)
                   2958:                         break;
                   2959:                     list = list->next;
                   2960:                 }
                   2961:             }
                   2962:             break;
                   2963:         case XML_RELAXNG_START:
                   2964:         case XML_RELAXNG_OPTIONAL:
                   2965:         case XML_RELAXNG_ZEROORMORE:
                   2966:         case XML_RELAXNG_ONEORMORE:
                   2967:         case XML_RELAXNG_CHOICE:
                   2968:         case XML_RELAXNG_GROUP:
                   2969:         case XML_RELAXNG_DEF:{
                   2970:                 xmlRelaxNGDefinePtr list;
                   2971: 
                   2972:                 list = def->content;
                   2973:                 while (list != NULL) {
                   2974:                     ret = xmlRelaxNGIsCompileable(list);
                   2975:                     if (ret != 1)
                   2976:                         break;
                   2977:                     list = list->next;
                   2978:                 }
                   2979:                 break;
                   2980:             }
                   2981:         case XML_RELAXNG_EXCEPT:
                   2982:         case XML_RELAXNG_ATTRIBUTE:
                   2983:         case XML_RELAXNG_INTERLEAVE:
                   2984:         case XML_RELAXNG_DATATYPE:
                   2985:         case XML_RELAXNG_LIST:
                   2986:         case XML_RELAXNG_PARAM:
                   2987:         case XML_RELAXNG_VALUE:
                   2988:         case XML_RELAXNG_NOT_ALLOWED:
                   2989:             ret = 0;
                   2990:             break;
                   2991:     }
                   2992:     if (ret == 0)
                   2993:         def->dflags |= IS_NOT_COMPILABLE;
                   2994:     if (ret == 1)
                   2995:         def->dflags |= IS_COMPILABLE;
                   2996: #ifdef DEBUG_COMPILE
                   2997:     if (ret == 1) {
                   2998:         xmlGenericError(xmlGenericErrorContext,
                   2999:                         "RelaxNGIsCompileable %s : true\n",
                   3000:                         xmlRelaxNGDefName(def));
                   3001:     } else if (ret == 0) {
                   3002:         xmlGenericError(xmlGenericErrorContext,
                   3003:                         "RelaxNGIsCompileable %s : false\n",
                   3004:                         xmlRelaxNGDefName(def));
                   3005:     } else {
                   3006:         xmlGenericError(xmlGenericErrorContext,
                   3007:                         "Problem in RelaxNGIsCompileable %s\n",
                   3008:                         xmlRelaxNGDefName(def));
                   3009:     }
                   3010: #endif
                   3011:     return (ret);
                   3012: }
                   3013: 
                   3014: /**
                   3015:  * xmlRelaxNGCompile:
                   3016:  * ctxt:  the RelaxNG parser context
                   3017:  * @define:  the definition tree to compile
                   3018:  *
                   3019:  * Compile the set of definitions, it works recursively, till the
                   3020:  * element boundaries, where it tries to compile the content if possible
                   3021:  *
                   3022:  * Returns 0 if success and -1 in case of error
                   3023:  */
                   3024: static int
                   3025: xmlRelaxNGCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def)
                   3026: {
                   3027:     int ret = 0;
                   3028:     xmlRelaxNGDefinePtr list;
                   3029: 
                   3030:     if ((ctxt == NULL) || (def == NULL))
                   3031:         return (-1);
                   3032: 
                   3033:     switch (def->type) {
                   3034:         case XML_RELAXNG_START:
                   3035:             if ((xmlRelaxNGIsCompileable(def) == 1) && (def->depth != -25)) {
                   3036:                 xmlAutomataPtr oldam = ctxt->am;
                   3037:                 xmlAutomataStatePtr oldstate = ctxt->state;
                   3038: 
                   3039:                 def->depth = -25;
                   3040: 
                   3041:                 list = def->content;
                   3042:                 ctxt->am = xmlNewAutomata();
                   3043:                 if (ctxt->am == NULL)
                   3044:                     return (-1);
                   3045: 
                   3046:                 /*
                   3047:                  * assume identical strings but not same pointer are different
                   3048:                  * atoms, needed for non-determinism detection
                   3049:                  * That way if 2 elements with the same name are in a choice
                   3050:                  * branch the automata is found non-deterministic and
                   3051:                  * we fallback to the normal validation which does the right
                   3052:                  * thing of exploring both choices.
                   3053:                  */
                   3054:                 xmlAutomataSetFlags(ctxt->am, 1);
                   3055: 
                   3056:                 ctxt->state = xmlAutomataGetInitState(ctxt->am);
                   3057:                 while (list != NULL) {
                   3058:                     xmlRelaxNGCompile(ctxt, list);
                   3059:                     list = list->next;
                   3060:                 }
                   3061:                 xmlAutomataSetFinalState(ctxt->am, ctxt->state);
                   3062:                 def->contModel = xmlAutomataCompile(ctxt->am);
                   3063:                 xmlRegexpIsDeterminist(def->contModel);
                   3064: 
                   3065:                 xmlFreeAutomata(ctxt->am);
                   3066:                 ctxt->state = oldstate;
                   3067:                 ctxt->am = oldam;
                   3068:             }
                   3069:             break;
                   3070:         case XML_RELAXNG_ELEMENT:
                   3071:             if ((ctxt->am != NULL) && (def->name != NULL)) {
                   3072:                 ctxt->state = xmlAutomataNewTransition2(ctxt->am,
                   3073:                                                         ctxt->state, NULL,
                   3074:                                                         def->name, def->ns,
                   3075:                                                         def);
                   3076:             }
                   3077:             if ((def->dflags & IS_COMPILABLE) && (def->depth != -25)) {
                   3078:                 xmlAutomataPtr oldam = ctxt->am;
                   3079:                 xmlAutomataStatePtr oldstate = ctxt->state;
                   3080: 
                   3081:                 def->depth = -25;
                   3082: 
                   3083:                 list = def->content;
                   3084:                 ctxt->am = xmlNewAutomata();
                   3085:                 if (ctxt->am == NULL)
                   3086:                     return (-1);
                   3087:                 xmlAutomataSetFlags(ctxt->am, 1);
                   3088:                 ctxt->state = xmlAutomataGetInitState(ctxt->am);
                   3089:                 while (list != NULL) {
                   3090:                     xmlRelaxNGCompile(ctxt, list);
                   3091:                     list = list->next;
                   3092:                 }
                   3093:                 xmlAutomataSetFinalState(ctxt->am, ctxt->state);
                   3094:                 def->contModel = xmlAutomataCompile(ctxt->am);
                   3095:                 if (!xmlRegexpIsDeterminist(def->contModel)) {
                   3096: #ifdef DEBUG_COMPILE
                   3097:                     xmlGenericError(xmlGenericErrorContext,
                   3098:                         "Content model not determinist %s\n",
                   3099:                                     def->name);
                   3100: #endif
                   3101:                     /*
                   3102:                      * we can only use the automata if it is determinist
                   3103:                      */
                   3104:                     xmlRegFreeRegexp(def->contModel);
                   3105:                     def->contModel = NULL;
                   3106:                 }
                   3107:                 xmlFreeAutomata(ctxt->am);
                   3108:                 ctxt->state = oldstate;
                   3109:                 ctxt->am = oldam;
                   3110:             } else {
                   3111:                 xmlAutomataPtr oldam = ctxt->am;
                   3112: 
                   3113:                 /*
                   3114:                  * we can't build the content model for this element content
                   3115:                  * but it still might be possible to build it for some of its
                   3116:                  * children, recurse.
                   3117:                  */
                   3118:                 ret = xmlRelaxNGTryCompile(ctxt, def);
                   3119:                 ctxt->am = oldam;
                   3120:             }
                   3121:             break;
                   3122:         case XML_RELAXNG_NOOP:
                   3123:             ret = xmlRelaxNGCompile(ctxt, def->content);
                   3124:             break;
                   3125:         case XML_RELAXNG_OPTIONAL:{
                   3126:                 xmlAutomataStatePtr oldstate = ctxt->state;
                   3127: 
                   3128:                 list = def->content;
                   3129:                 while (list != NULL) {
                   3130:                     xmlRelaxNGCompile(ctxt, list);
                   3131:                     list = list->next;
                   3132:                 }
                   3133:                 xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
                   3134:                 break;
                   3135:             }
                   3136:         case XML_RELAXNG_ZEROORMORE:{
                   3137:                 xmlAutomataStatePtr oldstate;
                   3138: 
                   3139:                 ctxt->state =
                   3140:                     xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
                   3141:                 oldstate = ctxt->state;
                   3142:                 list = def->content;
                   3143:                 while (list != NULL) {
                   3144:                     xmlRelaxNGCompile(ctxt, list);
                   3145:                     list = list->next;
                   3146:                 }
                   3147:                 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldstate);
                   3148:                 ctxt->state =
                   3149:                     xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
                   3150:                 break;
                   3151:             }
                   3152:         case XML_RELAXNG_ONEORMORE:{
                   3153:                 xmlAutomataStatePtr oldstate;
                   3154: 
                   3155:                 list = def->content;
                   3156:                 while (list != NULL) {
                   3157:                     xmlRelaxNGCompile(ctxt, list);
                   3158:                     list = list->next;
                   3159:                 }
                   3160:                 oldstate = ctxt->state;
                   3161:                 list = def->content;
                   3162:                 while (list != NULL) {
                   3163:                     xmlRelaxNGCompile(ctxt, list);
                   3164:                     list = list->next;
                   3165:                 }
                   3166:                 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldstate);
                   3167:                 ctxt->state =
                   3168:                     xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
                   3169:                 break;
                   3170:             }
                   3171:         case XML_RELAXNG_CHOICE:{
                   3172:                 xmlAutomataStatePtr target = NULL;
                   3173:                 xmlAutomataStatePtr oldstate = ctxt->state;
                   3174: 
                   3175:                 list = def->content;
                   3176:                 while (list != NULL) {
                   3177:                     ctxt->state = oldstate;
                   3178:                     ret = xmlRelaxNGCompile(ctxt, list);
                   3179:                     if (ret != 0)
                   3180:                         break;
                   3181:                     if (target == NULL)
                   3182:                         target = ctxt->state;
                   3183:                     else {
                   3184:                         xmlAutomataNewEpsilon(ctxt->am, ctxt->state,
                   3185:                                               target);
                   3186:                     }
                   3187:                     list = list->next;
                   3188:                 }
                   3189:                 ctxt->state = target;
                   3190: 
                   3191:                 break;
                   3192:             }
                   3193:         case XML_RELAXNG_REF:
                   3194:         case XML_RELAXNG_EXTERNALREF:
                   3195:         case XML_RELAXNG_PARENTREF:
                   3196:         case XML_RELAXNG_GROUP:
                   3197:         case XML_RELAXNG_DEF:
                   3198:             list = def->content;
                   3199:             while (list != NULL) {
                   3200:                 ret = xmlRelaxNGCompile(ctxt, list);
                   3201:                 if (ret != 0)
                   3202:                     break;
                   3203:                 list = list->next;
                   3204:             }
                   3205:             break;
                   3206:         case XML_RELAXNG_TEXT:{
                   3207:                 xmlAutomataStatePtr oldstate;
                   3208: 
                   3209:                 ctxt->state =
                   3210:                     xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
                   3211:                 oldstate = ctxt->state;
                   3212:                 xmlRelaxNGCompile(ctxt, def->content);
                   3213:                 xmlAutomataNewTransition(ctxt->am, ctxt->state,
                   3214:                                          ctxt->state, BAD_CAST "#text",
                   3215:                                          NULL);
                   3216:                 ctxt->state =
                   3217:                     xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
                   3218:                 break;
                   3219:             }
                   3220:         case XML_RELAXNG_EMPTY:
                   3221:             ctxt->state =
                   3222:                 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
                   3223:             break;
                   3224:         case XML_RELAXNG_EXCEPT:
                   3225:         case XML_RELAXNG_ATTRIBUTE:
                   3226:         case XML_RELAXNG_INTERLEAVE:
                   3227:         case XML_RELAXNG_NOT_ALLOWED:
                   3228:         case XML_RELAXNG_DATATYPE:
                   3229:         case XML_RELAXNG_LIST:
                   3230:         case XML_RELAXNG_PARAM:
                   3231:         case XML_RELAXNG_VALUE:
                   3232:             /* This should not happen and generate an internal error */
                   3233:             fprintf(stderr, "RNG internal error trying to compile %s\n",
                   3234:                     xmlRelaxNGDefName(def));
                   3235:             break;
                   3236:     }
                   3237:     return (ret);
                   3238: }
                   3239: 
                   3240: /**
                   3241:  * xmlRelaxNGTryCompile:
                   3242:  * ctxt:  the RelaxNG parser context
                   3243:  * @define:  the definition tree to compile
                   3244:  *
                   3245:  * Try to compile the set of definitions, it works recursively,
                   3246:  * possibly ignoring parts which cannot be compiled.
                   3247:  *
                   3248:  * Returns 0 if success and -1 in case of error
                   3249:  */
                   3250: static int
                   3251: xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def)
                   3252: {
                   3253:     int ret = 0;
                   3254:     xmlRelaxNGDefinePtr list;
                   3255: 
                   3256:     if ((ctxt == NULL) || (def == NULL))
                   3257:         return (-1);
                   3258: 
                   3259:     if ((def->type == XML_RELAXNG_START) ||
                   3260:         (def->type == XML_RELAXNG_ELEMENT)) {
                   3261:         ret = xmlRelaxNGIsCompileable(def);
                   3262:         if ((def->dflags & IS_COMPILABLE) && (def->depth != -25)) {
                   3263:             ctxt->am = NULL;
                   3264:             ret = xmlRelaxNGCompile(ctxt, def);
                   3265: #ifdef DEBUG_PROGRESSIVE
                   3266:             if (ret == 0) {
                   3267:                 if (def->type == XML_RELAXNG_START)
                   3268:                     xmlGenericError(xmlGenericErrorContext,
                   3269:                                     "compiled the start\n");
                   3270:                 else
                   3271:                     xmlGenericError(xmlGenericErrorContext,
                   3272:                                     "compiled element %s\n", def->name);
                   3273:             } else {
                   3274:                 if (def->type == XML_RELAXNG_START)
                   3275:                     xmlGenericError(xmlGenericErrorContext,
                   3276:                                     "failed to compile the start\n");
                   3277:                 else
                   3278:                     xmlGenericError(xmlGenericErrorContext,
                   3279:                                     "failed to compile element %s\n",
                   3280:                                     def->name);
                   3281:             }
                   3282: #endif
                   3283:             return (ret);
                   3284:         }
                   3285:     }
                   3286:     switch (def->type) {
                   3287:         case XML_RELAXNG_NOOP:
                   3288:             ret = xmlRelaxNGTryCompile(ctxt, def->content);
                   3289:             break;
                   3290:         case XML_RELAXNG_TEXT:
                   3291:         case XML_RELAXNG_DATATYPE:
                   3292:         case XML_RELAXNG_LIST:
                   3293:         case XML_RELAXNG_PARAM:
                   3294:         case XML_RELAXNG_VALUE:
                   3295:         case XML_RELAXNG_EMPTY:
                   3296:         case XML_RELAXNG_ELEMENT:
                   3297:             ret = 0;
                   3298:             break;
                   3299:         case XML_RELAXNG_OPTIONAL:
                   3300:         case XML_RELAXNG_ZEROORMORE:
                   3301:         case XML_RELAXNG_ONEORMORE:
                   3302:         case XML_RELAXNG_CHOICE:
                   3303:         case XML_RELAXNG_GROUP:
                   3304:         case XML_RELAXNG_DEF:
                   3305:         case XML_RELAXNG_START:
                   3306:         case XML_RELAXNG_REF:
                   3307:         case XML_RELAXNG_EXTERNALREF:
                   3308:         case XML_RELAXNG_PARENTREF:
                   3309:             list = def->content;
                   3310:             while (list != NULL) {
                   3311:                 ret = xmlRelaxNGTryCompile(ctxt, list);
                   3312:                 if (ret != 0)
                   3313:                     break;
                   3314:                 list = list->next;
                   3315:             }
                   3316:             break;
                   3317:         case XML_RELAXNG_EXCEPT:
                   3318:         case XML_RELAXNG_ATTRIBUTE:
                   3319:         case XML_RELAXNG_INTERLEAVE:
                   3320:         case XML_RELAXNG_NOT_ALLOWED:
                   3321:             ret = 0;
                   3322:             break;
                   3323:     }
                   3324:     return (ret);
                   3325: }
                   3326: 
                   3327: /************************************************************************
                   3328:  *                                                                     *
                   3329:  *                     Parsing functions                               *
                   3330:  *                                                                     *
                   3331:  ************************************************************************/
                   3332: 
                   3333: static xmlRelaxNGDefinePtr xmlRelaxNGParseAttribute(xmlRelaxNGParserCtxtPtr
                   3334:                                                     ctxt, xmlNodePtr node);
                   3335: static xmlRelaxNGDefinePtr xmlRelaxNGParseElement(xmlRelaxNGParserCtxtPtr
                   3336:                                                   ctxt, xmlNodePtr node);
                   3337: static xmlRelaxNGDefinePtr xmlRelaxNGParsePatterns(xmlRelaxNGParserCtxtPtr
                   3338:                                                    ctxt, xmlNodePtr nodes,
                   3339:                                                    int group);
                   3340: static xmlRelaxNGDefinePtr xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr
                   3341:                                                   ctxt, xmlNodePtr node);
                   3342: static xmlRelaxNGPtr xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt,
                   3343:                                              xmlNodePtr node);
                   3344: static int xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt,
                   3345:                                          xmlNodePtr nodes);
                   3346: static xmlRelaxNGDefinePtr xmlRelaxNGParseNameClass(xmlRelaxNGParserCtxtPtr
                   3347:                                                     ctxt, xmlNodePtr node,
                   3348:                                                     xmlRelaxNGDefinePtr
                   3349:                                                     def);
                   3350: static xmlRelaxNGGrammarPtr xmlRelaxNGParseGrammar(xmlRelaxNGParserCtxtPtr
                   3351:                                                    ctxt, xmlNodePtr nodes);
                   3352: static int xmlRelaxNGElementMatch(xmlRelaxNGValidCtxtPtr ctxt,
                   3353:                                   xmlRelaxNGDefinePtr define,
                   3354:                                   xmlNodePtr elem);
                   3355: 
                   3356: 
                   3357: #define IS_BLANK_NODE(n) (xmlRelaxNGIsBlank((n)->content))
                   3358: 
                   3359: /**
                   3360:  * xmlRelaxNGIsNullable:
                   3361:  * @define:  the definition to verify
                   3362:  *
                   3363:  * Check if a definition is nullable.
                   3364:  *
                   3365:  * Returns 1 if yes, 0 if no and -1 in case of error
                   3366:  */
                   3367: static int
                   3368: xmlRelaxNGIsNullable(xmlRelaxNGDefinePtr define)
                   3369: {
                   3370:     int ret;
                   3371: 
                   3372:     if (define == NULL)
                   3373:         return (-1);
                   3374: 
                   3375:     if (define->dflags & IS_NULLABLE)
                   3376:         return (1);
                   3377:     if (define->dflags & IS_NOT_NULLABLE)
                   3378:         return (0);
                   3379:     switch (define->type) {
                   3380:         case XML_RELAXNG_EMPTY:
                   3381:         case XML_RELAXNG_TEXT:
                   3382:             ret = 1;
                   3383:             break;
                   3384:         case XML_RELAXNG_NOOP:
                   3385:         case XML_RELAXNG_DEF:
                   3386:         case XML_RELAXNG_REF:
                   3387:         case XML_RELAXNG_EXTERNALREF:
                   3388:         case XML_RELAXNG_PARENTREF:
                   3389:         case XML_RELAXNG_ONEORMORE:
                   3390:             ret = xmlRelaxNGIsNullable(define->content);
                   3391:             break;
                   3392:         case XML_RELAXNG_EXCEPT:
                   3393:         case XML_RELAXNG_NOT_ALLOWED:
                   3394:         case XML_RELAXNG_ELEMENT:
                   3395:         case XML_RELAXNG_DATATYPE:
                   3396:         case XML_RELAXNG_PARAM:
                   3397:         case XML_RELAXNG_VALUE:
                   3398:         case XML_RELAXNG_LIST:
                   3399:         case XML_RELAXNG_ATTRIBUTE:
                   3400:             ret = 0;
                   3401:             break;
                   3402:         case XML_RELAXNG_CHOICE:{
                   3403:                 xmlRelaxNGDefinePtr list = define->content;
                   3404: 
                   3405:                 while (list != NULL) {
                   3406:                     ret = xmlRelaxNGIsNullable(list);
                   3407:                     if (ret != 0)
                   3408:                         goto done;
                   3409:                     list = list->next;
                   3410:                 }
                   3411:                 ret = 0;
                   3412:                 break;
                   3413:             }
                   3414:         case XML_RELAXNG_START:
                   3415:         case XML_RELAXNG_INTERLEAVE:
                   3416:         case XML_RELAXNG_GROUP:{
                   3417:                 xmlRelaxNGDefinePtr list = define->content;
                   3418: 
                   3419:                 while (list != NULL) {
                   3420:                     ret = xmlRelaxNGIsNullable(list);
                   3421:                     if (ret != 1)
                   3422:                         goto done;
                   3423:                     list = list->next;
                   3424:                 }
                   3425:                 return (1);
                   3426:             }
                   3427:         default:
                   3428:             return (-1);
                   3429:     }
                   3430:   done:
                   3431:     if (ret == 0)
                   3432:         define->dflags |= IS_NOT_NULLABLE;
                   3433:     if (ret == 1)
                   3434:         define->dflags |= IS_NULLABLE;
                   3435:     return (ret);
                   3436: }
                   3437: 
                   3438: /**
                   3439:  * xmlRelaxNGIsBlank:
                   3440:  * @str:  a string
                   3441:  *
                   3442:  * Check if a string is ignorable c.f. 4.2. Whitespace
                   3443:  *
                   3444:  * Returns 1 if the string is NULL or made of blanks chars, 0 otherwise
                   3445:  */
                   3446: static int
                   3447: xmlRelaxNGIsBlank(xmlChar * str)
                   3448: {
                   3449:     if (str == NULL)
                   3450:         return (1);
                   3451:     while (*str != 0) {
                   3452:         if (!(IS_BLANK_CH(*str)))
                   3453:             return (0);
                   3454:         str++;
                   3455:     }
                   3456:     return (1);
                   3457: }
                   3458: 
                   3459: /**
                   3460:  * xmlRelaxNGGetDataTypeLibrary:
                   3461:  * @ctxt:  a Relax-NG parser context
                   3462:  * @node:  the current data or value element
                   3463:  *
                   3464:  * Applies algorithm from 4.3. datatypeLibrary attribute
                   3465:  *
                   3466:  * Returns the datatypeLibary value or NULL if not found
                   3467:  */
                   3468: static xmlChar *
                   3469: xmlRelaxNGGetDataTypeLibrary(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
                   3470:                              xmlNodePtr node)
                   3471: {
                   3472:     xmlChar *ret, *escape;
                   3473: 
                   3474:     if (node == NULL)
                   3475:         return(NULL);
                   3476: 
                   3477:     if ((IS_RELAXNG(node, "data")) || (IS_RELAXNG(node, "value"))) {
                   3478:         ret = xmlGetProp(node, BAD_CAST "datatypeLibrary");
                   3479:         if (ret != NULL) {
                   3480:             if (ret[0] == 0) {
                   3481:                 xmlFree(ret);
                   3482:                 return (NULL);
                   3483:             }
                   3484:             escape = xmlURIEscapeStr(ret, BAD_CAST ":/#?");
                   3485:             if (escape == NULL) {
                   3486:                 return (ret);
                   3487:             }
                   3488:             xmlFree(ret);
                   3489:             return (escape);
                   3490:         }
                   3491:     }
                   3492:     node = node->parent;
                   3493:     while ((node != NULL) && (node->type == XML_ELEMENT_NODE)) {
                   3494:         ret = xmlGetProp(node, BAD_CAST "datatypeLibrary");
                   3495:         if (ret != NULL) {
                   3496:             if (ret[0] == 0) {
                   3497:                 xmlFree(ret);
                   3498:                 return (NULL);
                   3499:             }
                   3500:             escape = xmlURIEscapeStr(ret, BAD_CAST ":/#?");
                   3501:             if (escape == NULL) {
                   3502:                 return (ret);
                   3503:             }
                   3504:             xmlFree(ret);
                   3505:             return (escape);
                   3506:         }
                   3507:         node = node->parent;
                   3508:     }
                   3509:     return (NULL);
                   3510: }
                   3511: 
                   3512: /**
                   3513:  * xmlRelaxNGParseValue:
                   3514:  * @ctxt:  a Relax-NG parser context
                   3515:  * @node:  the data node.
                   3516:  *
                   3517:  * parse the content of a RelaxNG value node.
                   3518:  *
                   3519:  * Returns the definition pointer or NULL in case of error
                   3520:  */
                   3521: static xmlRelaxNGDefinePtr
                   3522: xmlRelaxNGParseValue(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
                   3523: {
                   3524:     xmlRelaxNGDefinePtr def = NULL;
                   3525:     xmlRelaxNGTypeLibraryPtr lib = NULL;
                   3526:     xmlChar *type;
                   3527:     xmlChar *library;
                   3528:     int success = 0;
                   3529: 
                   3530:     def = xmlRelaxNGNewDefine(ctxt, node);
                   3531:     if (def == NULL)
                   3532:         return (NULL);
                   3533:     def->type = XML_RELAXNG_VALUE;
                   3534: 
                   3535:     type = xmlGetProp(node, BAD_CAST "type");
                   3536:     if (type != NULL) {
                   3537:         xmlRelaxNGNormExtSpace(type);
                   3538:         if (xmlValidateNCName(type, 0)) {
                   3539:             xmlRngPErr(ctxt, node, XML_RNGP_TYPE_VALUE,
                   3540:                        "value type '%s' is not an NCName\n", type, NULL);
                   3541:         }
                   3542:         library = xmlRelaxNGGetDataTypeLibrary(ctxt, node);
                   3543:         if (library == NULL)
                   3544:             library =
                   3545:                 xmlStrdup(BAD_CAST "http://relaxng.org/ns/structure/1.0");
                   3546: 
                   3547:         def->name = type;
                   3548:         def->ns = library;
                   3549: 
                   3550:         lib = (xmlRelaxNGTypeLibraryPtr)
                   3551:             xmlHashLookup(xmlRelaxNGRegisteredTypes, library);
                   3552:         if (lib == NULL) {
                   3553:             xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_TYPE_LIB,
                   3554:                        "Use of unregistered type library '%s'\n", library,
                   3555:                        NULL);
                   3556:             def->data = NULL;
                   3557:         } else {
                   3558:             def->data = lib;
                   3559:             if (lib->have == NULL) {
                   3560:                 xmlRngPErr(ctxt, node, XML_RNGP_ERROR_TYPE_LIB,
                   3561:                            "Internal error with type library '%s': no 'have'\n",
                   3562:                            library, NULL);
                   3563:             } else {
                   3564:                 success = lib->have(lib->data, def->name);
                   3565:                 if (success != 1) {
                   3566:                     xmlRngPErr(ctxt, node, XML_RNGP_TYPE_NOT_FOUND,
                   3567:                                "Error type '%s' is not exported by type library '%s'\n",
                   3568:                                def->name, library);
                   3569:                 }
                   3570:             }
                   3571:         }
                   3572:     }
                   3573:     if (node->children == NULL) {
                   3574:         def->value = xmlStrdup(BAD_CAST "");
                   3575:     } else if (((node->children->type != XML_TEXT_NODE) &&
                   3576:                 (node->children->type != XML_CDATA_SECTION_NODE)) ||
                   3577:                (node->children->next != NULL)) {
                   3578:         xmlRngPErr(ctxt, node, XML_RNGP_TEXT_EXPECTED,
                   3579:                    "Expecting a single text value for <value>content\n",
                   3580:                    NULL, NULL);
                   3581:     } else if (def != NULL) {
                   3582:         def->value = xmlNodeGetContent(node);
                   3583:         if (def->value == NULL) {
                   3584:             xmlRngPErr(ctxt, node, XML_RNGP_VALUE_NO_CONTENT,
                   3585:                        "Element <value> has no content\n", NULL, NULL);
                   3586:         } else if ((lib != NULL) && (lib->check != NULL) && (success == 1)) {
                   3587:             void *val = NULL;
                   3588: 
                   3589:             success =
                   3590:                 lib->check(lib->data, def->name, def->value, &val, node);
                   3591:             if (success != 1) {
                   3592:                 xmlRngPErr(ctxt, node, XML_RNGP_INVALID_VALUE,
                   3593:                            "Value '%s' is not acceptable for type '%s'\n",
                   3594:                            def->value, def->name);
                   3595:             } else {
                   3596:                 if (val != NULL)
                   3597:                     def->attrs = val;
                   3598:             }
                   3599:         }
                   3600:     }
                   3601:     return (def);
                   3602: }
                   3603: 
                   3604: /**
                   3605:  * xmlRelaxNGParseData:
                   3606:  * @ctxt:  a Relax-NG parser context
                   3607:  * @node:  the data node.
                   3608:  *
                   3609:  * parse the content of a RelaxNG data node.
                   3610:  *
                   3611:  * Returns the definition pointer or NULL in case of error
                   3612:  */
                   3613: static xmlRelaxNGDefinePtr
                   3614: xmlRelaxNGParseData(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
                   3615: {
                   3616:     xmlRelaxNGDefinePtr def = NULL, except;
                   3617:     xmlRelaxNGDefinePtr param, lastparam = NULL;
                   3618:     xmlRelaxNGTypeLibraryPtr lib;
                   3619:     xmlChar *type;
                   3620:     xmlChar *library;
                   3621:     xmlNodePtr content;
                   3622:     int tmp;
                   3623: 
                   3624:     type = xmlGetProp(node, BAD_CAST "type");
                   3625:     if (type == NULL) {
                   3626:         xmlRngPErr(ctxt, node, XML_RNGP_TYPE_MISSING, "data has no type\n", NULL,
                   3627:                    NULL);
                   3628:         return (NULL);
                   3629:     }
                   3630:     xmlRelaxNGNormExtSpace(type);
                   3631:     if (xmlValidateNCName(type, 0)) {
                   3632:         xmlRngPErr(ctxt, node, XML_RNGP_TYPE_VALUE,
                   3633:                    "data type '%s' is not an NCName\n", type, NULL);
                   3634:     }
                   3635:     library = xmlRelaxNGGetDataTypeLibrary(ctxt, node);
                   3636:     if (library == NULL)
                   3637:         library =
                   3638:             xmlStrdup(BAD_CAST "http://relaxng.org/ns/structure/1.0");
                   3639: 
                   3640:     def = xmlRelaxNGNewDefine(ctxt, node);
                   3641:     if (def == NULL) {
                   3642:         xmlFree(type);
                   3643:         return (NULL);
                   3644:     }
                   3645:     def->type = XML_RELAXNG_DATATYPE;
                   3646:     def->name = type;
                   3647:     def->ns = library;
                   3648: 
                   3649:     lib = (xmlRelaxNGTypeLibraryPtr)
                   3650:         xmlHashLookup(xmlRelaxNGRegisteredTypes, library);
                   3651:     if (lib == NULL) {
                   3652:         xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_TYPE_LIB,
                   3653:                    "Use of unregistered type library '%s'\n", library,
                   3654:                    NULL);
                   3655:         def->data = NULL;
                   3656:     } else {
                   3657:         def->data = lib;
                   3658:         if (lib->have == NULL) {
                   3659:             xmlRngPErr(ctxt, node, XML_RNGP_ERROR_TYPE_LIB,
                   3660:                        "Internal error with type library '%s': no 'have'\n",
                   3661:                        library, NULL);
                   3662:         } else {
                   3663:             tmp = lib->have(lib->data, def->name);
                   3664:             if (tmp != 1) {
                   3665:                 xmlRngPErr(ctxt, node, XML_RNGP_TYPE_NOT_FOUND,
                   3666:                            "Error type '%s' is not exported by type library '%s'\n",
                   3667:                            def->name, library);
                   3668:             } else
                   3669:                 if ((xmlStrEqual
                   3670:                      (library,
                   3671:                       BAD_CAST
                   3672:                       "http://www.w3.org/2001/XMLSchema-datatypes"))
                   3673:                     && ((xmlStrEqual(def->name, BAD_CAST "IDREF"))
                   3674:                         || (xmlStrEqual(def->name, BAD_CAST "IDREFS")))) {
                   3675:                 ctxt->idref = 1;
                   3676:             }
                   3677:         }
                   3678:     }
                   3679:     content = node->children;
                   3680: 
                   3681:     /*
                   3682:      * Handle optional params
                   3683:      */
                   3684:     while (content != NULL) {
                   3685:         if (!xmlStrEqual(content->name, BAD_CAST "param"))
                   3686:             break;
                   3687:         if (xmlStrEqual(library,
                   3688:                         BAD_CAST "http://relaxng.org/ns/structure/1.0")) {
                   3689:             xmlRngPErr(ctxt, node, XML_RNGP_PARAM_FORBIDDEN,
                   3690:                        "Type library '%s' does not allow type parameters\n",
                   3691:                        library, NULL);
                   3692:             content = content->next;
                   3693:             while ((content != NULL) &&
                   3694:                    (xmlStrEqual(content->name, BAD_CAST "param")))
                   3695:                 content = content->next;
                   3696:         } else {
                   3697:             param = xmlRelaxNGNewDefine(ctxt, node);
                   3698:             if (param != NULL) {
                   3699:                 param->type = XML_RELAXNG_PARAM;
                   3700:                 param->name = xmlGetProp(content, BAD_CAST "name");
                   3701:                 if (param->name == NULL) {
                   3702:                     xmlRngPErr(ctxt, node, XML_RNGP_PARAM_NAME_MISSING,
                   3703:                                "param has no name\n", NULL, NULL);
                   3704:                 }
                   3705:                 param->value = xmlNodeGetContent(content);
                   3706:                 if (lastparam == NULL) {
                   3707:                     def->attrs = lastparam = param;
                   3708:                 } else {
                   3709:                     lastparam->next = param;
                   3710:                     lastparam = param;
                   3711:                 }
                   3712:                 if (lib != NULL) {
                   3713:                 }
                   3714:             }
                   3715:             content = content->next;
                   3716:         }
                   3717:     }
                   3718:     /*
                   3719:      * Handle optional except
                   3720:      */
                   3721:     if ((content != NULL)
                   3722:         && (xmlStrEqual(content->name, BAD_CAST "except"))) {
                   3723:         xmlNodePtr child;
                   3724:         xmlRelaxNGDefinePtr tmp2, last = NULL;
                   3725: 
                   3726:         except = xmlRelaxNGNewDefine(ctxt, node);
                   3727:         if (except == NULL) {
                   3728:             return (def);
                   3729:         }
                   3730:         except->type = XML_RELAXNG_EXCEPT;
                   3731:         child = content->children;
                   3732:        def->content = except;
                   3733:         if (child == NULL) {
                   3734:             xmlRngPErr(ctxt, content, XML_RNGP_EXCEPT_NO_CONTENT,
                   3735:                        "except has no content\n", NULL, NULL);
                   3736:         }
                   3737:         while (child != NULL) {
                   3738:             tmp2 = xmlRelaxNGParsePattern(ctxt, child);
                   3739:             if (tmp2 != NULL) {
                   3740:                 if (last == NULL) {
                   3741:                     except->content = last = tmp2;
                   3742:                 } else {
                   3743:                     last->next = tmp2;
                   3744:                     last = tmp2;
                   3745:                 }
                   3746:             }
                   3747:             child = child->next;
                   3748:         }
                   3749:         content = content->next;
                   3750:     }
                   3751:     /*
                   3752:      * Check there is no unhandled data
                   3753:      */
                   3754:     if (content != NULL) {
                   3755:         xmlRngPErr(ctxt, content, XML_RNGP_DATA_CONTENT,
                   3756:                    "Element data has unexpected content %s\n",
                   3757:                    content->name, NULL);
                   3758:     }
                   3759: 
                   3760:     return (def);
                   3761: }
                   3762: 
                   3763: static const xmlChar *invalidName = BAD_CAST "\1";
                   3764: 
                   3765: /**
                   3766:  * xmlRelaxNGCompareNameClasses:
                   3767:  * @defs1:  the first element/attribute defs
                   3768:  * @defs2:  the second element/attribute defs
                   3769:  * @name:  the restriction on the name
                   3770:  * @ns:  the restriction on the namespace
                   3771:  *
                   3772:  * Compare the 2 lists of element definitions. The comparison is
                   3773:  * that if both lists do not accept the same QNames, it returns 1
                   3774:  * If the 2 lists can accept the same QName the comparison returns 0
                   3775:  *
                   3776:  * Returns 1 disttinct, 0 if equal
                   3777:  */
                   3778: static int
                   3779: xmlRelaxNGCompareNameClasses(xmlRelaxNGDefinePtr def1,
                   3780:                              xmlRelaxNGDefinePtr def2)
                   3781: {
                   3782:     int ret = 1;
                   3783:     xmlNode node;
                   3784:     xmlNs ns;
                   3785:     xmlRelaxNGValidCtxt ctxt;
                   3786: 
                   3787:     memset(&ctxt, 0, sizeof(xmlRelaxNGValidCtxt));
                   3788: 
                   3789:     ctxt.flags = FLAGS_IGNORABLE | FLAGS_NOERROR;
                   3790: 
                   3791:     if ((def1->type == XML_RELAXNG_ELEMENT) ||
                   3792:         (def1->type == XML_RELAXNG_ATTRIBUTE)) {
                   3793:         if (def2->type == XML_RELAXNG_TEXT)
                   3794:             return (1);
                   3795:         if (def1->name != NULL) {
                   3796:             node.name = def1->name;
                   3797:         } else {
                   3798:             node.name = invalidName;
                   3799:         }
                   3800:         if (def1->ns != NULL) {
                   3801:             if (def1->ns[0] == 0) {
                   3802:                 node.ns = NULL;
                   3803:             } else {
                   3804:                node.ns = &ns;
                   3805:                 ns.href = def1->ns;
                   3806:             }
                   3807:         } else {
                   3808:             node.ns = NULL;
                   3809:         }
                   3810:         if (xmlRelaxNGElementMatch(&ctxt, def2, &node)) {
                   3811:             if (def1->nameClass != NULL) {
                   3812:                 ret = xmlRelaxNGCompareNameClasses(def1->nameClass, def2);
                   3813:             } else {
                   3814:                 ret = 0;
                   3815:             }
                   3816:         } else {
                   3817:             ret = 1;
                   3818:         }
                   3819:     } else if (def1->type == XML_RELAXNG_TEXT) {
                   3820:         if (def2->type == XML_RELAXNG_TEXT)
                   3821:             return (0);
                   3822:         return (1);
                   3823:     } else if (def1->type == XML_RELAXNG_EXCEPT) {
                   3824:         TODO ret = 0;
                   3825:     } else {
                   3826:         TODO ret = 0;
                   3827:     }
                   3828:     if (ret == 0)
                   3829:         return (ret);
                   3830:     if ((def2->type == XML_RELAXNG_ELEMENT) ||
                   3831:         (def2->type == XML_RELAXNG_ATTRIBUTE)) {
                   3832:         if (def2->name != NULL) {
                   3833:             node.name = def2->name;
                   3834:         } else {
                   3835:             node.name = invalidName;
                   3836:         }
                   3837:         node.ns = &ns;
                   3838:         if (def2->ns != NULL) {
                   3839:             if (def2->ns[0] == 0) {
                   3840:                 node.ns = NULL;
                   3841:             } else {
                   3842:                 ns.href = def2->ns;
                   3843:             }
                   3844:         } else {
                   3845:             ns.href = invalidName;
                   3846:         }
                   3847:         if (xmlRelaxNGElementMatch(&ctxt, def1, &node)) {
                   3848:             if (def2->nameClass != NULL) {
                   3849:                 ret = xmlRelaxNGCompareNameClasses(def2->nameClass, def1);
                   3850:             } else {
                   3851:                 ret = 0;
                   3852:             }
                   3853:         } else {
                   3854:             ret = 1;
                   3855:         }
                   3856:     } else {
                   3857:         TODO ret = 0;
                   3858:     }
                   3859: 
                   3860:     return (ret);
                   3861: }
                   3862: 
                   3863: /**
                   3864:  * xmlRelaxNGCompareElemDefLists:
                   3865:  * @ctxt:  a Relax-NG parser context
                   3866:  * @defs1:  the first list of element/attribute defs
                   3867:  * @defs2:  the second list of element/attribute defs
                   3868:  *
                   3869:  * Compare the 2 lists of element or attribute definitions. The comparison
                   3870:  * is that if both lists do not accept the same QNames, it returns 1
                   3871:  * If the 2 lists can accept the same QName the comparison returns 0
                   3872:  *
                   3873:  * Returns 1 disttinct, 0 if equal
                   3874:  */
                   3875: static int
                   3876: xmlRelaxNGCompareElemDefLists(xmlRelaxNGParserCtxtPtr ctxt
                   3877:                               ATTRIBUTE_UNUSED, xmlRelaxNGDefinePtr * def1,
                   3878:                               xmlRelaxNGDefinePtr * def2)
                   3879: {
                   3880:     xmlRelaxNGDefinePtr *basedef2 = def2;
                   3881: 
                   3882:     if ((def1 == NULL) || (def2 == NULL))
                   3883:         return (1);
                   3884:     if ((*def1 == NULL) || (*def2 == NULL))
                   3885:         return (1);
                   3886:     while (*def1 != NULL) {
                   3887:         while ((*def2) != NULL) {
                   3888:             if (xmlRelaxNGCompareNameClasses(*def1, *def2) == 0)
                   3889:                 return (0);
                   3890:             def2++;
                   3891:         }
                   3892:         def2 = basedef2;
                   3893:         def1++;
                   3894:     }
                   3895:     return (1);
                   3896: }
                   3897: 
                   3898: /**
                   3899:  * xmlRelaxNGGenerateAttributes:
                   3900:  * @ctxt:  a Relax-NG parser context
                   3901:  * @def:  the definition definition
                   3902:  *
                   3903:  * Check if the definition can only generate attributes
                   3904:  *
                   3905:  * Returns 1 if yes, 0 if no and -1 in case of error.
                   3906:  */
                   3907: static int
                   3908: xmlRelaxNGGenerateAttributes(xmlRelaxNGParserCtxtPtr ctxt,
                   3909:                              xmlRelaxNGDefinePtr def)
                   3910: {
                   3911:     xmlRelaxNGDefinePtr parent, cur, tmp;
                   3912: 
                   3913:     /*
                   3914:      * Don't run that check in case of error. Infinite recursion
                   3915:      * becomes possible.
                   3916:      */
                   3917:     if (ctxt->nbErrors != 0)
                   3918:         return (-1);
                   3919: 
                   3920:     parent = NULL;
                   3921:     cur = def;
                   3922:     while (cur != NULL) {
                   3923:         if ((cur->type == XML_RELAXNG_ELEMENT) ||
                   3924:             (cur->type == XML_RELAXNG_TEXT) ||
                   3925:             (cur->type == XML_RELAXNG_DATATYPE) ||
                   3926:             (cur->type == XML_RELAXNG_PARAM) ||
                   3927:             (cur->type == XML_RELAXNG_LIST) ||
                   3928:             (cur->type == XML_RELAXNG_VALUE) ||
                   3929:             (cur->type == XML_RELAXNG_EMPTY))
                   3930:             return (0);
                   3931:         if ((cur->type == XML_RELAXNG_CHOICE) ||
                   3932:             (cur->type == XML_RELAXNG_INTERLEAVE) ||
                   3933:             (cur->type == XML_RELAXNG_GROUP) ||
                   3934:             (cur->type == XML_RELAXNG_ONEORMORE) ||
                   3935:             (cur->type == XML_RELAXNG_ZEROORMORE) ||
                   3936:             (cur->type == XML_RELAXNG_OPTIONAL) ||
                   3937:             (cur->type == XML_RELAXNG_PARENTREF) ||
                   3938:             (cur->type == XML_RELAXNG_EXTERNALREF) ||
                   3939:             (cur->type == XML_RELAXNG_REF) ||
                   3940:             (cur->type == XML_RELAXNG_DEF)) {
                   3941:             if (cur->content != NULL) {
                   3942:                 parent = cur;
                   3943:                 cur = cur->content;
                   3944:                 tmp = cur;
                   3945:                 while (tmp != NULL) {
                   3946:                     tmp->parent = parent;
                   3947:                     tmp = tmp->next;
                   3948:                 }
                   3949:                 continue;
                   3950:             }
                   3951:         }
                   3952:         if (cur == def)
                   3953:             break;
                   3954:         if (cur->next != NULL) {
                   3955:             cur = cur->next;
                   3956:             continue;
                   3957:         }
                   3958:         do {
                   3959:             cur = cur->parent;
                   3960:             if (cur == NULL)
                   3961:                 break;
                   3962:             if (cur == def)
                   3963:                 return (1);
                   3964:             if (cur->next != NULL) {
                   3965:                 cur = cur->next;
                   3966:                 break;
                   3967:             }
                   3968:         } while (cur != NULL);
                   3969:     }
                   3970:     return (1);
                   3971: }
                   3972: 
                   3973: /**
                   3974:  * xmlRelaxNGGetElements:
                   3975:  * @ctxt:  a Relax-NG parser context
                   3976:  * @def:  the definition definition
                   3977:  * @eora:  gather elements (0) or attributes (1)
                   3978:  *
                   3979:  * Compute the list of top elements a definition can generate
                   3980:  *
                   3981:  * Returns a list of elements or NULL if none was found.
                   3982:  */
                   3983: static xmlRelaxNGDefinePtr *
                   3984: xmlRelaxNGGetElements(xmlRelaxNGParserCtxtPtr ctxt,
                   3985:                       xmlRelaxNGDefinePtr def, int eora)
                   3986: {
                   3987:     xmlRelaxNGDefinePtr *ret = NULL, parent, cur, tmp;
                   3988:     int len = 0;
                   3989:     int max = 0;
                   3990: 
                   3991:     /*
                   3992:      * Don't run that check in case of error. Infinite recursion
                   3993:      * becomes possible.
                   3994:      */
                   3995:     if (ctxt->nbErrors != 0)
                   3996:         return (NULL);
                   3997: 
                   3998:     parent = NULL;
                   3999:     cur = def;
                   4000:     while (cur != NULL) {
                   4001:         if (((eora == 0) && ((cur->type == XML_RELAXNG_ELEMENT) ||
                   4002:                              (cur->type == XML_RELAXNG_TEXT))) ||
                   4003:             ((eora == 1) && (cur->type == XML_RELAXNG_ATTRIBUTE))) {
                   4004:             if (ret == NULL) {
                   4005:                 max = 10;
                   4006:                 ret = (xmlRelaxNGDefinePtr *)
                   4007:                     xmlMalloc((max + 1) * sizeof(xmlRelaxNGDefinePtr));
                   4008:                 if (ret == NULL) {
                   4009:                     xmlRngPErrMemory(ctxt, "getting element list\n");
                   4010:                     return (NULL);
                   4011:                 }
                   4012:             } else if (max <= len) {
                   4013:                xmlRelaxNGDefinePtr *temp;
                   4014: 
                   4015:                 max *= 2;
                   4016:                 temp = xmlRealloc(ret,
                   4017:                                (max + 1) * sizeof(xmlRelaxNGDefinePtr));
                   4018:                 if (temp == NULL) {
                   4019:                     xmlRngPErrMemory(ctxt, "getting element list\n");
                   4020:                    xmlFree(ret);
                   4021:                     return (NULL);
                   4022:                 }
                   4023:                ret = temp;
                   4024:             }
                   4025:             ret[len++] = cur;
                   4026:             ret[len] = NULL;
                   4027:         } else if ((cur->type == XML_RELAXNG_CHOICE) ||
                   4028:                    (cur->type == XML_RELAXNG_INTERLEAVE) ||
                   4029:                    (cur->type == XML_RELAXNG_GROUP) ||
                   4030:                    (cur->type == XML_RELAXNG_ONEORMORE) ||
                   4031:                    (cur->type == XML_RELAXNG_ZEROORMORE) ||
                   4032:                    (cur->type == XML_RELAXNG_OPTIONAL) ||
                   4033:                    (cur->type == XML_RELAXNG_PARENTREF) ||
                   4034:                    (cur->type == XML_RELAXNG_REF) ||
                   4035:                    (cur->type == XML_RELAXNG_DEF) ||
                   4036:                   (cur->type == XML_RELAXNG_EXTERNALREF)) {
                   4037:             /*
                   4038:              * Don't go within elements or attributes or string values.
                   4039:              * Just gather the element top list
                   4040:              */
                   4041:             if (cur->content != NULL) {
                   4042:                 parent = cur;
                   4043:                 cur = cur->content;
                   4044:                 tmp = cur;
                   4045:                 while (tmp != NULL) {
                   4046:                     tmp->parent = parent;
                   4047:                     tmp = tmp->next;
                   4048:                 }
                   4049:                 continue;
                   4050:             }
                   4051:         }
                   4052:         if (cur == def)
                   4053:             break;
                   4054:         if (cur->next != NULL) {
                   4055:             cur = cur->next;
                   4056:             continue;
                   4057:         }
                   4058:         do {
                   4059:             cur = cur->parent;
                   4060:             if (cur == NULL)
                   4061:                 break;
                   4062:             if (cur == def)
                   4063:                 return (ret);
                   4064:             if (cur->next != NULL) {
                   4065:                 cur = cur->next;
                   4066:                 break;
                   4067:             }
                   4068:         } while (cur != NULL);
                   4069:     }
                   4070:     return (ret);
                   4071: }
                   4072: 
                   4073: /**
                   4074:  * xmlRelaxNGCheckChoiceDeterminism:
                   4075:  * @ctxt:  a Relax-NG parser context
                   4076:  * @def:  the choice definition
                   4077:  *
                   4078:  * Also used to find indeterministic pattern in choice
                   4079:  */
                   4080: static void
                   4081: xmlRelaxNGCheckChoiceDeterminism(xmlRelaxNGParserCtxtPtr ctxt,
                   4082:                                  xmlRelaxNGDefinePtr def)
                   4083: {
                   4084:     xmlRelaxNGDefinePtr **list;
                   4085:     xmlRelaxNGDefinePtr cur;
                   4086:     int nbchild = 0, i, j, ret;
                   4087:     int is_nullable = 0;
                   4088:     int is_indeterminist = 0;
                   4089:     xmlHashTablePtr triage = NULL;
                   4090:     int is_triable = 1;
                   4091: 
                   4092:     if ((def == NULL) || (def->type != XML_RELAXNG_CHOICE))
                   4093:         return;
                   4094: 
                   4095:     if (def->dflags & IS_PROCESSED)
                   4096:         return;
                   4097: 
                   4098:     /*
                   4099:      * Don't run that check in case of error. Infinite recursion
                   4100:      * becomes possible.
                   4101:      */
                   4102:     if (ctxt->nbErrors != 0)
                   4103:         return;
                   4104: 
                   4105:     is_nullable = xmlRelaxNGIsNullable(def);
                   4106: 
                   4107:     cur = def->content;
                   4108:     while (cur != NULL) {
                   4109:         nbchild++;
                   4110:         cur = cur->next;
                   4111:     }
                   4112: 
                   4113:     list = (xmlRelaxNGDefinePtr **) xmlMalloc(nbchild *
                   4114:                                               sizeof(xmlRelaxNGDefinePtr
                   4115:                                                      *));
                   4116:     if (list == NULL) {
                   4117:         xmlRngPErrMemory(ctxt, "building choice\n");
                   4118:         return;
                   4119:     }
                   4120:     i = 0;
                   4121:     /*
                   4122:      * a bit strong but safe
                   4123:      */
                   4124:     if (is_nullable == 0) {
                   4125:         triage = xmlHashCreate(10);
                   4126:     } else {
                   4127:         is_triable = 0;
                   4128:     }
                   4129:     cur = def->content;
                   4130:     while (cur != NULL) {
                   4131:         list[i] = xmlRelaxNGGetElements(ctxt, cur, 0);
                   4132:         if ((list[i] == NULL) || (list[i][0] == NULL)) {
                   4133:             is_triable = 0;
                   4134:         } else if (is_triable == 1) {
                   4135:             xmlRelaxNGDefinePtr *tmp;
                   4136:             int res;
                   4137: 
                   4138:             tmp = list[i];
                   4139:             while ((*tmp != NULL) && (is_triable == 1)) {
                   4140:                 if ((*tmp)->type == XML_RELAXNG_TEXT) {
                   4141:                     res = xmlHashAddEntry2(triage,
                   4142:                                            BAD_CAST "#text", NULL,
                   4143:                                            (void *) cur);
                   4144:                     if (res != 0)
                   4145:                         is_triable = -1;
                   4146:                 } else if (((*tmp)->type == XML_RELAXNG_ELEMENT) &&
                   4147:                            ((*tmp)->name != NULL)) {
                   4148:                     if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
                   4149:                         res = xmlHashAddEntry2(triage,
                   4150:                                                (*tmp)->name, NULL,
                   4151:                                                (void *) cur);
                   4152:                     else
                   4153:                         res = xmlHashAddEntry2(triage,
                   4154:                                                (*tmp)->name, (*tmp)->ns,
                   4155:                                                (void *) cur);
                   4156:                     if (res != 0)
                   4157:                         is_triable = -1;
                   4158:                 } else if ((*tmp)->type == XML_RELAXNG_ELEMENT) {
                   4159:                     if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
                   4160:                         res = xmlHashAddEntry2(triage,
                   4161:                                                BAD_CAST "#any", NULL,
                   4162:                                                (void *) cur);
                   4163:                     else
                   4164:                         res = xmlHashAddEntry2(triage,
                   4165:                                                BAD_CAST "#any", (*tmp)->ns,
                   4166:                                                (void *) cur);
                   4167:                     if (res != 0)
                   4168:                         is_triable = -1;
                   4169:                 } else {
                   4170:                     is_triable = -1;
                   4171:                 }
                   4172:                 tmp++;
                   4173:             }
                   4174:         }
                   4175:         i++;
                   4176:         cur = cur->next;
                   4177:     }
                   4178: 
                   4179:     for (i = 0; i < nbchild; i++) {
                   4180:         if (list[i] == NULL)
                   4181:             continue;
                   4182:         for (j = 0; j < i; j++) {
                   4183:             if (list[j] == NULL)
                   4184:                 continue;
                   4185:             ret = xmlRelaxNGCompareElemDefLists(ctxt, list[i], list[j]);
                   4186:             if (ret == 0) {
                   4187:                 is_indeterminist = 1;
                   4188:             }
                   4189:         }
                   4190:     }
                   4191:     for (i = 0; i < nbchild; i++) {
                   4192:         if (list[i] != NULL)
                   4193:             xmlFree(list[i]);
                   4194:     }
                   4195: 
                   4196:     xmlFree(list);
                   4197:     if (is_indeterminist) {
                   4198:         def->dflags |= IS_INDETERMINIST;
                   4199:     }
                   4200:     if (is_triable == 1) {
                   4201:         def->dflags |= IS_TRIABLE;
                   4202:         def->data = triage;
                   4203:     } else if (triage != NULL) {
                   4204:         xmlHashFree(triage, NULL);
                   4205:     }
                   4206:     def->dflags |= IS_PROCESSED;
                   4207: }
                   4208: 
                   4209: /**
                   4210:  * xmlRelaxNGCheckGroupAttrs:
                   4211:  * @ctxt:  a Relax-NG parser context
                   4212:  * @def:  the group definition
                   4213:  *
                   4214:  * Detects violations of rule 7.3
                   4215:  */
                   4216: static void
                   4217: xmlRelaxNGCheckGroupAttrs(xmlRelaxNGParserCtxtPtr ctxt,
                   4218:                           xmlRelaxNGDefinePtr def)
                   4219: {
                   4220:     xmlRelaxNGDefinePtr **list;
                   4221:     xmlRelaxNGDefinePtr cur;
                   4222:     int nbchild = 0, i, j, ret;
                   4223: 
                   4224:     if ((def == NULL) ||
                   4225:         ((def->type != XML_RELAXNG_GROUP) &&
                   4226:          (def->type != XML_RELAXNG_ELEMENT)))
                   4227:         return;
                   4228: 
                   4229:     if (def->dflags & IS_PROCESSED)
                   4230:         return;
                   4231: 
                   4232:     /*
                   4233:      * Don't run that check in case of error. Infinite recursion
                   4234:      * becomes possible.
                   4235:      */
                   4236:     if (ctxt->nbErrors != 0)
                   4237:         return;
                   4238: 
                   4239:     cur = def->attrs;
                   4240:     while (cur != NULL) {
                   4241:         nbchild++;
                   4242:         cur = cur->next;
                   4243:     }
                   4244:     cur = def->content;
                   4245:     while (cur != NULL) {
                   4246:         nbchild++;
                   4247:         cur = cur->next;
                   4248:     }
                   4249: 
                   4250:     list = (xmlRelaxNGDefinePtr **) xmlMalloc(nbchild *
                   4251:                                               sizeof(xmlRelaxNGDefinePtr
                   4252:                                                      *));
                   4253:     if (list == NULL) {
                   4254:         xmlRngPErrMemory(ctxt, "building group\n");
                   4255:         return;
                   4256:     }
                   4257:     i = 0;
                   4258:     cur = def->attrs;
                   4259:     while (cur != NULL) {
                   4260:         list[i] = xmlRelaxNGGetElements(ctxt, cur, 1);
                   4261:         i++;
                   4262:         cur = cur->next;
                   4263:     }
                   4264:     cur = def->content;
                   4265:     while (cur != NULL) {
                   4266:         list[i] = xmlRelaxNGGetElements(ctxt, cur, 1);
                   4267:         i++;
                   4268:         cur = cur->next;
                   4269:     }
                   4270: 
                   4271:     for (i = 0; i < nbchild; i++) {
                   4272:         if (list[i] == NULL)
                   4273:             continue;
                   4274:         for (j = 0; j < i; j++) {
                   4275:             if (list[j] == NULL)
                   4276:                 continue;
                   4277:             ret = xmlRelaxNGCompareElemDefLists(ctxt, list[i], list[j]);
                   4278:             if (ret == 0) {
                   4279:                 xmlRngPErr(ctxt, def->node, XML_RNGP_GROUP_ATTR_CONFLICT,
                   4280:                            "Attributes conflicts in group\n", NULL, NULL);
                   4281:             }
                   4282:         }
                   4283:     }
                   4284:     for (i = 0; i < nbchild; i++) {
                   4285:         if (list[i] != NULL)
                   4286:             xmlFree(list[i]);
                   4287:     }
                   4288: 
                   4289:     xmlFree(list);
                   4290:     def->dflags |= IS_PROCESSED;
                   4291: }
                   4292: 
                   4293: /**
                   4294:  * xmlRelaxNGComputeInterleaves:
                   4295:  * @def:  the interleave definition
                   4296:  * @ctxt:  a Relax-NG parser context
                   4297:  * @name:  the definition name
                   4298:  *
                   4299:  * A lot of work for preprocessing interleave definitions
                   4300:  * is potentially needed to get a decent execution speed at runtime
                   4301:  *   - trying to get a total order on the element nodes generated
                   4302:  *     by the interleaves, order the list of interleave definitions
                   4303:  *     following that order.
                   4304:  *   - if <text/> is used to handle mixed content, it is better to
                   4305:  *     flag this in the define and simplify the runtime checking
                   4306:  *     algorithm
                   4307:  */
                   4308: static void
                   4309: xmlRelaxNGComputeInterleaves(xmlRelaxNGDefinePtr def,
                   4310:                              xmlRelaxNGParserCtxtPtr ctxt,
                   4311:                              xmlChar * name ATTRIBUTE_UNUSED)
                   4312: {
                   4313:     xmlRelaxNGDefinePtr cur, *tmp;
                   4314: 
                   4315:     xmlRelaxNGPartitionPtr partitions = NULL;
                   4316:     xmlRelaxNGInterleaveGroupPtr *groups = NULL;
                   4317:     xmlRelaxNGInterleaveGroupPtr group;
                   4318:     int i, j, ret, res;
                   4319:     int nbgroups = 0;
                   4320:     int nbchild = 0;
                   4321:     int is_mixed = 0;
                   4322:     int is_determinist = 1;
                   4323: 
                   4324:     /*
                   4325:      * Don't run that check in case of error. Infinite recursion
                   4326:      * becomes possible.
                   4327:      */
                   4328:     if (ctxt->nbErrors != 0)
                   4329:         return;
                   4330: 
                   4331: #ifdef DEBUG_INTERLEAVE
                   4332:     xmlGenericError(xmlGenericErrorContext,
                   4333:                     "xmlRelaxNGComputeInterleaves(%s)\n", name);
                   4334: #endif
                   4335:     cur = def->content;
                   4336:     while (cur != NULL) {
                   4337:         nbchild++;
                   4338:         cur = cur->next;
                   4339:     }
                   4340: 
                   4341: #ifdef DEBUG_INTERLEAVE
                   4342:     xmlGenericError(xmlGenericErrorContext, "  %d child\n", nbchild);
                   4343: #endif
                   4344:     groups = (xmlRelaxNGInterleaveGroupPtr *)
                   4345:         xmlMalloc(nbchild * sizeof(xmlRelaxNGInterleaveGroupPtr));
                   4346:     if (groups == NULL)
                   4347:         goto error;
                   4348:     cur = def->content;
                   4349:     while (cur != NULL) {
                   4350:         groups[nbgroups] = (xmlRelaxNGInterleaveGroupPtr)
                   4351:             xmlMalloc(sizeof(xmlRelaxNGInterleaveGroup));
                   4352:         if (groups[nbgroups] == NULL)
                   4353:             goto error;
                   4354:         if (cur->type == XML_RELAXNG_TEXT)
                   4355:             is_mixed++;
                   4356:         groups[nbgroups]->rule = cur;
                   4357:         groups[nbgroups]->defs = xmlRelaxNGGetElements(ctxt, cur, 0);
                   4358:         groups[nbgroups]->attrs = xmlRelaxNGGetElements(ctxt, cur, 1);
                   4359:         nbgroups++;
                   4360:         cur = cur->next;
                   4361:     }
                   4362: #ifdef DEBUG_INTERLEAVE
                   4363:     xmlGenericError(xmlGenericErrorContext, "  %d groups\n", nbgroups);
                   4364: #endif
                   4365: 
                   4366:     /*
                   4367:      * Let's check that all rules makes a partitions according to 7.4
                   4368:      */
                   4369:     partitions = (xmlRelaxNGPartitionPtr)
                   4370:         xmlMalloc(sizeof(xmlRelaxNGPartition));
                   4371:     if (partitions == NULL)
                   4372:         goto error;
                   4373:     memset(partitions, 0, sizeof(xmlRelaxNGPartition));
                   4374:     partitions->nbgroups = nbgroups;
                   4375:     partitions->triage = xmlHashCreate(nbgroups);
                   4376:     for (i = 0; i < nbgroups; i++) {
                   4377:         group = groups[i];
                   4378:         for (j = i + 1; j < nbgroups; j++) {
                   4379:             if (groups[j] == NULL)
                   4380:                 continue;
                   4381: 
                   4382:             ret = xmlRelaxNGCompareElemDefLists(ctxt, group->defs,
                   4383:                                                 groups[j]->defs);
                   4384:             if (ret == 0) {
                   4385:                 xmlRngPErr(ctxt, def->node, XML_RNGP_ELEM_TEXT_CONFLICT,
                   4386:                            "Element or text conflicts in interleave\n",
                   4387:                            NULL, NULL);
                   4388:             }
                   4389:             ret = xmlRelaxNGCompareElemDefLists(ctxt, group->attrs,
                   4390:                                                 groups[j]->attrs);
                   4391:             if (ret == 0) {
                   4392:                 xmlRngPErr(ctxt, def->node, XML_RNGP_ATTR_CONFLICT,
                   4393:                            "Attributes conflicts in interleave\n", NULL,
                   4394:                            NULL);
                   4395:             }
                   4396:         }
                   4397:         tmp = group->defs;
                   4398:         if ((tmp != NULL) && (*tmp != NULL)) {
                   4399:             while (*tmp != NULL) {
                   4400:                 if ((*tmp)->type == XML_RELAXNG_TEXT) {
                   4401:                     res = xmlHashAddEntry2(partitions->triage,
                   4402:                                            BAD_CAST "#text", NULL,
                   4403:                                            (void *) (long) (i + 1));
                   4404:                     if (res != 0)
                   4405:                         is_determinist = -1;
                   4406:                 } else if (((*tmp)->type == XML_RELAXNG_ELEMENT) &&
                   4407:                            ((*tmp)->name != NULL)) {
                   4408:                     if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
                   4409:                         res = xmlHashAddEntry2(partitions->triage,
                   4410:                                                (*tmp)->name, NULL,
                   4411:                                                (void *) (long) (i + 1));
                   4412:                     else
                   4413:                         res = xmlHashAddEntry2(partitions->triage,
                   4414:                                                (*tmp)->name, (*tmp)->ns,
                   4415:                                                (void *) (long) (i + 1));
                   4416:                     if (res != 0)
                   4417:                         is_determinist = -1;
                   4418:                 } else if ((*tmp)->type == XML_RELAXNG_ELEMENT) {
                   4419:                     if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0))
                   4420:                         res = xmlHashAddEntry2(partitions->triage,
                   4421:                                                BAD_CAST "#any", NULL,
                   4422:                                                (void *) (long) (i + 1));
                   4423:                     else
                   4424:                         res = xmlHashAddEntry2(partitions->triage,
                   4425:                                                BAD_CAST "#any", (*tmp)->ns,
                   4426:                                                (void *) (long) (i + 1));
                   4427:                     if ((*tmp)->nameClass != NULL)
                   4428:                         is_determinist = 2;
                   4429:                     if (res != 0)
                   4430:                         is_determinist = -1;
                   4431:                 } else {
                   4432:                     is_determinist = -1;
                   4433:                 }
                   4434:                 tmp++;
                   4435:             }
                   4436:         } else {
                   4437:             is_determinist = 0;
                   4438:         }
                   4439:     }
                   4440:     partitions->groups = groups;
                   4441: 
                   4442:     /*
                   4443:      * and save the partition list back in the def
                   4444:      */
                   4445:     def->data = partitions;
                   4446:     if (is_mixed != 0)
                   4447:         def->dflags |= IS_MIXED;
                   4448:     if (is_determinist == 1)
                   4449:         partitions->flags = IS_DETERMINIST;
                   4450:     if (is_determinist == 2)
                   4451:         partitions->flags = IS_DETERMINIST | IS_NEEDCHECK;
                   4452:     return;
                   4453: 
                   4454:   error:
                   4455:     xmlRngPErrMemory(ctxt, "in interleave computation\n");
                   4456:     if (groups != NULL) {
                   4457:         for (i = 0; i < nbgroups; i++)
                   4458:             if (groups[i] != NULL) {
                   4459:                 if (groups[i]->defs != NULL)
                   4460:                     xmlFree(groups[i]->defs);
                   4461:                 xmlFree(groups[i]);
                   4462:             }
                   4463:         xmlFree(groups);
                   4464:     }
                   4465:     xmlRelaxNGFreePartition(partitions);
                   4466: }
                   4467: 
                   4468: /**
                   4469:  * xmlRelaxNGParseInterleave:
                   4470:  * @ctxt:  a Relax-NG parser context
                   4471:  * @node:  the data node.
                   4472:  *
                   4473:  * parse the content of a RelaxNG interleave node.
                   4474:  *
                   4475:  * Returns the definition pointer or NULL in case of error
                   4476:  */
                   4477: static xmlRelaxNGDefinePtr
                   4478: xmlRelaxNGParseInterleave(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
                   4479: {
                   4480:     xmlRelaxNGDefinePtr def = NULL;
                   4481:     xmlRelaxNGDefinePtr last = NULL, cur;
                   4482:     xmlNodePtr child;
                   4483: 
                   4484:     def = xmlRelaxNGNewDefine(ctxt, node);
                   4485:     if (def == NULL) {
                   4486:         return (NULL);
                   4487:     }
                   4488:     def->type = XML_RELAXNG_INTERLEAVE;
                   4489: 
                   4490:     if (ctxt->interleaves == NULL)
                   4491:         ctxt->interleaves = xmlHashCreate(10);
                   4492:     if (ctxt->interleaves == NULL) {
                   4493:         xmlRngPErrMemory(ctxt, "create interleaves\n");
                   4494:     } else {
                   4495:         char name[32];
                   4496: 
                   4497:         snprintf(name, 32, "interleave%d", ctxt->nbInterleaves++);
                   4498:         if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST name, def) < 0) {
                   4499:             xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_ADD,
                   4500:                        "Failed to add %s to hash table\n",
                   4501:                       (const xmlChar *) name, NULL);
                   4502:         }
                   4503:     }
                   4504:     child = node->children;
                   4505:     if (child == NULL) {
                   4506:         xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_NO_CONTENT,
                   4507:                    "Element interleave is empty\n", NULL, NULL);
                   4508:     }
                   4509:     while (child != NULL) {
                   4510:         if (IS_RELAXNG(child, "element")) {
                   4511:             cur = xmlRelaxNGParseElement(ctxt, child);
                   4512:         } else {
                   4513:             cur = xmlRelaxNGParsePattern(ctxt, child);
                   4514:         }
                   4515:         if (cur != NULL) {
                   4516:             cur->parent = def;
                   4517:             if (last == NULL) {
                   4518:                 def->content = last = cur;
                   4519:             } else {
                   4520:                 last->next = cur;
                   4521:                 last = cur;
                   4522:             }
                   4523:         }
                   4524:         child = child->next;
                   4525:     }
                   4526: 
                   4527:     return (def);
                   4528: }
                   4529: 
                   4530: /**
                   4531:  * xmlRelaxNGParseInclude:
                   4532:  * @ctxt:  a Relax-NG parser context
                   4533:  * @node:  the include node
                   4534:  *
                   4535:  * Integrate the content of an include node in the current grammar
                   4536:  *
                   4537:  * Returns 0 in case of success or -1 in case of error
                   4538:  */
                   4539: static int
                   4540: xmlRelaxNGParseInclude(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
                   4541: {
                   4542:     xmlRelaxNGIncludePtr incl;
                   4543:     xmlNodePtr root;
                   4544:     int ret = 0, tmp;
                   4545: 
                   4546:     incl = node->psvi;
                   4547:     if (incl == NULL) {
                   4548:         xmlRngPErr(ctxt, node, XML_RNGP_INCLUDE_EMPTY,
                   4549:                    "Include node has no data\n", NULL, NULL);
                   4550:         return (-1);
                   4551:     }
                   4552:     root = xmlDocGetRootElement(incl->doc);
                   4553:     if (root == NULL) {
                   4554:         xmlRngPErr(ctxt, node, XML_RNGP_EMPTY, "Include document is empty\n",
                   4555:                    NULL, NULL);
                   4556:         return (-1);
                   4557:     }
                   4558:     if (!xmlStrEqual(root->name, BAD_CAST "grammar")) {
                   4559:         xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
                   4560:                    "Include document root is not a grammar\n", NULL, NULL);
                   4561:         return (-1);
                   4562:     }
                   4563: 
                   4564:     /*
                   4565:      * Merge the definition from both the include and the internal list
                   4566:      */
                   4567:     if (root->children != NULL) {
                   4568:         tmp = xmlRelaxNGParseGrammarContent(ctxt, root->children);
                   4569:         if (tmp != 0)
                   4570:             ret = -1;
                   4571:     }
                   4572:     if (node->children != NULL) {
                   4573:         tmp = xmlRelaxNGParseGrammarContent(ctxt, node->children);
                   4574:         if (tmp != 0)
                   4575:             ret = -1;
                   4576:     }
                   4577:     return (ret);
                   4578: }
                   4579: 
                   4580: /**
                   4581:  * xmlRelaxNGParseDefine:
                   4582:  * @ctxt:  a Relax-NG parser context
                   4583:  * @node:  the define node
                   4584:  *
                   4585:  * parse the content of a RelaxNG define element node.
                   4586:  *
                   4587:  * Returns 0 in case of success or -1 in case of error
                   4588:  */
                   4589: static int
                   4590: xmlRelaxNGParseDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
                   4591: {
                   4592:     xmlChar *name;
                   4593:     int ret = 0, tmp;
                   4594:     xmlRelaxNGDefinePtr def;
                   4595:     const xmlChar *olddefine;
                   4596: 
                   4597:     name = xmlGetProp(node, BAD_CAST "name");
                   4598:     if (name == NULL) {
                   4599:         xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_NAME_MISSING,
                   4600:                    "define has no name\n", NULL, NULL);
                   4601:     } else {
                   4602:         xmlRelaxNGNormExtSpace(name);
                   4603:         if (xmlValidateNCName(name, 0)) {
                   4604:             xmlRngPErr(ctxt, node, XML_RNGP_INVALID_DEFINE_NAME,
                   4605:                        "define name '%s' is not an NCName\n", name, NULL);
                   4606:         }
                   4607:         def = xmlRelaxNGNewDefine(ctxt, node);
                   4608:         if (def == NULL) {
                   4609:             xmlFree(name);
                   4610:             return (-1);
                   4611:         }
                   4612:         def->type = XML_RELAXNG_DEF;
                   4613:         def->name = name;
                   4614:         if (node->children == NULL) {
                   4615:             xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_EMPTY,
                   4616:                        "define has no children\n", NULL, NULL);
                   4617:         } else {
                   4618:             olddefine = ctxt->define;
                   4619:             ctxt->define = name;
                   4620:             def->content =
                   4621:                 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
                   4622:             ctxt->define = olddefine;
                   4623:         }
                   4624:         if (ctxt->grammar->defs == NULL)
                   4625:             ctxt->grammar->defs = xmlHashCreate(10);
                   4626:         if (ctxt->grammar->defs == NULL) {
                   4627:             xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED,
                   4628:                        "Could not create definition hash\n", NULL, NULL);
                   4629:             ret = -1;
                   4630:         } else {
                   4631:             tmp = xmlHashAddEntry(ctxt->grammar->defs, name, def);
                   4632:             if (tmp < 0) {
                   4633:                 xmlRelaxNGDefinePtr prev;
                   4634: 
                   4635:                 prev = xmlHashLookup(ctxt->grammar->defs, name);
                   4636:                 if (prev == NULL) {
                   4637:                     xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED,
                   4638:                                "Internal error on define aggregation of %s\n",
                   4639:                                name, NULL);
                   4640:                     ret = -1;
                   4641:                 } else {
                   4642:                     while (prev->nextHash != NULL)
                   4643:                         prev = prev->nextHash;
                   4644:                     prev->nextHash = def;
                   4645:                 }
                   4646:             }
                   4647:         }
                   4648:     }
                   4649:     return (ret);
                   4650: }
                   4651: 
                   4652: /**
                   4653:  * xmlRelaxNGParseImportRef:
                   4654:  * @payload: the parser context
                   4655:  * @data: the current grammar
                   4656:  * @name: the reference name
                   4657:  *
                   4658:  * Import import one references into the current grammar
                   4659:  */
                   4660: static void
                   4661: xmlRelaxNGParseImportRef(void *payload, void *data, xmlChar *name) {
                   4662:     xmlRelaxNGParserCtxtPtr ctxt = (xmlRelaxNGParserCtxtPtr) data;
                   4663:     xmlRelaxNGDefinePtr def = (xmlRelaxNGDefinePtr) payload;
                   4664:     int tmp;
                   4665: 
                   4666:     def->dflags |= IS_EXTERNAL_REF;
                   4667: 
                   4668:     tmp = xmlHashAddEntry(ctxt->grammar->refs, name, def);
                   4669:     if (tmp < 0) {
                   4670:         xmlRelaxNGDefinePtr prev;
                   4671: 
                   4672:         prev = (xmlRelaxNGDefinePtr)
                   4673:             xmlHashLookup(ctxt->grammar->refs, def->name);
                   4674:         if (prev == NULL) {
                   4675:             if (def->name != NULL) {
                   4676:                 xmlRngPErr(ctxt, NULL, XML_RNGP_REF_CREATE_FAILED,
                   4677:                            "Error refs definitions '%s'\n",
                   4678:                            def->name, NULL);
                   4679:             } else {
                   4680:                 xmlRngPErr(ctxt, NULL, XML_RNGP_REF_CREATE_FAILED,
                   4681:                            "Error refs definitions\n",
                   4682:                            NULL, NULL);
                   4683:             }
                   4684:         } else {
                   4685:             def->nextHash = prev->nextHash;
                   4686:             prev->nextHash = def;
                   4687:         }
                   4688:     }
                   4689: }
                   4690: 
                   4691: /**
                   4692:  * xmlRelaxNGParseImportRefs:
                   4693:  * @ctxt: the parser context
                   4694:  * @grammar: the sub grammar
                   4695:  *
                   4696:  * Import references from the subgrammar into the current grammar
                   4697:  *
                   4698:  * Returns 0 in case of success, -1 in case of failure
                   4699:  */
                   4700: static int
                   4701: xmlRelaxNGParseImportRefs(xmlRelaxNGParserCtxtPtr ctxt,
                   4702:                           xmlRelaxNGGrammarPtr grammar) {
                   4703:     if ((ctxt == NULL) || (grammar == NULL) || (ctxt->grammar == NULL))
                   4704:         return(-1);
                   4705:     if (grammar->refs == NULL)
                   4706:         return(0);
                   4707:     if (ctxt->grammar->refs == NULL)
                   4708:         ctxt->grammar->refs = xmlHashCreate(10);
                   4709:     if (ctxt->grammar->refs == NULL) {
                   4710:         xmlRngPErr(ctxt, NULL, XML_RNGP_REF_CREATE_FAILED,
                   4711:                    "Could not create references hash\n", NULL, NULL);
                   4712:         return(-1);
                   4713:     }
                   4714:     xmlHashScan(grammar->refs, xmlRelaxNGParseImportRef, ctxt);
                   4715:     return(0);
                   4716: }
                   4717: 
                   4718: /**
                   4719:  * xmlRelaxNGProcessExternalRef:
                   4720:  * @ctxt: the parser context
                   4721:  * @node:  the externlRef node
                   4722:  *
                   4723:  * Process and compile an externlRef node
                   4724:  *
                   4725:  * Returns the xmlRelaxNGDefinePtr or NULL in case of error
                   4726:  */
                   4727: static xmlRelaxNGDefinePtr
                   4728: xmlRelaxNGProcessExternalRef(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
                   4729: {
                   4730:     xmlRelaxNGDocumentPtr docu;
                   4731:     xmlNodePtr root, tmp;
                   4732:     xmlChar *ns;
                   4733:     int newNs = 0, oldflags;
                   4734:     xmlRelaxNGDefinePtr def;
                   4735: 
                   4736:     docu = node->psvi;
                   4737:     if (docu != NULL) {
                   4738:         def = xmlRelaxNGNewDefine(ctxt, node);
                   4739:         if (def == NULL)
                   4740:             return (NULL);
                   4741:         def->type = XML_RELAXNG_EXTERNALREF;
                   4742: 
                   4743:         if (docu->content == NULL) {
                   4744:             /*
                   4745:              * Then do the parsing for good
                   4746:              */
                   4747:             root = xmlDocGetRootElement(docu->doc);
                   4748:             if (root == NULL) {
                   4749:                 xmlRngPErr(ctxt, node, XML_RNGP_EXTERNALREF_EMTPY,
                   4750:                            "xmlRelaxNGParse: %s is empty\n", ctxt->URL,
                   4751:                            NULL);
                   4752:                 return (NULL);
                   4753:             }
                   4754:             /*
                   4755:              * ns transmission rules
                   4756:              */
                   4757:             ns = xmlGetProp(root, BAD_CAST "ns");
                   4758:             if (ns == NULL) {
                   4759:                 tmp = node;
                   4760:                 while ((tmp != NULL) && (tmp->type == XML_ELEMENT_NODE)) {
                   4761:                     ns = xmlGetProp(tmp, BAD_CAST "ns");
                   4762:                     if (ns != NULL) {
                   4763:                         break;
                   4764:                     }
                   4765:                     tmp = tmp->parent;
                   4766:                 }
                   4767:                 if (ns != NULL) {
                   4768:                     xmlSetProp(root, BAD_CAST "ns", ns);
                   4769:                     newNs = 1;
                   4770:                     xmlFree(ns);
                   4771:                 }
                   4772:             } else {
                   4773:                 xmlFree(ns);
                   4774:             }
                   4775: 
                   4776:             /*
                   4777:              * Parsing to get a precompiled schemas.
                   4778:              */
                   4779:             oldflags = ctxt->flags;
                   4780:             ctxt->flags |= XML_RELAXNG_IN_EXTERNALREF;
                   4781:             docu->schema = xmlRelaxNGParseDocument(ctxt, root);
                   4782:             ctxt->flags = oldflags;
                   4783:             if ((docu->schema != NULL) &&
                   4784:                 (docu->schema->topgrammar != NULL)) {
                   4785:                 docu->content = docu->schema->topgrammar->start;
                   4786:                 if (docu->schema->topgrammar->refs)
                   4787:                     xmlRelaxNGParseImportRefs(ctxt, docu->schema->topgrammar);
                   4788:             }
                   4789: 
                   4790:             /*
                   4791:              * the externalRef may be reused in a different ns context
                   4792:              */
                   4793:             if (newNs == 1) {
                   4794:                 xmlUnsetProp(root, BAD_CAST "ns");
                   4795:             }
                   4796:         }
                   4797:         def->content = docu->content;
                   4798:     } else {
                   4799:         def = NULL;
                   4800:     }
                   4801:     return (def);
                   4802: }
                   4803: 
                   4804: /**
                   4805:  * xmlRelaxNGParsePattern:
                   4806:  * @ctxt:  a Relax-NG parser context
                   4807:  * @node:  the pattern node.
                   4808:  *
                   4809:  * parse the content of a RelaxNG pattern node.
                   4810:  *
                   4811:  * Returns the definition pointer or NULL in case of error or if no
                   4812:  *     pattern is generated.
                   4813:  */
                   4814: static xmlRelaxNGDefinePtr
                   4815: xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
                   4816: {
                   4817:     xmlRelaxNGDefinePtr def = NULL;
                   4818: 
                   4819:     if (node == NULL) {
                   4820:         return (NULL);
                   4821:     }
                   4822:     if (IS_RELAXNG(node, "element")) {
                   4823:         def = xmlRelaxNGParseElement(ctxt, node);
                   4824:     } else if (IS_RELAXNG(node, "attribute")) {
                   4825:         def = xmlRelaxNGParseAttribute(ctxt, node);
                   4826:     } else if (IS_RELAXNG(node, "empty")) {
                   4827:         def = xmlRelaxNGNewDefine(ctxt, node);
                   4828:         if (def == NULL)
                   4829:             return (NULL);
                   4830:         def->type = XML_RELAXNG_EMPTY;
                   4831:         if (node->children != NULL) {
                   4832:             xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_NOT_EMPTY,
                   4833:                        "empty: had a child node\n", NULL, NULL);
                   4834:         }
                   4835:     } else if (IS_RELAXNG(node, "text")) {
                   4836:         def = xmlRelaxNGNewDefine(ctxt, node);
                   4837:         if (def == NULL)
                   4838:             return (NULL);
                   4839:         def->type = XML_RELAXNG_TEXT;
                   4840:         if (node->children != NULL) {
                   4841:             xmlRngPErr(ctxt, node, XML_RNGP_TEXT_HAS_CHILD,
                   4842:                        "text: had a child node\n", NULL, NULL);
                   4843:         }
                   4844:     } else if (IS_RELAXNG(node, "zeroOrMore")) {
                   4845:         def = xmlRelaxNGNewDefine(ctxt, node);
                   4846:         if (def == NULL)
                   4847:             return (NULL);
                   4848:         def->type = XML_RELAXNG_ZEROORMORE;
                   4849:         if (node->children == NULL) {
                   4850:             xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
                   4851:                        "Element %s is empty\n", node->name, NULL);
                   4852:         } else {
                   4853:             def->content =
                   4854:                 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
                   4855:         }
                   4856:     } else if (IS_RELAXNG(node, "oneOrMore")) {
                   4857:         def = xmlRelaxNGNewDefine(ctxt, node);
                   4858:         if (def == NULL)
                   4859:             return (NULL);
                   4860:         def->type = XML_RELAXNG_ONEORMORE;
                   4861:         if (node->children == NULL) {
                   4862:             xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
                   4863:                        "Element %s is empty\n", node->name, NULL);
                   4864:         } else {
                   4865:             def->content =
                   4866:                 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
                   4867:         }
                   4868:     } else if (IS_RELAXNG(node, "optional")) {
                   4869:         def = xmlRelaxNGNewDefine(ctxt, node);
                   4870:         if (def == NULL)
                   4871:             return (NULL);
                   4872:         def->type = XML_RELAXNG_OPTIONAL;
                   4873:         if (node->children == NULL) {
                   4874:             xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
                   4875:                        "Element %s is empty\n", node->name, NULL);
                   4876:         } else {
                   4877:             def->content =
                   4878:                 xmlRelaxNGParsePatterns(ctxt, node->children, 1);
                   4879:         }
                   4880:     } else if (IS_RELAXNG(node, "choice")) {
                   4881:         def = xmlRelaxNGNewDefine(ctxt, node);
                   4882:         if (def == NULL)
                   4883:             return (NULL);
                   4884:         def->type = XML_RELAXNG_CHOICE;
                   4885:         if (node->children == NULL) {
                   4886:             xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
                   4887:                        "Element %s is empty\n", node->name, NULL);
                   4888:         } else {
                   4889:             def->content =
                   4890:                 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
                   4891:         }
                   4892:     } else if (IS_RELAXNG(node, "group")) {
                   4893:         def = xmlRelaxNGNewDefine(ctxt, node);
                   4894:         if (def == NULL)
                   4895:             return (NULL);
                   4896:         def->type = XML_RELAXNG_GROUP;
                   4897:         if (node->children == NULL) {
                   4898:             xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
                   4899:                        "Element %s is empty\n", node->name, NULL);
                   4900:         } else {
                   4901:             def->content =
                   4902:                 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
                   4903:         }
                   4904:     } else if (IS_RELAXNG(node, "ref")) {
                   4905:         def = xmlRelaxNGNewDefine(ctxt, node);
                   4906:         if (def == NULL)
                   4907:             return (NULL);
                   4908:         def->type = XML_RELAXNG_REF;
                   4909:         def->name = xmlGetProp(node, BAD_CAST "name");
                   4910:         if (def->name == NULL) {
                   4911:             xmlRngPErr(ctxt, node, XML_RNGP_REF_NO_NAME, "ref has no name\n",
                   4912:                        NULL, NULL);
                   4913:         } else {
                   4914:             xmlRelaxNGNormExtSpace(def->name);
                   4915:             if (xmlValidateNCName(def->name, 0)) {
                   4916:                 xmlRngPErr(ctxt, node, XML_RNGP_REF_NAME_INVALID,
                   4917:                            "ref name '%s' is not an NCName\n", def->name,
                   4918:                            NULL);
                   4919:             }
                   4920:         }
                   4921:         if (node->children != NULL) {
                   4922:             xmlRngPErr(ctxt, node, XML_RNGP_REF_NOT_EMPTY, "ref is not empty\n",
                   4923:                        NULL, NULL);
                   4924:         }
                   4925:         if (ctxt->grammar->refs == NULL)
                   4926:             ctxt->grammar->refs = xmlHashCreate(10);
                   4927:         if (ctxt->grammar->refs == NULL) {
                   4928:             xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
                   4929:                        "Could not create references hash\n", NULL, NULL);
                   4930:             def = NULL;
                   4931:         } else {
                   4932:             int tmp;
                   4933: 
                   4934:             tmp = xmlHashAddEntry(ctxt->grammar->refs, def->name, def);
                   4935:             if (tmp < 0) {
                   4936:                 xmlRelaxNGDefinePtr prev;
                   4937: 
                   4938:                 prev = (xmlRelaxNGDefinePtr)
                   4939:                     xmlHashLookup(ctxt->grammar->refs, def->name);
                   4940:                 if (prev == NULL) {
                   4941:                     if (def->name != NULL) {
                   4942:                        xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
                   4943:                                   "Error refs definitions '%s'\n",
                   4944:                                   def->name, NULL);
                   4945:                     } else {
                   4946:                        xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED,
                   4947:                                   "Error refs definitions\n",
                   4948:                                   NULL, NULL);
                   4949:                     }
                   4950:                     def = NULL;
                   4951:                 } else {
                   4952:                     def->nextHash = prev->nextHash;
                   4953:                     prev->nextHash = def;
                   4954:                 }
                   4955:             }
                   4956:         }
                   4957:     } else if (IS_RELAXNG(node, "data")) {
                   4958:         def = xmlRelaxNGParseData(ctxt, node);
                   4959:     } else if (IS_RELAXNG(node, "value")) {
                   4960:         def = xmlRelaxNGParseValue(ctxt, node);
                   4961:     } else if (IS_RELAXNG(node, "list")) {
                   4962:         def = xmlRelaxNGNewDefine(ctxt, node);
                   4963:         if (def == NULL)
                   4964:             return (NULL);
                   4965:         def->type = XML_RELAXNG_LIST;
                   4966:         if (node->children == NULL) {
                   4967:             xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT,
                   4968:                        "Element %s is empty\n", node->name, NULL);
                   4969:         } else {
                   4970:             def->content =
                   4971:                 xmlRelaxNGParsePatterns(ctxt, node->children, 0);
                   4972:         }
                   4973:     } else if (IS_RELAXNG(node, "interleave")) {
                   4974:         def = xmlRelaxNGParseInterleave(ctxt, node);
                   4975:     } else if (IS_RELAXNG(node, "externalRef")) {
                   4976:         def = xmlRelaxNGProcessExternalRef(ctxt, node);
                   4977:     } else if (IS_RELAXNG(node, "notAllowed")) {
                   4978:         def = xmlRelaxNGNewDefine(ctxt, node);
                   4979:         if (def == NULL)
                   4980:             return (NULL);
                   4981:         def->type = XML_RELAXNG_NOT_ALLOWED;
                   4982:         if (node->children != NULL) {
                   4983:             xmlRngPErr(ctxt, node, XML_RNGP_NOTALLOWED_NOT_EMPTY,
                   4984:                        "xmlRelaxNGParse: notAllowed element is not empty\n",
                   4985:                        NULL, NULL);
                   4986:         }
                   4987:     } else if (IS_RELAXNG(node, "grammar")) {
                   4988:         xmlRelaxNGGrammarPtr grammar, old;
                   4989:         xmlRelaxNGGrammarPtr oldparent;
                   4990: 
                   4991: #ifdef DEBUG_GRAMMAR
                   4992:         xmlGenericError(xmlGenericErrorContext,
                   4993:                         "Found <grammar> pattern\n");
                   4994: #endif
                   4995: 
                   4996:         oldparent = ctxt->parentgrammar;
                   4997:         old = ctxt->grammar;
                   4998:         ctxt->parentgrammar = old;
                   4999:         grammar = xmlRelaxNGParseGrammar(ctxt, node->children);
                   5000:         if (old != NULL) {
                   5001:             ctxt->grammar = old;
                   5002:             ctxt->parentgrammar = oldparent;
                   5003: #if 0
                   5004:             if (grammar != NULL) {
                   5005:                 grammar->next = old->next;
                   5006:                 old->next = grammar;
                   5007:             }
                   5008: #endif
                   5009:         }
                   5010:         if (grammar != NULL)
                   5011:             def = grammar->start;
                   5012:         else
                   5013:             def = NULL;
                   5014:     } else if (IS_RELAXNG(node, "parentRef")) {
                   5015:         if (ctxt->parentgrammar == NULL) {
                   5016:             xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_PARENT,
                   5017:                        "Use of parentRef without a parent grammar\n", NULL,
                   5018:                        NULL);
                   5019:             return (NULL);
                   5020:         }
                   5021:         def = xmlRelaxNGNewDefine(ctxt, node);
                   5022:         if (def == NULL)
                   5023:             return (NULL);
                   5024:         def->type = XML_RELAXNG_PARENTREF;
                   5025:         def->name = xmlGetProp(node, BAD_CAST "name");
                   5026:         if (def->name == NULL) {
                   5027:             xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_NAME,
                   5028:                        "parentRef has no name\n", NULL, NULL);
                   5029:         } else {
                   5030:             xmlRelaxNGNormExtSpace(def->name);
                   5031:             if (xmlValidateNCName(def->name, 0)) {
                   5032:                 xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NAME_INVALID,
                   5033:                            "parentRef name '%s' is not an NCName\n",
                   5034:                            def->name, NULL);
                   5035:             }
                   5036:         }
                   5037:         if (node->children != NULL) {
                   5038:             xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NOT_EMPTY,
                   5039:                        "parentRef is not empty\n", NULL, NULL);
                   5040:         }
                   5041:         if (ctxt->parentgrammar->refs == NULL)
                   5042:             ctxt->parentgrammar->refs = xmlHashCreate(10);
                   5043:         if (ctxt->parentgrammar->refs == NULL) {
                   5044:             xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED,
                   5045:                        "Could not create references hash\n", NULL, NULL);
                   5046:             def = NULL;
                   5047:         } else if (def->name != NULL) {
                   5048:             int tmp;
                   5049: 
                   5050:             tmp =
                   5051:                 xmlHashAddEntry(ctxt->parentgrammar->refs, def->name, def);
                   5052:             if (tmp < 0) {
                   5053:                 xmlRelaxNGDefinePtr prev;
                   5054: 
                   5055:                 prev = (xmlRelaxNGDefinePtr)
                   5056:                     xmlHashLookup(ctxt->parentgrammar->refs, def->name);
                   5057:                 if (prev == NULL) {
                   5058:                     xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED,
                   5059:                                "Internal error parentRef definitions '%s'\n",
                   5060:                                def->name, NULL);
                   5061:                     def = NULL;
                   5062:                 } else {
                   5063:                     def->nextHash = prev->nextHash;
                   5064:                     prev->nextHash = def;
                   5065:                 }
                   5066:             }
                   5067:         }
                   5068:     } else if (IS_RELAXNG(node, "mixed")) {
                   5069:         if (node->children == NULL) {
                   5070:             xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT, "Mixed is empty\n",
                   5071:                        NULL, NULL);
                   5072:             def = NULL;
                   5073:         } else {
                   5074:             def = xmlRelaxNGParseInterleave(ctxt, node);
                   5075:             if (def != NULL) {
                   5076:                 xmlRelaxNGDefinePtr tmp;
                   5077: 
                   5078:                 if ((def->content != NULL) && (def->content->next != NULL)) {
                   5079:                     tmp = xmlRelaxNGNewDefine(ctxt, node);
                   5080:                     if (tmp != NULL) {
                   5081:                         tmp->type = XML_RELAXNG_GROUP;
                   5082:                         tmp->content = def->content;
                   5083:                         def->content = tmp;
                   5084:                     }
                   5085:                 }
                   5086: 
                   5087:                 tmp = xmlRelaxNGNewDefine(ctxt, node);
                   5088:                 if (tmp == NULL)
                   5089:                     return (def);
                   5090:                 tmp->type = XML_RELAXNG_TEXT;
                   5091:                 tmp->next = def->content;
                   5092:                 def->content = tmp;
                   5093:             }
                   5094:         }
                   5095:     } else {
                   5096:         xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_CONSTRUCT,
                   5097:                    "Unexpected node %s is not a pattern\n", node->name,
                   5098:                    NULL);
                   5099:         def = NULL;
                   5100:     }
                   5101:     return (def);
                   5102: }
                   5103: 
                   5104: /**
                   5105:  * xmlRelaxNGParseAttribute:
                   5106:  * @ctxt:  a Relax-NG parser context
                   5107:  * @node:  the element node
                   5108:  *
                   5109:  * parse the content of a RelaxNG attribute node.
                   5110:  *
                   5111:  * Returns the definition pointer or NULL in case of error.
                   5112:  */
                   5113: static xmlRelaxNGDefinePtr
                   5114: xmlRelaxNGParseAttribute(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
                   5115: {
                   5116:     xmlRelaxNGDefinePtr ret, cur;
                   5117:     xmlNodePtr child;
                   5118:     int old_flags;
                   5119: 
                   5120:     ret = xmlRelaxNGNewDefine(ctxt, node);
                   5121:     if (ret == NULL)
                   5122:         return (NULL);
                   5123:     ret->type = XML_RELAXNG_ATTRIBUTE;
                   5124:     ret->parent = ctxt->def;
                   5125:     child = node->children;
                   5126:     if (child == NULL) {
                   5127:         xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_EMPTY,
                   5128:                    "xmlRelaxNGParseattribute: attribute has no children\n",
                   5129:                    NULL, NULL);
                   5130:         return (ret);
                   5131:     }
                   5132:     old_flags = ctxt->flags;
                   5133:     ctxt->flags |= XML_RELAXNG_IN_ATTRIBUTE;
                   5134:     cur = xmlRelaxNGParseNameClass(ctxt, child, ret);
                   5135:     if (cur != NULL)
                   5136:         child = child->next;
                   5137: 
                   5138:     if (child != NULL) {
                   5139:         cur = xmlRelaxNGParsePattern(ctxt, child);
                   5140:         if (cur != NULL) {
                   5141:             switch (cur->type) {
                   5142:                 case XML_RELAXNG_EMPTY:
                   5143:                 case XML_RELAXNG_NOT_ALLOWED:
                   5144:                 case XML_RELAXNG_TEXT:
                   5145:                 case XML_RELAXNG_ELEMENT:
                   5146:                 case XML_RELAXNG_DATATYPE:
                   5147:                 case XML_RELAXNG_VALUE:
                   5148:                 case XML_RELAXNG_LIST:
                   5149:                 case XML_RELAXNG_REF:
                   5150:                 case XML_RELAXNG_PARENTREF:
                   5151:                 case XML_RELAXNG_EXTERNALREF:
                   5152:                 case XML_RELAXNG_DEF:
                   5153:                 case XML_RELAXNG_ONEORMORE:
                   5154:                 case XML_RELAXNG_ZEROORMORE:
                   5155:                 case XML_RELAXNG_OPTIONAL:
                   5156:                 case XML_RELAXNG_CHOICE:
                   5157:                 case XML_RELAXNG_GROUP:
                   5158:                 case XML_RELAXNG_INTERLEAVE:
                   5159:                 case XML_RELAXNG_ATTRIBUTE:
                   5160:                     ret->content = cur;
                   5161:                     cur->parent = ret;
                   5162:                     break;
                   5163:                 case XML_RELAXNG_START:
                   5164:                 case XML_RELAXNG_PARAM:
                   5165:                 case XML_RELAXNG_EXCEPT:
                   5166:                     xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CONTENT,
                   5167:                                "attribute has invalid content\n", NULL,
                   5168:                                NULL);
                   5169:                     break;
                   5170:                 case XML_RELAXNG_NOOP:
                   5171:                     xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_NOOP,
                   5172:                                "RNG Internal error, noop found in attribute\n",
                   5173:                                NULL, NULL);
                   5174:                     break;
                   5175:             }
                   5176:         }
                   5177:         child = child->next;
                   5178:     }
                   5179:     if (child != NULL) {
                   5180:         xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CHILDREN,
                   5181:                    "attribute has multiple children\n", NULL, NULL);
                   5182:     }
                   5183:     ctxt->flags = old_flags;
                   5184:     return (ret);
                   5185: }
                   5186: 
                   5187: /**
                   5188:  * xmlRelaxNGParseExceptNameClass:
                   5189:  * @ctxt:  a Relax-NG parser context
                   5190:  * @node:  the except node
                   5191:  * @attr:  1 if within an attribute, 0 if within an element
                   5192:  *
                   5193:  * parse the content of a RelaxNG nameClass node.
                   5194:  *
                   5195:  * Returns the definition pointer or NULL in case of error.
                   5196:  */
                   5197: static xmlRelaxNGDefinePtr
                   5198: xmlRelaxNGParseExceptNameClass(xmlRelaxNGParserCtxtPtr ctxt,
                   5199:                                xmlNodePtr node, int attr)
                   5200: {
                   5201:     xmlRelaxNGDefinePtr ret, cur, last = NULL;
                   5202:     xmlNodePtr child;
                   5203: 
                   5204:     if (!IS_RELAXNG(node, "except")) {
                   5205:         xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MISSING,
                   5206:                    "Expecting an except node\n", NULL, NULL);
                   5207:         return (NULL);
                   5208:     }
                   5209:     if (node->next != NULL) {
                   5210:         xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MULTIPLE,
                   5211:                    "exceptNameClass allows only a single except node\n",
                   5212:                    NULL, NULL);
                   5213:     }
                   5214:     if (node->children == NULL) {
                   5215:         xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_EMPTY, "except has no content\n",
                   5216:                    NULL, NULL);
                   5217:         return (NULL);
                   5218:     }
                   5219: 
                   5220:     ret = xmlRelaxNGNewDefine(ctxt, node);
                   5221:     if (ret == NULL)
                   5222:         return (NULL);
                   5223:     ret->type = XML_RELAXNG_EXCEPT;
                   5224:     child = node->children;
                   5225:     while (child != NULL) {
                   5226:         cur = xmlRelaxNGNewDefine(ctxt, child);
                   5227:         if (cur == NULL)
                   5228:             break;
                   5229:         if (attr)
                   5230:             cur->type = XML_RELAXNG_ATTRIBUTE;
                   5231:         else
                   5232:             cur->type = XML_RELAXNG_ELEMENT;
                   5233: 
                   5234:         if (xmlRelaxNGParseNameClass(ctxt, child, cur) != NULL) {
                   5235:             if (last == NULL) {
                   5236:                 ret->content = cur;
                   5237:             } else {
                   5238:                 last->next = cur;
                   5239:             }
                   5240:             last = cur;
                   5241:         }
                   5242:         child = child->next;
                   5243:     }
                   5244: 
                   5245:     return (ret);
                   5246: }
                   5247: 
                   5248: /**
                   5249:  * xmlRelaxNGParseNameClass:
                   5250:  * @ctxt:  a Relax-NG parser context
                   5251:  * @node:  the nameClass node
                   5252:  * @def:  the current definition
                   5253:  *
                   5254:  * parse the content of a RelaxNG nameClass node.
                   5255:  *
                   5256:  * Returns the definition pointer or NULL in case of error.
                   5257:  */
                   5258: static xmlRelaxNGDefinePtr
                   5259: xmlRelaxNGParseNameClass(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node,
                   5260:                          xmlRelaxNGDefinePtr def)
                   5261: {
                   5262:     xmlRelaxNGDefinePtr ret, tmp;
                   5263:     xmlChar *val;
                   5264: 
                   5265:     ret = def;
                   5266:     if ((IS_RELAXNG(node, "name")) || (IS_RELAXNG(node, "anyName")) ||
                   5267:         (IS_RELAXNG(node, "nsName"))) {
                   5268:         if ((def->type != XML_RELAXNG_ELEMENT) &&
                   5269:             (def->type != XML_RELAXNG_ATTRIBUTE)) {
                   5270:             ret = xmlRelaxNGNewDefine(ctxt, node);
                   5271:             if (ret == NULL)
                   5272:                 return (NULL);
                   5273:             ret->parent = def;
                   5274:             if (ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE)
                   5275:                 ret->type = XML_RELAXNG_ATTRIBUTE;
                   5276:             else
                   5277:                 ret->type = XML_RELAXNG_ELEMENT;
                   5278:         }
                   5279:     }
                   5280:     if (IS_RELAXNG(node, "name")) {
                   5281:         val = xmlNodeGetContent(node);
                   5282:         xmlRelaxNGNormExtSpace(val);
                   5283:         if (xmlValidateNCName(val, 0)) {
                   5284:            if (node->parent != NULL)
                   5285:                xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME,
                   5286:                           "Element %s name '%s' is not an NCName\n",
                   5287:                           node->parent->name, val);
                   5288:            else
                   5289:                xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME,
                   5290:                           "name '%s' is not an NCName\n",
                   5291:                           val, NULL);
                   5292:         }
                   5293:         ret->name = val;
                   5294:         val = xmlGetProp(node, BAD_CAST "ns");
                   5295:         ret->ns = val;
                   5296:         if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
                   5297:             (val != NULL) &&
                   5298:             (xmlStrEqual(val, BAD_CAST "http://www.w3.org/2000/xmlns"))) {
                   5299:            xmlRngPErr(ctxt, node, XML_RNGP_XML_NS,
                   5300:                         "Attribute with namespace '%s' is not allowed\n",
                   5301:                         val, NULL);
                   5302:         }
                   5303:         if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
                   5304:             (val != NULL) &&
                   5305:             (val[0] == 0) && (xmlStrEqual(ret->name, BAD_CAST "xmlns"))) {
                   5306:            xmlRngPErr(ctxt, node, XML_RNGP_XMLNS_NAME,
                   5307:                        "Attribute with QName 'xmlns' is not allowed\n",
                   5308:                        val, NULL);
                   5309:         }
                   5310:     } else if (IS_RELAXNG(node, "anyName")) {
                   5311:         ret->name = NULL;
                   5312:         ret->ns = NULL;
                   5313:         if (node->children != NULL) {
                   5314:             ret->nameClass =
                   5315:                 xmlRelaxNGParseExceptNameClass(ctxt, node->children,
                   5316:                                                (def->type ==
                   5317:                                                 XML_RELAXNG_ATTRIBUTE));
                   5318:         }
                   5319:     } else if (IS_RELAXNG(node, "nsName")) {
                   5320:         ret->name = NULL;
                   5321:         ret->ns = xmlGetProp(node, BAD_CAST "ns");
                   5322:         if (ret->ns == NULL) {
                   5323:             xmlRngPErr(ctxt, node, XML_RNGP_NSNAME_NO_NS,
                   5324:                        "nsName has no ns attribute\n", NULL, NULL);
                   5325:         }
                   5326:         if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
                   5327:             (ret->ns != NULL) &&
                   5328:             (xmlStrEqual
                   5329:              (ret->ns, BAD_CAST "http://www.w3.org/2000/xmlns"))) {
                   5330:             xmlRngPErr(ctxt, node, XML_RNGP_XML_NS,
                   5331:                        "Attribute with namespace '%s' is not allowed\n",
                   5332:                        ret->ns, NULL);
                   5333:         }
                   5334:         if (node->children != NULL) {
                   5335:             ret->nameClass =
                   5336:                 xmlRelaxNGParseExceptNameClass(ctxt, node->children,
                   5337:                                                (def->type ==
                   5338:                                                 XML_RELAXNG_ATTRIBUTE));
                   5339:         }
                   5340:     } else if (IS_RELAXNG(node, "choice")) {
                   5341:         xmlNodePtr child;
                   5342:         xmlRelaxNGDefinePtr last = NULL;
                   5343: 
                   5344:         ret = xmlRelaxNGNewDefine(ctxt, node);
                   5345:         if (ret == NULL)
                   5346:             return (NULL);
                   5347:         ret->parent = def;
                   5348:         ret->type = XML_RELAXNG_CHOICE;
                   5349: 
                   5350:         if (node->children == NULL) {
                   5351:             xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_EMPTY,
                   5352:                        "Element choice is empty\n", NULL, NULL);
                   5353:         } else {
                   5354: 
                   5355:             child = node->children;
                   5356:             while (child != NULL) {
                   5357:                 tmp = xmlRelaxNGParseNameClass(ctxt, child, ret);
                   5358:                 if (tmp != NULL) {
                   5359:                     if (last == NULL) {
                   5360:                         last = ret->nameClass = tmp;
                   5361:                     } else {
                   5362:                         last->next = tmp;
                   5363:                         last = tmp;
                   5364:                     }
                   5365:                 }
                   5366:                 child = child->next;
                   5367:             }
                   5368:         }
                   5369:     } else {
                   5370:         xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_CONTENT,
                   5371:                    "expecting name, anyName, nsName or choice : got %s\n",
                   5372:                    (node == NULL ? (const xmlChar *) "nothing" : node->name),
                   5373:                   NULL);
                   5374:         return (NULL);
                   5375:     }
                   5376:     if (ret != def) {
                   5377:         if (def->nameClass == NULL) {
                   5378:             def->nameClass = ret;
                   5379:         } else {
                   5380:             tmp = def->nameClass;
                   5381:             while (tmp->next != NULL) {
                   5382:                 tmp = tmp->next;
                   5383:             }
                   5384:             tmp->next = ret;
                   5385:         }
                   5386:     }
                   5387:     return (ret);
                   5388: }
                   5389: 
                   5390: /**
                   5391:  * xmlRelaxNGParseElement:
                   5392:  * @ctxt:  a Relax-NG parser context
                   5393:  * @node:  the element node
                   5394:  *
                   5395:  * parse the content of a RelaxNG element node.
                   5396:  *
                   5397:  * Returns the definition pointer or NULL in case of error.
                   5398:  */
                   5399: static xmlRelaxNGDefinePtr
                   5400: xmlRelaxNGParseElement(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
                   5401: {
                   5402:     xmlRelaxNGDefinePtr ret, cur, last;
                   5403:     xmlNodePtr child;
                   5404:     const xmlChar *olddefine;
                   5405: 
                   5406:     ret = xmlRelaxNGNewDefine(ctxt, node);
                   5407:     if (ret == NULL)
                   5408:         return (NULL);
                   5409:     ret->type = XML_RELAXNG_ELEMENT;
                   5410:     ret->parent = ctxt->def;
                   5411:     child = node->children;
                   5412:     if (child == NULL) {
                   5413:         xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_EMPTY,
                   5414:                    "xmlRelaxNGParseElement: element has no children\n",
                   5415:                    NULL, NULL);
                   5416:         return (ret);
                   5417:     }
                   5418:     cur = xmlRelaxNGParseNameClass(ctxt, child, ret);
                   5419:     if (cur != NULL)
                   5420:         child = child->next;
                   5421: 
                   5422:     if (child == NULL) {
                   5423:         xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NO_CONTENT,
                   5424:                    "xmlRelaxNGParseElement: element has no content\n",
                   5425:                    NULL, NULL);
                   5426:         return (ret);
                   5427:     }
                   5428:     olddefine = ctxt->define;
                   5429:     ctxt->define = NULL;
                   5430:     last = NULL;
                   5431:     while (child != NULL) {
                   5432:         cur = xmlRelaxNGParsePattern(ctxt, child);
                   5433:         if (cur != NULL) {
                   5434:             cur->parent = ret;
                   5435:             switch (cur->type) {
                   5436:                 case XML_RELAXNG_EMPTY:
                   5437:                 case XML_RELAXNG_NOT_ALLOWED:
                   5438:                 case XML_RELAXNG_TEXT:
                   5439:                 case XML_RELAXNG_ELEMENT:
                   5440:                 case XML_RELAXNG_DATATYPE:
                   5441:                 case XML_RELAXNG_VALUE:
                   5442:                 case XML_RELAXNG_LIST:
                   5443:                 case XML_RELAXNG_REF:
                   5444:                 case XML_RELAXNG_PARENTREF:
                   5445:                 case XML_RELAXNG_EXTERNALREF:
                   5446:                 case XML_RELAXNG_DEF:
                   5447:                 case XML_RELAXNG_ZEROORMORE:
                   5448:                 case XML_RELAXNG_ONEORMORE:
                   5449:                 case XML_RELAXNG_OPTIONAL:
                   5450:                 case XML_RELAXNG_CHOICE:
                   5451:                 case XML_RELAXNG_GROUP:
                   5452:                 case XML_RELAXNG_INTERLEAVE:
                   5453:                     if (last == NULL) {
                   5454:                         ret->content = last = cur;
                   5455:                     } else {
                   5456:                         if ((last->type == XML_RELAXNG_ELEMENT) &&
                   5457:                             (ret->content == last)) {
                   5458:                             ret->content = xmlRelaxNGNewDefine(ctxt, node);
                   5459:                             if (ret->content != NULL) {
                   5460:                                 ret->content->type = XML_RELAXNG_GROUP;
                   5461:                                 ret->content->content = last;
                   5462:                             } else {
                   5463:                                 ret->content = last;
                   5464:                             }
                   5465:                         }
                   5466:                         last->next = cur;
                   5467:                         last = cur;
                   5468:                     }
                   5469:                     break;
                   5470:                 case XML_RELAXNG_ATTRIBUTE:
                   5471:                     cur->next = ret->attrs;
                   5472:                     ret->attrs = cur;
                   5473:                     break;
                   5474:                 case XML_RELAXNG_START:
                   5475:                     xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
                   5476:                                "RNG Internal error, start found in element\n",
                   5477:                                NULL, NULL);
                   5478:                     break;
                   5479:                 case XML_RELAXNG_PARAM:
                   5480:                     xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
                   5481:                                "RNG Internal error, param found in element\n",
                   5482:                                NULL, NULL);
                   5483:                     break;
                   5484:                 case XML_RELAXNG_EXCEPT:
                   5485:                     xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
                   5486:                                "RNG Internal error, except found in element\n",
                   5487:                                NULL, NULL);
                   5488:                     break;
                   5489:                 case XML_RELAXNG_NOOP:
                   5490:                     xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT,
                   5491:                                "RNG Internal error, noop found in element\n",
                   5492:                                NULL, NULL);
                   5493:                     break;
                   5494:             }
                   5495:         }
                   5496:         child = child->next;
                   5497:     }
                   5498:     ctxt->define = olddefine;
                   5499:     return (ret);
                   5500: }
                   5501: 
                   5502: /**
                   5503:  * xmlRelaxNGParsePatterns:
                   5504:  * @ctxt:  a Relax-NG parser context
                   5505:  * @nodes:  list of nodes
                   5506:  * @group:  use an implicit <group> for elements
                   5507:  *
                   5508:  * parse the content of a RelaxNG start node.
                   5509:  *
                   5510:  * Returns the definition pointer or NULL in case of error.
                   5511:  */
                   5512: static xmlRelaxNGDefinePtr
                   5513: xmlRelaxNGParsePatterns(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes,
                   5514:                         int group)
                   5515: {
                   5516:     xmlRelaxNGDefinePtr def = NULL, last = NULL, cur, parent;
                   5517: 
                   5518:     parent = ctxt->def;
                   5519:     while (nodes != NULL) {
                   5520:         if (IS_RELAXNG(nodes, "element")) {
                   5521:             cur = xmlRelaxNGParseElement(ctxt, nodes);
                   5522:             if (def == NULL) {
                   5523:                 def = last = cur;
                   5524:             } else {
                   5525:                 if ((group == 1) && (def->type == XML_RELAXNG_ELEMENT) &&
                   5526:                     (def == last)) {
                   5527:                     def = xmlRelaxNGNewDefine(ctxt, nodes);
                   5528:                     def->type = XML_RELAXNG_GROUP;
                   5529:                     def->content = last;
                   5530:                 }
                   5531:                 last->next = cur;
                   5532:                 last = cur;
                   5533:             }
                   5534:             cur->parent = parent;
                   5535:         } else {
                   5536:             cur = xmlRelaxNGParsePattern(ctxt, nodes);
                   5537:             if (cur != NULL) {
                   5538:                 if (def == NULL) {
                   5539:                     def = last = cur;
                   5540:                 } else {
                   5541:                     last->next = cur;
                   5542:                     last = cur;
                   5543:                 }
                   5544:             }
                   5545:         }
                   5546:         nodes = nodes->next;
                   5547:     }
                   5548:     return (def);
                   5549: }
                   5550: 
                   5551: /**
                   5552:  * xmlRelaxNGParseStart:
                   5553:  * @ctxt:  a Relax-NG parser context
                   5554:  * @nodes:  start children nodes
                   5555:  *
                   5556:  * parse the content of a RelaxNG start node.
                   5557:  *
                   5558:  * Returns 0 in case of success, -1 in case of error
                   5559:  */
                   5560: static int
                   5561: xmlRelaxNGParseStart(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes)
                   5562: {
                   5563:     int ret = 0;
                   5564:     xmlRelaxNGDefinePtr def = NULL, last;
                   5565: 
                   5566:     if (nodes == NULL) {
                   5567:         xmlRngPErr(ctxt, nodes, XML_RNGP_START_EMPTY, "start has no children\n",
                   5568:                    NULL, NULL);
                   5569:         return (-1);
                   5570:     }
                   5571:     if (IS_RELAXNG(nodes, "empty")) {
                   5572:         def = xmlRelaxNGNewDefine(ctxt, nodes);
                   5573:         if (def == NULL)
                   5574:             return (-1);
                   5575:         def->type = XML_RELAXNG_EMPTY;
                   5576:         if (nodes->children != NULL) {
                   5577:             xmlRngPErr(ctxt, nodes, XML_RNGP_EMPTY_CONTENT,
                   5578:                        "element empty is not empty\n", NULL, NULL);
                   5579:         }
                   5580:     } else if (IS_RELAXNG(nodes, "notAllowed")) {
                   5581:         def = xmlRelaxNGNewDefine(ctxt, nodes);
                   5582:         if (def == NULL)
                   5583:             return (-1);
                   5584:         def->type = XML_RELAXNG_NOT_ALLOWED;
                   5585:         if (nodes->children != NULL) {
                   5586:             xmlRngPErr(ctxt, nodes, XML_RNGP_NOTALLOWED_NOT_EMPTY,
                   5587:                        "element notAllowed is not empty\n", NULL, NULL);
                   5588:         }
                   5589:     } else {
                   5590:         def = xmlRelaxNGParsePatterns(ctxt, nodes, 1);
                   5591:     }
                   5592:     if (ctxt->grammar->start != NULL) {
                   5593:         last = ctxt->grammar->start;
                   5594:         while (last->next != NULL)
                   5595:             last = last->next;
                   5596:         last->next = def;
                   5597:     } else {
                   5598:         ctxt->grammar->start = def;
                   5599:     }
                   5600:     nodes = nodes->next;
                   5601:     if (nodes != NULL) {
                   5602:         xmlRngPErr(ctxt, nodes, XML_RNGP_START_CONTENT,
                   5603:                    "start more than one children\n", NULL, NULL);
                   5604:         return (-1);
                   5605:     }
                   5606:     return (ret);
                   5607: }
                   5608: 
                   5609: /**
                   5610:  * xmlRelaxNGParseGrammarContent:
                   5611:  * @ctxt:  a Relax-NG parser context
                   5612:  * @nodes:  grammar children nodes
                   5613:  *
                   5614:  * parse the content of a RelaxNG grammar node.
                   5615:  *
                   5616:  * Returns 0 in case of success, -1 in case of error
                   5617:  */
                   5618: static int
                   5619: xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt,
                   5620:                               xmlNodePtr nodes)
                   5621: {
                   5622:     int ret = 0, tmp;
                   5623: 
                   5624:     if (nodes == NULL) {
                   5625:         xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_EMPTY,
                   5626:                    "grammar has no children\n", NULL, NULL);
                   5627:         return (-1);
                   5628:     }
                   5629:     while (nodes != NULL) {
                   5630:         if (IS_RELAXNG(nodes, "start")) {
                   5631:             if (nodes->children == NULL) {
                   5632:                 xmlRngPErr(ctxt, nodes, XML_RNGP_START_EMPTY,
                   5633:                            "start has no children\n", NULL, NULL);
                   5634:             } else {
                   5635:                 tmp = xmlRelaxNGParseStart(ctxt, nodes->children);
                   5636:                 if (tmp != 0)
                   5637:                     ret = -1;
                   5638:             }
                   5639:         } else if (IS_RELAXNG(nodes, "define")) {
                   5640:             tmp = xmlRelaxNGParseDefine(ctxt, nodes);
                   5641:             if (tmp != 0)
                   5642:                 ret = -1;
                   5643:         } else if (IS_RELAXNG(nodes, "include")) {
                   5644:             tmp = xmlRelaxNGParseInclude(ctxt, nodes);
                   5645:             if (tmp != 0)
                   5646:                 ret = -1;
                   5647:         } else {
                   5648:             xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_CONTENT,
                   5649:                        "grammar has unexpected child %s\n", nodes->name,
                   5650:                        NULL);
                   5651:             ret = -1;
                   5652:         }
                   5653:         nodes = nodes->next;
                   5654:     }
                   5655:     return (ret);
                   5656: }
                   5657: 
                   5658: /**
                   5659:  * xmlRelaxNGCheckReference:
                   5660:  * @ref:  the ref
                   5661:  * @ctxt:  a Relax-NG parser context
                   5662:  * @name:  the name associated to the defines
                   5663:  *
                   5664:  * Applies the 4.17. combine attribute rule for all the define
                   5665:  * element of a given grammar using the same name.
                   5666:  */
                   5667: static void
                   5668: xmlRelaxNGCheckReference(xmlRelaxNGDefinePtr ref,
                   5669:                          xmlRelaxNGParserCtxtPtr ctxt,
                   5670:                          const xmlChar * name)
                   5671: {
                   5672:     xmlRelaxNGGrammarPtr grammar;
                   5673:     xmlRelaxNGDefinePtr def, cur;
                   5674: 
                   5675:     /*
                   5676:      * Those rules don't apply to imported ref from xmlRelaxNGParseImportRef
                   5677:      */
                   5678:     if (ref->dflags & IS_EXTERNAL_REF)
                   5679:         return;
                   5680: 
                   5681:     grammar = ctxt->grammar;
                   5682:     if (grammar == NULL) {
                   5683:         xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
                   5684:                    "Internal error: no grammar in CheckReference %s\n",
                   5685:                    name, NULL);
                   5686:         return;
                   5687:     }
                   5688:     if (ref->content != NULL) {
                   5689:         xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
                   5690:                    "Internal error: reference has content in CheckReference %s\n",
                   5691:                    name, NULL);
                   5692:         return;
                   5693:     }
                   5694:     if (grammar->defs != NULL) {
                   5695:         def = xmlHashLookup(grammar->defs, name);
                   5696:         if (def != NULL) {
                   5697:             cur = ref;
                   5698:             while (cur != NULL) {
                   5699:                 cur->content = def;
                   5700:                 cur = cur->nextHash;
                   5701:             }
                   5702:         } else {
                   5703:             xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
                   5704:                        "Reference %s has no matching definition\n", name,
                   5705:                        NULL);
                   5706:         }
                   5707:     } else {
                   5708:         xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
                   5709:                    "Reference %s has no matching definition\n", name,
                   5710:                    NULL);
                   5711:     }
                   5712: }
                   5713: 
                   5714: /**
                   5715:  * xmlRelaxNGCheckCombine:
                   5716:  * @define:  the define(s) list
                   5717:  * @ctxt:  a Relax-NG parser context
                   5718:  * @name:  the name associated to the defines
                   5719:  *
                   5720:  * Applies the 4.17. combine attribute rule for all the define
                   5721:  * element of a given grammar using the same name.
                   5722:  */
                   5723: static void
                   5724: xmlRelaxNGCheckCombine(xmlRelaxNGDefinePtr define,
                   5725:                        xmlRelaxNGParserCtxtPtr ctxt, const xmlChar * name)
                   5726: {
                   5727:     xmlChar *combine;
                   5728:     int choiceOrInterleave = -1;
                   5729:     int missing = 0;
                   5730:     xmlRelaxNGDefinePtr cur, last, tmp, tmp2;
                   5731: 
                   5732:     if (define->nextHash == NULL)
                   5733:         return;
                   5734:     cur = define;
                   5735:     while (cur != NULL) {
                   5736:         combine = xmlGetProp(cur->node, BAD_CAST "combine");
                   5737:         if (combine != NULL) {
                   5738:             if (xmlStrEqual(combine, BAD_CAST "choice")) {
                   5739:                 if (choiceOrInterleave == -1)
                   5740:                     choiceOrInterleave = 1;
                   5741:                 else if (choiceOrInterleave == 0) {
                   5742:                     xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
                   5743:                                "Defines for %s use both 'choice' and 'interleave'\n",
                   5744:                                name, NULL);
                   5745:                 }
                   5746:             } else if (xmlStrEqual(combine, BAD_CAST "interleave")) {
                   5747:                 if (choiceOrInterleave == -1)
                   5748:                     choiceOrInterleave = 0;
                   5749:                 else if (choiceOrInterleave == 1) {
                   5750:                     xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
                   5751:                                "Defines for %s use both 'choice' and 'interleave'\n",
                   5752:                                name, NULL);
                   5753:                 }
                   5754:             } else {
                   5755:                 xmlRngPErr(ctxt, define->node, XML_RNGP_UNKNOWN_COMBINE,
                   5756:                            "Defines for %s use unknown combine value '%s''\n",
                   5757:                            name, combine);
                   5758:             }
                   5759:             xmlFree(combine);
                   5760:         } else {
                   5761:             if (missing == 0)
                   5762:                 missing = 1;
                   5763:             else {
                   5764:                 xmlRngPErr(ctxt, define->node, XML_RNGP_NEED_COMBINE,
                   5765:                            "Some defines for %s needs the combine attribute\n",
                   5766:                            name, NULL);
                   5767:             }
                   5768:         }
                   5769: 
                   5770:         cur = cur->nextHash;
                   5771:     }
                   5772: #ifdef DEBUG
                   5773:     xmlGenericError(xmlGenericErrorContext,
                   5774:                     "xmlRelaxNGCheckCombine(): merging %s defines: %d\n",
                   5775:                     name, choiceOrInterleave);
                   5776: #endif
                   5777:     if (choiceOrInterleave == -1)
                   5778:         choiceOrInterleave = 0;
                   5779:     cur = xmlRelaxNGNewDefine(ctxt, define->node);
                   5780:     if (cur == NULL)
                   5781:         return;
                   5782:     if (choiceOrInterleave == 0)
                   5783:         cur->type = XML_RELAXNG_INTERLEAVE;
                   5784:     else
                   5785:         cur->type = XML_RELAXNG_CHOICE;
                   5786:     tmp = define;
                   5787:     last = NULL;
                   5788:     while (tmp != NULL) {
                   5789:         if (tmp->content != NULL) {
                   5790:             if (tmp->content->next != NULL) {
                   5791:                 /*
                   5792:                  * we need first to create a wrapper.
                   5793:                  */
                   5794:                 tmp2 = xmlRelaxNGNewDefine(ctxt, tmp->content->node);
                   5795:                 if (tmp2 == NULL)
                   5796:                     break;
                   5797:                 tmp2->type = XML_RELAXNG_GROUP;
                   5798:                 tmp2->content = tmp->content;
                   5799:             } else {
                   5800:                 tmp2 = tmp->content;
                   5801:             }
                   5802:             if (last == NULL) {
                   5803:                 cur->content = tmp2;
                   5804:             } else {
                   5805:                 last->next = tmp2;
                   5806:             }
                   5807:             last = tmp2;
                   5808:         }
                   5809:         tmp->content = cur;
                   5810:         tmp = tmp->nextHash;
                   5811:     }
                   5812:     define->content = cur;
                   5813:     if (choiceOrInterleave == 0) {
                   5814:         if (ctxt->interleaves == NULL)
                   5815:             ctxt->interleaves = xmlHashCreate(10);
                   5816:         if (ctxt->interleaves == NULL) {
                   5817:             xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
                   5818:                        "Failed to create interleaves hash table\n", NULL,
                   5819:                        NULL);
                   5820:         } else {
                   5821:             char tmpname[32];
                   5822: 
                   5823:             snprintf(tmpname, 32, "interleave%d", ctxt->nbInterleaves++);
                   5824:             if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST tmpname, cur) <
                   5825:                 0) {
                   5826:                 xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
                   5827:                            "Failed to add %s to hash table\n",
                   5828:                           (const xmlChar *) tmpname, NULL);
                   5829:             }
                   5830:         }
                   5831:     }
                   5832: }
                   5833: 
                   5834: /**
                   5835:  * xmlRelaxNGCombineStart:
                   5836:  * @ctxt:  a Relax-NG parser context
                   5837:  * @grammar:  the grammar
                   5838:  *
                   5839:  * Applies the 4.17. combine rule for all the start
                   5840:  * element of a given grammar.
                   5841:  */
                   5842: static void
                   5843: xmlRelaxNGCombineStart(xmlRelaxNGParserCtxtPtr ctxt,
                   5844:                        xmlRelaxNGGrammarPtr grammar)
                   5845: {
                   5846:     xmlRelaxNGDefinePtr starts;
                   5847:     xmlChar *combine;
                   5848:     int choiceOrInterleave = -1;
                   5849:     int missing = 0;
                   5850:     xmlRelaxNGDefinePtr cur;
                   5851: 
                   5852:     starts = grammar->start;
                   5853:     if ((starts == NULL) || (starts->next == NULL))
                   5854:         return;
                   5855:     cur = starts;
                   5856:     while (cur != NULL) {
                   5857:         if ((cur->node == NULL) || (cur->node->parent == NULL) ||
                   5858:             (!xmlStrEqual(cur->node->parent->name, BAD_CAST "start"))) {
                   5859:             combine = NULL;
                   5860:             xmlRngPErr(ctxt, cur->node, XML_RNGP_START_MISSING,
                   5861:                        "Internal error: start element not found\n", NULL,
                   5862:                        NULL);
                   5863:         } else {
                   5864:             combine = xmlGetProp(cur->node->parent, BAD_CAST "combine");
                   5865:         }
                   5866: 
                   5867:         if (combine != NULL) {
                   5868:             if (xmlStrEqual(combine, BAD_CAST "choice")) {
                   5869:                 if (choiceOrInterleave == -1)
                   5870:                     choiceOrInterleave = 1;
                   5871:                 else if (choiceOrInterleave == 0) {
                   5872:                     xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
                   5873:                                "<start> use both 'choice' and 'interleave'\n",
                   5874:                                NULL, NULL);
                   5875:                 }
                   5876:             } else if (xmlStrEqual(combine, BAD_CAST "interleave")) {
                   5877:                 if (choiceOrInterleave == -1)
                   5878:                     choiceOrInterleave = 0;
                   5879:                 else if (choiceOrInterleave == 1) {
                   5880:                     xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
                   5881:                                "<start> use both 'choice' and 'interleave'\n",
                   5882:                                NULL, NULL);
                   5883:                 }
                   5884:             } else {
                   5885:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_UNKNOWN_COMBINE,
                   5886:                            "<start> uses unknown combine value '%s''\n",
                   5887:                            combine, NULL);
                   5888:             }
                   5889:             xmlFree(combine);
                   5890:         } else {
                   5891:             if (missing == 0)
                   5892:                 missing = 1;
                   5893:             else {
                   5894:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_NEED_COMBINE,
                   5895:                            "Some <start> element miss the combine attribute\n",
                   5896:                            NULL, NULL);
                   5897:             }
                   5898:         }
                   5899: 
                   5900:         cur = cur->next;
                   5901:     }
                   5902: #ifdef DEBUG
                   5903:     xmlGenericError(xmlGenericErrorContext,
                   5904:                     "xmlRelaxNGCombineStart(): merging <start>: %d\n",
                   5905:                     choiceOrInterleave);
                   5906: #endif
                   5907:     if (choiceOrInterleave == -1)
                   5908:         choiceOrInterleave = 0;
                   5909:     cur = xmlRelaxNGNewDefine(ctxt, starts->node);
                   5910:     if (cur == NULL)
                   5911:         return;
                   5912:     if (choiceOrInterleave == 0)
                   5913:         cur->type = XML_RELAXNG_INTERLEAVE;
                   5914:     else
                   5915:         cur->type = XML_RELAXNG_CHOICE;
                   5916:     cur->content = grammar->start;
                   5917:     grammar->start = cur;
                   5918:     if (choiceOrInterleave == 0) {
                   5919:         if (ctxt->interleaves == NULL)
                   5920:             ctxt->interleaves = xmlHashCreate(10);
                   5921:         if (ctxt->interleaves == NULL) {
                   5922:             xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
                   5923:                        "Failed to create interleaves hash table\n", NULL,
                   5924:                        NULL);
                   5925:         } else {
                   5926:             char tmpname[32];
                   5927: 
                   5928:             snprintf(tmpname, 32, "interleave%d", ctxt->nbInterleaves++);
                   5929:             if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST tmpname, cur) <
                   5930:                 0) {
                   5931:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED,
                   5932:                            "Failed to add %s to hash table\n",
                   5933:                           (const xmlChar *) tmpname, NULL);
                   5934:             }
                   5935:         }
                   5936:     }
                   5937: }
                   5938: 
                   5939: /**
                   5940:  * xmlRelaxNGCheckCycles:
                   5941:  * @ctxt:  a Relax-NG parser context
                   5942:  * @nodes:  grammar children nodes
                   5943:  * @depth:  the counter
                   5944:  *
                   5945:  * Check for cycles.
                   5946:  *
                   5947:  * Returns 0 if check passed, and -1 in case of error
                   5948:  */
                   5949: static int
                   5950: xmlRelaxNGCheckCycles(xmlRelaxNGParserCtxtPtr ctxt,
                   5951:                       xmlRelaxNGDefinePtr cur, int depth)
                   5952: {
                   5953:     int ret = 0;
                   5954: 
                   5955:     while ((ret == 0) && (cur != NULL)) {
                   5956:         if ((cur->type == XML_RELAXNG_REF) ||
                   5957:             (cur->type == XML_RELAXNG_PARENTREF)) {
                   5958:             if (cur->depth == -1) {
                   5959:                 cur->depth = depth;
                   5960:                 ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth);
                   5961:                 cur->depth = -2;
                   5962:             } else if (depth == cur->depth) {
                   5963:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_CYCLE,
                   5964:                            "Detected a cycle in %s references\n",
                   5965:                            cur->name, NULL);
                   5966:                 return (-1);
                   5967:             }
                   5968:         } else if (cur->type == XML_RELAXNG_ELEMENT) {
                   5969:             ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth + 1);
                   5970:         } else {
                   5971:             ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth);
                   5972:         }
                   5973:         cur = cur->next;
                   5974:     }
                   5975:     return (ret);
                   5976: }
                   5977: 
                   5978: /**
                   5979:  * xmlRelaxNGTryUnlink:
                   5980:  * @ctxt:  a Relax-NG parser context
                   5981:  * @cur:  the definition to unlink
                   5982:  * @parent:  the parent definition
                   5983:  * @prev:  the previous sibling definition
                   5984:  *
                   5985:  * Try to unlink a definition. If not possble make it a NOOP
                   5986:  *
                   5987:  * Returns the new prev definition
                   5988:  */
                   5989: static xmlRelaxNGDefinePtr
                   5990: xmlRelaxNGTryUnlink(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
                   5991:                     xmlRelaxNGDefinePtr cur,
                   5992:                     xmlRelaxNGDefinePtr parent, xmlRelaxNGDefinePtr prev)
                   5993: {
                   5994:     if (prev != NULL) {
                   5995:         prev->next = cur->next;
                   5996:     } else {
                   5997:         if (parent != NULL) {
                   5998:             if (parent->content == cur)
                   5999:                 parent->content = cur->next;
                   6000:             else if (parent->attrs == cur)
                   6001:                 parent->attrs = cur->next;
                   6002:             else if (parent->nameClass == cur)
                   6003:                 parent->nameClass = cur->next;
                   6004:         } else {
                   6005:             cur->type = XML_RELAXNG_NOOP;
                   6006:             prev = cur;
                   6007:         }
                   6008:     }
                   6009:     return (prev);
                   6010: }
                   6011: 
                   6012: /**
                   6013:  * xmlRelaxNGSimplify:
                   6014:  * @ctxt:  a Relax-NG parser context
                   6015:  * @nodes:  grammar children nodes
                   6016:  *
                   6017:  * Check for simplification of empty and notAllowed
                   6018:  */
                   6019: static void
                   6020: xmlRelaxNGSimplify(xmlRelaxNGParserCtxtPtr ctxt,
                   6021:                    xmlRelaxNGDefinePtr cur, xmlRelaxNGDefinePtr parent)
                   6022: {
                   6023:     xmlRelaxNGDefinePtr prev = NULL;
                   6024: 
                   6025:     while (cur != NULL) {
                   6026:         if ((cur->type == XML_RELAXNG_REF) ||
                   6027:             (cur->type == XML_RELAXNG_PARENTREF)) {
                   6028:             if (cur->depth != -3) {
                   6029:                 cur->depth = -3;
                   6030:                 xmlRelaxNGSimplify(ctxt, cur->content, cur);
                   6031:             }
                   6032:         } else if (cur->type == XML_RELAXNG_NOT_ALLOWED) {
                   6033:             cur->parent = parent;
                   6034:             if ((parent != NULL) &&
                   6035:                 ((parent->type == XML_RELAXNG_ATTRIBUTE) ||
                   6036:                  (parent->type == XML_RELAXNG_LIST) ||
                   6037:                  (parent->type == XML_RELAXNG_GROUP) ||
                   6038:                  (parent->type == XML_RELAXNG_INTERLEAVE) ||
                   6039:                  (parent->type == XML_RELAXNG_ONEORMORE) ||
                   6040:                  (parent->type == XML_RELAXNG_ZEROORMORE))) {
                   6041:                 parent->type = XML_RELAXNG_NOT_ALLOWED;
                   6042:                 break;
                   6043:             }
                   6044:             if ((parent != NULL) && (parent->type == XML_RELAXNG_CHOICE)) {
                   6045:                 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
                   6046:             } else
                   6047:                 prev = cur;
                   6048:         } else if (cur->type == XML_RELAXNG_EMPTY) {
                   6049:             cur->parent = parent;
                   6050:             if ((parent != NULL) &&
                   6051:                 ((parent->type == XML_RELAXNG_ONEORMORE) ||
                   6052:                  (parent->type == XML_RELAXNG_ZEROORMORE))) {
                   6053:                 parent->type = XML_RELAXNG_EMPTY;
                   6054:                 break;
                   6055:             }
                   6056:             if ((parent != NULL) &&
                   6057:                 ((parent->type == XML_RELAXNG_GROUP) ||
                   6058:                  (parent->type == XML_RELAXNG_INTERLEAVE))) {
                   6059:                 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
                   6060:             } else
                   6061:                 prev = cur;
                   6062:         } else {
                   6063:             cur->parent = parent;
                   6064:             if (cur->content != NULL)
                   6065:                 xmlRelaxNGSimplify(ctxt, cur->content, cur);
                   6066:             if ((cur->type != XML_RELAXNG_VALUE) && (cur->attrs != NULL))
                   6067:                 xmlRelaxNGSimplify(ctxt, cur->attrs, cur);
                   6068:             if (cur->nameClass != NULL)
                   6069:                 xmlRelaxNGSimplify(ctxt, cur->nameClass, cur);
                   6070:             /*
                   6071:              * On Elements, try to move attribute only generating rules on
                   6072:              * the attrs rules.
                   6073:              */
                   6074:             if (cur->type == XML_RELAXNG_ELEMENT) {
                   6075:                 int attronly;
                   6076:                 xmlRelaxNGDefinePtr tmp, pre;
                   6077: 
                   6078:                 while (cur->content != NULL) {
                   6079:                     attronly =
                   6080:                         xmlRelaxNGGenerateAttributes(ctxt, cur->content);
                   6081:                     if (attronly == 1) {
                   6082:                         /*
                   6083:                          * migrate cur->content to attrs
                   6084:                          */
                   6085:                         tmp = cur->content;
                   6086:                         cur->content = tmp->next;
                   6087:                         tmp->next = cur->attrs;
                   6088:                         cur->attrs = tmp;
                   6089:                     } else {
                   6090:                         /*
                   6091:                          * cur->content can generate elements or text
                   6092:                          */
                   6093:                         break;
                   6094:                     }
                   6095:                 }
                   6096:                 pre = cur->content;
                   6097:                 while ((pre != NULL) && (pre->next != NULL)) {
                   6098:                     tmp = pre->next;
                   6099:                     attronly = xmlRelaxNGGenerateAttributes(ctxt, tmp);
                   6100:                     if (attronly == 1) {
                   6101:                         /*
                   6102:                          * migrate tmp to attrs
                   6103:                          */
                   6104:                         pre->next = tmp->next;
                   6105:                         tmp->next = cur->attrs;
                   6106:                         cur->attrs = tmp;
                   6107:                     } else {
                   6108:                         pre = tmp;
                   6109:                     }
                   6110:                 }
                   6111:             }
                   6112:             /*
                   6113:              * This may result in a simplification
                   6114:              */
                   6115:             if ((cur->type == XML_RELAXNG_GROUP) ||
                   6116:                 (cur->type == XML_RELAXNG_INTERLEAVE)) {
                   6117:                 if (cur->content == NULL)
                   6118:                     cur->type = XML_RELAXNG_EMPTY;
                   6119:                 else if (cur->content->next == NULL) {
                   6120:                     if ((parent == NULL) && (prev == NULL)) {
                   6121:                         cur->type = XML_RELAXNG_NOOP;
                   6122:                     } else if (prev == NULL) {
                   6123:                         parent->content = cur->content;
                   6124:                         cur->content->next = cur->next;
                   6125:                         cur = cur->content;
                   6126:                     } else {
                   6127:                         cur->content->next = cur->next;
                   6128:                         prev->next = cur->content;
                   6129:                         cur = cur->content;
                   6130:                     }
                   6131:                 }
                   6132:             }
                   6133:             /*
                   6134:              * the current node may have been transformed back
                   6135:              */
                   6136:             if ((cur->type == XML_RELAXNG_EXCEPT) &&
                   6137:                 (cur->content != NULL) &&
                   6138:                 (cur->content->type == XML_RELAXNG_NOT_ALLOWED)) {
                   6139:                 prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
                   6140:             } else if (cur->type == XML_RELAXNG_NOT_ALLOWED) {
                   6141:                 if ((parent != NULL) &&
                   6142:                     ((parent->type == XML_RELAXNG_ATTRIBUTE) ||
                   6143:                      (parent->type == XML_RELAXNG_LIST) ||
                   6144:                      (parent->type == XML_RELAXNG_GROUP) ||
                   6145:                      (parent->type == XML_RELAXNG_INTERLEAVE) ||
                   6146:                      (parent->type == XML_RELAXNG_ONEORMORE) ||
                   6147:                      (parent->type == XML_RELAXNG_ZEROORMORE))) {
                   6148:                     parent->type = XML_RELAXNG_NOT_ALLOWED;
                   6149:                     break;
                   6150:                 }
                   6151:                 if ((parent != NULL) &&
                   6152:                     (parent->type == XML_RELAXNG_CHOICE)) {
                   6153:                     prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
                   6154:                 } else
                   6155:                     prev = cur;
                   6156:             } else if (cur->type == XML_RELAXNG_EMPTY) {
                   6157:                 if ((parent != NULL) &&
                   6158:                     ((parent->type == XML_RELAXNG_ONEORMORE) ||
                   6159:                      (parent->type == XML_RELAXNG_ZEROORMORE))) {
                   6160:                     parent->type = XML_RELAXNG_EMPTY;
                   6161:                     break;
                   6162:                 }
                   6163:                 if ((parent != NULL) &&
                   6164:                     ((parent->type == XML_RELAXNG_GROUP) ||
                   6165:                      (parent->type == XML_RELAXNG_INTERLEAVE) ||
                   6166:                      (parent->type == XML_RELAXNG_CHOICE))) {
                   6167:                     prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev);
                   6168:                 } else
                   6169:                     prev = cur;
                   6170:             } else {
                   6171:                 prev = cur;
                   6172:             }
                   6173:         }
                   6174:         cur = cur->next;
                   6175:     }
                   6176: }
                   6177: 
                   6178: /**
                   6179:  * xmlRelaxNGGroupContentType:
                   6180:  * @ct1:  the first content type
                   6181:  * @ct2:  the second content type
                   6182:  *
                   6183:  * Try to group 2 content types
                   6184:  *
                   6185:  * Returns the content type
                   6186:  */
                   6187: static xmlRelaxNGContentType
                   6188: xmlRelaxNGGroupContentType(xmlRelaxNGContentType ct1,
                   6189:                            xmlRelaxNGContentType ct2)
                   6190: {
                   6191:     if ((ct1 == XML_RELAXNG_CONTENT_ERROR) ||
                   6192:         (ct2 == XML_RELAXNG_CONTENT_ERROR))
                   6193:         return (XML_RELAXNG_CONTENT_ERROR);
                   6194:     if (ct1 == XML_RELAXNG_CONTENT_EMPTY)
                   6195:         return (ct2);
                   6196:     if (ct2 == XML_RELAXNG_CONTENT_EMPTY)
                   6197:         return (ct1);
                   6198:     if ((ct1 == XML_RELAXNG_CONTENT_COMPLEX) &&
                   6199:         (ct2 == XML_RELAXNG_CONTENT_COMPLEX))
                   6200:         return (XML_RELAXNG_CONTENT_COMPLEX);
                   6201:     return (XML_RELAXNG_CONTENT_ERROR);
                   6202: }
                   6203: 
                   6204: /**
                   6205:  * xmlRelaxNGMaxContentType:
                   6206:  * @ct1:  the first content type
                   6207:  * @ct2:  the second content type
                   6208:  *
                   6209:  * Compute the max content-type
                   6210:  *
                   6211:  * Returns the content type
                   6212:  */
                   6213: static xmlRelaxNGContentType
                   6214: xmlRelaxNGMaxContentType(xmlRelaxNGContentType ct1,
                   6215:                          xmlRelaxNGContentType ct2)
                   6216: {
                   6217:     if ((ct1 == XML_RELAXNG_CONTENT_ERROR) ||
                   6218:         (ct2 == XML_RELAXNG_CONTENT_ERROR))
                   6219:         return (XML_RELAXNG_CONTENT_ERROR);
                   6220:     if ((ct1 == XML_RELAXNG_CONTENT_SIMPLE) ||
                   6221:         (ct2 == XML_RELAXNG_CONTENT_SIMPLE))
                   6222:         return (XML_RELAXNG_CONTENT_SIMPLE);
                   6223:     if ((ct1 == XML_RELAXNG_CONTENT_COMPLEX) ||
                   6224:         (ct2 == XML_RELAXNG_CONTENT_COMPLEX))
                   6225:         return (XML_RELAXNG_CONTENT_COMPLEX);
                   6226:     return (XML_RELAXNG_CONTENT_EMPTY);
                   6227: }
                   6228: 
                   6229: /**
                   6230:  * xmlRelaxNGCheckRules:
                   6231:  * @ctxt:  a Relax-NG parser context
                   6232:  * @cur:  the current definition
                   6233:  * @flags:  some accumulated flags
                   6234:  * @ptype:  the parent type
                   6235:  *
                   6236:  * Check for rules in section 7.1 and 7.2
                   6237:  *
                   6238:  * Returns the content type of @cur
                   6239:  */
                   6240: static xmlRelaxNGContentType
                   6241: xmlRelaxNGCheckRules(xmlRelaxNGParserCtxtPtr ctxt,
                   6242:                      xmlRelaxNGDefinePtr cur, int flags,
                   6243:                      xmlRelaxNGType ptype)
                   6244: {
                   6245:     int nflags;
                   6246:     xmlRelaxNGContentType ret, tmp, val = XML_RELAXNG_CONTENT_EMPTY;
                   6247: 
                   6248:     while (cur != NULL) {
                   6249:         ret = XML_RELAXNG_CONTENT_EMPTY;
                   6250:         if ((cur->type == XML_RELAXNG_REF) ||
                   6251:             (cur->type == XML_RELAXNG_PARENTREF)) {
                   6252:            /*
                   6253:             * This should actually be caught by list//element(ref) at the
                   6254:             * element boundaries, c.f. Bug #159968 local refs are dropped
                   6255:             * in step 4.19.
                   6256:             */
                   6257: #if 0
                   6258:             if (flags & XML_RELAXNG_IN_LIST) {
                   6259:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_REF,
                   6260:                            "Found forbidden pattern list//ref\n", NULL,
                   6261:                            NULL);
                   6262:             }
                   6263: #endif
                   6264:             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                   6265:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_REF,
                   6266:                            "Found forbidden pattern data/except//ref\n",
                   6267:                            NULL, NULL);
                   6268:             }
                   6269:             if (cur->content == NULL) {
                   6270:                 if (cur->type == XML_RELAXNG_PARENTREF)
                   6271:                     xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_NO_DEF,
                   6272:                                "Internal found no define for parent refs\n",
                   6273:                                NULL, NULL);
                   6274:                 else
                   6275:                     xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_NO_DEF,
                   6276:                                "Internal found no define for ref %s\n",
                   6277:                                (cur->name ? cur->name: BAD_CAST "null"), NULL);
                   6278:             }
                   6279:             if (cur->depth > -4) {
                   6280:                 cur->depth = -4;
                   6281:                 ret = xmlRelaxNGCheckRules(ctxt, cur->content,
                   6282:                                            flags, cur->type);
                   6283:                 cur->depth = ret - 15;
                   6284:             } else if (cur->depth == -4) {
                   6285:                 ret = XML_RELAXNG_CONTENT_COMPLEX;
                   6286:             } else {
                   6287:                 ret = (xmlRelaxNGContentType) (cur->depth + 15);
                   6288:             }
                   6289:         } else if (cur->type == XML_RELAXNG_ELEMENT) {
                   6290:             /*
                   6291:              * The 7.3 Attribute derivation rule for groups is plugged there
                   6292:              */
                   6293:             xmlRelaxNGCheckGroupAttrs(ctxt, cur);
                   6294:             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                   6295:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ELEM,
                   6296:                            "Found forbidden pattern data/except//element(ref)\n",
                   6297:                            NULL, NULL);
                   6298:             }
                   6299:             if (flags & XML_RELAXNG_IN_LIST) {
                   6300:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ELEM,
                   6301:                            "Found forbidden pattern list//element(ref)\n",
                   6302:                            NULL, NULL);
                   6303:             }
                   6304:             if (flags & XML_RELAXNG_IN_ATTRIBUTE) {
                   6305:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM,
                   6306:                            "Found forbidden pattern attribute//element(ref)\n",
                   6307:                            NULL, NULL);
                   6308:             }
                   6309:             if (flags & XML_RELAXNG_IN_ATTRIBUTE) {
                   6310:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM,
                   6311:                            "Found forbidden pattern attribute//element(ref)\n",
                   6312:                            NULL, NULL);
                   6313:             }
                   6314:             /*
                   6315:              * reset since in the simple form elements are only child
                   6316:              * of grammar/define
                   6317:              */
                   6318:             nflags = 0;
                   6319:             ret =
                   6320:                 xmlRelaxNGCheckRules(ctxt, cur->attrs, nflags, cur->type);
                   6321:             if (ret != XML_RELAXNG_CONTENT_EMPTY) {
                   6322:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_EMPTY,
                   6323:                            "Element %s attributes have a content type error\n",
                   6324:                            cur->name, NULL);
                   6325:             }
                   6326:             ret =
                   6327:                 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
                   6328:                                      cur->type);
                   6329:             if (ret == XML_RELAXNG_CONTENT_ERROR) {
                   6330:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_ERROR,
                   6331:                            "Element %s has a content type error\n",
                   6332:                            cur->name, NULL);
                   6333:             } else {
                   6334:                 ret = XML_RELAXNG_CONTENT_COMPLEX;
                   6335:             }
                   6336:         } else if (cur->type == XML_RELAXNG_ATTRIBUTE) {
                   6337:             if (flags & XML_RELAXNG_IN_ATTRIBUTE) {
                   6338:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ATTR,
                   6339:                            "Found forbidden pattern attribute//attribute\n",
                   6340:                            NULL, NULL);
                   6341:             }
                   6342:             if (flags & XML_RELAXNG_IN_LIST) {
                   6343:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ATTR,
                   6344:                            "Found forbidden pattern list//attribute\n",
                   6345:                            NULL, NULL);
                   6346:             }
                   6347:             if (flags & XML_RELAXNG_IN_OOMGROUP) {
                   6348:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_GROUP_ATTR,
                   6349:                            "Found forbidden pattern oneOrMore//group//attribute\n",
                   6350:                            NULL, NULL);
                   6351:             }
                   6352:             if (flags & XML_RELAXNG_IN_OOMINTERLEAVE) {
                   6353:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR,
                   6354:                            "Found forbidden pattern oneOrMore//interleave//attribute\n",
                   6355:                            NULL, NULL);
                   6356:             }
                   6357:             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                   6358:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ATTR,
                   6359:                            "Found forbidden pattern data/except//attribute\n",
                   6360:                            NULL, NULL);
                   6361:             }
                   6362:             if (flags & XML_RELAXNG_IN_START) {
                   6363:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ATTR,
                   6364:                            "Found forbidden pattern start//attribute\n",
                   6365:                            NULL, NULL);
                   6366:             }
                   6367:             if ((!(flags & XML_RELAXNG_IN_ONEORMORE))
                   6368:                 && (cur->name == NULL)) {
                   6369:                 if (cur->ns == NULL) {
                   6370:                     xmlRngPErr(ctxt, cur->node, XML_RNGP_ANYNAME_ATTR_ANCESTOR,
                   6371:                                "Found anyName attribute without oneOrMore ancestor\n",
                   6372:                                NULL, NULL);
                   6373:                 } else {
                   6374:                     xmlRngPErr(ctxt, cur->node, XML_RNGP_NSNAME_ATTR_ANCESTOR,
                   6375:                                "Found nsName attribute without oneOrMore ancestor\n",
                   6376:                                NULL, NULL);
                   6377:                 }
                   6378:             }
                   6379:             nflags = flags | XML_RELAXNG_IN_ATTRIBUTE;
                   6380:             xmlRelaxNGCheckRules(ctxt, cur->content, nflags, cur->type);
                   6381:             ret = XML_RELAXNG_CONTENT_EMPTY;
                   6382:         } else if ((cur->type == XML_RELAXNG_ONEORMORE) ||
                   6383:                    (cur->type == XML_RELAXNG_ZEROORMORE)) {
                   6384:             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                   6385:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ONEMORE,
                   6386:                            "Found forbidden pattern data/except//oneOrMore\n",
                   6387:                            NULL, NULL);
                   6388:             }
                   6389:             if (flags & XML_RELAXNG_IN_START) {
                   6390:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ONEMORE,
                   6391:                            "Found forbidden pattern start//oneOrMore\n",
                   6392:                            NULL, NULL);
                   6393:             }
                   6394:             nflags = flags | XML_RELAXNG_IN_ONEORMORE;
                   6395:             ret =
                   6396:                 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
                   6397:                                      cur->type);
                   6398:             ret = xmlRelaxNGGroupContentType(ret, ret);
                   6399:         } else if (cur->type == XML_RELAXNG_LIST) {
                   6400:             if (flags & XML_RELAXNG_IN_LIST) {
                   6401:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_LIST,
                   6402:                            "Found forbidden pattern list//list\n", NULL,
                   6403:                            NULL);
                   6404:             }
                   6405:             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                   6406:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_LIST,
                   6407:                            "Found forbidden pattern data/except//list\n",
                   6408:                            NULL, NULL);
                   6409:             }
                   6410:             if (flags & XML_RELAXNG_IN_START) {
                   6411:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_LIST,
                   6412:                            "Found forbidden pattern start//list\n", NULL,
                   6413:                            NULL);
                   6414:             }
                   6415:             nflags = flags | XML_RELAXNG_IN_LIST;
                   6416:             ret =
                   6417:                 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
                   6418:                                      cur->type);
                   6419:         } else if (cur->type == XML_RELAXNG_GROUP) {
                   6420:             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                   6421:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_GROUP,
                   6422:                            "Found forbidden pattern data/except//group\n",
                   6423:                            NULL, NULL);
                   6424:             }
                   6425:             if (flags & XML_RELAXNG_IN_START) {
                   6426:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_GROUP,
                   6427:                            "Found forbidden pattern start//group\n", NULL,
                   6428:                            NULL);
                   6429:             }
                   6430:             if (flags & XML_RELAXNG_IN_ONEORMORE)
                   6431:                 nflags = flags | XML_RELAXNG_IN_OOMGROUP;
                   6432:             else
                   6433:                 nflags = flags;
                   6434:             ret =
                   6435:                 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
                   6436:                                      cur->type);
                   6437:             /*
                   6438:              * The 7.3 Attribute derivation rule for groups is plugged there
                   6439:              */
                   6440:             xmlRelaxNGCheckGroupAttrs(ctxt, cur);
                   6441:         } else if (cur->type == XML_RELAXNG_INTERLEAVE) {
                   6442:             if (flags & XML_RELAXNG_IN_LIST) {
                   6443:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_INTERLEAVE,
                   6444:                            "Found forbidden pattern list//interleave\n",
                   6445:                            NULL, NULL);
                   6446:             }
                   6447:             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                   6448:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
                   6449:                            "Found forbidden pattern data/except//interleave\n",
                   6450:                            NULL, NULL);
                   6451:             }
                   6452:             if (flags & XML_RELAXNG_IN_START) {
                   6453:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
                   6454:                            "Found forbidden pattern start//interleave\n",
                   6455:                            NULL, NULL);
                   6456:             }
                   6457:             if (flags & XML_RELAXNG_IN_ONEORMORE)
                   6458:                 nflags = flags | XML_RELAXNG_IN_OOMINTERLEAVE;
                   6459:             else
                   6460:                 nflags = flags;
                   6461:             ret =
                   6462:                 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
                   6463:                                      cur->type);
                   6464:         } else if (cur->type == XML_RELAXNG_EXCEPT) {
                   6465:             if ((cur->parent != NULL) &&
                   6466:                 (cur->parent->type == XML_RELAXNG_DATATYPE))
                   6467:                 nflags = flags | XML_RELAXNG_IN_DATAEXCEPT;
                   6468:             else
                   6469:                 nflags = flags;
                   6470:             ret =
                   6471:                 xmlRelaxNGCheckRules(ctxt, cur->content, nflags,
                   6472:                                      cur->type);
                   6473:         } else if (cur->type == XML_RELAXNG_DATATYPE) {
                   6474:             if (flags & XML_RELAXNG_IN_START) {
                   6475:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_DATA,
                   6476:                            "Found forbidden pattern start//data\n", NULL,
                   6477:                            NULL);
                   6478:             }
                   6479:             xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
                   6480:             ret = XML_RELAXNG_CONTENT_SIMPLE;
                   6481:         } else if (cur->type == XML_RELAXNG_VALUE) {
                   6482:             if (flags & XML_RELAXNG_IN_START) {
                   6483:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_VALUE,
                   6484:                            "Found forbidden pattern start//value\n", NULL,
                   6485:                            NULL);
                   6486:             }
                   6487:             xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
                   6488:             ret = XML_RELAXNG_CONTENT_SIMPLE;
                   6489:         } else if (cur->type == XML_RELAXNG_TEXT) {
                   6490:             if (flags & XML_RELAXNG_IN_LIST) {
                   6491:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_TEXT,
                   6492:                            "Found forbidden pattern list//text\n", NULL,
                   6493:                            NULL);
                   6494:             }
                   6495:             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                   6496:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_TEXT,
                   6497:                            "Found forbidden pattern data/except//text\n",
                   6498:                            NULL, NULL);
                   6499:             }
                   6500:             if (flags & XML_RELAXNG_IN_START) {
                   6501:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_TEXT,
                   6502:                            "Found forbidden pattern start//text\n", NULL,
                   6503:                            NULL);
                   6504:             }
                   6505:             ret = XML_RELAXNG_CONTENT_COMPLEX;
                   6506:         } else if (cur->type == XML_RELAXNG_EMPTY) {
                   6507:             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                   6508:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_EMPTY,
                   6509:                            "Found forbidden pattern data/except//empty\n",
                   6510:                            NULL, NULL);
                   6511:             }
                   6512:             if (flags & XML_RELAXNG_IN_START) {
                   6513:                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_EMPTY,
                   6514:                            "Found forbidden pattern start//empty\n", NULL,
                   6515:                            NULL);
                   6516:             }
                   6517:             ret = XML_RELAXNG_CONTENT_EMPTY;
                   6518:         } else if (cur->type == XML_RELAXNG_CHOICE) {
                   6519:             xmlRelaxNGCheckChoiceDeterminism(ctxt, cur);
                   6520:             ret =
                   6521:                 xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
                   6522:         } else {
                   6523:             ret =
                   6524:                 xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
                   6525:         }
                   6526:         cur = cur->next;
                   6527:         if (ptype == XML_RELAXNG_GROUP) {
                   6528:             val = xmlRelaxNGGroupContentType(val, ret);
                   6529:         } else if (ptype == XML_RELAXNG_INTERLEAVE) {
                   6530:             /*
                   6531:              * TODO: scan complain that tmp is never used, seems on purpose
                   6532:              *       need double-checking
                   6533:              */
                   6534:             tmp = xmlRelaxNGGroupContentType(val, ret);
                   6535:             if (tmp != XML_RELAXNG_CONTENT_ERROR)
                   6536:                 tmp = xmlRelaxNGMaxContentType(val, ret);
                   6537:         } else if (ptype == XML_RELAXNG_CHOICE) {
                   6538:             val = xmlRelaxNGMaxContentType(val, ret);
                   6539:         } else if (ptype == XML_RELAXNG_LIST) {
                   6540:             val = XML_RELAXNG_CONTENT_SIMPLE;
                   6541:         } else if (ptype == XML_RELAXNG_EXCEPT) {
                   6542:             if (ret == XML_RELAXNG_CONTENT_ERROR)
                   6543:                 val = XML_RELAXNG_CONTENT_ERROR;
                   6544:             else
                   6545:                 val = XML_RELAXNG_CONTENT_SIMPLE;
                   6546:         } else {
                   6547:             val = xmlRelaxNGGroupContentType(val, ret);
                   6548:         }
                   6549: 
                   6550:     }
                   6551:     return (val);
                   6552: }
                   6553: 
                   6554: /**
                   6555:  * xmlRelaxNGParseGrammar:
                   6556:  * @ctxt:  a Relax-NG parser context
                   6557:  * @nodes:  grammar children nodes
                   6558:  *
                   6559:  * parse a Relax-NG <grammar> node
                   6560:  *
                   6561:  * Returns the internal xmlRelaxNGGrammarPtr built or
                   6562:  *         NULL in case of error
                   6563:  */
                   6564: static xmlRelaxNGGrammarPtr
                   6565: xmlRelaxNGParseGrammar(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes)
                   6566: {
                   6567:     xmlRelaxNGGrammarPtr ret, tmp, old;
                   6568: 
                   6569: #ifdef DEBUG_GRAMMAR
                   6570:     xmlGenericError(xmlGenericErrorContext, "Parsing a new grammar\n");
                   6571: #endif
                   6572: 
                   6573:     ret = xmlRelaxNGNewGrammar(ctxt);
                   6574:     if (ret == NULL)
                   6575:         return (NULL);
                   6576: 
                   6577:     /*
                   6578:      * Link the new grammar in the tree
                   6579:      */
                   6580:     ret->parent = ctxt->grammar;
                   6581:     if (ctxt->grammar != NULL) {
                   6582:         tmp = ctxt->grammar->children;
                   6583:         if (tmp == NULL) {
                   6584:             ctxt->grammar->children = ret;
                   6585:         } else {
                   6586:             while (tmp->next != NULL)
                   6587:                 tmp = tmp->next;
                   6588:             tmp->next = ret;
                   6589:         }
                   6590:     }
                   6591: 
                   6592:     old = ctxt->grammar;
                   6593:     ctxt->grammar = ret;
                   6594:     xmlRelaxNGParseGrammarContent(ctxt, nodes);
                   6595:     ctxt->grammar = ret;
                   6596:     if (ctxt->grammar == NULL) {
                   6597:         xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_CONTENT,
                   6598:                    "Failed to parse <grammar> content\n", NULL, NULL);
                   6599:     } else if (ctxt->grammar->start == NULL) {
                   6600:         xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_NO_START,
                   6601:                    "Element <grammar> has no <start>\n", NULL, NULL);
                   6602:     }
                   6603: 
                   6604:     /*
                   6605:      * Apply 4.17 mergingd rules to defines and starts
                   6606:      */
                   6607:     xmlRelaxNGCombineStart(ctxt, ret);
                   6608:     if (ret->defs != NULL) {
                   6609:         xmlHashScan(ret->defs, (xmlHashScanner) xmlRelaxNGCheckCombine,
                   6610:                     ctxt);
                   6611:     }
                   6612: 
                   6613:     /*
                   6614:      * link together defines and refs in this grammar
                   6615:      */
                   6616:     if (ret->refs != NULL) {
                   6617:         xmlHashScan(ret->refs, (xmlHashScanner) xmlRelaxNGCheckReference,
                   6618:                     ctxt);
                   6619:     }
                   6620: 
                   6621: 
                   6622:     /* @@@@ */
                   6623: 
                   6624:     ctxt->grammar = old;
                   6625:     return (ret);
                   6626: }
                   6627: 
                   6628: /**
                   6629:  * xmlRelaxNGParseDocument:
                   6630:  * @ctxt:  a Relax-NG parser context
                   6631:  * @node:  the root node of the RelaxNG schema
                   6632:  *
                   6633:  * parse a Relax-NG definition resource and build an internal
                   6634:  * xmlRelaxNG struture which can be used to validate instances.
                   6635:  *
                   6636:  * Returns the internal XML RelaxNG structure built or
                   6637:  *         NULL in case of error
                   6638:  */
                   6639: static xmlRelaxNGPtr
                   6640: xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
                   6641: {
                   6642:     xmlRelaxNGPtr schema = NULL;
                   6643:     const xmlChar *olddefine;
                   6644:     xmlRelaxNGGrammarPtr old;
                   6645: 
                   6646:     if ((ctxt == NULL) || (node == NULL))
                   6647:         return (NULL);
                   6648: 
                   6649:     schema = xmlRelaxNGNewRelaxNG(ctxt);
                   6650:     if (schema == NULL)
                   6651:         return (NULL);
                   6652: 
                   6653:     olddefine = ctxt->define;
                   6654:     ctxt->define = NULL;
                   6655:     if (IS_RELAXNG(node, "grammar")) {
                   6656:         schema->topgrammar = xmlRelaxNGParseGrammar(ctxt, node->children);
                   6657:     } else {
                   6658:         xmlRelaxNGGrammarPtr tmp, ret;
                   6659: 
                   6660:         schema->topgrammar = ret = xmlRelaxNGNewGrammar(ctxt);
                   6661:         if (schema->topgrammar == NULL) {
                   6662:             return (schema);
                   6663:         }
                   6664:         /*
                   6665:          * Link the new grammar in the tree
                   6666:          */
                   6667:         ret->parent = ctxt->grammar;
                   6668:         if (ctxt->grammar != NULL) {
                   6669:             tmp = ctxt->grammar->children;
                   6670:             if (tmp == NULL) {
                   6671:                 ctxt->grammar->children = ret;
                   6672:             } else {
                   6673:                 while (tmp->next != NULL)
                   6674:                     tmp = tmp->next;
                   6675:                 tmp->next = ret;
                   6676:             }
                   6677:         }
                   6678:         old = ctxt->grammar;
                   6679:         ctxt->grammar = ret;
                   6680:         xmlRelaxNGParseStart(ctxt, node);
                   6681:         if (old != NULL)
                   6682:             ctxt->grammar = old;
                   6683:     }
                   6684:     ctxt->define = olddefine;
                   6685:     if (schema->topgrammar->start != NULL) {
                   6686:         xmlRelaxNGCheckCycles(ctxt, schema->topgrammar->start, 0);
                   6687:         if ((ctxt->flags & XML_RELAXNG_IN_EXTERNALREF) == 0) {
                   6688:             xmlRelaxNGSimplify(ctxt, schema->topgrammar->start, NULL);
                   6689:             while ((schema->topgrammar->start != NULL) &&
                   6690:                    (schema->topgrammar->start->type == XML_RELAXNG_NOOP) &&
                   6691:                    (schema->topgrammar->start->next != NULL))
                   6692:                 schema->topgrammar->start =
                   6693:                     schema->topgrammar->start->content;
                   6694:             xmlRelaxNGCheckRules(ctxt, schema->topgrammar->start,
                   6695:                                  XML_RELAXNG_IN_START, XML_RELAXNG_NOOP);
                   6696:         }
                   6697:     }
                   6698: #ifdef DEBUG
                   6699:     if (schema == NULL)
                   6700:         xmlGenericError(xmlGenericErrorContext,
                   6701:                         "xmlRelaxNGParseDocument() failed\n");
                   6702: #endif
                   6703: 
                   6704:     return (schema);
                   6705: }
                   6706: 
                   6707: /************************************************************************
                   6708:  *                                                                     *
                   6709:  *                     Reading RelaxNGs                                *
                   6710:  *                                                                     *
                   6711:  ************************************************************************/
                   6712: 
                   6713: /**
                   6714:  * xmlRelaxNGNewParserCtxt:
                   6715:  * @URL:  the location of the schema
                   6716:  *
                   6717:  * Create an XML RelaxNGs parse context for that file/resource expected
                   6718:  * to contain an XML RelaxNGs file.
                   6719:  *
                   6720:  * Returns the parser context or NULL in case of error
                   6721:  */
                   6722: xmlRelaxNGParserCtxtPtr
                   6723: xmlRelaxNGNewParserCtxt(const char *URL)
                   6724: {
                   6725:     xmlRelaxNGParserCtxtPtr ret;
                   6726: 
                   6727:     if (URL == NULL)
                   6728:         return (NULL);
                   6729: 
                   6730:     ret =
                   6731:         (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
                   6732:     if (ret == NULL) {
                   6733:         xmlRngPErrMemory(NULL, "building parser\n");
                   6734:         return (NULL);
                   6735:     }
                   6736:     memset(ret, 0, sizeof(xmlRelaxNGParserCtxt));
                   6737:     ret->URL = xmlStrdup((const xmlChar *) URL);
                   6738:     ret->error = xmlGenericError;
                   6739:     ret->userData = xmlGenericErrorContext;
                   6740:     return (ret);
                   6741: }
                   6742: 
                   6743: /**
                   6744:  * xmlRelaxNGNewMemParserCtxt:
                   6745:  * @buffer:  a pointer to a char array containing the schemas
                   6746:  * @size:  the size of the array
                   6747:  *
                   6748:  * Create an XML RelaxNGs parse context for that memory buffer expected
                   6749:  * to contain an XML RelaxNGs file.
                   6750:  *
                   6751:  * Returns the parser context or NULL in case of error
                   6752:  */
                   6753: xmlRelaxNGParserCtxtPtr
                   6754: xmlRelaxNGNewMemParserCtxt(const char *buffer, int size)
                   6755: {
                   6756:     xmlRelaxNGParserCtxtPtr ret;
                   6757: 
                   6758:     if ((buffer == NULL) || (size <= 0))
                   6759:         return (NULL);
                   6760: 
                   6761:     ret =
                   6762:         (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
                   6763:     if (ret == NULL) {
                   6764:         xmlRngPErrMemory(NULL, "building parser\n");
                   6765:         return (NULL);
                   6766:     }
                   6767:     memset(ret, 0, sizeof(xmlRelaxNGParserCtxt));
                   6768:     ret->buffer = buffer;
                   6769:     ret->size = size;
                   6770:     ret->error = xmlGenericError;
                   6771:     ret->userData = xmlGenericErrorContext;
                   6772:     return (ret);
                   6773: }
                   6774: 
                   6775: /**
                   6776:  * xmlRelaxNGNewDocParserCtxt:
                   6777:  * @doc:  a preparsed document tree
                   6778:  *
                   6779:  * Create an XML RelaxNGs parser context for that document.
                   6780:  * Note: since the process of compiling a RelaxNG schemas modifies the
                   6781:  *       document, the @doc parameter is duplicated internally.
                   6782:  *
                   6783:  * Returns the parser context or NULL in case of error
                   6784:  */
                   6785: xmlRelaxNGParserCtxtPtr
                   6786: xmlRelaxNGNewDocParserCtxt(xmlDocPtr doc)
                   6787: {
                   6788:     xmlRelaxNGParserCtxtPtr ret;
                   6789:     xmlDocPtr copy;
                   6790: 
                   6791:     if (doc == NULL)
                   6792:         return (NULL);
                   6793:     copy = xmlCopyDoc(doc, 1);
                   6794:     if (copy == NULL)
                   6795:         return (NULL);
                   6796: 
                   6797:     ret =
                   6798:         (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
                   6799:     if (ret == NULL) {
                   6800:         xmlRngPErrMemory(NULL, "building parser\n");
                   6801:         return (NULL);
                   6802:     }
                   6803:     memset(ret, 0, sizeof(xmlRelaxNGParserCtxt));
                   6804:     ret->document = copy;
                   6805:     ret->freedoc = 1;
                   6806:     ret->userData = xmlGenericErrorContext;
                   6807:     return (ret);
                   6808: }
                   6809: 
                   6810: /**
                   6811:  * xmlRelaxNGFreeParserCtxt:
                   6812:  * @ctxt:  the schema parser context
                   6813:  *
                   6814:  * Free the resources associated to the schema parser context
                   6815:  */
                   6816: void
                   6817: xmlRelaxNGFreeParserCtxt(xmlRelaxNGParserCtxtPtr ctxt)
                   6818: {
                   6819:     if (ctxt == NULL)
                   6820:         return;
                   6821:     if (ctxt->URL != NULL)
                   6822:         xmlFree(ctxt->URL);
                   6823:     if (ctxt->doc != NULL)
                   6824:         xmlRelaxNGFreeDocument(ctxt->doc);
                   6825:     if (ctxt->interleaves != NULL)
                   6826:         xmlHashFree(ctxt->interleaves, NULL);
                   6827:     if (ctxt->documents != NULL)
                   6828:         xmlRelaxNGFreeDocumentList(ctxt->documents);
                   6829:     if (ctxt->includes != NULL)
                   6830:         xmlRelaxNGFreeIncludeList(ctxt->includes);
                   6831:     if (ctxt->docTab != NULL)
                   6832:         xmlFree(ctxt->docTab);
                   6833:     if (ctxt->incTab != NULL)
                   6834:         xmlFree(ctxt->incTab);
                   6835:     if (ctxt->defTab != NULL) {
                   6836:         int i;
                   6837: 
                   6838:         for (i = 0; i < ctxt->defNr; i++)
                   6839:             xmlRelaxNGFreeDefine(ctxt->defTab[i]);
                   6840:         xmlFree(ctxt->defTab);
                   6841:     }
                   6842:     if ((ctxt->document != NULL) && (ctxt->freedoc))
                   6843:         xmlFreeDoc(ctxt->document);
                   6844:     xmlFree(ctxt);
                   6845: }
                   6846: 
                   6847: /**
                   6848:  * xmlRelaxNGNormExtSpace:
                   6849:  * @value:  a value
                   6850:  *
                   6851:  * Removes the leading and ending spaces of the value
                   6852:  * The string is modified "in situ"
                   6853:  */
                   6854: static void
                   6855: xmlRelaxNGNormExtSpace(xmlChar * value)
                   6856: {
                   6857:     xmlChar *start = value;
                   6858:     xmlChar *cur = value;
                   6859: 
                   6860:     if (value == NULL)
                   6861:         return;
                   6862: 
                   6863:     while (IS_BLANK_CH(*cur))
                   6864:         cur++;
                   6865:     if (cur == start) {
                   6866:         do {
                   6867:             while ((*cur != 0) && (!IS_BLANK_CH(*cur)))
                   6868:                 cur++;
                   6869:             if (*cur == 0)
                   6870:                 return;
                   6871:             start = cur;
                   6872:             while (IS_BLANK_CH(*cur))
                   6873:                 cur++;
                   6874:             if (*cur == 0) {
                   6875:                 *start = 0;
                   6876:                 return;
                   6877:             }
                   6878:         } while (1);
                   6879:     } else {
                   6880:         do {
                   6881:             while ((*cur != 0) && (!IS_BLANK_CH(*cur)))
                   6882:                 *start++ = *cur++;
                   6883:             if (*cur == 0) {
                   6884:                 *start = 0;
                   6885:                 return;
                   6886:             }
                   6887:             /* don't try to normalize the inner spaces */
                   6888:             while (IS_BLANK_CH(*cur))
                   6889:                 cur++;
                   6890:             if (*cur == 0) {
                   6891:                 *start = 0;
                   6892:                 return;
                   6893:             }
                   6894:             *start++ = *cur++;
                   6895:         } while (1);
                   6896:     }
                   6897: }
                   6898: 
                   6899: /**
                   6900:  * xmlRelaxNGCleanupAttributes:
                   6901:  * @ctxt:  a Relax-NG parser context
                   6902:  * @node:  a Relax-NG node
                   6903:  *
                   6904:  * Check all the attributes on the given node
                   6905:  */
                   6906: static void
                   6907: xmlRelaxNGCleanupAttributes(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
                   6908: {
                   6909:     xmlAttrPtr cur, next;
                   6910: 
                   6911:     cur = node->properties;
                   6912:     while (cur != NULL) {
                   6913:         next = cur->next;
                   6914:         if ((cur->ns == NULL) ||
                   6915:             (xmlStrEqual(cur->ns->href, xmlRelaxNGNs))) {
                   6916:             if (xmlStrEqual(cur->name, BAD_CAST "name")) {
                   6917:                 if ((!xmlStrEqual(node->name, BAD_CAST "element")) &&
                   6918:                     (!xmlStrEqual(node->name, BAD_CAST "attribute")) &&
                   6919:                     (!xmlStrEqual(node->name, BAD_CAST "ref")) &&
                   6920:                     (!xmlStrEqual(node->name, BAD_CAST "parentRef")) &&
                   6921:                     (!xmlStrEqual(node->name, BAD_CAST "param")) &&
                   6922:                     (!xmlStrEqual(node->name, BAD_CAST "define"))) {
                   6923:                     xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
                   6924:                                "Attribute %s is not allowed on %s\n",
                   6925:                                cur->name, node->name);
                   6926:                 }
                   6927:             } else if (xmlStrEqual(cur->name, BAD_CAST "type")) {
                   6928:                 if ((!xmlStrEqual(node->name, BAD_CAST "value")) &&
                   6929:                     (!xmlStrEqual(node->name, BAD_CAST "data"))) {
                   6930:                     xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
                   6931:                                "Attribute %s is not allowed on %s\n",
                   6932:                                cur->name, node->name);
                   6933:                 }
                   6934:             } else if (xmlStrEqual(cur->name, BAD_CAST "href")) {
                   6935:                 if ((!xmlStrEqual(node->name, BAD_CAST "externalRef")) &&
                   6936:                     (!xmlStrEqual(node->name, BAD_CAST "include"))) {
                   6937:                     xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
                   6938:                                "Attribute %s is not allowed on %s\n",
                   6939:                                cur->name, node->name);
                   6940:                 }
                   6941:             } else if (xmlStrEqual(cur->name, BAD_CAST "combine")) {
                   6942:                 if ((!xmlStrEqual(node->name, BAD_CAST "start")) &&
                   6943:                     (!xmlStrEqual(node->name, BAD_CAST "define"))) {
                   6944:                     xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE,
                   6945:                                "Attribute %s is not allowed on %s\n",
                   6946:                                cur->name, node->name);
                   6947:                 }
                   6948:             } else if (xmlStrEqual(cur->name, BAD_CAST "datatypeLibrary")) {
                   6949:                 xmlChar *val;
                   6950:                 xmlURIPtr uri;
                   6951: 
                   6952:                 val = xmlNodeListGetString(node->doc, cur->children, 1);
                   6953:                 if (val != NULL) {
                   6954:                     if (val[0] != 0) {
                   6955:                         uri = xmlParseURI((const char *) val);
                   6956:                         if (uri == NULL) {
                   6957:                             xmlRngPErr(ctxt, node, XML_RNGP_INVALID_URI,
                   6958:                                        "Attribute %s contains invalid URI %s\n",
                   6959:                                        cur->name, val);
                   6960:                         } else {
                   6961:                             if (uri->scheme == NULL) {
                   6962:                                 xmlRngPErr(ctxt, node, XML_RNGP_URI_NOT_ABSOLUTE,
                   6963:                                            "Attribute %s URI %s is not absolute\n",
                   6964:                                            cur->name, val);
                   6965:                             }
                   6966:                             if (uri->fragment != NULL) {
                   6967:                                 xmlRngPErr(ctxt, node, XML_RNGP_URI_FRAGMENT,
                   6968:                                            "Attribute %s URI %s has a fragment ID\n",
                   6969:                                            cur->name, val);
                   6970:                             }
                   6971:                             xmlFreeURI(uri);
                   6972:                         }
                   6973:                     }
                   6974:                     xmlFree(val);
                   6975:                 }
                   6976:             } else if (!xmlStrEqual(cur->name, BAD_CAST "ns")) {
                   6977:                 xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_ATTRIBUTE,
                   6978:                            "Unknown attribute %s on %s\n", cur->name,
                   6979:                            node->name);
                   6980:             }
                   6981:         }
                   6982:         cur = next;
                   6983:     }
                   6984: }
                   6985: 
                   6986: /**
                   6987:  * xmlRelaxNGCleanupTree:
                   6988:  * @ctxt:  a Relax-NG parser context
                   6989:  * @root:  an xmlNodePtr subtree
                   6990:  *
                   6991:  * Cleanup the subtree from unwanted nodes for parsing, resolve
                   6992:  * Include and externalRef lookups.
                   6993:  */
                   6994: static void
                   6995: xmlRelaxNGCleanupTree(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr root)
                   6996: {
                   6997:     xmlNodePtr cur, delete;
                   6998: 
                   6999:     delete = NULL;
                   7000:     cur = root;
                   7001:     while (cur != NULL) {
                   7002:         if (delete != NULL) {
                   7003:             xmlUnlinkNode(delete);
                   7004:             xmlFreeNode(delete);
                   7005:             delete = NULL;
                   7006:         }
                   7007:         if (cur->type == XML_ELEMENT_NODE) {
                   7008:             /*
                   7009:              * Simplification 4.1. Annotations
                   7010:              */
                   7011:             if ((cur->ns == NULL) ||
                   7012:                 (!xmlStrEqual(cur->ns->href, xmlRelaxNGNs))) {
                   7013:                 if ((cur->parent != NULL) &&
                   7014:                     (cur->parent->type == XML_ELEMENT_NODE) &&
                   7015:                     ((xmlStrEqual(cur->parent->name, BAD_CAST "name")) ||
                   7016:                      (xmlStrEqual(cur->parent->name, BAD_CAST "value")) ||
                   7017:                      (xmlStrEqual(cur->parent->name, BAD_CAST "param")))) {
                   7018:                     xmlRngPErr(ctxt, cur, XML_RNGP_FOREIGN_ELEMENT,
                   7019:                                "element %s doesn't allow foreign elements\n",
                   7020:                                cur->parent->name, NULL);
                   7021:                 }
                   7022:                 delete = cur;
                   7023:                 goto skip_children;
                   7024:             } else {
                   7025:                 xmlRelaxNGCleanupAttributes(ctxt, cur);
                   7026:                 if (xmlStrEqual(cur->name, BAD_CAST "externalRef")) {
                   7027:                     xmlChar *href, *ns, *base, *URL;
                   7028:                     xmlRelaxNGDocumentPtr docu;
                   7029:                     xmlNodePtr tmp;
                   7030:                    xmlURIPtr uri;
                   7031: 
                   7032:                     ns = xmlGetProp(cur, BAD_CAST "ns");
                   7033:                     if (ns == NULL) {
                   7034:                         tmp = cur->parent;
                   7035:                         while ((tmp != NULL) &&
                   7036:                                (tmp->type == XML_ELEMENT_NODE)) {
                   7037:                             ns = xmlGetProp(tmp, BAD_CAST "ns");
                   7038:                             if (ns != NULL)
                   7039:                                 break;
                   7040:                             tmp = tmp->parent;
                   7041:                         }
                   7042:                     }
                   7043:                     href = xmlGetProp(cur, BAD_CAST "href");
                   7044:                     if (href == NULL) {
                   7045:                         xmlRngPErr(ctxt, cur, XML_RNGP_MISSING_HREF,
                   7046:                                    "xmlRelaxNGParse: externalRef has no href attribute\n",
                   7047:                                    NULL, NULL);
                   7048:                         if (ns != NULL)
                   7049:                             xmlFree(ns);
                   7050:                         delete = cur;
                   7051:                         goto skip_children;
                   7052:                     }
                   7053:                    uri = xmlParseURI((const char *) href);
                   7054:                    if (uri == NULL) {
                   7055:                         xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
                   7056:                                    "Incorrect URI for externalRef %s\n",
                   7057:                                    href, NULL);
                   7058:                         if (ns != NULL)
                   7059:                             xmlFree(ns);
                   7060:                         if (href != NULL)
                   7061:                             xmlFree(href);
                   7062:                         delete = cur;
                   7063:                         goto skip_children;
                   7064:                    }
                   7065:                    if (uri->fragment != NULL) {
                   7066:                         xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
                   7067:                               "Fragment forbidden in URI for externalRef %s\n",
                   7068:                                    href, NULL);
                   7069:                         if (ns != NULL)
                   7070:                             xmlFree(ns);
                   7071:                        xmlFreeURI(uri);
                   7072:                         if (href != NULL)
                   7073:                             xmlFree(href);
                   7074:                         delete = cur;
                   7075:                         goto skip_children;
                   7076:                    }
                   7077:                    xmlFreeURI(uri);
                   7078:                     base = xmlNodeGetBase(cur->doc, cur);
                   7079:                     URL = xmlBuildURI(href, base);
                   7080:                     if (URL == NULL) {
                   7081:                         xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
                   7082:                                    "Failed to compute URL for externalRef %s\n",
                   7083:                                    href, NULL);
                   7084:                         if (ns != NULL)
                   7085:                             xmlFree(ns);
                   7086:                         if (href != NULL)
                   7087:                             xmlFree(href);
                   7088:                         if (base != NULL)
                   7089:                             xmlFree(base);
                   7090:                         delete = cur;
                   7091:                         goto skip_children;
                   7092:                     }
                   7093:                     if (href != NULL)
                   7094:                         xmlFree(href);
                   7095:                     if (base != NULL)
                   7096:                         xmlFree(base);
                   7097:                     docu = xmlRelaxNGLoadExternalRef(ctxt, URL, ns);
                   7098:                     if (docu == NULL) {
                   7099:                         xmlRngPErr(ctxt, cur, XML_RNGP_EXTERNAL_REF_FAILURE,
                   7100:                                    "Failed to load externalRef %s\n", URL,
                   7101:                                    NULL);
                   7102:                         if (ns != NULL)
                   7103:                             xmlFree(ns);
                   7104:                         xmlFree(URL);
                   7105:                         delete = cur;
                   7106:                         goto skip_children;
                   7107:                     }
                   7108:                     if (ns != NULL)
                   7109:                         xmlFree(ns);
                   7110:                     xmlFree(URL);
                   7111:                     cur->psvi = docu;
                   7112:                 } else if (xmlStrEqual(cur->name, BAD_CAST "include")) {
                   7113:                     xmlChar *href, *ns, *base, *URL;
                   7114:                     xmlRelaxNGIncludePtr incl;
                   7115:                     xmlNodePtr tmp;
                   7116: 
                   7117:                     href = xmlGetProp(cur, BAD_CAST "href");
                   7118:                     if (href == NULL) {
                   7119:                         xmlRngPErr(ctxt, cur, XML_RNGP_MISSING_HREF,
                   7120:                                    "xmlRelaxNGParse: include has no href attribute\n",
                   7121:                                    NULL, NULL);
                   7122:                         delete = cur;
                   7123:                         goto skip_children;
                   7124:                     }
                   7125:                     base = xmlNodeGetBase(cur->doc, cur);
                   7126:                     URL = xmlBuildURI(href, base);
                   7127:                     if (URL == NULL) {
                   7128:                         xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR,
                   7129:                                    "Failed to compute URL for include %s\n",
                   7130:                                    href, NULL);
                   7131:                         if (href != NULL)
                   7132:                             xmlFree(href);
                   7133:                         if (base != NULL)
                   7134:                             xmlFree(base);
                   7135:                         delete = cur;
                   7136:                         goto skip_children;
                   7137:                     }
                   7138:                     if (href != NULL)
                   7139:                         xmlFree(href);
                   7140:                     if (base != NULL)
                   7141:                         xmlFree(base);
                   7142:                     ns = xmlGetProp(cur, BAD_CAST "ns");
                   7143:                     if (ns == NULL) {
                   7144:                         tmp = cur->parent;
                   7145:                         while ((tmp != NULL) &&
                   7146:                                (tmp->type == XML_ELEMENT_NODE)) {
                   7147:                             ns = xmlGetProp(tmp, BAD_CAST "ns");
                   7148:                             if (ns != NULL)
                   7149:                                 break;
                   7150:                             tmp = tmp->parent;
                   7151:                         }
                   7152:                     }
                   7153:                     incl = xmlRelaxNGLoadInclude(ctxt, URL, cur, ns);
                   7154:                     if (ns != NULL)
                   7155:                         xmlFree(ns);
                   7156:                     if (incl == NULL) {
                   7157:                         xmlRngPErr(ctxt, cur, XML_RNGP_INCLUDE_FAILURE,
                   7158:                                    "Failed to load include %s\n", URL,
                   7159:                                    NULL);
                   7160:                         xmlFree(URL);
                   7161:                         delete = cur;
                   7162:                         goto skip_children;
                   7163:                     }
                   7164:                     xmlFree(URL);
                   7165:                     cur->psvi = incl;
                   7166:                 } else if ((xmlStrEqual(cur->name, BAD_CAST "element")) ||
                   7167:                            (xmlStrEqual(cur->name, BAD_CAST "attribute")))
                   7168:                 {
                   7169:                     xmlChar *name, *ns;
                   7170:                     xmlNodePtr text = NULL;
                   7171: 
                   7172:                     /*
                   7173:                      * Simplification 4.8. name attribute of element
                   7174:                      * and attribute elements
                   7175:                      */
                   7176:                     name = xmlGetProp(cur, BAD_CAST "name");
                   7177:                     if (name != NULL) {
                   7178:                         if (cur->children == NULL) {
                   7179:                             text =
                   7180:                                 xmlNewChild(cur, cur->ns, BAD_CAST "name",
                   7181:                                             name);
                   7182:                         } else {
                   7183:                             xmlNodePtr node;
                   7184: 
                   7185:                             node = xmlNewDocNode(cur->doc, cur->ns,
                   7186:                                                 BAD_CAST "name", NULL);
                   7187:                             if (node != NULL) {
                   7188:                                 xmlAddPrevSibling(cur->children, node);
                   7189:                                 text = xmlNewText(name);
                   7190:                                 xmlAddChild(node, text);
                   7191:                                 text = node;
                   7192:                             }
                   7193:                         }
                   7194:                         if (text == NULL) {
                   7195:                             xmlRngPErr(ctxt, cur, XML_RNGP_CREATE_FAILURE,
                   7196:                                        "Failed to create a name %s element\n",
                   7197:                                        name, NULL);
                   7198:                         }
                   7199:                         xmlUnsetProp(cur, BAD_CAST "name");
                   7200:                         xmlFree(name);
                   7201:                         ns = xmlGetProp(cur, BAD_CAST "ns");
                   7202:                         if (ns != NULL) {
                   7203:                             if (text != NULL) {
                   7204:                                 xmlSetProp(text, BAD_CAST "ns", ns);
                   7205:                                 /* xmlUnsetProp(cur, BAD_CAST "ns"); */
                   7206:                             }
                   7207:                             xmlFree(ns);
                   7208:                         } else if (xmlStrEqual(cur->name,
                   7209:                                                BAD_CAST "attribute")) {
                   7210:                             xmlSetProp(text, BAD_CAST "ns", BAD_CAST "");
                   7211:                         }
                   7212:                     }
                   7213:                 } else if ((xmlStrEqual(cur->name, BAD_CAST "name")) ||
                   7214:                            (xmlStrEqual(cur->name, BAD_CAST "nsName")) ||
                   7215:                            (xmlStrEqual(cur->name, BAD_CAST "value"))) {
                   7216:                     /*
                   7217:                      * Simplification 4.8. name attribute of element
                   7218:                      * and attribute elements
                   7219:                      */
                   7220:                     if (xmlHasProp(cur, BAD_CAST "ns") == NULL) {
                   7221:                         xmlNodePtr node;
                   7222:                         xmlChar *ns = NULL;
                   7223: 
                   7224:                         node = cur->parent;
                   7225:                         while ((node != NULL) &&
                   7226:                                (node->type == XML_ELEMENT_NODE)) {
                   7227:                             ns = xmlGetProp(node, BAD_CAST "ns");
                   7228:                             if (ns != NULL) {
                   7229:                                 break;
                   7230:                             }
                   7231:                             node = node->parent;
                   7232:                         }
                   7233:                         if (ns == NULL) {
                   7234:                             xmlSetProp(cur, BAD_CAST "ns", BAD_CAST "");
                   7235:                         } else {
                   7236:                             xmlSetProp(cur, BAD_CAST "ns", ns);
                   7237:                             xmlFree(ns);
                   7238:                         }
                   7239:                     }
                   7240:                     if (xmlStrEqual(cur->name, BAD_CAST "name")) {
                   7241:                         xmlChar *name, *local, *prefix;
                   7242: 
                   7243:                         /*
                   7244:                          * Simplification: 4.10. QNames
                   7245:                          */
                   7246:                         name = xmlNodeGetContent(cur);
                   7247:                         if (name != NULL) {
                   7248:                             local = xmlSplitQName2(name, &prefix);
                   7249:                             if (local != NULL) {
                   7250:                                 xmlNsPtr ns;
                   7251: 
                   7252:                                 ns = xmlSearchNs(cur->doc, cur, prefix);
                   7253:                                 if (ns == NULL) {
                   7254:                                     xmlRngPErr(ctxt, cur,
                   7255:                                                XML_RNGP_PREFIX_UNDEFINED,
                   7256:                                                "xmlRelaxNGParse: no namespace for prefix %s\n",
                   7257:                                                prefix, NULL);
                   7258:                                 } else {
                   7259:                                     xmlSetProp(cur, BAD_CAST "ns",
                   7260:                                                ns->href);
                   7261:                                     xmlNodeSetContent(cur, local);
                   7262:                                 }
                   7263:                                 xmlFree(local);
                   7264:                                 xmlFree(prefix);
                   7265:                             }
                   7266:                             xmlFree(name);
                   7267:                         }
                   7268:                     }
                   7269:                     /*
                   7270:                      * 4.16
                   7271:                      */
                   7272:                     if (xmlStrEqual(cur->name, BAD_CAST "nsName")) {
                   7273:                         if (ctxt->flags & XML_RELAXNG_IN_NSEXCEPT) {
                   7274:                             xmlRngPErr(ctxt, cur,
                   7275:                                        XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME,
                   7276:                                        "Found nsName/except//nsName forbidden construct\n",
                   7277:                                        NULL, NULL);
                   7278:                         }
                   7279:                     }
                   7280:                 } else if ((xmlStrEqual(cur->name, BAD_CAST "except")) &&
                   7281:                            (cur != root)) {
                   7282:                     int oldflags = ctxt->flags;
                   7283: 
                   7284:                     /*
                   7285:                      * 4.16
                   7286:                      */
                   7287:                     if ((cur->parent != NULL) &&
                   7288:                         (xmlStrEqual
                   7289:                          (cur->parent->name, BAD_CAST "anyName"))) {
                   7290:                         ctxt->flags |= XML_RELAXNG_IN_ANYEXCEPT;
                   7291:                         xmlRelaxNGCleanupTree(ctxt, cur);
                   7292:                         ctxt->flags = oldflags;
                   7293:                         goto skip_children;
                   7294:                     } else if ((cur->parent != NULL) &&
                   7295:                                (xmlStrEqual
                   7296:                                 (cur->parent->name, BAD_CAST "nsName"))) {
                   7297:                         ctxt->flags |= XML_RELAXNG_IN_NSEXCEPT;
                   7298:                         xmlRelaxNGCleanupTree(ctxt, cur);
                   7299:                         ctxt->flags = oldflags;
                   7300:                         goto skip_children;
                   7301:                     }
                   7302:                 } else if (xmlStrEqual(cur->name, BAD_CAST "anyName")) {
                   7303:                     /*
                   7304:                      * 4.16
                   7305:                      */
                   7306:                     if (ctxt->flags & XML_RELAXNG_IN_ANYEXCEPT) {
                   7307:                         xmlRngPErr(ctxt, cur,
                   7308:                                    XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME,
                   7309:                                    "Found anyName/except//anyName forbidden construct\n",
                   7310:                                    NULL, NULL);
                   7311:                     } else if (ctxt->flags & XML_RELAXNG_IN_NSEXCEPT) {
                   7312:                         xmlRngPErr(ctxt, cur,
                   7313:                                    XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME,
                   7314:                                    "Found nsName/except//anyName forbidden construct\n",
                   7315:                                    NULL, NULL);
                   7316:                     }
                   7317:                 }
                   7318:                 /*
                   7319:                  * Thisd is not an else since "include" is transformed
                   7320:                  * into a div
                   7321:                  */
                   7322:                 if (xmlStrEqual(cur->name, BAD_CAST "div")) {
                   7323:                     xmlChar *ns;
                   7324:                     xmlNodePtr child, ins, tmp;
                   7325: 
                   7326:                     /*
                   7327:                      * implements rule 4.11
                   7328:                      */
                   7329: 
                   7330:                     ns = xmlGetProp(cur, BAD_CAST "ns");
                   7331: 
                   7332:                     child = cur->children;
                   7333:                     ins = cur;
                   7334:                     while (child != NULL) {
                   7335:                         if (ns != NULL) {
                   7336:                             if (!xmlHasProp(child, BAD_CAST "ns")) {
                   7337:                                 xmlSetProp(child, BAD_CAST "ns", ns);
                   7338:                             }
                   7339:                         }
                   7340:                         tmp = child->next;
                   7341:                         xmlUnlinkNode(child);
                   7342:                         ins = xmlAddNextSibling(ins, child);
                   7343:                         child = tmp;
                   7344:                     }
                   7345:                     if (ns != NULL)
                   7346:                         xmlFree(ns);
                   7347:                    /*
                   7348:                     * Since we are about to delete cur, if it's nsDef is non-NULL we
                   7349:                     * need to preserve it (it contains the ns definitions for the
                   7350:                     * children we just moved).  We'll just stick it on to the end
                   7351:                     * of cur->parent's list, since it's never going to be re-serialized
                   7352:                     * (bug 143738).
                   7353:                     */
                   7354:                    if (cur->nsDef != NULL) {
                   7355:                        xmlNsPtr parDef = (xmlNsPtr)&cur->parent->nsDef;
                   7356:                        while (parDef->next != NULL)
                   7357:                            parDef = parDef->next;
                   7358:                        parDef->next = cur->nsDef;
                   7359:                        cur->nsDef = NULL;
                   7360:                    }
                   7361:                     delete = cur;
                   7362:                     goto skip_children;
                   7363:                 }
                   7364:             }
                   7365:         }
                   7366:         /*
                   7367:          * Simplification 4.2 whitespaces
                   7368:          */
                   7369:         else if ((cur->type == XML_TEXT_NODE) ||
                   7370:                  (cur->type == XML_CDATA_SECTION_NODE)) {
                   7371:             if (IS_BLANK_NODE(cur)) {
                   7372:                 if (cur->parent->type == XML_ELEMENT_NODE) {
                   7373:                     if ((!xmlStrEqual(cur->parent->name, BAD_CAST "value"))
                   7374:                         &&
                   7375:                         (!xmlStrEqual
                   7376:                          (cur->parent->name, BAD_CAST "param")))
                   7377:                         delete = cur;
                   7378:                 } else {
                   7379:                     delete = cur;
                   7380:                     goto skip_children;
                   7381:                 }
                   7382:             }
                   7383:         } else {
                   7384:             delete = cur;
                   7385:             goto skip_children;
                   7386:         }
                   7387: 
                   7388:         /*
                   7389:          * Skip to next node
                   7390:          */
                   7391:         if (cur->children != NULL) {
                   7392:             if ((cur->children->type != XML_ENTITY_DECL) &&
                   7393:                 (cur->children->type != XML_ENTITY_REF_NODE) &&
                   7394:                 (cur->children->type != XML_ENTITY_NODE)) {
                   7395:                 cur = cur->children;
                   7396:                 continue;
                   7397:             }
                   7398:         }
                   7399:       skip_children:
                   7400:         if (cur->next != NULL) {
                   7401:             cur = cur->next;
                   7402:             continue;
                   7403:         }
                   7404: 
                   7405:         do {
                   7406:             cur = cur->parent;
                   7407:             if (cur == NULL)
                   7408:                 break;
                   7409:             if (cur == root) {
                   7410:                 cur = NULL;
                   7411:                 break;
                   7412:             }
                   7413:             if (cur->next != NULL) {
                   7414:                 cur = cur->next;
                   7415:                 break;
                   7416:             }
                   7417:         } while (cur != NULL);
                   7418:     }
                   7419:     if (delete != NULL) {
                   7420:         xmlUnlinkNode(delete);
                   7421:         xmlFreeNode(delete);
                   7422:         delete = NULL;
                   7423:     }
                   7424: }
                   7425: 
                   7426: /**
                   7427:  * xmlRelaxNGCleanupDoc:
                   7428:  * @ctxt:  a Relax-NG parser context
                   7429:  * @doc:  an xmldocPtr document pointer
                   7430:  *
                   7431:  * Cleanup the document from unwanted nodes for parsing, resolve
                   7432:  * Include and externalRef lookups.
                   7433:  *
                   7434:  * Returns the cleaned up document or NULL in case of error
                   7435:  */
                   7436: static xmlDocPtr
                   7437: xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt, xmlDocPtr doc)
                   7438: {
                   7439:     xmlNodePtr root;
                   7440: 
                   7441:     /*
                   7442:      * Extract the root
                   7443:      */
                   7444:     root = xmlDocGetRootElement(doc);
                   7445:     if (root == NULL) {
                   7446:         xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_RNGP_EMPTY, "xmlRelaxNGParse: %s is empty\n",
                   7447:                    ctxt->URL, NULL);
                   7448:         return (NULL);
                   7449:     }
                   7450:     xmlRelaxNGCleanupTree(ctxt, root);
                   7451:     return (doc);
                   7452: }
                   7453: 
                   7454: /**
                   7455:  * xmlRelaxNGParse:
                   7456:  * @ctxt:  a Relax-NG parser context
                   7457:  *
                   7458:  * parse a schema definition resource and build an internal
                   7459:  * XML Shema struture which can be used to validate instances.
                   7460:  *
                   7461:  * Returns the internal XML RelaxNG structure built from the resource or
                   7462:  *         NULL in case of error
                   7463:  */
                   7464: xmlRelaxNGPtr
                   7465: xmlRelaxNGParse(xmlRelaxNGParserCtxtPtr ctxt)
                   7466: {
                   7467:     xmlRelaxNGPtr ret = NULL;
                   7468:     xmlDocPtr doc;
                   7469:     xmlNodePtr root;
                   7470: 
                   7471:     xmlRelaxNGInitTypes();
                   7472: 
                   7473:     if (ctxt == NULL)
                   7474:         return (NULL);
                   7475: 
                   7476:     /*
                   7477:      * First step is to parse the input document into an DOM/Infoset
                   7478:      */
                   7479:     if (ctxt->URL != NULL) {
                   7480:         doc = xmlReadFile((const char *) ctxt->URL,NULL,0);
                   7481:         if (doc == NULL) {
                   7482:             xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
                   7483:                        "xmlRelaxNGParse: could not load %s\n", ctxt->URL,
                   7484:                        NULL);
                   7485:             return (NULL);
                   7486:         }
                   7487:     } else if (ctxt->buffer != NULL) {
                   7488:         doc = xmlReadMemory(ctxt->buffer, ctxt->size,NULL,NULL,0);
                   7489:         if (doc == NULL) {
                   7490:             xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
                   7491:                        "xmlRelaxNGParse: could not parse schemas\n", NULL,
                   7492:                        NULL);
                   7493:             return (NULL);
                   7494:         }
                   7495:         doc->URL = xmlStrdup(BAD_CAST "in_memory_buffer");
                   7496:         ctxt->URL = xmlStrdup(BAD_CAST "in_memory_buffer");
                   7497:     } else if (ctxt->document != NULL) {
                   7498:         doc = ctxt->document;
                   7499:     } else {
                   7500:         xmlRngPErr(ctxt, NULL, XML_RNGP_EMPTY,
                   7501:                    "xmlRelaxNGParse: nothing to parse\n", NULL, NULL);
                   7502:         return (NULL);
                   7503:     }
                   7504:     ctxt->document = doc;
                   7505: 
                   7506:     /*
                   7507:      * Some preprocessing of the document content
                   7508:      */
                   7509:     doc = xmlRelaxNGCleanupDoc(ctxt, doc);
                   7510:     if (doc == NULL) {
                   7511:         xmlFreeDoc(ctxt->document);
                   7512:         ctxt->document = NULL;
                   7513:         return (NULL);
                   7514:     }
                   7515: 
                   7516:     /*
                   7517:      * Then do the parsing for good
                   7518:      */
                   7519:     root = xmlDocGetRootElement(doc);
                   7520:     if (root == NULL) {
                   7521:         xmlRngPErr(ctxt, (xmlNodePtr) doc,
                   7522:                   XML_RNGP_EMPTY, "xmlRelaxNGParse: %s is empty\n",
                   7523:                    (ctxt->URL ? ctxt->URL : BAD_CAST "schemas"), NULL);
                   7524:        
                   7525:         xmlFreeDoc(ctxt->document);
                   7526:         ctxt->document = NULL;
                   7527:         return (NULL);
                   7528:     }
                   7529:     ret = xmlRelaxNGParseDocument(ctxt, root);
                   7530:     if (ret == NULL) {
                   7531:         xmlFreeDoc(ctxt->document);
                   7532:         ctxt->document = NULL;
                   7533:         return (NULL);
                   7534:     }
                   7535: 
                   7536:     /*
                   7537:      * Check the ref/defines links
                   7538:      */
                   7539:     /*
                   7540:      * try to preprocess interleaves
                   7541:      */
                   7542:     if (ctxt->interleaves != NULL) {
                   7543:         xmlHashScan(ctxt->interleaves,
                   7544:                     (xmlHashScanner) xmlRelaxNGComputeInterleaves, ctxt);
                   7545:     }
                   7546: 
                   7547:     /*
                   7548:      * if there was a parsing error return NULL
                   7549:      */
                   7550:     if (ctxt->nbErrors > 0) {
                   7551:         xmlRelaxNGFree(ret);
                   7552:         ctxt->document = NULL;
                   7553:         xmlFreeDoc(doc);
                   7554:         return (NULL);
                   7555:     }
                   7556: 
                   7557:     /*
                   7558:      * try to compile (parts of) the schemas
                   7559:      */
                   7560:     if ((ret->topgrammar != NULL) && (ret->topgrammar->start != NULL)) {
                   7561:         if (ret->topgrammar->start->type != XML_RELAXNG_START) {
                   7562:             xmlRelaxNGDefinePtr def;
                   7563: 
                   7564:             def = xmlRelaxNGNewDefine(ctxt, NULL);
                   7565:             if (def != NULL) {
                   7566:                 def->type = XML_RELAXNG_START;
                   7567:                 def->content = ret->topgrammar->start;
                   7568:                 ret->topgrammar->start = def;
                   7569:             }
                   7570:         }
                   7571:         xmlRelaxNGTryCompile(ctxt, ret->topgrammar->start);
                   7572:     }
                   7573: 
                   7574:     /*
                   7575:      * Transfer the pointer for cleanup at the schema level.
                   7576:      */
                   7577:     ret->doc = doc;
                   7578:     ctxt->document = NULL;
                   7579:     ret->documents = ctxt->documents;
                   7580:     ctxt->documents = NULL;
                   7581: 
                   7582:     ret->includes = ctxt->includes;
                   7583:     ctxt->includes = NULL;
                   7584:     ret->defNr = ctxt->defNr;
                   7585:     ret->defTab = ctxt->defTab;
                   7586:     ctxt->defTab = NULL;
                   7587:     if (ctxt->idref == 1)
                   7588:         ret->idref = 1;
                   7589: 
                   7590:     return (ret);
                   7591: }
                   7592: 
                   7593: /**
                   7594:  * xmlRelaxNGSetParserErrors:
                   7595:  * @ctxt:  a Relax-NG validation context
                   7596:  * @err:  the error callback
                   7597:  * @warn:  the warning callback
                   7598:  * @ctx:  contextual data for the callbacks
                   7599:  *
                   7600:  * Set the callback functions used to handle errors for a validation context
                   7601:  */
                   7602: void
                   7603: xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
                   7604:                           xmlRelaxNGValidityErrorFunc err,
                   7605:                           xmlRelaxNGValidityWarningFunc warn, void *ctx)
                   7606: {
                   7607:     if (ctxt == NULL)
                   7608:         return;
                   7609:     ctxt->error = err;
                   7610:     ctxt->warning = warn;
                   7611:     ctxt->serror = NULL;
                   7612:     ctxt->userData = ctx;
                   7613: }
                   7614: 
                   7615: /**
                   7616:  * xmlRelaxNGGetParserErrors:
                   7617:  * @ctxt:  a Relax-NG validation context
                   7618:  * @err:  the error callback result
                   7619:  * @warn:  the warning callback result
                   7620:  * @ctx:  contextual data for the callbacks result
                   7621:  *
                   7622:  * Get the callback information used to handle errors for a validation context
                   7623:  *
                   7624:  * Returns -1 in case of failure, 0 otherwise.
                   7625:  */
                   7626: int
                   7627: xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
                   7628:                           xmlRelaxNGValidityErrorFunc * err,
                   7629:                           xmlRelaxNGValidityWarningFunc * warn, void **ctx)
                   7630: {
                   7631:     if (ctxt == NULL)
                   7632:         return (-1);
                   7633:     if (err != NULL)
                   7634:         *err = ctxt->error;
                   7635:     if (warn != NULL)
                   7636:         *warn = ctxt->warning;
                   7637:     if (ctx != NULL)
                   7638:         *ctx = ctxt->userData;
                   7639:     return (0);
                   7640: }
                   7641: 
                   7642: /**
                   7643:  * xmlRelaxNGSetParserStructuredErrors:
                   7644:  * @ctxt:  a Relax-NG parser context
                   7645:  * @serror:  the error callback
                   7646:  * @ctx:  contextual data for the callbacks
                   7647:  *
                   7648:  * Set the callback functions used to handle errors for a parsing context
                   7649:  */
                   7650: void
                   7651: xmlRelaxNGSetParserStructuredErrors(xmlRelaxNGParserCtxtPtr ctxt,
                   7652:                                    xmlStructuredErrorFunc serror,
                   7653:                                    void *ctx)
                   7654: {
                   7655:     if (ctxt == NULL)
                   7656:         return;
                   7657:     ctxt->serror = serror;
                   7658:     ctxt->error = NULL;
                   7659:     ctxt->warning = NULL;
                   7660:     ctxt->userData = ctx;
                   7661: }
                   7662: 
                   7663: #ifdef LIBXML_OUTPUT_ENABLED
                   7664: 
                   7665: /************************************************************************
                   7666:  *                                                                     *
                   7667:  *                     Dump back a compiled form                       *
                   7668:  *                                                                     *
                   7669:  ************************************************************************/
                   7670: static void xmlRelaxNGDumpDefine(FILE * output,
                   7671:                                  xmlRelaxNGDefinePtr define);
                   7672: 
                   7673: /**
                   7674:  * xmlRelaxNGDumpDefines:
                   7675:  * @output:  the file output
                   7676:  * @defines:  a list of define structures
                   7677:  *
                   7678:  * Dump a RelaxNG structure back
                   7679:  */
                   7680: static void
                   7681: xmlRelaxNGDumpDefines(FILE * output, xmlRelaxNGDefinePtr defines)
                   7682: {
                   7683:     while (defines != NULL) {
                   7684:         xmlRelaxNGDumpDefine(output, defines);
                   7685:         defines = defines->next;
                   7686:     }
                   7687: }
                   7688: 
                   7689: /**
                   7690:  * xmlRelaxNGDumpDefine:
                   7691:  * @output:  the file output
                   7692:  * @define:  a define structure
                   7693:  *
                   7694:  * Dump a RelaxNG structure back
                   7695:  */
                   7696: static void
                   7697: xmlRelaxNGDumpDefine(FILE * output, xmlRelaxNGDefinePtr define)
                   7698: {
                   7699:     if (define == NULL)
                   7700:         return;
                   7701:     switch (define->type) {
                   7702:         case XML_RELAXNG_EMPTY:
                   7703:             fprintf(output, "<empty/>\n");
                   7704:             break;
                   7705:         case XML_RELAXNG_NOT_ALLOWED:
                   7706:             fprintf(output, "<notAllowed/>\n");
                   7707:             break;
                   7708:         case XML_RELAXNG_TEXT:
                   7709:             fprintf(output, "<text/>\n");
                   7710:             break;
                   7711:         case XML_RELAXNG_ELEMENT:
                   7712:             fprintf(output, "<element>\n");
                   7713:             if (define->name != NULL) {
                   7714:                 fprintf(output, "<name");
                   7715:                 if (define->ns != NULL)
                   7716:                     fprintf(output, " ns=\"%s\"", define->ns);
                   7717:                 fprintf(output, ">%s</name>\n", define->name);
                   7718:             }
                   7719:             xmlRelaxNGDumpDefines(output, define->attrs);
                   7720:             xmlRelaxNGDumpDefines(output, define->content);
                   7721:             fprintf(output, "</element>\n");
                   7722:             break;
                   7723:         case XML_RELAXNG_LIST:
                   7724:             fprintf(output, "<list>\n");
                   7725:             xmlRelaxNGDumpDefines(output, define->content);
                   7726:             fprintf(output, "</list>\n");
                   7727:             break;
                   7728:         case XML_RELAXNG_ONEORMORE:
                   7729:             fprintf(output, "<oneOrMore>\n");
                   7730:             xmlRelaxNGDumpDefines(output, define->content);
                   7731:             fprintf(output, "</oneOrMore>\n");
                   7732:             break;
                   7733:         case XML_RELAXNG_ZEROORMORE:
                   7734:             fprintf(output, "<zeroOrMore>\n");
                   7735:             xmlRelaxNGDumpDefines(output, define->content);
                   7736:             fprintf(output, "</zeroOrMore>\n");
                   7737:             break;
                   7738:         case XML_RELAXNG_CHOICE:
                   7739:             fprintf(output, "<choice>\n");
                   7740:             xmlRelaxNGDumpDefines(output, define->content);
                   7741:             fprintf(output, "</choice>\n");
                   7742:             break;
                   7743:         case XML_RELAXNG_GROUP:
                   7744:             fprintf(output, "<group>\n");
                   7745:             xmlRelaxNGDumpDefines(output, define->content);
                   7746:             fprintf(output, "</group>\n");
                   7747:             break;
                   7748:         case XML_RELAXNG_INTERLEAVE:
                   7749:             fprintf(output, "<interleave>\n");
                   7750:             xmlRelaxNGDumpDefines(output, define->content);
                   7751:             fprintf(output, "</interleave>\n");
                   7752:             break;
                   7753:         case XML_RELAXNG_OPTIONAL:
                   7754:             fprintf(output, "<optional>\n");
                   7755:             xmlRelaxNGDumpDefines(output, define->content);
                   7756:             fprintf(output, "</optional>\n");
                   7757:             break;
                   7758:         case XML_RELAXNG_ATTRIBUTE:
                   7759:             fprintf(output, "<attribute>\n");
                   7760:             xmlRelaxNGDumpDefines(output, define->content);
                   7761:             fprintf(output, "</attribute>\n");
                   7762:             break;
                   7763:         case XML_RELAXNG_DEF:
                   7764:             fprintf(output, "<define");
                   7765:             if (define->name != NULL)
                   7766:                 fprintf(output, " name=\"%s\"", define->name);
                   7767:             fprintf(output, ">\n");
                   7768:             xmlRelaxNGDumpDefines(output, define->content);
                   7769:             fprintf(output, "</define>\n");
                   7770:             break;
                   7771:         case XML_RELAXNG_REF:
                   7772:             fprintf(output, "<ref");
                   7773:             if (define->name != NULL)
                   7774:                 fprintf(output, " name=\"%s\"", define->name);
                   7775:             fprintf(output, ">\n");
                   7776:             xmlRelaxNGDumpDefines(output, define->content);
                   7777:             fprintf(output, "</ref>\n");
                   7778:             break;
                   7779:         case XML_RELAXNG_PARENTREF:
                   7780:             fprintf(output, "<parentRef");
                   7781:             if (define->name != NULL)
                   7782:                 fprintf(output, " name=\"%s\"", define->name);
                   7783:             fprintf(output, ">\n");
                   7784:             xmlRelaxNGDumpDefines(output, define->content);
                   7785:             fprintf(output, "</parentRef>\n");
                   7786:             break;
                   7787:         case XML_RELAXNG_EXTERNALREF:
                   7788:             fprintf(output, "<externalRef>");
                   7789:             xmlRelaxNGDumpDefines(output, define->content);
                   7790:             fprintf(output, "</externalRef>\n");
                   7791:             break;
                   7792:         case XML_RELAXNG_DATATYPE:
                   7793:         case XML_RELAXNG_VALUE:
                   7794:             TODO break;
                   7795:         case XML_RELAXNG_START:
                   7796:         case XML_RELAXNG_EXCEPT:
                   7797:         case XML_RELAXNG_PARAM:
                   7798:             TODO break;
                   7799:         case XML_RELAXNG_NOOP:
                   7800:             xmlRelaxNGDumpDefines(output, define->content);
                   7801:             break;
                   7802:     }
                   7803: }
                   7804: 
                   7805: /**
                   7806:  * xmlRelaxNGDumpGrammar:
                   7807:  * @output:  the file output
                   7808:  * @grammar:  a grammar structure
                   7809:  * @top:  is this a top grammar 
                   7810:  *
                   7811:  * Dump a RelaxNG structure back
                   7812:  */
                   7813: static void
                   7814: xmlRelaxNGDumpGrammar(FILE * output, xmlRelaxNGGrammarPtr grammar, int top)
                   7815: {
                   7816:     if (grammar == NULL)
                   7817:         return;
                   7818: 
                   7819:     fprintf(output, "<grammar");
                   7820:     if (top)
                   7821:         fprintf(output, " xmlns=\"http://relaxng.org/ns/structure/1.0\"");
                   7822:     switch (grammar->combine) {
                   7823:         case XML_RELAXNG_COMBINE_UNDEFINED:
                   7824:             break;
                   7825:         case XML_RELAXNG_COMBINE_CHOICE:
                   7826:             fprintf(output, " combine=\"choice\"");
                   7827:             break;
                   7828:         case XML_RELAXNG_COMBINE_INTERLEAVE:
                   7829:             fprintf(output, " combine=\"interleave\"");
                   7830:             break;
                   7831:         default:
                   7832:             fprintf(output, " <!-- invalid combine value -->");
                   7833:     }
                   7834:     fprintf(output, ">\n");
                   7835:     if (grammar->start == NULL) {
                   7836:         fprintf(output, " <!-- grammar had no start -->");
                   7837:     } else {
                   7838:         fprintf(output, "<start>\n");
                   7839:         xmlRelaxNGDumpDefine(output, grammar->start);
                   7840:         fprintf(output, "</start>\n");
                   7841:     }
                   7842:     /* TODO ? Dump the defines ? */
                   7843:     fprintf(output, "</grammar>\n");
                   7844: }
                   7845: 
                   7846: /**
                   7847:  * xmlRelaxNGDump:
                   7848:  * @output:  the file output
                   7849:  * @schema:  a schema structure
                   7850:  *
                   7851:  * Dump a RelaxNG structure back
                   7852:  */
                   7853: void
                   7854: xmlRelaxNGDump(FILE * output, xmlRelaxNGPtr schema)
                   7855: {
                   7856:     if (output == NULL)
                   7857:         return;
                   7858:     if (schema == NULL) {
                   7859:         fprintf(output, "RelaxNG empty or failed to compile\n");
                   7860:         return;
                   7861:     }
                   7862:     fprintf(output, "RelaxNG: ");
                   7863:     if (schema->doc == NULL) {
                   7864:         fprintf(output, "no document\n");
                   7865:     } else if (schema->doc->URL != NULL) {
                   7866:         fprintf(output, "%s\n", schema->doc->URL);
                   7867:     } else {
                   7868:         fprintf(output, "\n");
                   7869:     }
                   7870:     if (schema->topgrammar == NULL) {
                   7871:         fprintf(output, "RelaxNG has no top grammar\n");
                   7872:         return;
                   7873:     }
                   7874:     xmlRelaxNGDumpGrammar(output, schema->topgrammar, 1);
                   7875: }
                   7876: 
                   7877: /**
                   7878:  * xmlRelaxNGDumpTree:
                   7879:  * @output:  the file output
                   7880:  * @schema:  a schema structure
                   7881:  *
                   7882:  * Dump the transformed RelaxNG tree.
                   7883:  */
                   7884: void
                   7885: xmlRelaxNGDumpTree(FILE * output, xmlRelaxNGPtr schema)
                   7886: {
                   7887:     if (output == NULL)
                   7888:         return;
                   7889:     if (schema == NULL) {
                   7890:         fprintf(output, "RelaxNG empty or failed to compile\n");
                   7891:         return;
                   7892:     }
                   7893:     if (schema->doc == NULL) {
                   7894:         fprintf(output, "no document\n");
                   7895:     } else {
                   7896:         xmlDocDump(output, schema->doc);
                   7897:     }
                   7898: }
                   7899: #endif /* LIBXML_OUTPUT_ENABLED */
                   7900: 
                   7901: /************************************************************************
                   7902:  *                                                                     *
                   7903:  *             Validation of compiled content                          *
                   7904:  *                                                                     *
                   7905:  ************************************************************************/
                   7906: static int xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt,
                   7907:                                         xmlRelaxNGDefinePtr define);
                   7908: 
                   7909: /**
                   7910:  * xmlRelaxNGValidateCompiledCallback:
                   7911:  * @exec:  the regular expression instance
                   7912:  * @token:  the token which matched
                   7913:  * @transdata:  callback data, the define for the subelement if available
                   7914:  @ @inputdata:  callback data, the Relax NG validation context
                   7915:  *
                   7916:  * Handle the callback and if needed validate the element children.
                   7917:  */
                   7918: static void
                   7919: xmlRelaxNGValidateCompiledCallback(xmlRegExecCtxtPtr exec ATTRIBUTE_UNUSED,
                   7920:                                    const xmlChar * token,
                   7921:                                    void *transdata, void *inputdata)
                   7922: {
                   7923:     xmlRelaxNGValidCtxtPtr ctxt = (xmlRelaxNGValidCtxtPtr) inputdata;
                   7924:     xmlRelaxNGDefinePtr define = (xmlRelaxNGDefinePtr) transdata;
                   7925:     int ret;
                   7926: 
                   7927: #ifdef DEBUG_COMPILE
                   7928:     xmlGenericError(xmlGenericErrorContext,
                   7929:                     "Compiled callback for: '%s'\n", token);
                   7930: #endif
                   7931:     if (ctxt == NULL) {
                   7932:         fprintf(stderr, "callback on %s missing context\n", token);
                   7933:         return;
                   7934:     }
                   7935:     if (define == NULL) {
                   7936:         if (token[0] == '#')
                   7937:             return;
                   7938:         fprintf(stderr, "callback on %s missing define\n", token);
                   7939:         if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
                   7940:             ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
                   7941:         return;
                   7942:     }
                   7943:     if ((ctxt == NULL) || (define == NULL)) {
                   7944:         fprintf(stderr, "callback on %s missing info\n", token);
                   7945:         if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
                   7946:             ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
                   7947:         return;
                   7948:     } else if (define->type != XML_RELAXNG_ELEMENT) {
                   7949:         fprintf(stderr, "callback on %s define is not element\n", token);
                   7950:         if (ctxt->errNo == XML_RELAXNG_OK)
                   7951:             ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
                   7952:         return;
                   7953:     }
                   7954:     ret = xmlRelaxNGValidateDefinition(ctxt, define);
                   7955:     if (ret != 0)
                   7956:         ctxt->perr = ret;
                   7957: }
                   7958: 
                   7959: /**
                   7960:  * xmlRelaxNGValidateCompiledContent:
                   7961:  * @ctxt:  the RelaxNG validation context
                   7962:  * @regexp:  the regular expression as compiled
                   7963:  * @content:  list of children to test against the regexp
                   7964:  *
                   7965:  * Validate the content model of an element or start using the regexp
                   7966:  *
                   7967:  * Returns 0 in case of success, -1 in case of error.
                   7968:  */
                   7969: static int
                   7970: xmlRelaxNGValidateCompiledContent(xmlRelaxNGValidCtxtPtr ctxt,
                   7971:                                   xmlRegexpPtr regexp, xmlNodePtr content)
                   7972: {
                   7973:     xmlRegExecCtxtPtr exec;
                   7974:     xmlNodePtr cur;
                   7975:     int ret = 0;
                   7976:     int oldperr;
                   7977: 
                   7978:     if ((ctxt == NULL) || (regexp == NULL))
                   7979:         return (-1);
                   7980:     oldperr = ctxt->perr;
                   7981:     exec = xmlRegNewExecCtxt(regexp,
                   7982:                              xmlRelaxNGValidateCompiledCallback, ctxt);
                   7983:     ctxt->perr = 0;
                   7984:     cur = content;
                   7985:     while (cur != NULL) {
                   7986:         ctxt->state->seq = cur;
                   7987:         switch (cur->type) {
                   7988:             case XML_TEXT_NODE:
                   7989:             case XML_CDATA_SECTION_NODE:
                   7990:                 if (xmlIsBlankNode(cur))
                   7991:                     break;
                   7992:                 ret = xmlRegExecPushString(exec, BAD_CAST "#text", ctxt);
                   7993:                 if (ret < 0) {
                   7994:                     VALID_ERR2(XML_RELAXNG_ERR_TEXTWRONG,
                   7995:                                cur->parent->name);
                   7996:                 }
                   7997:                 break;
                   7998:             case XML_ELEMENT_NODE:
                   7999:                 if (cur->ns != NULL) {
                   8000:                     ret = xmlRegExecPushString2(exec, cur->name,
                   8001:                                                 cur->ns->href, ctxt);
                   8002:                 } else {
                   8003:                     ret = xmlRegExecPushString(exec, cur->name, ctxt);
                   8004:                 }
                   8005:                 if (ret < 0) {
                   8006:                     VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, cur->name);
                   8007:                 }
                   8008:                 break;
                   8009:             default:
                   8010:                 break;
                   8011:         }
                   8012:         if (ret < 0)
                   8013:             break;
                   8014:         /*
                   8015:          * Switch to next element
                   8016:          */
                   8017:         cur = cur->next;
                   8018:     }
                   8019:     ret = xmlRegExecPushString(exec, NULL, NULL);
                   8020:     if (ret == 1) {
                   8021:         ret = 0;
                   8022:         ctxt->state->seq = NULL;
                   8023:     } else if (ret == 0) {
                   8024:         /*
                   8025:          * TODO: get some of the names needed to exit the current state of exec
                   8026:          */
                   8027:         VALID_ERR2(XML_RELAXNG_ERR_NOELEM, BAD_CAST "");
                   8028:         ret = -1;
                   8029:         if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
                   8030:             xmlRelaxNGDumpValidError(ctxt);
                   8031:     } else {
                   8032:         ret = -1;
                   8033:     }
                   8034:     xmlRegFreeExecCtxt(exec);
                   8035:     /*
                   8036:      * There might be content model errors outside of the pure
                   8037:      * regexp validation, e.g. for attribute values.
                   8038:      */
                   8039:     if ((ret == 0) && (ctxt->perr != 0)) {
                   8040:         ret = ctxt->perr;
                   8041:     }
                   8042:     ctxt->perr = oldperr;
                   8043:     return (ret);
                   8044: }
                   8045: 
                   8046: /************************************************************************
                   8047:  *                                                                     *
                   8048:  *             Progressive validation of when possible                 *
                   8049:  *                                                                     *
                   8050:  ************************************************************************/
                   8051: static int xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
                   8052:                                            xmlRelaxNGDefinePtr defines);
                   8053: static int xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt,
                   8054:                                         int dolog);
                   8055: static void xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt);
                   8056: 
                   8057: /**
                   8058:  * xmlRelaxNGElemPush:
                   8059:  * @ctxt:  the validation context
                   8060:  * @exec:  the regexp runtime for the new content model
                   8061:  *
                   8062:  * Push a new regexp for the current node content model on the stack
                   8063:  *
                   8064:  * Returns 0 in case of success and -1 in case of error.
                   8065:  */
                   8066: static int
                   8067: xmlRelaxNGElemPush(xmlRelaxNGValidCtxtPtr ctxt, xmlRegExecCtxtPtr exec)
                   8068: {
                   8069:     if (ctxt->elemTab == NULL) {
                   8070:         ctxt->elemMax = 10;
                   8071:         ctxt->elemTab = (xmlRegExecCtxtPtr *) xmlMalloc(ctxt->elemMax *
                   8072:                                                         sizeof
                   8073:                                                         (xmlRegExecCtxtPtr));
                   8074:         if (ctxt->elemTab == NULL) {
                   8075:             xmlRngVErrMemory(ctxt, "validating\n");
                   8076:             return (-1);
                   8077:         }
                   8078:     }
                   8079:     if (ctxt->elemNr >= ctxt->elemMax) {
                   8080:         ctxt->elemMax *= 2;
                   8081:         ctxt->elemTab = (xmlRegExecCtxtPtr *) xmlRealloc(ctxt->elemTab,
                   8082:                                                          ctxt->elemMax *
                   8083:                                                          sizeof
                   8084:                                                          (xmlRegExecCtxtPtr));
                   8085:         if (ctxt->elemTab == NULL) {
                   8086:             xmlRngVErrMemory(ctxt, "validating\n");
                   8087:             return (-1);
                   8088:         }
                   8089:     }
                   8090:     ctxt->elemTab[ctxt->elemNr++] = exec;
                   8091:     ctxt->elem = exec;
                   8092:     return (0);
                   8093: }
                   8094: 
                   8095: /**
                   8096:  * xmlRelaxNGElemPop:
                   8097:  * @ctxt:  the validation context
                   8098:  *
                   8099:  * Pop the regexp of the current node content model from the stack
                   8100:  *
                   8101:  * Returns the exec or NULL if empty
                   8102:  */
                   8103: static xmlRegExecCtxtPtr
                   8104: xmlRelaxNGElemPop(xmlRelaxNGValidCtxtPtr ctxt)
                   8105: {
                   8106:     xmlRegExecCtxtPtr ret;
                   8107: 
                   8108:     if (ctxt->elemNr <= 0)
                   8109:         return (NULL);
                   8110:     ctxt->elemNr--;
                   8111:     ret = ctxt->elemTab[ctxt->elemNr];
                   8112:     ctxt->elemTab[ctxt->elemNr] = NULL;
                   8113:     if (ctxt->elemNr > 0)
                   8114:         ctxt->elem = ctxt->elemTab[ctxt->elemNr - 1];
                   8115:     else
                   8116:         ctxt->elem = NULL;
                   8117:     return (ret);
                   8118: }
                   8119: 
                   8120: /**
                   8121:  * xmlRelaxNGValidateProgressiveCallback:
                   8122:  * @exec:  the regular expression instance
                   8123:  * @token:  the token which matched
                   8124:  * @transdata:  callback data, the define for the subelement if available
                   8125:  @ @inputdata:  callback data, the Relax NG validation context
                   8126:  *
                   8127:  * Handle the callback and if needed validate the element children.
                   8128:  * some of the in/out informations are passed via the context in @inputdata.
                   8129:  */
                   8130: static void
                   8131: xmlRelaxNGValidateProgressiveCallback(xmlRegExecCtxtPtr exec
                   8132:                                       ATTRIBUTE_UNUSED,
                   8133:                                       const xmlChar * token,
                   8134:                                       void *transdata, void *inputdata)
                   8135: {
                   8136:     xmlRelaxNGValidCtxtPtr ctxt = (xmlRelaxNGValidCtxtPtr) inputdata;
                   8137:     xmlRelaxNGDefinePtr define = (xmlRelaxNGDefinePtr) transdata;
                   8138:     xmlRelaxNGValidStatePtr state, oldstate;
                   8139:     xmlNodePtr node;
                   8140:     int ret = 0, oldflags;
                   8141: 
                   8142: #ifdef DEBUG_PROGRESSIVE
                   8143:     xmlGenericError(xmlGenericErrorContext,
                   8144:                     "Progressive callback for: '%s'\n", token);
                   8145: #endif
                   8146:     if (ctxt == NULL) {
                   8147:         fprintf(stderr, "callback on %s missing context\n", token);
                   8148:         return;
                   8149:     }
                   8150:     node = ctxt->pnode;
                   8151:     ctxt->pstate = 1;
                   8152:     if (define == NULL) {
                   8153:         if (token[0] == '#')
                   8154:             return;
                   8155:         fprintf(stderr, "callback on %s missing define\n", token);
                   8156:         if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
                   8157:             ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
                   8158:         ctxt->pstate = -1;
                   8159:         return;
                   8160:     }
                   8161:     if ((ctxt == NULL) || (define == NULL)) {
                   8162:         fprintf(stderr, "callback on %s missing info\n", token);
                   8163:         if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
                   8164:             ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
                   8165:         ctxt->pstate = -1;
                   8166:         return;
                   8167:     } else if (define->type != XML_RELAXNG_ELEMENT) {
                   8168:         fprintf(stderr, "callback on %s define is not element\n", token);
                   8169:         if (ctxt->errNo == XML_RELAXNG_OK)
                   8170:             ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
                   8171:         ctxt->pstate = -1;
                   8172:         return;
                   8173:     }
                   8174:     if (node->type != XML_ELEMENT_NODE) {
                   8175:         VALID_ERR(XML_RELAXNG_ERR_NOTELEM);
                   8176:         if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
                   8177:             xmlRelaxNGDumpValidError(ctxt);
                   8178:         ctxt->pstate = -1;
                   8179:         return;
                   8180:     }
                   8181:     if (define->contModel == NULL) {
                   8182:         /*
                   8183:          * this node cannot be validated in a streamable fashion
                   8184:          */
                   8185: #ifdef DEBUG_PROGRESSIVE
                   8186:         xmlGenericError(xmlGenericErrorContext,
                   8187:                         "Element '%s' validation is not streamable\n",
                   8188:                         token);
                   8189: #endif
                   8190:         ctxt->pstate = 0;
                   8191:         ctxt->pdef = define;
                   8192:         return;
                   8193:     }
                   8194:     exec = xmlRegNewExecCtxt(define->contModel,
                   8195:                              xmlRelaxNGValidateProgressiveCallback, ctxt);
                   8196:     if (exec == NULL) {
                   8197:         ctxt->pstate = -1;
                   8198:         return;
                   8199:     }
                   8200:     xmlRelaxNGElemPush(ctxt, exec);
                   8201: 
                   8202:     /*
                   8203:      * Validate the attributes part of the content.
                   8204:      */
                   8205:     state = xmlRelaxNGNewValidState(ctxt, node);
                   8206:     if (state == NULL) {
                   8207:         ctxt->pstate = -1;
                   8208:         return;
                   8209:     }
                   8210:     oldstate = ctxt->state;
                   8211:     ctxt->state = state;
                   8212:     if (define->attrs != NULL) {
                   8213:         ret = xmlRelaxNGValidateAttributeList(ctxt, define->attrs);
                   8214:         if (ret != 0) {
                   8215:             ctxt->pstate = -1;
                   8216:             VALID_ERR2(XML_RELAXNG_ERR_ATTRVALID, node->name);
                   8217:         }
                   8218:     }
                   8219:     if (ctxt->state != NULL) {
                   8220:         ctxt->state->seq = NULL;
                   8221:         ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
                   8222:         if (ret != 0) {
                   8223:             ctxt->pstate = -1;
                   8224:         }
                   8225:         xmlRelaxNGFreeValidState(ctxt, ctxt->state);
                   8226:     } else if (ctxt->states != NULL) {
                   8227:         int tmp = -1, i;
                   8228: 
                   8229:         oldflags = ctxt->flags;
                   8230: 
                   8231:         for (i = 0; i < ctxt->states->nbState; i++) {
                   8232:             state = ctxt->states->tabState[i];
                   8233:             ctxt->state = state;
                   8234:             ctxt->state->seq = NULL;
                   8235: 
                   8236:             if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
                   8237:                 tmp = 0;
                   8238:                 break;
                   8239:             }
                   8240:         }
                   8241:         if (tmp != 0) {
                   8242:             /*
                   8243:              * validation error, log the message for the "best" one
                   8244:              */
                   8245:             ctxt->flags |= FLAGS_IGNORABLE;
                   8246:             xmlRelaxNGLogBestError(ctxt);
                   8247:         }
                   8248:         for (i = 0; i < ctxt->states->nbState; i++) {
                   8249:             xmlRelaxNGFreeValidState(ctxt, ctxt->states->tabState[i]);
                   8250:         }
                   8251:         xmlRelaxNGFreeStates(ctxt, ctxt->states);
                   8252:         ctxt->states = NULL;
                   8253:         if ((ret == 0) && (tmp == -1))
                   8254:             ctxt->pstate = -1;
                   8255:         ctxt->flags = oldflags;
                   8256:     }
                   8257:     if (ctxt->pstate == -1) {
                   8258:         if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
                   8259:             xmlRelaxNGDumpValidError(ctxt);
                   8260:         }
                   8261:     }
                   8262:     ctxt->state = oldstate;
                   8263: }
                   8264: 
                   8265: /**
                   8266:  * xmlRelaxNGValidatePushElement:
                   8267:  * @ctxt:  the validation context
                   8268:  * @doc:  a document instance
                   8269:  * @elem:  an element instance
                   8270:  *
                   8271:  * Push a new element start on the RelaxNG validation stack.
                   8272:  *
                   8273:  * returns 1 if no validation problem was found or 0 if validating the
                   8274:  *         element requires a full node, and -1 in case of error.
                   8275:  */
                   8276: int
                   8277: xmlRelaxNGValidatePushElement(xmlRelaxNGValidCtxtPtr ctxt,
                   8278:                               xmlDocPtr doc ATTRIBUTE_UNUSED,
                   8279:                               xmlNodePtr elem)
                   8280: {
                   8281:     int ret = 1;
                   8282: 
                   8283:     if ((ctxt == NULL) || (elem == NULL))
                   8284:         return (-1);
                   8285: 
                   8286: #ifdef DEBUG_PROGRESSIVE
                   8287:     xmlGenericError(xmlGenericErrorContext, "PushElem %s\n", elem->name);
                   8288: #endif
                   8289:     if (ctxt->elem == 0) {
                   8290:         xmlRelaxNGPtr schema;
                   8291:         xmlRelaxNGGrammarPtr grammar;
                   8292:         xmlRegExecCtxtPtr exec;
                   8293:         xmlRelaxNGDefinePtr define;
                   8294: 
                   8295:         schema = ctxt->schema;
                   8296:         if (schema == NULL) {
                   8297:             VALID_ERR(XML_RELAXNG_ERR_NOGRAMMAR);
                   8298:             return (-1);
                   8299:         }
                   8300:         grammar = schema->topgrammar;
                   8301:         if ((grammar == NULL) || (grammar->start == NULL)) {
                   8302:             VALID_ERR(XML_RELAXNG_ERR_NOGRAMMAR);
                   8303:             return (-1);
                   8304:         }
                   8305:         define = grammar->start;
                   8306:         if (define->contModel == NULL) {
                   8307:             ctxt->pdef = define;
                   8308:             return (0);
                   8309:         }
                   8310:         exec = xmlRegNewExecCtxt(define->contModel,
                   8311:                                  xmlRelaxNGValidateProgressiveCallback,
                   8312:                                  ctxt);
                   8313:         if (exec == NULL) {
                   8314:             return (-1);
                   8315:         }
                   8316:         xmlRelaxNGElemPush(ctxt, exec);
                   8317:     }
                   8318:     ctxt->pnode = elem;
                   8319:     ctxt->pstate = 0;
                   8320:     if (elem->ns != NULL) {
                   8321:         ret =
                   8322:             xmlRegExecPushString2(ctxt->elem, elem->name, elem->ns->href,
                   8323:                                   ctxt);
                   8324:     } else {
                   8325:         ret = xmlRegExecPushString(ctxt->elem, elem->name, ctxt);
                   8326:     }
                   8327:     if (ret < 0) {
                   8328:         VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, elem->name);
                   8329:     } else {
                   8330:         if (ctxt->pstate == 0)
                   8331:             ret = 0;
                   8332:         else if (ctxt->pstate < 0)
                   8333:             ret = -1;
                   8334:         else
                   8335:             ret = 1;
                   8336:     }
                   8337: #ifdef DEBUG_PROGRESSIVE
                   8338:     if (ret < 0)
                   8339:         xmlGenericError(xmlGenericErrorContext, "PushElem %s failed\n",
                   8340:                         elem->name);
                   8341: #endif
                   8342:     return (ret);
                   8343: }
                   8344: 
                   8345: /**
                   8346:  * xmlRelaxNGValidatePushCData:
                   8347:  * @ctxt:  the RelaxNG validation context
                   8348:  * @data:  some character data read
                   8349:  * @len:  the lenght of the data
                   8350:  *
                   8351:  * check the CData parsed for validation in the current stack
                   8352:  *
                   8353:  * returns 1 if no validation problem was found or -1 otherwise
                   8354:  */
                   8355: int
                   8356: xmlRelaxNGValidatePushCData(xmlRelaxNGValidCtxtPtr ctxt,
                   8357:                             const xmlChar * data, int len ATTRIBUTE_UNUSED)
                   8358: {
                   8359:     int ret = 1;
                   8360: 
                   8361:     if ((ctxt == NULL) || (ctxt->elem == NULL) || (data == NULL))
                   8362:         return (-1);
                   8363: 
                   8364: #ifdef DEBUG_PROGRESSIVE
                   8365:     xmlGenericError(xmlGenericErrorContext, "CDATA %s %d\n", data, len);
                   8366: #endif
                   8367: 
                   8368:     while (*data != 0) {
                   8369:         if (!IS_BLANK_CH(*data))
                   8370:             break;
                   8371:         data++;
                   8372:     }
                   8373:     if (*data == 0)
                   8374:         return (1);
                   8375: 
                   8376:     ret = xmlRegExecPushString(ctxt->elem, BAD_CAST "#text", ctxt);
                   8377:     if (ret < 0) {
                   8378:         VALID_ERR2(XML_RELAXNG_ERR_TEXTWRONG, BAD_CAST " TODO ");
                   8379: #ifdef DEBUG_PROGRESSIVE
                   8380:         xmlGenericError(xmlGenericErrorContext, "CDATA failed\n");
                   8381: #endif
                   8382: 
                   8383:         return (-1);
                   8384:     }
                   8385:     return (1);
                   8386: }
                   8387: 
                   8388: /**
                   8389:  * xmlRelaxNGValidatePopElement:
                   8390:  * @ctxt:  the RelaxNG validation context
                   8391:  * @doc:  a document instance
                   8392:  * @elem:  an element instance
                   8393:  *
                   8394:  * Pop the element end from the RelaxNG validation stack.
                   8395:  *
                   8396:  * returns 1 if no validation problem was found or 0 otherwise
                   8397:  */
                   8398: int
                   8399: xmlRelaxNGValidatePopElement(xmlRelaxNGValidCtxtPtr ctxt,
                   8400:                              xmlDocPtr doc ATTRIBUTE_UNUSED,
                   8401:                              xmlNodePtr elem)
                   8402: {
                   8403:     int ret;
                   8404:     xmlRegExecCtxtPtr exec;
                   8405: 
                   8406:     if ((ctxt == NULL) || (ctxt->elem == NULL) || (elem == NULL))
                   8407:         return (-1);
                   8408: #ifdef DEBUG_PROGRESSIVE
                   8409:     xmlGenericError(xmlGenericErrorContext, "PopElem %s\n", elem->name);
                   8410: #endif
                   8411:     /*
                   8412:      * verify that we reached a terminal state of the content model.
                   8413:      */
                   8414:     exec = xmlRelaxNGElemPop(ctxt);
                   8415:     ret = xmlRegExecPushString(exec, NULL, NULL);
                   8416:     if (ret == 0) {
                   8417:         /*
                   8418:          * TODO: get some of the names needed to exit the current state of exec
                   8419:          */
                   8420:         VALID_ERR2(XML_RELAXNG_ERR_NOELEM, BAD_CAST "");
                   8421:         ret = -1;
                   8422:     } else if (ret < 0) {
                   8423:         ret = -1;
                   8424:     } else {
                   8425:         ret = 1;
                   8426:     }
                   8427:     xmlRegFreeExecCtxt(exec);
                   8428: #ifdef DEBUG_PROGRESSIVE
                   8429:     if (ret < 0)
                   8430:         xmlGenericError(xmlGenericErrorContext, "PopElem %s failed\n",
                   8431:                         elem->name);
                   8432: #endif
                   8433:     return (ret);
                   8434: }
                   8435: 
                   8436: /**
                   8437:  * xmlRelaxNGValidateFullElement:
                   8438:  * @ctxt:  the validation context
                   8439:  * @doc:  a document instance
                   8440:  * @elem:  an element instance
                   8441:  *
                   8442:  * Validate a full subtree when xmlRelaxNGValidatePushElement() returned
                   8443:  * 0 and the content of the node has been expanded.
                   8444:  *
                   8445:  * returns 1 if no validation problem was found or -1 in case of error.
                   8446:  */
                   8447: int
                   8448: xmlRelaxNGValidateFullElement(xmlRelaxNGValidCtxtPtr ctxt,
                   8449:                               xmlDocPtr doc ATTRIBUTE_UNUSED,
                   8450:                               xmlNodePtr elem)
                   8451: {
                   8452:     int ret;
                   8453:     xmlRelaxNGValidStatePtr state;
                   8454: 
                   8455:     if ((ctxt == NULL) || (ctxt->pdef == NULL) || (elem == NULL))
                   8456:         return (-1);
                   8457: #ifdef DEBUG_PROGRESSIVE
                   8458:     xmlGenericError(xmlGenericErrorContext, "FullElem %s\n", elem->name);
                   8459: #endif
                   8460:     state = xmlRelaxNGNewValidState(ctxt, elem->parent);
                   8461:     if (state == NULL) {
                   8462:         return (-1);
                   8463:     }
                   8464:     state->seq = elem;
                   8465:     ctxt->state = state;
                   8466:     ctxt->errNo = XML_RELAXNG_OK;
                   8467:     ret = xmlRelaxNGValidateDefinition(ctxt, ctxt->pdef);
                   8468:     if ((ret != 0) || (ctxt->errNo != XML_RELAXNG_OK))
                   8469:         ret = -1;
                   8470:     else
                   8471:         ret = 1;
                   8472:     xmlRelaxNGFreeValidState(ctxt, ctxt->state);
                   8473:     ctxt->state = NULL;
                   8474: #ifdef DEBUG_PROGRESSIVE
                   8475:     if (ret < 0)
                   8476:         xmlGenericError(xmlGenericErrorContext, "FullElem %s failed\n",
                   8477:                         elem->name);
                   8478: #endif
                   8479:     return (ret);
                   8480: }
                   8481: 
                   8482: /************************************************************************
                   8483:  *                                                                     *
                   8484:  *             Generic interpreted validation implementation           *
                   8485:  *                                                                     *
                   8486:  ************************************************************************/
                   8487: static int xmlRelaxNGValidateValue(xmlRelaxNGValidCtxtPtr ctxt,
                   8488:                                    xmlRelaxNGDefinePtr define);
                   8489: 
                   8490: /**
                   8491:  * xmlRelaxNGSkipIgnored:
                   8492:  * @ctxt:  a schema validation context
                   8493:  * @node:  the top node.
                   8494:  *
                   8495:  * Skip ignorable nodes in that context
                   8496:  *
                   8497:  * Returns the new sibling or NULL in case of error.
                   8498:  */
                   8499: static xmlNodePtr
                   8500: xmlRelaxNGSkipIgnored(xmlRelaxNGValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
                   8501:                       xmlNodePtr node)
                   8502: {
                   8503:     /*
                   8504:      * TODO complete and handle entities
                   8505:      */
                   8506:     while ((node != NULL) &&
                   8507:            ((node->type == XML_COMMENT_NODE) ||
                   8508:             (node->type == XML_PI_NODE) ||
                   8509:            (node->type == XML_XINCLUDE_START) ||
                   8510:            (node->type == XML_XINCLUDE_END) ||
                   8511:             (((node->type == XML_TEXT_NODE) ||
                   8512:               (node->type == XML_CDATA_SECTION_NODE)) &&
                   8513:              ((ctxt->flags & FLAGS_MIXED_CONTENT) ||
                   8514:               (IS_BLANK_NODE(node)))))) {
                   8515:         node = node->next;
                   8516:     }
                   8517:     return (node);
                   8518: }
                   8519: 
                   8520: /**
                   8521:  * xmlRelaxNGNormalize:
                   8522:  * @ctxt:  a schema validation context
                   8523:  * @str:  the string to normalize
                   8524:  *
                   8525:  * Implements the  normalizeWhiteSpace( s ) function from
                   8526:  * section 6.2.9 of the spec
                   8527:  *
                   8528:  * Returns the new string or NULL in case of error.
                   8529:  */
                   8530: static xmlChar *
                   8531: xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt, const xmlChar * str)
                   8532: {
                   8533:     xmlChar *ret, *p;
                   8534:     const xmlChar *tmp;
                   8535:     int len;
                   8536: 
                   8537:     if (str == NULL)
                   8538:         return (NULL);
                   8539:     tmp = str;
                   8540:     while (*tmp != 0)
                   8541:         tmp++;
                   8542:     len = tmp - str;
                   8543: 
                   8544:     ret = (xmlChar *) xmlMallocAtomic((len + 1) * sizeof(xmlChar));
                   8545:     if (ret == NULL) {
                   8546:         xmlRngVErrMemory(ctxt, "validating\n");
                   8547:         return (NULL);
                   8548:     }
                   8549:     p = ret;
                   8550:     while (IS_BLANK_CH(*str))
                   8551:         str++;
                   8552:     while (*str != 0) {
                   8553:         if (IS_BLANK_CH(*str)) {
                   8554:             while (IS_BLANK_CH(*str))
                   8555:                 str++;
                   8556:             if (*str == 0)
                   8557:                 break;
                   8558:             *p++ = ' ';
                   8559:         } else
                   8560:             *p++ = *str++;
                   8561:     }
                   8562:     *p = 0;
                   8563:     return (ret);
                   8564: }
                   8565: 
                   8566: /**
                   8567:  * xmlRelaxNGValidateDatatype:
                   8568:  * @ctxt:  a Relax-NG validation context
                   8569:  * @value:  the string value
                   8570:  * @type:  the datatype definition
                   8571:  * @node:  the node
                   8572:  *
                   8573:  * Validate the given value against the dataype
                   8574:  *
                   8575:  * Returns 0 if the validation succeeded or an error code.
                   8576:  */
                   8577: static int
                   8578: xmlRelaxNGValidateDatatype(xmlRelaxNGValidCtxtPtr ctxt,
                   8579:                            const xmlChar * value,
                   8580:                            xmlRelaxNGDefinePtr define, xmlNodePtr node)
                   8581: {
                   8582:     int ret, tmp;
                   8583:     xmlRelaxNGTypeLibraryPtr lib;
                   8584:     void *result = NULL;
                   8585:     xmlRelaxNGDefinePtr cur;
                   8586: 
                   8587:     if ((define == NULL) || (define->data == NULL)) {
                   8588:         return (-1);
                   8589:     }
                   8590:     lib = (xmlRelaxNGTypeLibraryPtr) define->data;
                   8591:     if (lib->check != NULL) {
                   8592:         if ((define->attrs != NULL) &&
                   8593:             (define->attrs->type == XML_RELAXNG_PARAM)) {
                   8594:             ret =
                   8595:                 lib->check(lib->data, define->name, value, &result, node);
                   8596:         } else {
                   8597:             ret = lib->check(lib->data, define->name, value, NULL, node);
                   8598:         }
                   8599:     } else
                   8600:         ret = -1;
                   8601:     if (ret < 0) {
                   8602:         VALID_ERR2(XML_RELAXNG_ERR_TYPE, define->name);
                   8603:         if ((result != NULL) && (lib != NULL) && (lib->freef != NULL))
                   8604:             lib->freef(lib->data, result);
                   8605:         return (-1);
                   8606:     } else if (ret == 1) {
                   8607:         ret = 0;
                   8608:     } else if (ret == 2) {
                   8609:         VALID_ERR2P(XML_RELAXNG_ERR_DUPID, value);
                   8610:     } else {
                   8611:         VALID_ERR3P(XML_RELAXNG_ERR_TYPEVAL, define->name, value);
                   8612:         ret = -1;
                   8613:     }
                   8614:     cur = define->attrs;
                   8615:     while ((ret == 0) && (cur != NULL) && (cur->type == XML_RELAXNG_PARAM)) {
                   8616:         if (lib->facet != NULL) {
                   8617:             tmp = lib->facet(lib->data, define->name, cur->name,
                   8618:                              cur->value, value, result);
                   8619:             if (tmp != 0)
                   8620:                 ret = -1;
                   8621:         }
                   8622:         cur = cur->next;
                   8623:     }
                   8624:     if ((ret == 0) && (define->content != NULL)) {
                   8625:         const xmlChar *oldvalue, *oldendvalue;
                   8626: 
                   8627:         oldvalue = ctxt->state->value;
                   8628:         oldendvalue = ctxt->state->endvalue;
                   8629:         ctxt->state->value = (xmlChar *) value;
                   8630:         ctxt->state->endvalue = NULL;
                   8631:         ret = xmlRelaxNGValidateValue(ctxt, define->content);
                   8632:         ctxt->state->value = (xmlChar *) oldvalue;
                   8633:         ctxt->state->endvalue = (xmlChar *) oldendvalue;
                   8634:     }
                   8635:     if ((result != NULL) && (lib != NULL) && (lib->freef != NULL))
                   8636:         lib->freef(lib->data, result);
                   8637:     return (ret);
                   8638: }
                   8639: 
                   8640: /**
                   8641:  * xmlRelaxNGNextValue:
                   8642:  * @ctxt:  a Relax-NG validation context
                   8643:  *
                   8644:  * Skip to the next value when validating within a list
                   8645:  *
                   8646:  * Returns 0 if the operation succeeded or an error code.
                   8647:  */
                   8648: static int
                   8649: xmlRelaxNGNextValue(xmlRelaxNGValidCtxtPtr ctxt)
                   8650: {
                   8651:     xmlChar *cur;
                   8652: 
                   8653:     cur = ctxt->state->value;
                   8654:     if ((cur == NULL) || (ctxt->state->endvalue == NULL)) {
                   8655:         ctxt->state->value = NULL;
                   8656:         ctxt->state->endvalue = NULL;
                   8657:         return (0);
                   8658:     }
                   8659:     while (*cur != 0)
                   8660:         cur++;
                   8661:     while ((cur != ctxt->state->endvalue) && (*cur == 0))
                   8662:         cur++;
                   8663:     if (cur == ctxt->state->endvalue)
                   8664:         ctxt->state->value = NULL;
                   8665:     else
                   8666:         ctxt->state->value = cur;
                   8667:     return (0);
                   8668: }
                   8669: 
                   8670: /**
                   8671:  * xmlRelaxNGValidateValueList:
                   8672:  * @ctxt:  a Relax-NG validation context
                   8673:  * @defines:  the list of definitions to verify
                   8674:  *
                   8675:  * Validate the given set of definitions for the current value
                   8676:  *
                   8677:  * Returns 0 if the validation succeeded or an error code.
                   8678:  */
                   8679: static int
                   8680: xmlRelaxNGValidateValueList(xmlRelaxNGValidCtxtPtr ctxt,
                   8681:                             xmlRelaxNGDefinePtr defines)
                   8682: {
                   8683:     int ret = 0;
                   8684: 
                   8685:     while (defines != NULL) {
                   8686:         ret = xmlRelaxNGValidateValue(ctxt, defines);
                   8687:         if (ret != 0)
                   8688:             break;
                   8689:         defines = defines->next;
                   8690:     }
                   8691:     return (ret);
                   8692: }
                   8693: 
                   8694: /**
                   8695:  * xmlRelaxNGValidateValue:
                   8696:  * @ctxt:  a Relax-NG validation context
                   8697:  * @define:  the definition to verify
                   8698:  *
                   8699:  * Validate the given definition for the current value
                   8700:  *
                   8701:  * Returns 0 if the validation succeeded or an error code.
                   8702:  */
                   8703: static int
                   8704: xmlRelaxNGValidateValue(xmlRelaxNGValidCtxtPtr ctxt,
                   8705:                         xmlRelaxNGDefinePtr define)
                   8706: {
                   8707:     int ret = 0, oldflags;
                   8708:     xmlChar *value;
                   8709: 
                   8710:     value = ctxt->state->value;
                   8711:     switch (define->type) {
                   8712:         case XML_RELAXNG_EMPTY:{
                   8713:                 if ((value != NULL) && (value[0] != 0)) {
                   8714:                     int idx = 0;
                   8715: 
                   8716:                     while (IS_BLANK_CH(value[idx]))
                   8717:                         idx++;
                   8718:                     if (value[idx] != 0)
                   8719:                         ret = -1;
                   8720:                 }
                   8721:                 break;
                   8722:             }
                   8723:         case XML_RELAXNG_TEXT:
                   8724:             break;
                   8725:         case XML_RELAXNG_VALUE:{
                   8726:                 if (!xmlStrEqual(value, define->value)) {
                   8727:                     if (define->name != NULL) {
                   8728:                         xmlRelaxNGTypeLibraryPtr lib;
                   8729: 
                   8730:                         lib = (xmlRelaxNGTypeLibraryPtr) define->data;
                   8731:                         if ((lib != NULL) && (lib->comp != NULL)) {
                   8732:                             ret = lib->comp(lib->data, define->name,
                   8733:                                             define->value, define->node,
                   8734:                                             (void *) define->attrs,
                   8735:                                             value, ctxt->state->node);
                   8736:                         } else
                   8737:                             ret = -1;
                   8738:                         if (ret < 0) {
                   8739:                             VALID_ERR2(XML_RELAXNG_ERR_TYPECMP,
                   8740:                                        define->name);
                   8741:                             return (-1);
                   8742:                         } else if (ret == 1) {
                   8743:                             ret = 0;
                   8744:                         } else {
                   8745:                             ret = -1;
                   8746:                         }
                   8747:                     } else {
                   8748:                         xmlChar *nval, *nvalue;
                   8749: 
                   8750:                         /*
                   8751:                          * TODO: trivial optimizations are possible by
                   8752:                          * computing at compile-time
                   8753:                          */
                   8754:                         nval = xmlRelaxNGNormalize(ctxt, define->value);
                   8755:                         nvalue = xmlRelaxNGNormalize(ctxt, value);
                   8756: 
                   8757:                         if ((nval == NULL) || (nvalue == NULL) ||
                   8758:                             (!xmlStrEqual(nval, nvalue)))
                   8759:                             ret = -1;
                   8760:                         if (nval != NULL)
                   8761:                             xmlFree(nval);
                   8762:                         if (nvalue != NULL)
                   8763:                             xmlFree(nvalue);
                   8764:                     }
                   8765:                 }
                   8766:                 if (ret == 0)
                   8767:                     xmlRelaxNGNextValue(ctxt);
                   8768:                 break;
                   8769:             }
                   8770:         case XML_RELAXNG_DATATYPE:{
                   8771:                 ret = xmlRelaxNGValidateDatatype(ctxt, value, define,
                   8772:                                                  ctxt->state->seq);
                   8773:                 if (ret == 0)
                   8774:                     xmlRelaxNGNextValue(ctxt);
                   8775: 
                   8776:                 break;
                   8777:             }
                   8778:         case XML_RELAXNG_CHOICE:{
                   8779:                 xmlRelaxNGDefinePtr list = define->content;
                   8780:                 xmlChar *oldvalue;
                   8781: 
                   8782:                 oldflags = ctxt->flags;
                   8783:                 ctxt->flags |= FLAGS_IGNORABLE;
                   8784: 
                   8785:                 oldvalue = ctxt->state->value;
                   8786:                 while (list != NULL) {
                   8787:                     ret = xmlRelaxNGValidateValue(ctxt, list);
                   8788:                     if (ret == 0) {
                   8789:                         break;
                   8790:                     }
                   8791:                     ctxt->state->value = oldvalue;
                   8792:                     list = list->next;
                   8793:                 }
                   8794:                 ctxt->flags = oldflags;
                   8795:                 if (ret != 0) {
                   8796:                     if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
                   8797:                         xmlRelaxNGDumpValidError(ctxt);
                   8798:                 } else {
                   8799:                     if (ctxt->errNr > 0)
                   8800:                         xmlRelaxNGPopErrors(ctxt, 0);
                   8801:                 }
                   8802:                 break;
                   8803:             }
                   8804:         case XML_RELAXNG_LIST:{
                   8805:                 xmlRelaxNGDefinePtr list = define->content;
                   8806:                 xmlChar *oldvalue, *oldend, *val, *cur;
                   8807: 
                   8808: #ifdef DEBUG_LIST
                   8809:                 int nb_values = 0;
                   8810: #endif
                   8811: 
                   8812:                 oldvalue = ctxt->state->value;
                   8813:                 oldend = ctxt->state->endvalue;
                   8814: 
                   8815:                 val = xmlStrdup(oldvalue);
                   8816:                 if (val == NULL) {
                   8817:                     val = xmlStrdup(BAD_CAST "");
                   8818:                 }
                   8819:                 if (val == NULL) {
                   8820:                     VALID_ERR(XML_RELAXNG_ERR_NOSTATE);
                   8821:                     return (-1);
                   8822:                 }
                   8823:                 cur = val;
                   8824:                 while (*cur != 0) {
                   8825:                     if (IS_BLANK_CH(*cur)) {
                   8826:                         *cur = 0;
                   8827:                         cur++;
                   8828: #ifdef DEBUG_LIST
                   8829:                         nb_values++;
                   8830: #endif
                   8831:                         while (IS_BLANK_CH(*cur))
                   8832:                             *cur++ = 0;
                   8833:                     } else
                   8834:                         cur++;
                   8835:                 }
                   8836: #ifdef DEBUG_LIST
                   8837:                 xmlGenericError(xmlGenericErrorContext,
                   8838:                                 "list value: '%s' found %d items\n",
                   8839:                                 oldvalue, nb_values);
                   8840:                 nb_values = 0;
                   8841: #endif
                   8842:                 ctxt->state->endvalue = cur;
                   8843:                 cur = val;
                   8844:                 while ((*cur == 0) && (cur != ctxt->state->endvalue))
                   8845:                     cur++;
                   8846: 
                   8847:                 ctxt->state->value = cur;
                   8848: 
                   8849:                 while (list != NULL) {
                   8850:                     if (ctxt->state->value == ctxt->state->endvalue)
                   8851:                         ctxt->state->value = NULL;
                   8852:                     ret = xmlRelaxNGValidateValue(ctxt, list);
                   8853:                     if (ret != 0) {
                   8854: #ifdef DEBUG_LIST
                   8855:                         xmlGenericError(xmlGenericErrorContext,
                   8856:                                         "Failed to validate value: '%s' with %d rule\n",
                   8857:                                         ctxt->state->value, nb_values);
                   8858: #endif
                   8859:                         break;
                   8860:                     }
                   8861: #ifdef DEBUG_LIST
                   8862:                     nb_values++;
                   8863: #endif
                   8864:                     list = list->next;
                   8865:                 }
                   8866: 
                   8867:                 if ((ret == 0) && (ctxt->state->value != NULL) &&
                   8868:                     (ctxt->state->value != ctxt->state->endvalue)) {
                   8869:                     VALID_ERR2(XML_RELAXNG_ERR_LISTEXTRA,
                   8870:                                ctxt->state->value);
                   8871:                     ret = -1;
                   8872:                 }
                   8873:                 xmlFree(val);
                   8874:                 ctxt->state->value = oldvalue;
                   8875:                 ctxt->state->endvalue = oldend;
                   8876:                 break;
                   8877:             }
                   8878:         case XML_RELAXNG_ONEORMORE:
                   8879:             ret = xmlRelaxNGValidateValueList(ctxt, define->content);
                   8880:             if (ret != 0) {
                   8881:                 break;
                   8882:             }
                   8883:             /* no break on purpose */
                   8884:         case XML_RELAXNG_ZEROORMORE:{
                   8885:                 xmlChar *cur, *temp;
                   8886: 
                   8887:                 oldflags = ctxt->flags;
                   8888:                 ctxt->flags |= FLAGS_IGNORABLE;
                   8889:                 cur = ctxt->state->value;
                   8890:                 temp = NULL;
                   8891:                 while ((cur != NULL) && (cur != ctxt->state->endvalue) &&
                   8892:                        (temp != cur)) {
                   8893:                     temp = cur;
                   8894:                     ret =
                   8895:                         xmlRelaxNGValidateValueList(ctxt, define->content);
                   8896:                     if (ret != 0) {
                   8897:                         ctxt->state->value = temp;
                   8898:                         ret = 0;
                   8899:                         break;
                   8900:                     }
                   8901:                     cur = ctxt->state->value;
                   8902:                 }
                   8903:                 ctxt->flags = oldflags;
                   8904:                if (ctxt->errNr > 0)
                   8905:                    xmlRelaxNGPopErrors(ctxt, 0);
                   8906:                 break;
                   8907:             }
                   8908:         case XML_RELAXNG_EXCEPT:{
                   8909:                 xmlRelaxNGDefinePtr list;
                   8910: 
                   8911:                 list = define->content;
                   8912:                 while (list != NULL) {
                   8913:                     ret = xmlRelaxNGValidateValue(ctxt, list);
                   8914:                     if (ret == 0) {
                   8915:                         ret = -1;
                   8916:                         break;
                   8917:                     } else
                   8918:                         ret = 0;
                   8919:                     list = list->next;
                   8920:                 }
                   8921:                 break;
                   8922:             }
                   8923:         case XML_RELAXNG_DEF:
                   8924:         case XML_RELAXNG_GROUP:{
                   8925:                 xmlRelaxNGDefinePtr list;
                   8926: 
                   8927:                 list = define->content;
                   8928:                 while (list != NULL) {
                   8929:                     ret = xmlRelaxNGValidateValue(ctxt, list);
                   8930:                     if (ret != 0) {
                   8931:                         ret = -1;
                   8932:                         break;
                   8933:                     } else
                   8934:                         ret = 0;
                   8935:                     list = list->next;
                   8936:                 }
                   8937:                 break;
                   8938:             }
                   8939:         case XML_RELAXNG_REF:
                   8940:         case XML_RELAXNG_PARENTREF:
                   8941:            if (define->content == NULL) {
                   8942:                 VALID_ERR(XML_RELAXNG_ERR_NODEFINE);
                   8943:                 ret = -1;
                   8944:            } else {
                   8945:                 ret = xmlRelaxNGValidateValue(ctxt, define->content);
                   8946:             }
                   8947:             break;
                   8948:         default:
                   8949:             TODO ret = -1;
                   8950:     }
                   8951:     return (ret);
                   8952: }
                   8953: 
                   8954: /**
                   8955:  * xmlRelaxNGValidateValueContent:
                   8956:  * @ctxt:  a Relax-NG validation context
                   8957:  * @defines:  the list of definitions to verify
                   8958:  *
                   8959:  * Validate the given definitions for the current value
                   8960:  *
                   8961:  * Returns 0 if the validation succeeded or an error code.
                   8962:  */
                   8963: static int
                   8964: xmlRelaxNGValidateValueContent(xmlRelaxNGValidCtxtPtr ctxt,
                   8965:                                xmlRelaxNGDefinePtr defines)
                   8966: {
                   8967:     int ret = 0;
                   8968: 
                   8969:     while (defines != NULL) {
                   8970:         ret = xmlRelaxNGValidateValue(ctxt, defines);
                   8971:         if (ret != 0)
                   8972:             break;
                   8973:         defines = defines->next;
                   8974:     }
                   8975:     return (ret);
                   8976: }
                   8977: 
                   8978: /**
                   8979:  * xmlRelaxNGAttributeMatch:
                   8980:  * @ctxt:  a Relax-NG validation context
                   8981:  * @define:  the definition to check
                   8982:  * @prop:  the attribute
                   8983:  *
                   8984:  * Check if the attribute matches the definition nameClass
                   8985:  *
                   8986:  * Returns 1 if the attribute matches, 0 if no, or -1 in case of error
                   8987:  */
                   8988: static int
                   8989: xmlRelaxNGAttributeMatch(xmlRelaxNGValidCtxtPtr ctxt,
                   8990:                          xmlRelaxNGDefinePtr define, xmlAttrPtr prop)
                   8991: {
                   8992:     int ret;
                   8993: 
                   8994:     if (define->name != NULL) {
                   8995:         if (!xmlStrEqual(define->name, prop->name))
                   8996:             return (0);
                   8997:     }
                   8998:     if (define->ns != NULL) {
                   8999:         if (define->ns[0] == 0) {
                   9000:             if (prop->ns != NULL)
                   9001:                 return (0);
                   9002:         } else {
                   9003:             if ((prop->ns == NULL) ||
                   9004:                 (!xmlStrEqual(define->ns, prop->ns->href)))
                   9005:                 return (0);
                   9006:         }
                   9007:     }
                   9008:     if (define->nameClass == NULL)
                   9009:         return (1);
                   9010:     define = define->nameClass;
                   9011:     if (define->type == XML_RELAXNG_EXCEPT) {
                   9012:         xmlRelaxNGDefinePtr list;
                   9013: 
                   9014:         list = define->content;
                   9015:         while (list != NULL) {
                   9016:             ret = xmlRelaxNGAttributeMatch(ctxt, list, prop);
                   9017:             if (ret == 1)
                   9018:                 return (0);
                   9019:             if (ret < 0)
                   9020:                 return (ret);
                   9021:             list = list->next;
                   9022:         }
                   9023:     } else {
                   9024:     TODO}
                   9025:     return (1);
                   9026: }
                   9027: 
                   9028: /**
                   9029:  * xmlRelaxNGValidateAttribute:
                   9030:  * @ctxt:  a Relax-NG validation context
                   9031:  * @define:  the definition to verify
                   9032:  *
                   9033:  * Validate the given attribute definition for that node
                   9034:  *
                   9035:  * Returns 0 if the validation succeeded or an error code.
                   9036:  */
                   9037: static int
                   9038: xmlRelaxNGValidateAttribute(xmlRelaxNGValidCtxtPtr ctxt,
                   9039:                             xmlRelaxNGDefinePtr define)
                   9040: {
                   9041:     int ret = 0, i;
                   9042:     xmlChar *value, *oldvalue;
                   9043:     xmlAttrPtr prop = NULL, tmp;
                   9044:     xmlNodePtr oldseq;
                   9045: 
                   9046:     if (ctxt->state->nbAttrLeft <= 0)
                   9047:         return (-1);
                   9048:     if (define->name != NULL) {
                   9049:         for (i = 0; i < ctxt->state->nbAttrs; i++) {
                   9050:             tmp = ctxt->state->attrs[i];
                   9051:             if ((tmp != NULL) && (xmlStrEqual(define->name, tmp->name))) {
                   9052:                 if ((((define->ns == NULL) || (define->ns[0] == 0)) &&
                   9053:                      (tmp->ns == NULL)) ||
                   9054:                     ((tmp->ns != NULL) &&
                   9055:                      (xmlStrEqual(define->ns, tmp->ns->href)))) {
                   9056:                     prop = tmp;
                   9057:                     break;
                   9058:                 }
                   9059:             }
                   9060:         }
                   9061:         if (prop != NULL) {
                   9062:             value = xmlNodeListGetString(prop->doc, prop->children, 1);
                   9063:             oldvalue = ctxt->state->value;
                   9064:             oldseq = ctxt->state->seq;
                   9065:             ctxt->state->seq = (xmlNodePtr) prop;
                   9066:             ctxt->state->value = value;
                   9067:             ctxt->state->endvalue = NULL;
                   9068:             ret = xmlRelaxNGValidateValueContent(ctxt, define->content);
                   9069:             if (ctxt->state->value != NULL)
                   9070:                 value = ctxt->state->value;
                   9071:             if (value != NULL)
                   9072:                 xmlFree(value);
                   9073:             ctxt->state->value = oldvalue;
                   9074:             ctxt->state->seq = oldseq;
                   9075:             if (ret == 0) {
                   9076:                 /*
                   9077:                  * flag the attribute as processed
                   9078:                  */
                   9079:                 ctxt->state->attrs[i] = NULL;
                   9080:                 ctxt->state->nbAttrLeft--;
                   9081:             }
                   9082:         } else {
                   9083:             ret = -1;
                   9084:         }
                   9085: #ifdef DEBUG
                   9086:         xmlGenericError(xmlGenericErrorContext,
                   9087:                         "xmlRelaxNGValidateAttribute(%s): %d\n",
                   9088:                         define->name, ret);
                   9089: #endif
                   9090:     } else {
                   9091:         for (i = 0; i < ctxt->state->nbAttrs; i++) {
                   9092:             tmp = ctxt->state->attrs[i];
                   9093:             if ((tmp != NULL) &&
                   9094:                 (xmlRelaxNGAttributeMatch(ctxt, define, tmp) == 1)) {
                   9095:                 prop = tmp;
                   9096:                 break;
                   9097:             }
                   9098:         }
                   9099:         if (prop != NULL) {
                   9100:             value = xmlNodeListGetString(prop->doc, prop->children, 1);
                   9101:             oldvalue = ctxt->state->value;
                   9102:             oldseq = ctxt->state->seq;
                   9103:             ctxt->state->seq = (xmlNodePtr) prop;
                   9104:             ctxt->state->value = value;
                   9105:             ret = xmlRelaxNGValidateValueContent(ctxt, define->content);
                   9106:             if (ctxt->state->value != NULL)
                   9107:                 value = ctxt->state->value;
                   9108:             if (value != NULL)
                   9109:                 xmlFree(value);
                   9110:             ctxt->state->value = oldvalue;
                   9111:             ctxt->state->seq = oldseq;
                   9112:             if (ret == 0) {
                   9113:                 /*
                   9114:                  * flag the attribute as processed
                   9115:                  */
                   9116:                 ctxt->state->attrs[i] = NULL;
                   9117:                 ctxt->state->nbAttrLeft--;
                   9118:             }
                   9119:         } else {
                   9120:             ret = -1;
                   9121:         }
                   9122: #ifdef DEBUG
                   9123:         if (define->ns != NULL) {
                   9124:             xmlGenericError(xmlGenericErrorContext,
                   9125:                             "xmlRelaxNGValidateAttribute(nsName ns = %s): %d\n",
                   9126:                             define->ns, ret);
                   9127:         } else {
                   9128:             xmlGenericError(xmlGenericErrorContext,
                   9129:                             "xmlRelaxNGValidateAttribute(anyName): %d\n",
                   9130:                             ret);
                   9131:         }
                   9132: #endif
                   9133:     }
                   9134: 
                   9135:     return (ret);
                   9136: }
                   9137: 
                   9138: /**
                   9139:  * xmlRelaxNGValidateAttributeList:
                   9140:  * @ctxt:  a Relax-NG validation context
                   9141:  * @define:  the list of definition to verify
                   9142:  *
                   9143:  * Validate the given node against the list of attribute definitions
                   9144:  *
                   9145:  * Returns 0 if the validation succeeded or an error code.
                   9146:  */
                   9147: static int
                   9148: xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
                   9149:                                 xmlRelaxNGDefinePtr defines)
                   9150: {
                   9151:     int ret = 0, res;
                   9152:     int needmore = 0;
                   9153:     xmlRelaxNGDefinePtr cur;
                   9154: 
                   9155:     cur = defines;
                   9156:     while (cur != NULL) {
                   9157:         if (cur->type == XML_RELAXNG_ATTRIBUTE) {
                   9158:             if (xmlRelaxNGValidateAttribute(ctxt, cur) != 0)
                   9159:                 ret = -1;
                   9160:         } else
                   9161:             needmore = 1;
                   9162:         cur = cur->next;
                   9163:     }
                   9164:     if (!needmore)
                   9165:         return (ret);
                   9166:     cur = defines;
                   9167:     while (cur != NULL) {
                   9168:         if (cur->type != XML_RELAXNG_ATTRIBUTE) {
                   9169:             if ((ctxt->state != NULL) || (ctxt->states != NULL)) {
                   9170:                 res = xmlRelaxNGValidateDefinition(ctxt, cur);
                   9171:                 if (res < 0)
                   9172:                     ret = -1;
                   9173:             } else {
                   9174:                 VALID_ERR(XML_RELAXNG_ERR_NOSTATE);
                   9175:                 return (-1);
                   9176:             }
                   9177:             if (res == -1)      /* continues on -2 */
                   9178:                 break;
                   9179:         }
                   9180:         cur = cur->next;
                   9181:     }
                   9182: 
                   9183:     return (ret);
                   9184: }
                   9185: 
                   9186: /**
                   9187:  * xmlRelaxNGNodeMatchesList:
                   9188:  * @node:  the node
                   9189:  * @list:  a NULL terminated array of definitions
                   9190:  *
                   9191:  * Check if a node can be matched by one of the definitions
                   9192:  *
                   9193:  * Returns 1 if matches 0 otherwise
                   9194:  */
                   9195: static int
                   9196: xmlRelaxNGNodeMatchesList(xmlNodePtr node, xmlRelaxNGDefinePtr * list)
                   9197: {
                   9198:     xmlRelaxNGDefinePtr cur;
                   9199:     int i = 0, tmp;
                   9200: 
                   9201:     if ((node == NULL) || (list == NULL))
                   9202:         return (0);
                   9203: 
                   9204:     cur = list[i++];
                   9205:     while (cur != NULL) {
                   9206:         if ((node->type == XML_ELEMENT_NODE) &&
                   9207:             (cur->type == XML_RELAXNG_ELEMENT)) {
                   9208:             tmp = xmlRelaxNGElementMatch(NULL, cur, node);
                   9209:             if (tmp == 1)
                   9210:                 return (1);
                   9211:         } else if (((node->type == XML_TEXT_NODE) ||
                   9212:                     (node->type == XML_CDATA_SECTION_NODE)) &&
                   9213:                    (cur->type == XML_RELAXNG_TEXT)) {
                   9214:             return (1);
                   9215:         }
                   9216:         cur = list[i++];
                   9217:     }
                   9218:     return (0);
                   9219: }
                   9220: 
                   9221: /**
                   9222:  * xmlRelaxNGValidateInterleave:
                   9223:  * @ctxt:  a Relax-NG validation context
                   9224:  * @define:  the definition to verify
                   9225:  *
                   9226:  * Validate an interleave definition for a node.
                   9227:  *
                   9228:  * Returns 0 if the validation succeeded or an error code.
                   9229:  */
                   9230: static int
                   9231: xmlRelaxNGValidateInterleave(xmlRelaxNGValidCtxtPtr ctxt,
                   9232:                              xmlRelaxNGDefinePtr define)
                   9233: {
                   9234:     int ret = 0, i, nbgroups;
                   9235:     int errNr = ctxt->errNr;
                   9236:     int oldflags;
                   9237: 
                   9238:     xmlRelaxNGValidStatePtr oldstate;
                   9239:     xmlRelaxNGPartitionPtr partitions;
                   9240:     xmlRelaxNGInterleaveGroupPtr group = NULL;
                   9241:     xmlNodePtr cur, start, last = NULL, lastchg = NULL, lastelem;
                   9242:     xmlNodePtr *list = NULL, *lasts = NULL;
                   9243: 
                   9244:     if (define->data != NULL) {
                   9245:         partitions = (xmlRelaxNGPartitionPtr) define->data;
                   9246:         nbgroups = partitions->nbgroups;
                   9247:     } else {
                   9248:         VALID_ERR(XML_RELAXNG_ERR_INTERNODATA);
                   9249:         return (-1);
                   9250:     }
                   9251:     /*
                   9252:      * Optimizations for MIXED
                   9253:      */
                   9254:     oldflags = ctxt->flags;
                   9255:     if (define->dflags & IS_MIXED) {
                   9256:         ctxt->flags |= FLAGS_MIXED_CONTENT;
                   9257:         if (nbgroups == 2) {
                   9258:             /*
                   9259:              * this is a pure <mixed> case
                   9260:              */
                   9261:             if (ctxt->state != NULL)
                   9262:                 ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt,
                   9263:                                                          ctxt->state->seq);
                   9264:             if (partitions->groups[0]->rule->type == XML_RELAXNG_TEXT)
                   9265:                 ret = xmlRelaxNGValidateDefinition(ctxt,
                   9266:                                                    partitions->groups[1]->
                   9267:                                                    rule);
                   9268:             else
                   9269:                 ret = xmlRelaxNGValidateDefinition(ctxt,
                   9270:                                                    partitions->groups[0]->
                   9271:                                                    rule);
                   9272:             if (ret == 0) {
                   9273:                 if (ctxt->state != NULL)
                   9274:                     ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt,
                   9275:                                                              ctxt->state->
                   9276:                                                              seq);
                   9277:             }
                   9278:             ctxt->flags = oldflags;
                   9279:             return (ret);
                   9280:         }
                   9281:     }
                   9282: 
                   9283:     /*
                   9284:      * Build arrays to store the first and last node of the chain
                   9285:      * pertaining to each group
                   9286:      */
                   9287:     list = (xmlNodePtr *) xmlMalloc(nbgroups * sizeof(xmlNodePtr));
                   9288:     if (list == NULL) {
                   9289:         xmlRngVErrMemory(ctxt, "validating\n");
                   9290:         return (-1);
                   9291:     }
                   9292:     memset(list, 0, nbgroups * sizeof(xmlNodePtr));
                   9293:     lasts = (xmlNodePtr *) xmlMalloc(nbgroups * sizeof(xmlNodePtr));
                   9294:     if (lasts == NULL) {
                   9295:         xmlRngVErrMemory(ctxt, "validating\n");
                   9296:         return (-1);
                   9297:     }
                   9298:     memset(lasts, 0, nbgroups * sizeof(xmlNodePtr));
                   9299: 
                   9300:     /*
                   9301:      * Walk the sequence of children finding the right group and
                   9302:      * sorting them in sequences.
                   9303:      */
                   9304:     cur = ctxt->state->seq;
                   9305:     cur = xmlRelaxNGSkipIgnored(ctxt, cur);
                   9306:     start = cur;
                   9307:     while (cur != NULL) {
                   9308:         ctxt->state->seq = cur;
                   9309:         if ((partitions->triage != NULL) &&
                   9310:             (partitions->flags & IS_DETERMINIST)) {
                   9311:             void *tmp = NULL;
                   9312: 
                   9313:             if ((cur->type == XML_TEXT_NODE) ||
                   9314:                 (cur->type == XML_CDATA_SECTION_NODE)) {
                   9315:                 tmp = xmlHashLookup2(partitions->triage, BAD_CAST "#text",
                   9316:                                      NULL);
                   9317:             } else if (cur->type == XML_ELEMENT_NODE) {
                   9318:                 if (cur->ns != NULL) {
                   9319:                     tmp = xmlHashLookup2(partitions->triage, cur->name,
                   9320:                                          cur->ns->href);
                   9321:                     if (tmp == NULL)
                   9322:                         tmp = xmlHashLookup2(partitions->triage,
                   9323:                                              BAD_CAST "#any",
                   9324:                                              cur->ns->href);
                   9325:                 } else
                   9326:                     tmp =
                   9327:                         xmlHashLookup2(partitions->triage, cur->name,
                   9328:                                        NULL);
                   9329:                 if (tmp == NULL)
                   9330:                     tmp =
                   9331:                         xmlHashLookup2(partitions->triage, BAD_CAST "#any",
                   9332:                                        NULL);
                   9333:             }
                   9334: 
                   9335:             if (tmp == NULL) {
                   9336:                 i = nbgroups;
                   9337:             } else {
                   9338:                 i = ((long) tmp) - 1;
                   9339:                 if (partitions->flags & IS_NEEDCHECK) {
                   9340:                     group = partitions->groups[i];
                   9341:                     if (!xmlRelaxNGNodeMatchesList(cur, group->defs))
                   9342:                         i = nbgroups;
                   9343:                 }
                   9344:             }
                   9345:         } else {
                   9346:             for (i = 0; i < nbgroups; i++) {
                   9347:                 group = partitions->groups[i];
                   9348:                 if (group == NULL)
                   9349:                     continue;
                   9350:                 if (xmlRelaxNGNodeMatchesList(cur, group->defs))
                   9351:                     break;
                   9352:             }
                   9353:         }
                   9354:         /*
                   9355:          * We break as soon as an element not matched is found
                   9356:          */
                   9357:         if (i >= nbgroups) {
                   9358:             break;
                   9359:         }
                   9360:         if (lasts[i] != NULL) {
                   9361:             lasts[i]->next = cur;
                   9362:             lasts[i] = cur;
                   9363:         } else {
                   9364:             list[i] = cur;
                   9365:             lasts[i] = cur;
                   9366:         }
                   9367:         if (cur->next != NULL)
                   9368:             lastchg = cur->next;
                   9369:         else
                   9370:             lastchg = cur;
                   9371:         cur = xmlRelaxNGSkipIgnored(ctxt, cur->next);
                   9372:     }
                   9373:     if (ret != 0) {
                   9374:         VALID_ERR(XML_RELAXNG_ERR_INTERSEQ);
                   9375:         ret = -1;
                   9376:         goto done;
                   9377:     }
                   9378:     lastelem = cur;
                   9379:     oldstate = ctxt->state;
                   9380:     for (i = 0; i < nbgroups; i++) {
                   9381:         ctxt->state = xmlRelaxNGCopyValidState(ctxt, oldstate);
                   9382:         group = partitions->groups[i];
                   9383:         if (lasts[i] != NULL) {
                   9384:             last = lasts[i]->next;
                   9385:             lasts[i]->next = NULL;
                   9386:         }
                   9387:         ctxt->state->seq = list[i];
                   9388:         ret = xmlRelaxNGValidateDefinition(ctxt, group->rule);
                   9389:         if (ret != 0)
                   9390:             break;
                   9391:         if (ctxt->state != NULL) {
                   9392:             cur = ctxt->state->seq;
                   9393:             cur = xmlRelaxNGSkipIgnored(ctxt, cur);
                   9394:             xmlRelaxNGFreeValidState(ctxt, oldstate);
                   9395:             oldstate = ctxt->state;
                   9396:             ctxt->state = NULL;
                   9397:             if (cur != NULL) {
                   9398:                 VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA, cur->name);
                   9399:                 ret = -1;
                   9400:                 ctxt->state = oldstate;
                   9401:                 goto done;
                   9402:             }
                   9403:         } else if (ctxt->states != NULL) {
                   9404:             int j;
                   9405:             int found = 0;
                   9406:            int best = -1;
                   9407:            int lowattr = -1;
                   9408: 
                   9409:            /*
                   9410:             * PBM: what happen if there is attributes checks in the interleaves
                   9411:             */
                   9412: 
                   9413:             for (j = 0; j < ctxt->states->nbState; j++) {
                   9414:                 cur = ctxt->states->tabState[j]->seq;
                   9415:                 cur = xmlRelaxNGSkipIgnored(ctxt, cur);
                   9416:                 if (cur == NULL) {
                   9417:                    if (found == 0) {
                   9418:                        lowattr = ctxt->states->tabState[j]->nbAttrLeft;
                   9419:                        best = j;
                   9420:                    }
                   9421:                     found = 1;
                   9422:                    if (ctxt->states->tabState[j]->nbAttrLeft <= lowattr) {
                   9423:                        /* try  to keep the latest one to mach old heuristic */
                   9424:                        lowattr = ctxt->states->tabState[j]->nbAttrLeft;
                   9425:                        best = j;
                   9426:                    }
                   9427:                     if (lowattr == 0)
                   9428:                        break;
                   9429:                 } else if (found == 0) {
                   9430:                     if (lowattr == -1) {
                   9431:                        lowattr = ctxt->states->tabState[j]->nbAttrLeft;
                   9432:                        best = j;
                   9433:                    } else
                   9434:                    if (ctxt->states->tabState[j]->nbAttrLeft <= lowattr)  {
                   9435:                        /* try  to keep the latest one to mach old heuristic */
                   9436:                        lowattr = ctxt->states->tabState[j]->nbAttrLeft;
                   9437:                        best = j;
                   9438:                    }
                   9439:                }
                   9440:             }
                   9441:            /*
                   9442:             * BIG PBM: here we pick only one restarting point :-(
                   9443:             */
                   9444:             if (ctxt->states->nbState > 0) {
                   9445:                 xmlRelaxNGFreeValidState(ctxt, oldstate);
                   9446:                if (best != -1) {
                   9447:                    oldstate = ctxt->states->tabState[best];
                   9448:                    ctxt->states->tabState[best] = NULL;
                   9449:                } else {
                   9450:                    oldstate =
                   9451:                        ctxt->states->tabState[ctxt->states->nbState - 1];
                   9452:                     ctxt->states->tabState[ctxt->states->nbState - 1] = NULL;
                   9453:                     ctxt->states->nbState--;
                   9454:                }
                   9455:             }
                   9456:             for (j = 0; j < ctxt->states->nbState ; j++) {
                   9457:                 xmlRelaxNGFreeValidState(ctxt, ctxt->states->tabState[j]);
                   9458:             }
                   9459:             xmlRelaxNGFreeStates(ctxt, ctxt->states);
                   9460:             ctxt->states = NULL;
                   9461:             if (found == 0) {
                   9462:                 if (cur == NULL) {
                   9463:                    VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA,
                   9464:                               (const xmlChar *) "noname");
                   9465:                 } else {
                   9466:                     VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA, cur->name);
                   9467:                 }
                   9468:                 ret = -1;
                   9469:                 ctxt->state = oldstate;
                   9470:                 goto done;
                   9471:             }
                   9472:         } else {
                   9473:             ret = -1;
                   9474:             break;
                   9475:         }
                   9476:         if (lasts[i] != NULL) {
                   9477:             lasts[i]->next = last;
                   9478:         }
                   9479:     }
                   9480:     if (ctxt->state != NULL)
                   9481:         xmlRelaxNGFreeValidState(ctxt, ctxt->state);
                   9482:     ctxt->state = oldstate;
                   9483:     ctxt->state->seq = lastelem;
                   9484:     if (ret != 0) {
                   9485:         VALID_ERR(XML_RELAXNG_ERR_INTERSEQ);
                   9486:         ret = -1;
                   9487:         goto done;
                   9488:     }
                   9489: 
                   9490:   done:
                   9491:     ctxt->flags = oldflags;
                   9492:     /*
                   9493:      * builds the next links chain from the prev one
                   9494:      */
                   9495:     cur = lastchg;
                   9496:     while (cur != NULL) {
                   9497:         if ((cur == start) || (cur->prev == NULL))
                   9498:             break;
                   9499:         cur->prev->next = cur;
                   9500:         cur = cur->prev;
                   9501:     }
                   9502:     if (ret == 0) {
                   9503:         if (ctxt->errNr > errNr)
                   9504:             xmlRelaxNGPopErrors(ctxt, errNr);
                   9505:     }
                   9506: 
                   9507:     xmlFree(list);
                   9508:     xmlFree(lasts);
                   9509:     return (ret);
                   9510: }
                   9511: 
                   9512: /**
                   9513:  * xmlRelaxNGValidateDefinitionList:
                   9514:  * @ctxt:  a Relax-NG validation context
                   9515:  * @define:  the list of definition to verify
                   9516:  *
                   9517:  * Validate the given node content against the (list) of definitions
                   9518:  *
                   9519:  * Returns 0 if the validation succeeded or an error code.
                   9520:  */
                   9521: static int
                   9522: xmlRelaxNGValidateDefinitionList(xmlRelaxNGValidCtxtPtr ctxt,
                   9523:                                  xmlRelaxNGDefinePtr defines)
                   9524: {
                   9525:     int ret = 0, res;
                   9526: 
                   9527: 
                   9528:     if (defines == NULL) {
                   9529:         VALID_ERR2(XML_RELAXNG_ERR_INTERNAL,
                   9530:                    BAD_CAST "NULL definition list");
                   9531:         return (-1);
                   9532:     }
                   9533:     while (defines != NULL) {
                   9534:         if ((ctxt->state != NULL) || (ctxt->states != NULL)) {
                   9535:             res = xmlRelaxNGValidateDefinition(ctxt, defines);
                   9536:             if (res < 0)
                   9537:                 ret = -1;
                   9538:         } else {
                   9539:             VALID_ERR(XML_RELAXNG_ERR_NOSTATE);
                   9540:             return (-1);
                   9541:         }
                   9542:         if (res == -1)          /* continues on -2 */
                   9543:             break;
                   9544:         defines = defines->next;
                   9545:     }
                   9546: 
                   9547:     return (ret);
                   9548: }
                   9549: 
                   9550: /**
                   9551:  * xmlRelaxNGElementMatch:
                   9552:  * @ctxt:  a Relax-NG validation context
                   9553:  * @define:  the definition to check
                   9554:  * @elem:  the element
                   9555:  *
                   9556:  * Check if the element matches the definition nameClass
                   9557:  *
                   9558:  * Returns 1 if the element matches, 0 if no, or -1 in case of error
                   9559:  */
                   9560: static int
                   9561: xmlRelaxNGElementMatch(xmlRelaxNGValidCtxtPtr ctxt,
                   9562:                        xmlRelaxNGDefinePtr define, xmlNodePtr elem)
                   9563: {
                   9564:     int ret = 0, oldflags = 0;
                   9565: 
                   9566:     if (define->name != NULL) {
                   9567:         if (!xmlStrEqual(elem->name, define->name)) {
                   9568:             VALID_ERR3(XML_RELAXNG_ERR_ELEMNAME, define->name, elem->name);
                   9569:             return (0);
                   9570:         }
                   9571:     }
                   9572:     if ((define->ns != NULL) && (define->ns[0] != 0)) {
                   9573:         if (elem->ns == NULL) {
                   9574:             VALID_ERR2(XML_RELAXNG_ERR_ELEMNONS, elem->name);
                   9575:             return (0);
                   9576:         } else if (!xmlStrEqual(elem->ns->href, define->ns)) {
                   9577:             VALID_ERR3(XML_RELAXNG_ERR_ELEMWRONGNS,
                   9578:                        elem->name, define->ns);
                   9579:             return (0);
                   9580:         }
                   9581:     } else if ((elem->ns != NULL) && (define->ns != NULL) &&
                   9582:                (define->name == NULL)) {
                   9583:         VALID_ERR2(XML_RELAXNG_ERR_ELEMEXTRANS, elem->name);
                   9584:         return (0);
                   9585:     } else if ((elem->ns != NULL) && (define->name != NULL)) {
                   9586:         VALID_ERR2(XML_RELAXNG_ERR_ELEMEXTRANS, define->name);
                   9587:         return (0);
                   9588:     }
                   9589: 
                   9590:     if (define->nameClass == NULL)
                   9591:         return (1);
                   9592: 
                   9593:     define = define->nameClass;
                   9594:     if (define->type == XML_RELAXNG_EXCEPT) {
                   9595:         xmlRelaxNGDefinePtr list;
                   9596: 
                   9597:         if (ctxt != NULL) {
                   9598:             oldflags = ctxt->flags;
                   9599:             ctxt->flags |= FLAGS_IGNORABLE;
                   9600:         }
                   9601: 
                   9602:         list = define->content;
                   9603:         while (list != NULL) {
                   9604:             ret = xmlRelaxNGElementMatch(ctxt, list, elem);
                   9605:             if (ret == 1) {
                   9606:                 if (ctxt != NULL)
                   9607:                     ctxt->flags = oldflags;
                   9608:                 return (0);
                   9609:             }
                   9610:             if (ret < 0) {
                   9611:                 if (ctxt != NULL)
                   9612:                     ctxt->flags = oldflags;
                   9613:                 return (ret);
                   9614:             }
                   9615:             list = list->next;
                   9616:         }
                   9617:         ret = 1;
                   9618:         if (ctxt != NULL) {
                   9619:             ctxt->flags = oldflags;
                   9620:         }
                   9621:     } else if (define->type == XML_RELAXNG_CHOICE) {
                   9622:         xmlRelaxNGDefinePtr list;
                   9623: 
                   9624:         if (ctxt != NULL) {
                   9625:             oldflags = ctxt->flags;
                   9626:             ctxt->flags |= FLAGS_IGNORABLE;
                   9627:         }
                   9628: 
                   9629:         list = define->nameClass;
                   9630:         while (list != NULL) {
                   9631:             ret = xmlRelaxNGElementMatch(ctxt, list, elem);
                   9632:             if (ret == 1) {
                   9633:                 if (ctxt != NULL)
                   9634:                     ctxt->flags = oldflags;
                   9635:                 return (1);
                   9636:             }
                   9637:             if (ret < 0) {
                   9638:                 if (ctxt != NULL)
                   9639:                     ctxt->flags = oldflags;
                   9640:                 return (ret);
                   9641:             }
                   9642:             list = list->next;
                   9643:         }
                   9644:         if (ctxt != NULL) {
                   9645:             if (ret != 0) {
                   9646:                 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
                   9647:                     xmlRelaxNGDumpValidError(ctxt);
                   9648:             } else {
                   9649:                 if (ctxt->errNr > 0)
                   9650:                     xmlRelaxNGPopErrors(ctxt, 0);
                   9651:             }
                   9652:         }
                   9653:         ret = 0;
                   9654:         if (ctxt != NULL) {
                   9655:             ctxt->flags = oldflags;
                   9656:         }
                   9657:     } else {
                   9658:         TODO ret = -1;
                   9659:     }
                   9660:     return (ret);
                   9661: }
                   9662: 
                   9663: /**
                   9664:  * xmlRelaxNGBestState:
                   9665:  * @ctxt:  a Relax-NG validation context
                   9666:  *
                   9667:  * Find the "best" state in the ctxt->states list of states to report
                   9668:  * errors about. I.e. a state with no element left in the child list
                   9669:  * or the one with the less attributes left.
                   9670:  * This is called only if a falidation error was detected
                   9671:  *
                   9672:  * Returns the index of the "best" state or -1 in case of error
                   9673:  */
                   9674: static int
                   9675: xmlRelaxNGBestState(xmlRelaxNGValidCtxtPtr ctxt)
                   9676: {
                   9677:     xmlRelaxNGValidStatePtr state;
                   9678:     int i, tmp;
                   9679:     int best = -1;
                   9680:     int value = 1000000;
                   9681: 
                   9682:     if ((ctxt == NULL) || (ctxt->states == NULL) ||
                   9683:         (ctxt->states->nbState <= 0))
                   9684:         return (-1);
                   9685: 
                   9686:     for (i = 0; i < ctxt->states->nbState; i++) {
                   9687:         state = ctxt->states->tabState[i];
                   9688:         if (state == NULL)
                   9689:             continue;
                   9690:         if (state->seq != NULL) {
                   9691:             if ((best == -1) || (value > 100000)) {
                   9692:                 value = 100000;
                   9693:                 best = i;
                   9694:             }
                   9695:         } else {
                   9696:             tmp = state->nbAttrLeft;
                   9697:             if ((best == -1) || (value > tmp)) {
                   9698:                 value = tmp;
                   9699:                 best = i;
                   9700:             }
                   9701:         }
                   9702:     }
                   9703:     return (best);
                   9704: }
                   9705: 
                   9706: /**
                   9707:  * xmlRelaxNGLogBestError:
                   9708:  * @ctxt:  a Relax-NG validation context
                   9709:  *
                   9710:  * Find the "best" state in the ctxt->states list of states to report
                   9711:  * errors about and log it.
                   9712:  */
                   9713: static void
                   9714: xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt)
                   9715: {
                   9716:     int best;
                   9717: 
                   9718:     if ((ctxt == NULL) || (ctxt->states == NULL) ||
                   9719:         (ctxt->states->nbState <= 0))
                   9720:         return;
                   9721: 
                   9722:     best = xmlRelaxNGBestState(ctxt);
                   9723:     if ((best >= 0) && (best < ctxt->states->nbState)) {
                   9724:         ctxt->state = ctxt->states->tabState[best];
                   9725: 
                   9726:         xmlRelaxNGValidateElementEnd(ctxt, 1);
                   9727:     }
                   9728: }
                   9729: 
                   9730: /**
                   9731:  * xmlRelaxNGValidateElementEnd:
                   9732:  * @ctxt:  a Relax-NG validation context
                   9733:  * @dolog:  indicate that error logging should be done
                   9734:  *
                   9735:  * Validate the end of the element, implements check that
                   9736:  * there is nothing left not consumed in the element content
                   9737:  * or in the attribute list.
                   9738:  *
                   9739:  * Returns 0 if the validation succeeded or an error code.
                   9740:  */
                   9741: static int
                   9742: xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt, int dolog)
                   9743: {
                   9744:     int i;
                   9745:     xmlRelaxNGValidStatePtr state;
                   9746: 
                   9747:     state = ctxt->state;
                   9748:     if (state->seq != NULL) {
                   9749:         state->seq = xmlRelaxNGSkipIgnored(ctxt, state->seq);
                   9750:         if (state->seq != NULL) {
                   9751:             if (dolog) {
                   9752:                 VALID_ERR3(XML_RELAXNG_ERR_EXTRACONTENT,
                   9753:                            state->node->name, state->seq->name);
                   9754:             }
                   9755:             return (-1);
                   9756:         }
                   9757:     }
                   9758:     for (i = 0; i < state->nbAttrs; i++) {
                   9759:         if (state->attrs[i] != NULL) {
                   9760:             if (dolog) {
                   9761:                 VALID_ERR3(XML_RELAXNG_ERR_INVALIDATTR,
                   9762:                            state->attrs[i]->name, state->node->name);
                   9763:             }
                   9764:             return (-1 - i);
                   9765:         }
                   9766:     }
                   9767:     return (0);
                   9768: }
                   9769: 
                   9770: /**
                   9771:  * xmlRelaxNGValidateState:
                   9772:  * @ctxt:  a Relax-NG validation context
                   9773:  * @define:  the definition to verify
                   9774:  *
                   9775:  * Validate the current state against the definition
                   9776:  *
                   9777:  * Returns 0 if the validation succeeded or an error code.
                   9778:  */
                   9779: static int
                   9780: xmlRelaxNGValidateState(xmlRelaxNGValidCtxtPtr ctxt,
                   9781:                         xmlRelaxNGDefinePtr define)
                   9782: {
                   9783:     xmlNodePtr node;
                   9784:     int ret = 0, i, tmp, oldflags, errNr;
                   9785:     xmlRelaxNGValidStatePtr oldstate = NULL, state;
                   9786: 
                   9787:     if (define == NULL) {
                   9788:         VALID_ERR(XML_RELAXNG_ERR_NODEFINE);
                   9789:         return (-1);
                   9790:     }
                   9791: 
                   9792:     if (ctxt->state != NULL) {
                   9793:         node = ctxt->state->seq;
                   9794:     } else {
                   9795:         node = NULL;
                   9796:     }
                   9797: #ifdef DEBUG
                   9798:     for (i = 0; i < ctxt->depth; i++)
                   9799:         xmlGenericError(xmlGenericErrorContext, " ");
                   9800:     xmlGenericError(xmlGenericErrorContext,
                   9801:                     "Start validating %s ", xmlRelaxNGDefName(define));
                   9802:     if (define->name != NULL)
                   9803:         xmlGenericError(xmlGenericErrorContext, "%s ", define->name);
                   9804:     if ((node != NULL) && (node->name != NULL))
                   9805:         xmlGenericError(xmlGenericErrorContext, "on %s\n", node->name);
                   9806:     else
                   9807:         xmlGenericError(xmlGenericErrorContext, "\n");
                   9808: #endif
                   9809:     ctxt->depth++;
                   9810:     switch (define->type) {
                   9811:         case XML_RELAXNG_EMPTY:
                   9812:             node = xmlRelaxNGSkipIgnored(ctxt, node);
                   9813:             ret = 0;
                   9814:             break;
                   9815:         case XML_RELAXNG_NOT_ALLOWED:
                   9816:             ret = -1;
                   9817:             break;
                   9818:         case XML_RELAXNG_TEXT:
                   9819:             while ((node != NULL) &&
                   9820:                    ((node->type == XML_TEXT_NODE) ||
                   9821:                     (node->type == XML_COMMENT_NODE) ||
                   9822:                     (node->type == XML_PI_NODE) ||
                   9823:                     (node->type == XML_CDATA_SECTION_NODE)))
                   9824:                 node = node->next;
                   9825:             ctxt->state->seq = node;
                   9826:             break;
                   9827:         case XML_RELAXNG_ELEMENT:
                   9828:             errNr = ctxt->errNr;
                   9829:             node = xmlRelaxNGSkipIgnored(ctxt, node);
                   9830:             if (node == NULL) {
                   9831:                 VALID_ERR2(XML_RELAXNG_ERR_NOELEM, define->name);
                   9832:                 ret = -1;
                   9833:                 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
                   9834:                     xmlRelaxNGDumpValidError(ctxt);
                   9835:                 break;
                   9836:             }
                   9837:             if (node->type != XML_ELEMENT_NODE) {
                   9838:                 VALID_ERR(XML_RELAXNG_ERR_NOTELEM);
                   9839:                 ret = -1;
                   9840:                 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
                   9841:                     xmlRelaxNGDumpValidError(ctxt);
                   9842:                 break;
                   9843:             }
                   9844:             /*
                   9845:              * This node was already validated successfully against
                   9846:              * this definition.
                   9847:              */
                   9848:             if (node->psvi == define) {
                   9849:                 ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt, node->next);
                   9850:                 if (ctxt->errNr > errNr)
                   9851:                     xmlRelaxNGPopErrors(ctxt, errNr);
                   9852:                 if (ctxt->errNr != 0) {
                   9853:                     while ((ctxt->err != NULL) &&
                   9854:                            (((ctxt->err->err == XML_RELAXNG_ERR_ELEMNAME)
                   9855:                              && (xmlStrEqual(ctxt->err->arg2, node->name)))
                   9856:                             ||
                   9857:                             ((ctxt->err->err ==
                   9858:                               XML_RELAXNG_ERR_ELEMEXTRANS)
                   9859:                              && (xmlStrEqual(ctxt->err->arg1, node->name)))
                   9860:                             || (ctxt->err->err == XML_RELAXNG_ERR_NOELEM)
                   9861:                             || (ctxt->err->err ==
                   9862:                                 XML_RELAXNG_ERR_NOTELEM)))
                   9863:                         xmlRelaxNGValidErrorPop(ctxt);
                   9864:                 }
                   9865:                 break;
                   9866:             }
                   9867: 
                   9868:             ret = xmlRelaxNGElementMatch(ctxt, define, node);
                   9869:             if (ret <= 0) {
                   9870:                 ret = -1;
                   9871:                 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
                   9872:                     xmlRelaxNGDumpValidError(ctxt);
                   9873:                 break;
                   9874:             }
                   9875:             ret = 0;
                   9876:             if (ctxt->errNr != 0) {
                   9877:                 if (ctxt->errNr > errNr)
                   9878:                     xmlRelaxNGPopErrors(ctxt, errNr);
                   9879:                 while ((ctxt->err != NULL) &&
                   9880:                        (((ctxt->err->err == XML_RELAXNG_ERR_ELEMNAME) &&
                   9881:                          (xmlStrEqual(ctxt->err->arg2, node->name))) ||
                   9882:                         ((ctxt->err->err == XML_RELAXNG_ERR_ELEMEXTRANS) &&
                   9883:                          (xmlStrEqual(ctxt->err->arg1, node->name))) ||
                   9884:                         (ctxt->err->err == XML_RELAXNG_ERR_NOELEM) ||
                   9885:                         (ctxt->err->err == XML_RELAXNG_ERR_NOTELEM)))
                   9886:                     xmlRelaxNGValidErrorPop(ctxt);
                   9887:             }
                   9888:             errNr = ctxt->errNr;
                   9889: 
                   9890:             oldflags = ctxt->flags;
                   9891:             if (ctxt->flags & FLAGS_MIXED_CONTENT) {
                   9892:                 ctxt->flags -= FLAGS_MIXED_CONTENT;
                   9893:             }
                   9894:             state = xmlRelaxNGNewValidState(ctxt, node);
                   9895:             if (state == NULL) {
                   9896:                 ret = -1;
                   9897:                 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
                   9898:                     xmlRelaxNGDumpValidError(ctxt);
                   9899:                 break;
                   9900:             }
                   9901: 
                   9902:             oldstate = ctxt->state;
                   9903:             ctxt->state = state;
                   9904:             if (define->attrs != NULL) {
                   9905:                 tmp = xmlRelaxNGValidateAttributeList(ctxt, define->attrs);
                   9906:                 if (tmp != 0) {
                   9907:                     ret = -1;
                   9908:                     VALID_ERR2(XML_RELAXNG_ERR_ATTRVALID, node->name);
                   9909:                 }
                   9910:             }
                   9911:             if (define->contModel != NULL) {
                   9912:                 xmlRelaxNGValidStatePtr nstate, tmpstate = ctxt->state;
                   9913:                 xmlRelaxNGStatesPtr tmpstates = ctxt->states;
                   9914:                 xmlNodePtr nseq;
                   9915: 
                   9916:                 nstate = xmlRelaxNGNewValidState(ctxt, node);
                   9917:                 ctxt->state = nstate;
                   9918:                 ctxt->states = NULL;
                   9919: 
                   9920:                 tmp = xmlRelaxNGValidateCompiledContent(ctxt,
                   9921:                                                         define->contModel,
                   9922:                                                         ctxt->state->seq);
                   9923:                 nseq = ctxt->state->seq;
                   9924:                 ctxt->state = tmpstate;
                   9925:                 ctxt->states = tmpstates;
                   9926:                 xmlRelaxNGFreeValidState(ctxt, nstate);
                   9927: 
                   9928: #ifdef DEBUG_COMPILE
                   9929:                 xmlGenericError(xmlGenericErrorContext,
                   9930:                                 "Validating content of '%s' : %d\n",
                   9931:                                 define->name, tmp);
                   9932: #endif
                   9933:                 if (tmp != 0)
                   9934:                     ret = -1;
                   9935: 
                   9936:                 if (ctxt->states != NULL) {
                   9937:                     tmp = -1;
                   9938: 
                   9939:                     for (i = 0; i < ctxt->states->nbState; i++) {
                   9940:                         state = ctxt->states->tabState[i];
                   9941:                         ctxt->state = state;
                   9942:                         ctxt->state->seq = nseq;
                   9943: 
                   9944:                         if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
                   9945:                             tmp = 0;
                   9946:                             break;
                   9947:                         }
                   9948:                     }
                   9949:                     if (tmp != 0) {
                   9950:                         /*
                   9951:                          * validation error, log the message for the "best" one
                   9952:                          */
                   9953:                         ctxt->flags |= FLAGS_IGNORABLE;
                   9954:                         xmlRelaxNGLogBestError(ctxt);
                   9955:                     }
                   9956:                     for (i = 0; i < ctxt->states->nbState; i++) {
                   9957:                         xmlRelaxNGFreeValidState(ctxt,
                   9958:                                                  ctxt->states->
                   9959:                                                  tabState[i]);
                   9960:                     }
                   9961:                     xmlRelaxNGFreeStates(ctxt, ctxt->states);
                   9962:                     ctxt->flags = oldflags;
                   9963:                     ctxt->states = NULL;
                   9964:                     if ((ret == 0) && (tmp == -1))
                   9965:                         ret = -1;
                   9966:                 } else {
                   9967:                     state = ctxt->state;
                   9968:                    if (ctxt->state != NULL)
                   9969:                        ctxt->state->seq = nseq;
                   9970:                     if (ret == 0)
                   9971:                         ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
                   9972:                     xmlRelaxNGFreeValidState(ctxt, state);
                   9973:                 }
                   9974:             } else {
                   9975:                 if (define->content != NULL) {
                   9976:                     tmp = xmlRelaxNGValidateDefinitionList(ctxt,
                   9977:                                                            define->
                   9978:                                                            content);
                   9979:                     if (tmp != 0) {
                   9980:                         ret = -1;
                   9981:                         if (ctxt->state == NULL) {
                   9982:                             ctxt->state = oldstate;
                   9983:                             VALID_ERR2(XML_RELAXNG_ERR_CONTENTVALID,
                   9984:                                        node->name);
                   9985:                             ctxt->state = NULL;
                   9986:                         } else {
                   9987:                             VALID_ERR2(XML_RELAXNG_ERR_CONTENTVALID,
                   9988:                                        node->name);
                   9989:                         }
                   9990: 
                   9991:                     }
                   9992:                 }
                   9993:                 if (ctxt->states != NULL) {
                   9994:                     tmp = -1;
                   9995: 
                   9996:                     for (i = 0; i < ctxt->states->nbState; i++) {
                   9997:                         state = ctxt->states->tabState[i];
                   9998:                         ctxt->state = state;
                   9999: 
                   10000:                         if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
                   10001:                             tmp = 0;
                   10002:                             break;
                   10003:                         }
                   10004:                     }
                   10005:                     if (tmp != 0) {
                   10006:                         /*
                   10007:                          * validation error, log the message for the "best" one
                   10008:                          */
                   10009:                         ctxt->flags |= FLAGS_IGNORABLE;
                   10010:                         xmlRelaxNGLogBestError(ctxt);
                   10011:                     }
                   10012:                     for (i = 0; i < ctxt->states->nbState; i++) {
                   10013:                         xmlRelaxNGFreeValidState(ctxt,
                   10014:                                                  ctxt->states->tabState[i]);
                   10015:                         ctxt->states->tabState[i] = NULL;
                   10016:                     }
                   10017:                     xmlRelaxNGFreeStates(ctxt, ctxt->states);
                   10018:                     ctxt->flags = oldflags;
                   10019:                     ctxt->states = NULL;
                   10020:                     if ((ret == 0) && (tmp == -1))
                   10021:                         ret = -1;
                   10022:                 } else {
                   10023:                     state = ctxt->state;
                   10024:                     if (ret == 0)
                   10025:                         ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
                   10026:                     xmlRelaxNGFreeValidState(ctxt, state);
                   10027:                 }
                   10028:             }
                   10029:             if (ret == 0) {
                   10030:                 node->psvi = define;
                   10031:             }
                   10032:             ctxt->flags = oldflags;
                   10033:             ctxt->state = oldstate;
                   10034:             if (oldstate != NULL)
                   10035:                 oldstate->seq = xmlRelaxNGSkipIgnored(ctxt, node->next);
                   10036:             if (ret != 0) {
                   10037:                 if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
                   10038:                     xmlRelaxNGDumpValidError(ctxt);
                   10039:                     ret = 0;
                   10040: #if 0
                   10041:                 } else {
                   10042:                     ret = -2;
                   10043: #endif
                   10044:                 }
                   10045:             } else {
                   10046:                 if (ctxt->errNr > errNr)
                   10047:                     xmlRelaxNGPopErrors(ctxt, errNr);
                   10048:             }
                   10049: 
                   10050: #ifdef DEBUG
                   10051:             xmlGenericError(xmlGenericErrorContext,
                   10052:                             "xmlRelaxNGValidateDefinition(): validated %s : %d",
                   10053:                             node->name, ret);
                   10054:             if (oldstate == NULL)
                   10055:                 xmlGenericError(xmlGenericErrorContext, ": no state\n");
                   10056:             else if (oldstate->seq == NULL)
                   10057:                 xmlGenericError(xmlGenericErrorContext, ": done\n");
                   10058:             else if (oldstate->seq->type == XML_ELEMENT_NODE)
                   10059:                 xmlGenericError(xmlGenericErrorContext, ": next elem %s\n",
                   10060:                                 oldstate->seq->name);
                   10061:             else
                   10062:                 xmlGenericError(xmlGenericErrorContext, ": next %s %d\n",
                   10063:                                 oldstate->seq->name, oldstate->seq->type);
                   10064: #endif
                   10065:             break;
                   10066:         case XML_RELAXNG_OPTIONAL:{
                   10067:                 errNr = ctxt->errNr;
                   10068:                 oldflags = ctxt->flags;
                   10069:                 ctxt->flags |= FLAGS_IGNORABLE;
                   10070:                 oldstate = xmlRelaxNGCopyValidState(ctxt, ctxt->state);
                   10071:                 ret =
                   10072:                     xmlRelaxNGValidateDefinitionList(ctxt,
                   10073:                                                      define->content);
                   10074:                 if (ret != 0) {
                   10075:                     if (ctxt->state != NULL)
                   10076:                         xmlRelaxNGFreeValidState(ctxt, ctxt->state);
                   10077:                     ctxt->state = oldstate;
                   10078:                     ctxt->flags = oldflags;
                   10079:                     ret = 0;
                   10080:                     if (ctxt->errNr > errNr)
                   10081:                         xmlRelaxNGPopErrors(ctxt, errNr);
                   10082:                     break;
                   10083:                 }
                   10084:                 if (ctxt->states != NULL) {
                   10085:                     xmlRelaxNGAddStates(ctxt, ctxt->states, oldstate);
                   10086:                 } else {
                   10087:                     ctxt->states = xmlRelaxNGNewStates(ctxt, 1);
                   10088:                     if (ctxt->states == NULL) {
                   10089:                         xmlRelaxNGFreeValidState(ctxt, oldstate);
                   10090:                         ctxt->flags = oldflags;
                   10091:                         ret = -1;
                   10092:                         if (ctxt->errNr > errNr)
                   10093:                             xmlRelaxNGPopErrors(ctxt, errNr);
                   10094:                         break;
                   10095:                     }
                   10096:                     xmlRelaxNGAddStates(ctxt, ctxt->states, oldstate);
                   10097:                     xmlRelaxNGAddStates(ctxt, ctxt->states, ctxt->state);
                   10098:                     ctxt->state = NULL;
                   10099:                 }
                   10100:                 ctxt->flags = oldflags;
                   10101:                 ret = 0;
                   10102:                 if (ctxt->errNr > errNr)
                   10103:                     xmlRelaxNGPopErrors(ctxt, errNr);
                   10104:                 break;
                   10105:             }
                   10106:         case XML_RELAXNG_ONEORMORE:
                   10107:             errNr = ctxt->errNr;
                   10108:             ret = xmlRelaxNGValidateDefinitionList(ctxt, define->content);
                   10109:             if (ret != 0) {
                   10110:                 break;
                   10111:             }
                   10112:             if (ctxt->errNr > errNr)
                   10113:                 xmlRelaxNGPopErrors(ctxt, errNr);
                   10114:             /* no break on purpose */
                   10115:         case XML_RELAXNG_ZEROORMORE:{
                   10116:                 int progress;
                   10117:                 xmlRelaxNGStatesPtr states = NULL, res = NULL;
                   10118:                 int base, j;
                   10119: 
                   10120:                 errNr = ctxt->errNr;
                   10121:                 res = xmlRelaxNGNewStates(ctxt, 1);
                   10122:                 if (res == NULL) {
                   10123:                     ret = -1;
                   10124:                     break;
                   10125:                 }
                   10126:                 /*
                   10127:                  * All the input states are also exit states
                   10128:                  */
                   10129:                 if (ctxt->state != NULL) {
                   10130:                     xmlRelaxNGAddStates(ctxt, res,
                   10131:                                         xmlRelaxNGCopyValidState(ctxt,
                   10132:                                                                  ctxt->
                   10133:                                                                  state));
                   10134:                 } else {
                   10135:                     for (j = 0; j < ctxt->states->nbState; j++) {
                   10136:                         xmlRelaxNGAddStates(ctxt, res,
                   10137:                             xmlRelaxNGCopyValidState(ctxt,
                   10138:                                             ctxt->states->tabState[j]));
                   10139:                     }
                   10140:                 }
                   10141:                 oldflags = ctxt->flags;
                   10142:                 ctxt->flags |= FLAGS_IGNORABLE;
                   10143:                 do {
                   10144:                     progress = 0;
                   10145:                     base = res->nbState;
                   10146: 
                   10147:                     if (ctxt->states != NULL) {
                   10148:                         states = ctxt->states;
                   10149:                         for (i = 0; i < states->nbState; i++) {
                   10150:                             ctxt->state = states->tabState[i];
                   10151:                             ctxt->states = NULL;
                   10152:                             ret = xmlRelaxNGValidateDefinitionList(ctxt,
                   10153:                                                                    define->
                   10154:                                                                    content);
                   10155:                             if (ret == 0) {
                   10156:                                 if (ctxt->state != NULL) {
                   10157:                                     tmp = xmlRelaxNGAddStates(ctxt, res,
                   10158:                                                               ctxt->state);
                   10159:                                     ctxt->state = NULL;
                   10160:                                     if (tmp == 1)
                   10161:                                         progress = 1;
                   10162:                                 } else if (ctxt->states != NULL) {
                   10163:                                     for (j = 0; j < ctxt->states->nbState;
                   10164:                                          j++) {
                   10165:                                         tmp =
                   10166:                                             xmlRelaxNGAddStates(ctxt, res,
                   10167:                                                    ctxt->states->tabState[j]);
                   10168:                                         if (tmp == 1)
                   10169:                                             progress = 1;
                   10170:                                     }
                   10171:                                     xmlRelaxNGFreeStates(ctxt,
                   10172:                                                          ctxt->states);
                   10173:                                     ctxt->states = NULL;
                   10174:                                 }
                   10175:                             } else {
                   10176:                                 if (ctxt->state != NULL) {
                   10177:                                     xmlRelaxNGFreeValidState(ctxt,
                   10178:                                                              ctxt->state);
                   10179:                                     ctxt->state = NULL;
                   10180:                                 }
                   10181:                             }
                   10182:                         }
                   10183:                     } else {
                   10184:                         ret = xmlRelaxNGValidateDefinitionList(ctxt,
                   10185:                                                                define->
                   10186:                                                                content);
                   10187:                         if (ret != 0) {
                   10188:                             xmlRelaxNGFreeValidState(ctxt, ctxt->state);
                   10189:                             ctxt->state = NULL;
                   10190:                         } else {
                   10191:                             base = res->nbState;
                   10192:                             if (ctxt->state != NULL) {
                   10193:                                 tmp = xmlRelaxNGAddStates(ctxt, res,
                   10194:                                                           ctxt->state);
                   10195:                                 ctxt->state = NULL;
                   10196:                                 if (tmp == 1)
                   10197:                                     progress = 1;
                   10198:                             } else if (ctxt->states != NULL) {
                   10199:                                 for (j = 0; j < ctxt->states->nbState; j++) {
                   10200:                                     tmp = xmlRelaxNGAddStates(ctxt, res,
                   10201:                                                ctxt->states->tabState[j]);
                   10202:                                     if (tmp == 1)
                   10203:                                         progress = 1;
                   10204:                                 }
                   10205:                                 if (states == NULL) {
                   10206:                                     states = ctxt->states;
                   10207:                                 } else {
                   10208:                                     xmlRelaxNGFreeStates(ctxt,
                   10209:                                                          ctxt->states);
                   10210:                                 }
                   10211:                                 ctxt->states = NULL;
                   10212:                             }
                   10213:                         }
                   10214:                     }
                   10215:                     if (progress) {
                   10216:                         /*
                   10217:                          * Collect all the new nodes added at that step
                   10218:                          * and make them the new node set
                   10219:                          */
                   10220:                         if (res->nbState - base == 1) {
                   10221:                             ctxt->state = xmlRelaxNGCopyValidState(ctxt,
                   10222:                                                                    res->
                   10223:                                                                    tabState
                   10224:                                                                    [base]);
                   10225:                         } else {
                   10226:                             if (states == NULL) {
                   10227:                                 xmlRelaxNGNewStates(ctxt,
                   10228:                                                     res->nbState - base);
                   10229:                                states = ctxt->states;
                   10230:                                if (states == NULL) {
                   10231:                                    progress = 0;
                   10232:                                    break;
                   10233:                                }
                   10234:                             }
                   10235:                             states->nbState = 0;
                   10236:                             for (i = base; i < res->nbState; i++)
                   10237:                                 xmlRelaxNGAddStates(ctxt, states,
                   10238:                                                     xmlRelaxNGCopyValidState
                   10239:                                                     (ctxt, res->tabState[i]));
                   10240:                             ctxt->states = states;
                   10241:                         }
                   10242:                     }
                   10243:                 } while (progress == 1);
                   10244:                 if (states != NULL) {
                   10245:                     xmlRelaxNGFreeStates(ctxt, states);
                   10246:                 }
                   10247:                 ctxt->states = res;
                   10248:                 ctxt->flags = oldflags;
                   10249: #if 0
                   10250:                 /*
                   10251:                  * errors may have to be propagated back...
                   10252:                  */
                   10253:                 if (ctxt->errNr > errNr)
                   10254:                     xmlRelaxNGPopErrors(ctxt, errNr);
                   10255: #endif
                   10256:                 ret = 0;
                   10257:                 break;
                   10258:             }
                   10259:         case XML_RELAXNG_CHOICE:{
                   10260:                 xmlRelaxNGDefinePtr list = NULL;
                   10261:                 xmlRelaxNGStatesPtr states = NULL;
                   10262: 
                   10263:                 node = xmlRelaxNGSkipIgnored(ctxt, node);
                   10264: 
                   10265:                 errNr = ctxt->errNr;
                   10266:                 if ((define->dflags & IS_TRIABLE) && (define->data != NULL) &&
                   10267:                    (node != NULL)) {
                   10268:                    /*
                   10269:                     * node == NULL can't be optimized since IS_TRIABLE
                   10270:                     * doesn't account for choice which may lead to
                   10271:                     * only attributes.
                   10272:                     */
                   10273:                     xmlHashTablePtr triage =
                   10274:                         (xmlHashTablePtr) define->data;
                   10275: 
                   10276:                     /*
                   10277:                      * Something we can optimize cleanly there is only one
                   10278:                      * possble branch out !
                   10279:                      */
                   10280:                     if ((node->type == XML_TEXT_NODE) ||
                   10281:                         (node->type == XML_CDATA_SECTION_NODE)) {
                   10282:                         list =
                   10283:                             xmlHashLookup2(triage, BAD_CAST "#text", NULL);
                   10284:                     } else if (node->type == XML_ELEMENT_NODE) {
                   10285:                         if (node->ns != NULL) {
                   10286:                             list = xmlHashLookup2(triage, node->name,
                   10287:                                                   node->ns->href);
                   10288:                             if (list == NULL)
                   10289:                                 list =
                   10290:                                     xmlHashLookup2(triage, BAD_CAST "#any",
                   10291:                                                    node->ns->href);
                   10292:                         } else
                   10293:                             list =
                   10294:                                 xmlHashLookup2(triage, node->name, NULL);
                   10295:                         if (list == NULL)
                   10296:                             list =
                   10297:                                 xmlHashLookup2(triage, BAD_CAST "#any",
                   10298:                                                NULL);
                   10299:                     }
                   10300:                     if (list == NULL) {
                   10301:                         ret = -1;
                   10302:                        VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, node->name);
                   10303:                         break;
                   10304:                     }
                   10305:                     ret = xmlRelaxNGValidateDefinition(ctxt, list);
                   10306:                     if (ret == 0) {
                   10307:                     }
                   10308:                     break;
                   10309:                 }
                   10310: 
                   10311:                 list = define->content;
                   10312:                 oldflags = ctxt->flags;
                   10313:                 ctxt->flags |= FLAGS_IGNORABLE;
                   10314: 
                   10315:                 while (list != NULL) {
                   10316:                     oldstate = xmlRelaxNGCopyValidState(ctxt, ctxt->state);
                   10317:                     ret = xmlRelaxNGValidateDefinition(ctxt, list);
                   10318:                     if (ret == 0) {
                   10319:                         if (states == NULL) {
                   10320:                             states = xmlRelaxNGNewStates(ctxt, 1);
                   10321:                         }
                   10322:                         if (ctxt->state != NULL) {
                   10323:                             xmlRelaxNGAddStates(ctxt, states, ctxt->state);
                   10324:                         } else if (ctxt->states != NULL) {
                   10325:                             for (i = 0; i < ctxt->states->nbState; i++) {
                   10326:                                 xmlRelaxNGAddStates(ctxt, states,
                   10327:                                                     ctxt->states->
                   10328:                                                     tabState[i]);
                   10329:                             }
                   10330:                             xmlRelaxNGFreeStates(ctxt, ctxt->states);
                   10331:                             ctxt->states = NULL;
                   10332:                         }
                   10333:                     } else {
                   10334:                         xmlRelaxNGFreeValidState(ctxt, ctxt->state);
                   10335:                     }
                   10336:                     ctxt->state = oldstate;
                   10337:                     list = list->next;
                   10338:                 }
                   10339:                 if (states != NULL) {
                   10340:                     xmlRelaxNGFreeValidState(ctxt, oldstate);
                   10341:                     ctxt->states = states;
                   10342:                     ctxt->state = NULL;
                   10343:                     ret = 0;
                   10344:                 } else {
                   10345:                     ctxt->states = NULL;
                   10346:                 }
                   10347:                 ctxt->flags = oldflags;
                   10348:                 if (ret != 0) {
                   10349:                     if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
                   10350:                         xmlRelaxNGDumpValidError(ctxt);
                   10351:                     }
                   10352:                 } else {
                   10353:                     if (ctxt->errNr > errNr)
                   10354:                         xmlRelaxNGPopErrors(ctxt, errNr);
                   10355:                 }
                   10356:                 break;
                   10357:             }
                   10358:         case XML_RELAXNG_DEF:
                   10359:         case XML_RELAXNG_GROUP:
                   10360:             ret = xmlRelaxNGValidateDefinitionList(ctxt, define->content);
                   10361:             break;
                   10362:         case XML_RELAXNG_INTERLEAVE:
                   10363:             ret = xmlRelaxNGValidateInterleave(ctxt, define);
                   10364:             break;
                   10365:         case XML_RELAXNG_ATTRIBUTE:
                   10366:             ret = xmlRelaxNGValidateAttribute(ctxt, define);
                   10367:             break;
                   10368:         case XML_RELAXNG_START:
                   10369:         case XML_RELAXNG_NOOP:
                   10370:         case XML_RELAXNG_REF:
                   10371:         case XML_RELAXNG_EXTERNALREF:
                   10372:         case XML_RELAXNG_PARENTREF:
                   10373:             ret = xmlRelaxNGValidateDefinition(ctxt, define->content);
                   10374:             break;
                   10375:         case XML_RELAXNG_DATATYPE:{
                   10376:                 xmlNodePtr child;
                   10377:                 xmlChar *content = NULL;
                   10378: 
                   10379:                 child = node;
                   10380:                 while (child != NULL) {
                   10381:                     if (child->type == XML_ELEMENT_NODE) {
                   10382:                         VALID_ERR2(XML_RELAXNG_ERR_DATAELEM,
                   10383:                                    node->parent->name);
                   10384:                         ret = -1;
                   10385:                         break;
                   10386:                     } else if ((child->type == XML_TEXT_NODE) ||
                   10387:                                (child->type == XML_CDATA_SECTION_NODE)) {
                   10388:                         content = xmlStrcat(content, child->content);
                   10389:                     }
                   10390:                     /* TODO: handle entities ... */
                   10391:                     child = child->next;
                   10392:                 }
                   10393:                 if (ret == -1) {
                   10394:                     if (content != NULL)
                   10395:                         xmlFree(content);
                   10396:                     break;
                   10397:                 }
                   10398:                 if (content == NULL) {
                   10399:                     content = xmlStrdup(BAD_CAST "");
                   10400:                     if (content == NULL) {
                   10401:                         xmlRngVErrMemory(ctxt, "validating\n");
                   10402:                         ret = -1;
                   10403:                         break;
                   10404:                     }
                   10405:                 }
                   10406:                 ret = xmlRelaxNGValidateDatatype(ctxt, content, define,
                   10407:                                                  ctxt->state->seq);
                   10408:                 if (ret == -1) {
                   10409:                     VALID_ERR2(XML_RELAXNG_ERR_DATATYPE, define->name);
                   10410:                 } else if (ret == 0) {
                   10411:                     ctxt->state->seq = NULL;
                   10412:                 }
                   10413:                 if (content != NULL)
                   10414:                     xmlFree(content);
                   10415:                 break;
                   10416:             }
                   10417:         case XML_RELAXNG_VALUE:{
                   10418:                 xmlChar *content = NULL;
                   10419:                 xmlChar *oldvalue;
                   10420:                 xmlNodePtr child;
                   10421: 
                   10422:                 child = node;
                   10423:                 while (child != NULL) {
                   10424:                     if (child->type == XML_ELEMENT_NODE) {
                   10425:                         VALID_ERR2(XML_RELAXNG_ERR_VALELEM,
                   10426:                                    node->parent->name);
                   10427:                         ret = -1;
                   10428:                         break;
                   10429:                     } else if ((child->type == XML_TEXT_NODE) ||
                   10430:                                (child->type == XML_CDATA_SECTION_NODE)) {
                   10431:                         content = xmlStrcat(content, child->content);
                   10432:                     }
                   10433:                     /* TODO: handle entities ... */
                   10434:                     child = child->next;
                   10435:                 }
                   10436:                 if (ret == -1) {
                   10437:                     if (content != NULL)
                   10438:                         xmlFree(content);
                   10439:                     break;
                   10440:                 }
                   10441:                 if (content == NULL) {
                   10442:                     content = xmlStrdup(BAD_CAST "");
                   10443:                     if (content == NULL) {
                   10444:                         xmlRngVErrMemory(ctxt, "validating\n");
                   10445:                         ret = -1;
                   10446:                         break;
                   10447:                     }
                   10448:                 }
                   10449:                 oldvalue = ctxt->state->value;
                   10450:                 ctxt->state->value = content;
                   10451:                 ret = xmlRelaxNGValidateValue(ctxt, define);
                   10452:                 ctxt->state->value = oldvalue;
                   10453:                 if (ret == -1) {
                   10454:                     VALID_ERR2(XML_RELAXNG_ERR_VALUE, define->name);
                   10455:                 } else if (ret == 0) {
                   10456:                     ctxt->state->seq = NULL;
                   10457:                 }
                   10458:                 if (content != NULL)
                   10459:                     xmlFree(content);
                   10460:                 break;
                   10461:             }
                   10462:         case XML_RELAXNG_LIST:{
                   10463:                 xmlChar *content;
                   10464:                 xmlNodePtr child;
                   10465:                 xmlChar *oldvalue, *oldendvalue;
                   10466:                 int len;
                   10467: 
                   10468:                 /*
                   10469:                  * Make sure it's only text nodes
                   10470:                  */
                   10471: 
                   10472:                 content = NULL;
                   10473:                 child = node;
                   10474:                 while (child != NULL) {
                   10475:                     if (child->type == XML_ELEMENT_NODE) {
                   10476:                         VALID_ERR2(XML_RELAXNG_ERR_LISTELEM,
                   10477:                                    node->parent->name);
                   10478:                         ret = -1;
                   10479:                         break;
                   10480:                     } else if ((child->type == XML_TEXT_NODE) ||
                   10481:                                (child->type == XML_CDATA_SECTION_NODE)) {
                   10482:                         content = xmlStrcat(content, child->content);
                   10483:                     }
                   10484:                     /* TODO: handle entities ... */
                   10485:                     child = child->next;
                   10486:                 }
                   10487:                 if (ret == -1) {
                   10488:                     if (content != NULL)
                   10489:                         xmlFree(content);
                   10490:                     break;
                   10491:                 }
                   10492:                 if (content == NULL) {
                   10493:                     content = xmlStrdup(BAD_CAST "");
                   10494:                     if (content == NULL) {
                   10495:                         xmlRngVErrMemory(ctxt, "validating\n");
                   10496:                         ret = -1;
                   10497:                         break;
                   10498:                     }
                   10499:                 }
                   10500:                 len = xmlStrlen(content);
                   10501:                 oldvalue = ctxt->state->value;
                   10502:                 oldendvalue = ctxt->state->endvalue;
                   10503:                 ctxt->state->value = content;
                   10504:                 ctxt->state->endvalue = content + len;
                   10505:                 ret = xmlRelaxNGValidateValue(ctxt, define);
                   10506:                 ctxt->state->value = oldvalue;
                   10507:                 ctxt->state->endvalue = oldendvalue;
                   10508:                 if (ret == -1) {
                   10509:                     VALID_ERR(XML_RELAXNG_ERR_LIST);
                   10510:                 } else if ((ret == 0) && (node != NULL)) {
                   10511:                     ctxt->state->seq = node->next;
                   10512:                 }
                   10513:                 if (content != NULL)
                   10514:                     xmlFree(content);
                   10515:                 break;
                   10516:             }
                   10517:         case XML_RELAXNG_EXCEPT:
                   10518:         case XML_RELAXNG_PARAM:
                   10519:             TODO ret = -1;
                   10520:             break;
                   10521:     }
                   10522:     ctxt->depth--;
                   10523: #ifdef DEBUG
                   10524:     for (i = 0; i < ctxt->depth; i++)
                   10525:         xmlGenericError(xmlGenericErrorContext, " ");
                   10526:     xmlGenericError(xmlGenericErrorContext,
                   10527:                     "Validating %s ", xmlRelaxNGDefName(define));
                   10528:     if (define->name != NULL)
                   10529:         xmlGenericError(xmlGenericErrorContext, "%s ", define->name);
                   10530:     if (ret == 0)
                   10531:         xmlGenericError(xmlGenericErrorContext, "suceeded\n");
                   10532:     else
                   10533:         xmlGenericError(xmlGenericErrorContext, "failed\n");
                   10534: #endif
                   10535:     return (ret);
                   10536: }
                   10537: 
                   10538: /**
                   10539:  * xmlRelaxNGValidateDefinition:
                   10540:  * @ctxt:  a Relax-NG validation context
                   10541:  * @define:  the definition to verify
                   10542:  *
                   10543:  * Validate the current node lists against the definition
                   10544:  *
                   10545:  * Returns 0 if the validation succeeded or an error code.
                   10546:  */
                   10547: static int
                   10548: xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt,
                   10549:                              xmlRelaxNGDefinePtr define)
                   10550: {
                   10551:     xmlRelaxNGStatesPtr states, res;
                   10552:     int i, j, k, ret, oldflags;
                   10553: 
                   10554:     /*
                   10555:      * We should NOT have both ctxt->state and ctxt->states
                   10556:      */
                   10557:     if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
                   10558:         TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
                   10559:         ctxt->state = NULL;
                   10560:     }
                   10561: 
                   10562:     if ((ctxt->states == NULL) || (ctxt->states->nbState == 1)) {
                   10563:         if (ctxt->states != NULL) {
                   10564:             ctxt->state = ctxt->states->tabState[0];
                   10565:             xmlRelaxNGFreeStates(ctxt, ctxt->states);
                   10566:             ctxt->states = NULL;
                   10567:         }
                   10568:         ret = xmlRelaxNGValidateState(ctxt, define);
                   10569:         if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
                   10570:             TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
                   10571:             ctxt->state = NULL;
                   10572:         }
                   10573:         if ((ctxt->states != NULL) && (ctxt->states->nbState == 1)) {
                   10574:             ctxt->state = ctxt->states->tabState[0];
                   10575:             xmlRelaxNGFreeStates(ctxt, ctxt->states);
                   10576:             ctxt->states = NULL;
                   10577:         }
                   10578:         return (ret);
                   10579:     }
                   10580: 
                   10581:     states = ctxt->states;
                   10582:     ctxt->states = NULL;
                   10583:     res = NULL;
                   10584:     j = 0;
                   10585:     oldflags = ctxt->flags;
                   10586:     ctxt->flags |= FLAGS_IGNORABLE;
                   10587:     for (i = 0; i < states->nbState; i++) {
                   10588:         ctxt->state = states->tabState[i];
                   10589:         ctxt->states = NULL;
                   10590:         ret = xmlRelaxNGValidateState(ctxt, define);
                   10591:         /*
                   10592:          * We should NOT have both ctxt->state and ctxt->states
                   10593:          */
                   10594:         if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
                   10595:             TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
                   10596:             ctxt->state = NULL;
                   10597:         }
                   10598:         if (ret == 0) {
                   10599:             if (ctxt->states == NULL) {
                   10600:                 if (res != NULL) {
                   10601:                     /* add the state to the container */
                   10602:                     xmlRelaxNGAddStates(ctxt, res, ctxt->state);
                   10603:                     ctxt->state = NULL;
                   10604:                 } else {
                   10605:                     /* add the state directly in states */
                   10606:                     states->tabState[j++] = ctxt->state;
                   10607:                     ctxt->state = NULL;
                   10608:                 }
                   10609:             } else {
                   10610:                 if (res == NULL) {
                   10611:                     /* make it the new container and copy other results */
                   10612:                     res = ctxt->states;
                   10613:                     ctxt->states = NULL;
                   10614:                     for (k = 0; k < j; k++)
                   10615:                         xmlRelaxNGAddStates(ctxt, res,
                   10616:                                             states->tabState[k]);
                   10617:                 } else {
                   10618:                     /* add all the new results to res and reff the container */
                   10619:                     for (k = 0; k < ctxt->states->nbState; k++)
                   10620:                         xmlRelaxNGAddStates(ctxt, res,
                   10621:                                             ctxt->states->tabState[k]);
                   10622:                     xmlRelaxNGFreeStates(ctxt, ctxt->states);
                   10623:                     ctxt->states = NULL;
                   10624:                 }
                   10625:             }
                   10626:         } else {
                   10627:             if (ctxt->state != NULL) {
                   10628:                 xmlRelaxNGFreeValidState(ctxt, ctxt->state);
                   10629:                 ctxt->state = NULL;
                   10630:             } else if (ctxt->states != NULL) {
                   10631:                 for (k = 0; k < ctxt->states->nbState; k++)
                   10632:                     xmlRelaxNGFreeValidState(ctxt,
                   10633:                                              ctxt->states->tabState[k]);
                   10634:                 xmlRelaxNGFreeStates(ctxt, ctxt->states);
                   10635:                 ctxt->states = NULL;
                   10636:             }
                   10637:         }
                   10638:     }
                   10639:     ctxt->flags = oldflags;
                   10640:     if (res != NULL) {
                   10641:         xmlRelaxNGFreeStates(ctxt, states);
                   10642:         ctxt->states = res;
                   10643:         ret = 0;
                   10644:     } else if (j > 1) {
                   10645:         states->nbState = j;
                   10646:         ctxt->states = states;
                   10647:         ret = 0;
                   10648:     } else if (j == 1) {
                   10649:         ctxt->state = states->tabState[0];
                   10650:         xmlRelaxNGFreeStates(ctxt, states);
                   10651:         ret = 0;
                   10652:     } else {
                   10653:         ret = -1;
                   10654:         xmlRelaxNGFreeStates(ctxt, states);
                   10655:         if (ctxt->states != NULL) {
                   10656:             xmlRelaxNGFreeStates(ctxt, ctxt->states);
                   10657:             ctxt->states = NULL;
                   10658:         }
                   10659:     }
                   10660:     if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
                   10661:         TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
                   10662:         ctxt->state = NULL;
                   10663:     }
                   10664:     return (ret);
                   10665: }
                   10666: 
                   10667: /**
                   10668:  * xmlRelaxNGValidateDocument:
                   10669:  * @ctxt:  a Relax-NG validation context
                   10670:  * @doc:  the document
                   10671:  *
                   10672:  * Validate the given document
                   10673:  *
                   10674:  * Returns 0 if the validation succeeded or an error code.
                   10675:  */
                   10676: static int
                   10677: xmlRelaxNGValidateDocument(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc)
                   10678: {
                   10679:     int ret;
                   10680:     xmlRelaxNGPtr schema;
                   10681:     xmlRelaxNGGrammarPtr grammar;
                   10682:     xmlRelaxNGValidStatePtr state;
                   10683:     xmlNodePtr node;
                   10684: 
                   10685:     if ((ctxt == NULL) || (ctxt->schema == NULL) || (doc == NULL))
                   10686:         return (-1);
                   10687: 
                   10688:     ctxt->errNo = XML_RELAXNG_OK;
                   10689:     schema = ctxt->schema;
                   10690:     grammar = schema->topgrammar;
                   10691:     if (grammar == NULL) {
                   10692:         VALID_ERR(XML_RELAXNG_ERR_NOGRAMMAR);
                   10693:         return (-1);
                   10694:     }
                   10695:     state = xmlRelaxNGNewValidState(ctxt, NULL);
                   10696:     ctxt->state = state;
                   10697:     ret = xmlRelaxNGValidateDefinition(ctxt, grammar->start);
                   10698:     if ((ctxt->state != NULL) && (state->seq != NULL)) {
                   10699:         state = ctxt->state;
                   10700:         node = state->seq;
                   10701:         node = xmlRelaxNGSkipIgnored(ctxt, node);
                   10702:         if (node != NULL) {
                   10703:             if (ret != -1) {
                   10704:                 VALID_ERR(XML_RELAXNG_ERR_EXTRADATA);
                   10705:                 ret = -1;
                   10706:             }
                   10707:         }
                   10708:     } else if (ctxt->states != NULL) {
                   10709:         int i;
                   10710:         int tmp = -1;
                   10711: 
                   10712:         for (i = 0; i < ctxt->states->nbState; i++) {
                   10713:             state = ctxt->states->tabState[i];
                   10714:             node = state->seq;
                   10715:             node = xmlRelaxNGSkipIgnored(ctxt, node);
                   10716:             if (node == NULL)
                   10717:                 tmp = 0;
                   10718:             xmlRelaxNGFreeValidState(ctxt, state);
                   10719:         }
                   10720:         if (tmp == -1) {
                   10721:             if (ret != -1) {
                   10722:                 VALID_ERR(XML_RELAXNG_ERR_EXTRADATA);
                   10723:                 ret = -1;
                   10724:             }
                   10725:         }
                   10726:     }
                   10727:     if (ctxt->state != NULL) {
                   10728:         xmlRelaxNGFreeValidState(ctxt, ctxt->state);
                   10729:         ctxt->state = NULL;
                   10730:     }
                   10731:     if (ret != 0)
                   10732:         xmlRelaxNGDumpValidError(ctxt);
                   10733: #ifdef DEBUG
                   10734:     else if (ctxt->errNr != 0) {
                   10735:         ctxt->error(ctxt->userData,
                   10736:                     "%d Extra error messages left on stack !\n",
                   10737:                     ctxt->errNr);
                   10738:         xmlRelaxNGDumpValidError(ctxt);
                   10739:     }
                   10740: #endif
                   10741: #ifdef LIBXML_VALID_ENABLED
                   10742:     if (ctxt->idref == 1) {
                   10743:         xmlValidCtxt vctxt;
                   10744: 
                   10745:         memset(&vctxt, 0, sizeof(xmlValidCtxt));
                   10746:         vctxt.valid = 1;
                   10747:         vctxt.error = ctxt->error;
                   10748:         vctxt.warning = ctxt->warning;
                   10749:         vctxt.userData = ctxt->userData;
                   10750: 
                   10751:         if (xmlValidateDocumentFinal(&vctxt, doc) != 1)
                   10752:             ret = -1;
                   10753:     }
                   10754: #endif /* LIBXML_VALID_ENABLED */
                   10755:     if ((ret == 0) && (ctxt->errNo != XML_RELAXNG_OK))
                   10756:         ret = -1;
                   10757: 
                   10758:     return (ret);
                   10759: }
                   10760: 
                   10761: /**
                   10762:  * xmlRelaxNGCleanPSVI:
                   10763:  * @node:  an input element or document
                   10764:  *
                   10765:  * Call this routine to speed up XPath computation on static documents.
                   10766:  * This stamps all the element nodes with the document order
                   10767:  * Like for line information, the order is kept in the element->content
                   10768:  * field, the value stored is actually - the node number (starting at -1)
                   10769:  * to be able to differentiate from line numbers.
                   10770:  *
                   10771:  * Returns the number of elements found in the document or -1 in case
                   10772:  *    of error.
                   10773:  */
                   10774: static void
                   10775: xmlRelaxNGCleanPSVI(xmlNodePtr node) {
                   10776:     xmlNodePtr cur;
                   10777: 
                   10778:     if ((node == NULL) ||
                   10779:         ((node->type != XML_ELEMENT_NODE) &&
                   10780:          (node->type != XML_DOCUMENT_NODE) &&
                   10781:          (node->type != XML_HTML_DOCUMENT_NODE)))
                   10782:        return;
                   10783:     if (node->type == XML_ELEMENT_NODE)
                   10784:         node->psvi = NULL;
                   10785: 
                   10786:     cur = node->children;
                   10787:     while (cur != NULL) {
                   10788:        if (cur->type == XML_ELEMENT_NODE) {
                   10789:            cur->psvi = NULL;
                   10790:            if (cur->children != NULL) {
                   10791:                cur = cur->children;
                   10792:                continue;
                   10793:            }
                   10794:        }
                   10795:        if (cur->next != NULL) {
                   10796:            cur = cur->next;
                   10797:            continue;
                   10798:        }
                   10799:        do {
                   10800:            cur = cur->parent;
                   10801:            if (cur == NULL)
                   10802:                break;
                   10803:            if (cur == node) {
                   10804:                cur = NULL;
                   10805:                break;
                   10806:            }
                   10807:            if (cur->next != NULL) {
                   10808:                cur = cur->next;
                   10809:                break;
                   10810:            }
                   10811:        } while (cur != NULL);
                   10812:     }
                   10813:     return;
                   10814: }
                   10815: /************************************************************************
                   10816:  *                                                                     *
                   10817:  *                     Validation interfaces                           *
                   10818:  *                                                                     *
                   10819:  ************************************************************************/
                   10820: 
                   10821: /**
                   10822:  * xmlRelaxNGNewValidCtxt:
                   10823:  * @schema:  a precompiled XML RelaxNGs
                   10824:  *
                   10825:  * Create an XML RelaxNGs validation context based on the given schema
                   10826:  *
                   10827:  * Returns the validation context or NULL in case of error
                   10828:  */
                   10829: xmlRelaxNGValidCtxtPtr
                   10830: xmlRelaxNGNewValidCtxt(xmlRelaxNGPtr schema)
                   10831: {
                   10832:     xmlRelaxNGValidCtxtPtr ret;
                   10833: 
                   10834:     ret = (xmlRelaxNGValidCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGValidCtxt));
                   10835:     if (ret == NULL) {
                   10836:         xmlRngVErrMemory(NULL, "building context\n");
                   10837:         return (NULL);
                   10838:     }
                   10839:     memset(ret, 0, sizeof(xmlRelaxNGValidCtxt));
                   10840:     ret->schema = schema;
                   10841:     ret->error = xmlGenericError;
                   10842:     ret->userData = xmlGenericErrorContext;
                   10843:     ret->errNr = 0;
                   10844:     ret->errMax = 0;
                   10845:     ret->err = NULL;
                   10846:     ret->errTab = NULL;
                   10847:     if (schema != NULL)
                   10848:        ret->idref = schema->idref;
                   10849:     ret->states = NULL;
                   10850:     ret->freeState = NULL;
                   10851:     ret->freeStates = NULL;
                   10852:     ret->errNo = XML_RELAXNG_OK;
                   10853:     return (ret);
                   10854: }
                   10855: 
                   10856: /**
                   10857:  * xmlRelaxNGFreeValidCtxt:
                   10858:  * @ctxt:  the schema validation context
                   10859:  *
                   10860:  * Free the resources associated to the schema validation context
                   10861:  */
                   10862: void
                   10863: xmlRelaxNGFreeValidCtxt(xmlRelaxNGValidCtxtPtr ctxt)
                   10864: {
                   10865:     int k;
                   10866: 
                   10867:     if (ctxt == NULL)
                   10868:         return;
                   10869:     if (ctxt->states != NULL)
                   10870:         xmlRelaxNGFreeStates(NULL, ctxt->states);
                   10871:     if (ctxt->freeState != NULL) {
                   10872:         for (k = 0; k < ctxt->freeState->nbState; k++) {
                   10873:             xmlRelaxNGFreeValidState(NULL, ctxt->freeState->tabState[k]);
                   10874:         }
                   10875:         xmlRelaxNGFreeStates(NULL, ctxt->freeState);
                   10876:     }
                   10877:     if (ctxt->freeStates != NULL) {
                   10878:         for (k = 0; k < ctxt->freeStatesNr; k++) {
                   10879:             xmlRelaxNGFreeStates(NULL, ctxt->freeStates[k]);
                   10880:         }
                   10881:         xmlFree(ctxt->freeStates);
                   10882:     }
                   10883:     if (ctxt->errTab != NULL)
                   10884:         xmlFree(ctxt->errTab);
                   10885:     if (ctxt->elemTab != NULL) {
                   10886:         xmlRegExecCtxtPtr exec;
                   10887: 
                   10888:         exec = xmlRelaxNGElemPop(ctxt);
                   10889:         while (exec != NULL) {
                   10890:             xmlRegFreeExecCtxt(exec);
                   10891:             exec = xmlRelaxNGElemPop(ctxt);
                   10892:         }
                   10893:         xmlFree(ctxt->elemTab);
                   10894:     }
                   10895:     xmlFree(ctxt);
                   10896: }
                   10897: 
                   10898: /**
                   10899:  * xmlRelaxNGSetValidErrors:
                   10900:  * @ctxt:  a Relax-NG validation context
                   10901:  * @err:  the error function
                   10902:  * @warn: the warning function
                   10903:  * @ctx: the functions context
                   10904:  *
                   10905:  * Set the error and warning callback informations
                   10906:  */
                   10907: void
                   10908: xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
                   10909:                          xmlRelaxNGValidityErrorFunc err,
                   10910:                          xmlRelaxNGValidityWarningFunc warn, void *ctx)
                   10911: {
                   10912:     if (ctxt == NULL)
                   10913:         return;
                   10914:     ctxt->error = err;
                   10915:     ctxt->warning = warn;
                   10916:     ctxt->userData = ctx;
                   10917:     ctxt->serror = NULL;
                   10918: }
                   10919: 
                   10920: /**
                   10921:  * xmlRelaxNGSetValidStructuredErrors:
                   10922:  * @ctxt:  a Relax-NG validation context
                   10923:  * @serror:  the structured error function
                   10924:  * @ctx: the functions context
                   10925:  *
                   10926:  * Set the structured error callback
                   10927:  */
                   10928: void
                   10929: xmlRelaxNGSetValidStructuredErrors(xmlRelaxNGValidCtxtPtr ctxt,
                   10930:                                    xmlStructuredErrorFunc serror, void *ctx)
                   10931: {
                   10932:     if (ctxt == NULL)
                   10933:         return;
                   10934:     ctxt->serror = serror;
                   10935:     ctxt->error = NULL;
                   10936:     ctxt->warning = NULL;
                   10937:     ctxt->userData = ctx;
                   10938: }
                   10939: 
                   10940: /**
                   10941:  * xmlRelaxNGGetValidErrors:
                   10942:  * @ctxt:  a Relax-NG validation context
                   10943:  * @err:  the error function result
                   10944:  * @warn: the warning function result
                   10945:  * @ctx: the functions context result
                   10946:  *
                   10947:  * Get the error and warning callback informations
                   10948:  *
                   10949:  * Returns -1 in case of error and 0 otherwise
                   10950:  */
                   10951: int
                   10952: xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
                   10953:                          xmlRelaxNGValidityErrorFunc * err,
                   10954:                          xmlRelaxNGValidityWarningFunc * warn, void **ctx)
                   10955: {
                   10956:     if (ctxt == NULL)
                   10957:         return (-1);
                   10958:     if (err != NULL)
                   10959:         *err = ctxt->error;
                   10960:     if (warn != NULL)
                   10961:         *warn = ctxt->warning;
                   10962:     if (ctx != NULL)
                   10963:         *ctx = ctxt->userData;
                   10964:     return (0);
                   10965: }
                   10966: 
                   10967: /**
                   10968:  * xmlRelaxNGValidateDoc:
                   10969:  * @ctxt:  a Relax-NG validation context
                   10970:  * @doc:  a parsed document tree
                   10971:  *
                   10972:  * Validate a document tree in memory.
                   10973:  *
                   10974:  * Returns 0 if the document is valid, a positive error code
                   10975:  *     number otherwise and -1 in case of internal or API error.
                   10976:  */
                   10977: int
                   10978: xmlRelaxNGValidateDoc(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc)
                   10979: {
                   10980:     int ret;
                   10981: 
                   10982:     if ((ctxt == NULL) || (doc == NULL))
                   10983:         return (-1);
                   10984: 
                   10985:     ctxt->doc = doc;
                   10986: 
                   10987:     ret = xmlRelaxNGValidateDocument(ctxt, doc);
                   10988:     /*
                   10989:      * Remove all left PSVI
                   10990:      */
                   10991:     xmlRelaxNGCleanPSVI((xmlNodePtr) doc);
                   10992: 
                   10993:     /*
                   10994:      * TODO: build error codes
                   10995:      */
                   10996:     if (ret == -1)
                   10997:         return (1);
                   10998:     return (ret);
                   10999: }
                   11000: 
                   11001: #define bottom_relaxng
                   11002: #include "elfgcchack.h"
                   11003: #endif /* LIBXML_SCHEMAS_ENABLED */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>