relaxng.c

   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                                                  xmlDocGetRootElement(inc->doc)->children,
1565                                                  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                 if (xmlAutomataIsDeterminist(ctxt->am))
3063                     def->contModel = xmlAutomataCompile(ctxt->am);
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                 if ((ctxt->state->value == NULL) ||
8888                     (*ctxt->state->value == 0)) {
8889                     ret = 0;
8890                     break;
8891                 }
8892                 oldflags = ctxt->flags;
8893                 ctxt->flags |= FLAGS_IGNORABLE;
8894                 cur = ctxt->state->value;
8895                 temp = NULL;
8896                 while ((cur != NULL) && (cur != ctxt->state->endvalue) &&
8897                        (temp != cur)) {
8898                     temp = cur;
8899                     ret =
8900                         xmlRelaxNGValidateValueList(ctxt, define->content);
8901                     if (ret != 0) {
8902                         ctxt->state->value = temp;
8903                         ret = 0;
8904                         break;
8905                     }
8906                     cur = ctxt->state->value;
8907                 }
8908                 ctxt->flags = oldflags;
8909                 if (ctxt->errNr > 0)
8910                     xmlRelaxNGPopErrors(ctxt, 0);
8911                 break;
8912             }
8913         case XML_RELAXNG_OPTIONAL:{
8914                 xmlChar *temp;
8915
8916                 if ((ctxt->state->value == NULL) ||
8917                     (*ctxt->state->value == 0)) {
8918                     ret = 0;
8919                     break;
8920                 }
8921                 oldflags = ctxt->flags;
8922                 ctxt->flags |= FLAGS_IGNORABLE;
8923                 temp = ctxt->state->value;
8924                 ret = xmlRelaxNGValidateValue(ctxt, define->content);
8925                 ctxt->flags = oldflags;
8926                 if (ret != 0) {
8927                     ctxt->state->value = temp;
8928                     if (ctxt->errNr > 0)
8929                         xmlRelaxNGPopErrors(ctxt, 0);
8930                     ret = 0;
8931                     break;
8932                 }
8933                 if (ctxt->errNr > 0)
8934                     xmlRelaxNGPopErrors(ctxt, 0);
8935                 break;
8936             }
8937         case XML_RELAXNG_EXCEPT:{
8938                 xmlRelaxNGDefinePtr list;
8939
8940                 list = define->content;
8941                 while (list != NULL) {
8942                     ret = xmlRelaxNGValidateValue(ctxt, list);
8943                     if (ret == 0) {
8944                         ret = -1;
8945                         break;
8946                     } else
8947                         ret = 0;
8948                     list = list->next;
8949                 }
8950                 break;
8951             }
8952         case XML_RELAXNG_DEF:
8953         case XML_RELAXNG_GROUP:{
8954                 xmlRelaxNGDefinePtr list;
8955
8956                 list = define->content;
8957                 while (list != NULL) {
8958                     ret = xmlRelaxNGValidateValue(ctxt, list);
8959                     if (ret != 0) {
8960                         ret = -1;
8961                         break;
8962                     } else
8963                         ret = 0;
8964                     list = list->next;
8965                 }
8966                 break;
8967             }
8968         case XML_RELAXNG_REF:
8969         case XML_RELAXNG_PARENTREF:
8970             if (define->content == NULL) {
8971                 VALID_ERR(XML_RELAXNG_ERR_NODEFINE);
8972                 ret = -1;
8973             } else {
8974                 ret = xmlRelaxNGValidateValue(ctxt, define->content);
8975             }
8976             break;
8977         default:
8978             TODO ret = -1;
8979     }
8980     return (ret);
8981 }
8982
8983 /**
8984  * xmlRelaxNGValidateValueContent:
8985  * @ctxt:  a Relax-NG validation context
8986  * @defines:  the list of definitions to verify
8987  *
8988  * Validate the given definitions for the current value
8989  *
8990  * Returns 0 if the validation succeeded or an error code.
8991  */
8992 static int
8993 xmlRelaxNGValidateValueContent(xmlRelaxNGValidCtxtPtr ctxt,
8994                                xmlRelaxNGDefinePtr defines)
8995 {
8996     int ret = 0;
8997
8998     while (defines != NULL) {
8999         ret = xmlRelaxNGValidateValue(ctxt, defines);
9000         if (ret != 0)
9001             break;
9002         defines = defines->next;
9003     }
9004     return (ret);
9005 }
9006
9007 /**
9008  * xmlRelaxNGAttributeMatch:
9009  * @ctxt:  a Relax-NG validation context
9010  * @define:  the definition to check
9011  * @prop:  the attribute
9012  *
9013  * Check if the attribute matches the definition nameClass
9014  *
9015  * Returns 1 if the attribute matches, 0 if no, or -1 in case of error
9016  */
9017 static int
9018 xmlRelaxNGAttributeMatch(xmlRelaxNGValidCtxtPtr ctxt,
9019                          xmlRelaxNGDefinePtr define, xmlAttrPtr prop)
9020 {
9021     int ret;
9022
9023     if (define->name != NULL) {
9024         if (!xmlStrEqual(define->name, prop->name))
9025             return (0);
9026     }
9027     if (define->ns != NULL) {
9028         if (define->ns[0] == 0) {
9029             if (prop->ns != NULL)
9030                 return (0);
9031         } else {
9032             if ((prop->ns == NULL) ||
9033                 (!xmlStrEqual(define->ns, prop->ns->href)))
9034                 return (0);
9035         }
9036     }
9037     if (define->nameClass == NULL)
9038         return (1);
9039     define = define->nameClass;
9040     if (define->type == XML_RELAXNG_EXCEPT) {
9041         xmlRelaxNGDefinePtr list;
9042
9043         list = define->content;
9044         while (list != NULL) {
9045             ret = xmlRelaxNGAttributeMatch(ctxt, list, prop);
9046             if (ret == 1)
9047                 return (0);
9048             if (ret < 0)
9049                 return (ret);
9050             list = list->next;
9051         }
9052     } else {
9053     TODO}
9054     return (1);
9055 }
9056
9057 /**
9058  * xmlRelaxNGValidateAttribute:
9059  * @ctxt:  a Relax-NG validation context
9060  * @define:  the definition to verify
9061  *
9062  * Validate the given attribute definition for that node
9063  *
9064  * Returns 0 if the validation succeeded or an error code.
9065  */
9066 static int
9067 xmlRelaxNGValidateAttribute(xmlRelaxNGValidCtxtPtr ctxt,
9068                             xmlRelaxNGDefinePtr define)
9069 {
9070     int ret = 0, i;
9071     xmlChar *value, *oldvalue;
9072     xmlAttrPtr prop = NULL, tmp;
9073     xmlNodePtr oldseq;
9074
9075     if (ctxt->state->nbAttrLeft <= 0)
9076         return (-1);
9077     if (define->name != NULL) {
9078         for (i = 0; i < ctxt->state->nbAttrs; i++) {
9079             tmp = ctxt->state->attrs[i];
9080             if ((tmp != NULL) && (xmlStrEqual(define->name, tmp->name))) {
9081                 if ((((define->ns == NULL) || (define->ns[0] == 0)) &&
9082                      (tmp->ns == NULL)) ||
9083                     ((tmp->ns != NULL) &&
9084                      (xmlStrEqual(define->ns, tmp->ns->href)))) {
9085                     prop = tmp;
9086                     break;
9087                 }
9088             }
9089         }
9090         if (prop != NULL) {
9091             value = xmlNodeListGetString(prop->doc, prop->children, 1);
9092             oldvalue = ctxt->state->value;
9093             oldseq = ctxt->state->seq;
9094             ctxt->state->seq = (xmlNodePtr) prop;
9095             ctxt->state->value = value;
9096             ctxt->state->endvalue = NULL;
9097             ret = xmlRelaxNGValidateValueContent(ctxt, define->content);
9098             if (ctxt->state->value != NULL)
9099                 value = ctxt->state->value;
9100             if (value != NULL)
9101                 xmlFree(value);
9102             ctxt->state->value = oldvalue;
9103             ctxt->state->seq = oldseq;
9104             if (ret == 0) {
9105                 /*
9106                  * flag the attribute as processed
9107                  */
9108                 ctxt->state->attrs[i] = NULL;
9109                 ctxt->state->nbAttrLeft--;
9110             }
9111         } else {
9112             ret = -1;
9113         }
9114 #ifdef DEBUG
9115         xmlGenericError(xmlGenericErrorContext,
9116                         "xmlRelaxNGValidateAttribute(%s): %d\n",
9117                         define->name, ret);
9118 #endif
9119     } else {
9120         for (i = 0; i < ctxt->state->nbAttrs; i++) {
9121             tmp = ctxt->state->attrs[i];
9122             if ((tmp != NULL) &&
9123                 (xmlRelaxNGAttributeMatch(ctxt, define, tmp) == 1)) {
9124                 prop = tmp;
9125                 break;
9126             }
9127         }
9128         if (prop != NULL) {
9129             value = xmlNodeListGetString(prop->doc, prop->children, 1);
9130             oldvalue = ctxt->state->value;
9131             oldseq = ctxt->state->seq;
9132             ctxt->state->seq = (xmlNodePtr) prop;
9133             ctxt->state->value = value;
9134             ret = xmlRelaxNGValidateValueContent(ctxt, define->content);
9135             if (ctxt->state->value != NULL)
9136                 value = ctxt->state->value;
9137             if (value != NULL)
9138                 xmlFree(value);
9139             ctxt->state->value = oldvalue;
9140             ctxt->state->seq = oldseq;
9141             if (ret == 0) {
9142                 /*
9143                  * flag the attribute as processed
9144                  */
9145                 ctxt->state->attrs[i] = NULL;
9146                 ctxt->state->nbAttrLeft--;
9147             }
9148         } else {
9149             ret = -1;
9150         }
9151 #ifdef DEBUG
9152         if (define->ns != NULL) {
9153             xmlGenericError(xmlGenericErrorContext,
9154                             "xmlRelaxNGValidateAttribute(nsName ns = %s): %d\n",
9155                             define->ns, ret);
9156         } else {
9157             xmlGenericError(xmlGenericErrorContext,
9158                             "xmlRelaxNGValidateAttribute(anyName): %d\n",
9159                             ret);
9160         }
9161 #endif
9162     }
9163
9164     return (ret);
9165 }
9166
9167 /**
9168  * xmlRelaxNGValidateAttributeList:
9169  * @ctxt:  a Relax-NG validation context
9170  * @define:  the list of definition to verify
9171  *
9172  * Validate the given node against the list of attribute definitions
9173  *
9174  * Returns 0 if the validation succeeded or an error code.
9175  */
9176 static int
9177 xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
9178                                 xmlRelaxNGDefinePtr defines)
9179 {
9180     int ret = 0, res;
9181     int needmore = 0;
9182     xmlRelaxNGDefinePtr cur;
9183
9184     cur = defines;
9185     while (cur != NULL) {
9186         if (cur->type == XML_RELAXNG_ATTRIBUTE) {
9187             if (xmlRelaxNGValidateAttribute(ctxt, cur) != 0)
9188                 ret = -1;
9189         } else
9190             needmore = 1;
9191         cur = cur->next;
9192     }
9193     if (!needmore)
9194         return (ret);
9195     cur = defines;
9196     while (cur != NULL) {
9197         if (cur->type != XML_RELAXNG_ATTRIBUTE) {
9198             if ((ctxt->state != NULL) || (ctxt->states != NULL)) {
9199                 res = xmlRelaxNGValidateDefinition(ctxt, cur);
9200                 if (res < 0)
9201                     ret = -1;
9202             } else {
9203                 VALID_ERR(XML_RELAXNG_ERR_NOSTATE);
9204                 return (-1);
9205             }
9206             if (res == -1)      /* continues on -2 */
9207                 break;
9208         }
9209         cur = cur->next;
9210     }
9211
9212     return (ret);
9213 }
9214
9215 /**
9216  * xmlRelaxNGNodeMatchesList:
9217  * @node:  the node
9218  * @list:  a NULL terminated array of definitions
9219  *
9220  * Check if a node can be matched by one of the definitions
9221  *
9222  * Returns 1 if matches 0 otherwise
9223  */
9224 static int
9225 xmlRelaxNGNodeMatchesList(xmlNodePtr node, xmlRelaxNGDefinePtr * list)
9226 {
9227     xmlRelaxNGDefinePtr cur;
9228     int i = 0, tmp;
9229
9230     if ((node == NULL) || (list == NULL))
9231         return (0);
9232
9233     cur = list[i++];
9234     while (cur != NULL) {
9235         if ((node->type == XML_ELEMENT_NODE) &&
9236             (cur->type == XML_RELAXNG_ELEMENT)) {
9237             tmp = xmlRelaxNGElementMatch(NULL, cur, node);
9238             if (tmp == 1)
9239                 return (1);
9240         } else if (((node->type == XML_TEXT_NODE) ||
9241                     (node->type == XML_CDATA_SECTION_NODE)) &&
9242                    (cur->type == XML_RELAXNG_TEXT)) {
9243             return (1);
9244         }
9245         cur = list[i++];
9246     }
9247     return (0);
9248 }
9249
9250 /**
9251  * xmlRelaxNGValidateInterleave:
9252  * @ctxt:  a Relax-NG validation context
9253  * @define:  the definition to verify
9254  *
9255  * Validate an interleave definition for a node.
9256  *
9257  * Returns 0 if the validation succeeded or an error code.
9258  */
9259 static int
9260 xmlRelaxNGValidateInterleave(xmlRelaxNGValidCtxtPtr ctxt,
9261                              xmlRelaxNGDefinePtr define)
9262 {
9263     int ret = 0, i, nbgroups;
9264     int errNr = ctxt->errNr;
9265     int oldflags;
9266
9267     xmlRelaxNGValidStatePtr oldstate;
9268     xmlRelaxNGPartitionPtr partitions;
9269     xmlRelaxNGInterleaveGroupPtr group = NULL;
9270     xmlNodePtr cur, start, last = NULL, lastchg = NULL, lastelem;
9271     xmlNodePtr *list = NULL, *lasts = NULL;
9272
9273     if (define->data != NULL) {
9274         partitions = (xmlRelaxNGPartitionPtr) define->data;
9275         nbgroups = partitions->nbgroups;
9276     } else {
9277         VALID_ERR(XML_RELAXNG_ERR_INTERNODATA);
9278         return (-1);
9279     }
9280     /*
9281      * Optimizations for MIXED
9282      */
9283     oldflags = ctxt->flags;
9284     if (define->dflags & IS_MIXED) {
9285         ctxt->flags |= FLAGS_MIXED_CONTENT;
9286         if (nbgroups == 2) {
9287             /*
9288              * this is a pure <mixed> case
9289              */
9290             if (ctxt->state != NULL)
9291                 ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt,
9292                                                          ctxt->state->seq);
9293             if (partitions->groups[0]->rule->type == XML_RELAXNG_TEXT)
9294                 ret = xmlRelaxNGValidateDefinition(ctxt,
9295                                                    partitions->groups[1]->
9296                                                    rule);
9297             else
9298                 ret = xmlRelaxNGValidateDefinition(ctxt,
9299                                                    partitions->groups[0]->
9300                                                    rule);
9301             if (ret == 0) {
9302                 if (ctxt->state != NULL)
9303                     ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt,
9304                                                              ctxt->state->
9305                                                              seq);
9306             }
9307             ctxt->flags = oldflags;
9308             return (ret);
9309         }
9310     }
9311
9312     /*
9313      * Build arrays to store the first and last node of the chain
9314      * pertaining to each group
9315      */
9316     list = (xmlNodePtr *) xmlMalloc(nbgroups * sizeof(xmlNodePtr));
9317     if (list == NULL) {
9318         xmlRngVErrMemory(ctxt, "validating\n");
9319         return (-1);
9320     }
9321     memset(list, 0, nbgroups * sizeof(xmlNodePtr));
9322     lasts = (xmlNodePtr *) xmlMalloc(nbgroups * sizeof(xmlNodePtr));
9323     if (lasts == NULL) {
9324         xmlRngVErrMemory(ctxt, "validating\n");
9325         return (-1);
9326     }
9327     memset(lasts, 0, nbgroups * sizeof(xmlNodePtr));
9328
9329     /*
9330      * Walk the sequence of children finding the right group and
9331      * sorting them in sequences.
9332      */
9333     cur = ctxt->state->seq;
9334     cur = xmlRelaxNGSkipIgnored(ctxt, cur);
9335     start = cur;
9336     while (cur != NULL) {
9337         ctxt->state->seq = cur;
9338         if ((partitions->triage != NULL) &&
9339             (partitions->flags & IS_DETERMINIST)) {
9340             void *tmp = NULL;
9341
9342             if ((cur->type == XML_TEXT_NODE) ||
9343                 (cur->type == XML_CDATA_SECTION_NODE)) {
9344                 tmp = xmlHashLookup2(partitions->triage, BAD_CAST "#text",
9345                                      NULL);
9346             } else if (cur->type == XML_ELEMENT_NODE) {
9347                 if (cur->ns != NULL) {
9348                     tmp = xmlHashLookup2(partitions->triage, cur->name,
9349                                          cur->ns->href);
9350                     if (tmp == NULL)
9351                         tmp = xmlHashLookup2(partitions->triage,
9352                                              BAD_CAST "#any",
9353                                              cur->ns->href);
9354                 } else
9355                     tmp =
9356                         xmlHashLookup2(partitions->triage, cur->name,
9357                                        NULL);
9358                 if (tmp == NULL)
9359                     tmp =
9360                         xmlHashLookup2(partitions->triage, BAD_CAST "#any",
9361                                        NULL);
9362             }
9363
9364             if (tmp == NULL) {
9365                 i = nbgroups;
9366             } else {
9367                 i = ((long) tmp) - 1;
9368                 if (partitions->flags & IS_NEEDCHECK) {
9369                     group = partitions->groups[i];
9370                     if (!xmlRelaxNGNodeMatchesList(cur, group->defs))
9371                         i = nbgroups;
9372                 }
9373             }
9374         } else {
9375             for (i = 0; i < nbgroups; i++) {
9376                 group = partitions->groups[i];
9377                 if (group == NULL)
9378                     continue;
9379                 if (xmlRelaxNGNodeMatchesList(cur, group->defs))
9380                     break;
9381             }
9382         }
9383         /*
9384          * We break as soon as an element not matched is found
9385          */
9386         if (i >= nbgroups) {
9387             break;
9388         }
9389         if (lasts[i] != NULL) {
9390             lasts[i]->next = cur;
9391             lasts[i] = cur;
9392         } else {
9393             list[i] = cur;
9394             lasts[i] = cur;
9395         }
9396         if (cur->next != NULL)
9397             lastchg = cur->next;
9398         else
9399             lastchg = cur;
9400         cur = xmlRelaxNGSkipIgnored(ctxt, cur->next);
9401     }
9402     if (ret != 0) {
9403         VALID_ERR(XML_RELAXNG_ERR_INTERSEQ);
9404         ret = -1;
9405         goto done;
9406     }
9407     lastelem = cur;
9408     oldstate = ctxt->state;
9409     for (i = 0; i < nbgroups; i++) {
9410         ctxt->state = xmlRelaxNGCopyValidState(ctxt, oldstate);
9411         group = partitions->groups[i];
9412         if (lasts[i] != NULL) {
9413             last = lasts[i]->next;
9414             lasts[i]->next = NULL;
9415         }
9416         ctxt->state->seq = list[i];
9417         ret = xmlRelaxNGValidateDefinition(ctxt, group->rule);
9418         if (ret != 0)
9419             break;
9420         if (ctxt->state != NULL) {
9421             cur = ctxt->state->seq;
9422             cur = xmlRelaxNGSkipIgnored(ctxt, cur);
9423             xmlRelaxNGFreeValidState(ctxt, oldstate);
9424             oldstate = ctxt->state;
9425             ctxt->state = NULL;
9426             if (cur != NULL) {
9427                 VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA, cur->name);
9428                 ret = -1;
9429                 ctxt->state = oldstate;
9430                 goto done;
9431             }
9432         } else if (ctxt->states != NULL) {
9433             int j;
9434             int found = 0;
9435             int best = -1;
9436             int lowattr = -1;
9437
9438             /*
9439              * PBM: what happen if there is attributes checks in the interleaves
9440              */
9441
9442             for (j = 0; j < ctxt->states->nbState; j++) {
9443                 cur = ctxt->states->tabState[j]->seq;
9444                 cur = xmlRelaxNGSkipIgnored(ctxt, cur);
9445                 if (cur == NULL) {
9446                     if (found == 0) {
9447                         lowattr = ctxt->states->tabState[j]->nbAttrLeft;
9448                         best = j;
9449                     }
9450                     found = 1;
9451                     if (ctxt->states->tabState[j]->nbAttrLeft <= lowattr) {
9452                         /* try  to keep the latest one to mach old heuristic */
9453                         lowattr = ctxt->states->tabState[j]->nbAttrLeft;
9454                         best = j;
9455                     }
9456                     if (lowattr == 0)
9457                         break;
9458                 } else if (found == 0) {
9459                     if (lowattr == -1) {
9460                         lowattr = ctxt->states->tabState[j]->nbAttrLeft;
9461                         best = j;
9462                     } else
9463                     if (ctxt->states->tabState[j]->nbAttrLeft <= lowattr)  {
9464                         /* try  to keep the latest one to mach old heuristic */
9465                         lowattr = ctxt->states->tabState[j]->nbAttrLeft;
9466                         best = j;
9467                     }
9468                 }
9469             }
9470             /*
9471              * BIG PBM: here we pick only one restarting point :-(
9472              */
9473             if (ctxt->states->nbState > 0) {
9474                 xmlRelaxNGFreeValidState(ctxt, oldstate);
9475                 if (best != -1) {
9476                     oldstate = ctxt->states->tabState[best];
9477                     ctxt->states->tabState[best] = NULL;
9478                 } else {
9479                     oldstate =
9480                         ctxt->states->tabState[ctxt->states->nbState - 1];
9481                     ctxt->states->tabState[ctxt->states->nbState - 1] = NULL;
9482                     ctxt->states->nbState--;
9483                 }
9484             }
9485             for (j = 0; j < ctxt->states->nbState ; j++) {
9486                 xmlRelaxNGFreeValidState(ctxt, ctxt->states->tabState[j]);
9487             }
9488             xmlRelaxNGFreeStates(ctxt, ctxt->states);
9489             ctxt->states = NULL;
9490             if (found == 0) {
9491                 if (cur == NULL) {
9492                     VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA,
9493                                (const xmlChar *) "noname");
9494                 } else {
9495                     VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA, cur->name);
9496                 }
9497                 ret = -1;
9498                 ctxt->state = oldstate;
9499                 goto done;
9500             }
9501         } else {
9502             ret = -1;
9503             break;
9504         }
9505         if (lasts[i] != NULL) {
9506             lasts[i]->next = last;
9507         }
9508     }
9509     if (ctxt->state != NULL)
9510         xmlRelaxNGFreeValidState(ctxt, ctxt->state);
9511     ctxt->state = oldstate;
9512     ctxt->state->seq = lastelem;
9513     if (ret != 0) {
9514         VALID_ERR(XML_RELAXNG_ERR_INTERSEQ);
9515         ret = -1;
9516         goto done;
9517     }
9518
9519   done:
9520     ctxt->flags = oldflags;
9521     /*
9522      * builds the next links chain from the prev one
9523      */
9524     cur = lastchg;
9525     while (cur != NULL) {
9526         if ((cur == start) || (cur->prev == NULL))
9527             break;
9528         cur->prev->next = cur;
9529         cur = cur->prev;
9530     }
9531     if (ret == 0) {
9532         if (ctxt->errNr > errNr)
9533             xmlRelaxNGPopErrors(ctxt, errNr);
9534     }
9535
9536     xmlFree(list);
9537     xmlFree(lasts);
9538     return (ret);
9539 }
9540
9541 /**
9542  * xmlRelaxNGValidateDefinitionList:
9543  * @ctxt:  a Relax-NG validation context
9544  * @define:  the list of definition to verify
9545  *
9546  * Validate the given node content against the (list) of definitions
9547  *
9548  * Returns 0 if the validation succeeded or an error code.
9549  */
9550 static int
9551 xmlRelaxNGValidateDefinitionList(xmlRelaxNGValidCtxtPtr ctxt,
9552                                  xmlRelaxNGDefinePtr defines)
9553 {
9554     int ret = 0, res;
9555
9556
9557     if (defines == NULL) {
9558         VALID_ERR2(XML_RELAXNG_ERR_INTERNAL,
9559                    BAD_CAST "NULL definition list");
9560         return (-1);
9561     }
9562     while (defines != NULL) {
9563         if ((ctxt->state != NULL) || (ctxt->states != NULL)) {
9564             res = xmlRelaxNGValidateDefinition(ctxt, defines);
9565             if (res < 0)
9566                 ret = -1;
9567         } else {
9568             VALID_ERR(XML_RELAXNG_ERR_NOSTATE);
9569             return (-1);
9570         }
9571         if (res == -1)          /* continues on -2 */
9572             break;
9573         defines = defines->next;
9574     }
9575
9576     return (ret);
9577 }
9578
9579 /**
9580  * xmlRelaxNGElementMatch:
9581  * @ctxt:  a Relax-NG validation context
9582  * @define:  the definition to check
9583  * @elem:  the element
9584  *
9585  * Check if the element matches the definition nameClass
9586  *
9587  * Returns 1 if the element matches, 0 if no, or -1 in case of error
9588  */
9589 static int
9590 xmlRelaxNGElementMatch(xmlRelaxNGValidCtxtPtr ctxt,
9591                        xmlRelaxNGDefinePtr define, xmlNodePtr elem)
9592 {
9593     int ret = 0, oldflags = 0;
9594
9595     if (define->name != NULL) {
9596         if (!xmlStrEqual(elem->name, define->name)) {
9597             VALID_ERR3(XML_RELAXNG_ERR_ELEMNAME, define->name, elem->name);
9598             return (0);
9599         }
9600     }
9601     if ((define->ns != NULL) && (define->ns[0] != 0)) {
9602         if (elem->ns == NULL) {
9603             VALID_ERR2(XML_RELAXNG_ERR_ELEMNONS, elem->name);
9604             return (0);
9605         } else if (!xmlStrEqual(elem->ns->href, define->ns)) {
9606             VALID_ERR3(XML_RELAXNG_ERR_ELEMWRONGNS,
9607                        elem->name, define->ns);
9608             return (0);
9609         }
9610     } else if ((elem->ns != NULL) && (define->ns != NULL) &&
9611                (define->name == NULL)) {
9612         VALID_ERR2(XML_RELAXNG_ERR_ELEMEXTRANS, elem->name);
9613         return (0);
9614     } else if ((elem->ns != NULL) && (define->name != NULL)) {
9615         VALID_ERR2(XML_RELAXNG_ERR_ELEMEXTRANS, define->name);
9616         return (0);
9617     }
9618
9619     if (define->nameClass == NULL)
9620         return (1);
9621
9622     define = define->nameClass;
9623     if (define->type == XML_RELAXNG_EXCEPT) {
9624         xmlRelaxNGDefinePtr list;
9625
9626         if (ctxt != NULL) {
9627             oldflags = ctxt->flags;
9628             ctxt->flags |= FLAGS_IGNORABLE;
9629         }
9630
9631         list = define->content;
9632         while (list != NULL) {
9633             ret = xmlRelaxNGElementMatch(ctxt, list, elem);
9634             if (ret == 1) {
9635                 if (ctxt != NULL)
9636                     ctxt->flags = oldflags;
9637                 return (0);
9638             }
9639             if (ret < 0) {
9640                 if (ctxt != NULL)
9641                     ctxt->flags = oldflags;
9642                 return (ret);
9643             }
9644             list = list->next;
9645         }
9646         ret = 1;
9647         if (ctxt != NULL) {
9648             ctxt->flags = oldflags;
9649         }
9650     } else if (define->type == XML_RELAXNG_CHOICE) {
9651         xmlRelaxNGDefinePtr list;
9652
9653         if (ctxt != NULL) {
9654             oldflags = ctxt->flags;
9655             ctxt->flags |= FLAGS_IGNORABLE;
9656         }
9657
9658         list = define->nameClass;
9659         while (list != NULL) {
9660             ret = xmlRelaxNGElementMatch(ctxt, list, elem);
9661             if (ret == 1) {
9662                 if (ctxt != NULL)
9663                     ctxt->flags = oldflags;
9664                 return (1);
9665             }
9666             if (ret < 0) {
9667                 if (ctxt != NULL)
9668                     ctxt->flags = oldflags;
9669                 return (ret);
9670             }
9671             list = list->next;
9672         }
9673         if (ctxt != NULL) {
9674             if (ret != 0) {
9675                 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9676                     xmlRelaxNGDumpValidError(ctxt);
9677             } else {
9678                 if (ctxt->errNr > 0)
9679                     xmlRelaxNGPopErrors(ctxt, 0);
9680             }
9681         }
9682         ret = 0;
9683         if (ctxt != NULL) {
9684             ctxt->flags = oldflags;
9685         }
9686     } else {
9687         TODO ret = -1;
9688     }
9689     return (ret);
9690 }
9691
9692 /**
9693  * xmlRelaxNGBestState:
9694  * @ctxt:  a Relax-NG validation context
9695  *
9696  * Find the "best" state in the ctxt->states list of states to report
9697  * errors about. I.e. a state with no element left in the child list
9698  * or the one with the less attributes left.
9699  * This is called only if a falidation error was detected
9700  *
9701  * Returns the index of the "best" state or -1 in case of error
9702  */
9703 static int
9704 xmlRelaxNGBestState(xmlRelaxNGValidCtxtPtr ctxt)
9705 {
9706     xmlRelaxNGValidStatePtr state;
9707     int i, tmp;
9708     int best = -1;
9709     int value = 1000000;
9710
9711     if ((ctxt == NULL) || (ctxt->states == NULL) ||
9712         (ctxt->states->nbState <= 0))
9713         return (-1);
9714
9715     for (i = 0; i < ctxt->states->nbState; i++) {
9716         state = ctxt->states->tabState[i];
9717         if (state == NULL)
9718             continue;
9719         if (state->seq != NULL) {
9720             if ((best == -1) || (value > 100000)) {
9721                 value = 100000;
9722                 best = i;
9723             }
9724         } else {
9725             tmp = state->nbAttrLeft;
9726             if ((best == -1) || (value > tmp)) {
9727                 value = tmp;
9728                 best = i;
9729             }
9730         }
9731     }
9732     return (best);
9733 }
9734
9735 /**
9736  * xmlRelaxNGLogBestError:
9737  * @ctxt:  a Relax-NG validation context
9738  *
9739  * Find the "best" state in the ctxt->states list of states to report
9740  * errors about and log it.
9741  */
9742 static void
9743 xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt)
9744 {
9745     int best;
9746
9747     if ((ctxt == NULL) || (ctxt->states == NULL) ||
9748         (ctxt->states->nbState <= 0))
9749         return;
9750
9751     best = xmlRelaxNGBestState(ctxt);
9752     if ((best >= 0) && (best < ctxt->states->nbState)) {
9753         ctxt->state = ctxt->states->tabState[best];
9754
9755         xmlRelaxNGValidateElementEnd(ctxt, 1);
9756     }
9757 }
9758
9759 /**
9760  * xmlRelaxNGValidateElementEnd:
9761  * @ctxt:  a Relax-NG validation context
9762  * @dolog:  indicate that error logging should be done
9763  *
9764  * Validate the end of the element, implements check that
9765  * there is nothing left not consumed in the element content
9766  * or in the attribute list.
9767  *
9768  * Returns 0 if the validation succeeded or an error code.
9769  */
9770 static int
9771 xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt, int dolog)
9772 {
9773     int i;
9774     xmlRelaxNGValidStatePtr state;
9775
9776     state = ctxt->state;
9777     if (state->seq != NULL) {
9778         state->seq = xmlRelaxNGSkipIgnored(ctxt, state->seq);
9779         if (state->seq != NULL) {
9780             if (dolog) {
9781                 VALID_ERR3(XML_RELAXNG_ERR_EXTRACONTENT,
9782                            state->node->name, state->seq->name);
9783             }
9784             return (-1);
9785         }
9786     }
9787     for (i = 0; i < state->nbAttrs; i++) {
9788         if (state->attrs[i] != NULL) {
9789             if (dolog) {
9790                 VALID_ERR3(XML_RELAXNG_ERR_INVALIDATTR,
9791                            state->attrs[i]->name, state->node->name);
9792             }
9793             return (-1 - i);
9794         }
9795     }
9796     return (0);
9797 }
9798
9799 /**
9800  * xmlRelaxNGValidateState:
9801  * @ctxt:  a Relax-NG validation context
9802  * @define:  the definition to verify
9803  *
9804  * Validate the current state against the definition
9805  *
9806  * Returns 0 if the validation succeeded or an error code.
9807  */
9808 static int
9809 xmlRelaxNGValidateState(xmlRelaxNGValidCtxtPtr ctxt,
9810                         xmlRelaxNGDefinePtr define)
9811 {
9812     xmlNodePtr node;
9813     int ret = 0, i, tmp, oldflags, errNr;
9814     xmlRelaxNGValidStatePtr oldstate = NULL, state;
9815
9816     if (define == NULL) {
9817         VALID_ERR(XML_RELAXNG_ERR_NODEFINE);
9818         return (-1);
9819     }
9820
9821     if (ctxt->state != NULL) {
9822         node = ctxt->state->seq;
9823     } else {
9824         node = NULL;
9825     }
9826 #ifdef DEBUG
9827     for (i = 0; i < ctxt->depth; i++)
9828         xmlGenericError(xmlGenericErrorContext, " ");
9829     xmlGenericError(xmlGenericErrorContext,
9830                     "Start validating %s ", xmlRelaxNGDefName(define));
9831     if (define->name != NULL)
9832         xmlGenericError(xmlGenericErrorContext, "%s ", define->name);
9833     if ((node != NULL) && (node->name != NULL))
9834         xmlGenericError(xmlGenericErrorContext, "on %s\n", node->name);
9835     else
9836         xmlGenericError(xmlGenericErrorContext, "\n");
9837 #endif
9838     ctxt->depth++;
9839     switch (define->type) {
9840         case XML_RELAXNG_EMPTY:
9841             node = xmlRelaxNGSkipIgnored(ctxt, node);
9842             ret = 0;
9843             break;
9844         case XML_RELAXNG_NOT_ALLOWED:
9845             ret = -1;
9846             break;
9847         case XML_RELAXNG_TEXT:
9848             while ((node != NULL) &&
9849                    ((node->type == XML_TEXT_NODE) ||
9850                     (node->type == XML_COMMENT_NODE) ||
9851                     (node->type == XML_PI_NODE) ||
9852                     (node->type == XML_CDATA_SECTION_NODE)))
9853                 node = node->next;
9854             ctxt->state->seq = node;
9855             break;
9856         case XML_RELAXNG_ELEMENT:
9857             errNr = ctxt->errNr;
9858             node = xmlRelaxNGSkipIgnored(ctxt, node);
9859             if (node == NULL) {
9860                 VALID_ERR2(XML_RELAXNG_ERR_NOELEM, define->name);
9861                 ret = -1;
9862                 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9863                     xmlRelaxNGDumpValidError(ctxt);
9864                 break;
9865             }
9866             if (node->type != XML_ELEMENT_NODE) {
9867                 VALID_ERR(XML_RELAXNG_ERR_NOTELEM);
9868                 ret = -1;
9869                 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9870                     xmlRelaxNGDumpValidError(ctxt);
9871                 break;
9872             }
9873             /*
9874              * This node was already validated successfully against
9875              * this definition.
9876              */
9877             if (node->psvi == define) {
9878                 ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt, node->next);
9879                 if (ctxt->errNr > errNr)
9880                     xmlRelaxNGPopErrors(ctxt, errNr);
9881                 if (ctxt->errNr != 0) {
9882                     while ((ctxt->err != NULL) &&
9883                            (((ctxt->err->err == XML_RELAXNG_ERR_ELEMNAME)
9884                              && (xmlStrEqual(ctxt->err->arg2, node->name)))
9885                             ||
9886                             ((ctxt->err->err ==
9887                               XML_RELAXNG_ERR_ELEMEXTRANS)
9888                              && (xmlStrEqual(ctxt->err->arg1, node->name)))
9889                             || (ctxt->err->err == XML_RELAXNG_ERR_NOELEM)
9890                             || (ctxt->err->err ==
9891                                 XML_RELAXNG_ERR_NOTELEM)))
9892                         xmlRelaxNGValidErrorPop(ctxt);
9893                 }
9894                 break;
9895             }
9896
9897             ret = xmlRelaxNGElementMatch(ctxt, define, node);
9898             if (ret <= 0) {
9899                 ret = -1;
9900                 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9901                     xmlRelaxNGDumpValidError(ctxt);
9902                 break;
9903             }
9904             ret = 0;
9905             if (ctxt->errNr != 0) {
9906                 if (ctxt->errNr > errNr)
9907                     xmlRelaxNGPopErrors(ctxt, errNr);
9908                 while ((ctxt->err != NULL) &&
9909                        (((ctxt->err->err == XML_RELAXNG_ERR_ELEMNAME) &&
9910                          (xmlStrEqual(ctxt->err->arg2, node->name))) ||
9911                         ((ctxt->err->err == XML_RELAXNG_ERR_ELEMEXTRANS) &&
9912                          (xmlStrEqual(ctxt->err->arg1, node->name))) ||
9913                         (ctxt->err->err == XML_RELAXNG_ERR_NOELEM) ||
9914                         (ctxt->err->err == XML_RELAXNG_ERR_NOTELEM)))
9915                     xmlRelaxNGValidErrorPop(ctxt);
9916             }
9917             errNr = ctxt->errNr;
9918
9919             oldflags = ctxt->flags;
9920             if (ctxt->flags & FLAGS_MIXED_CONTENT) {
9921                 ctxt->flags -= FLAGS_MIXED_CONTENT;
9922             }
9923             state = xmlRelaxNGNewValidState(ctxt, node);
9924             if (state == NULL) {
9925                 ret = -1;
9926                 if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
9927                     xmlRelaxNGDumpValidError(ctxt);
9928                 break;
9929             }
9930
9931             oldstate = ctxt->state;
9932             ctxt->state = state;
9933             if (define->attrs != NULL) {
9934                 tmp = xmlRelaxNGValidateAttributeList(ctxt, define->attrs);
9935                 if (tmp != 0) {
9936                     ret = -1;
9937                     VALID_ERR2(XML_RELAXNG_ERR_ATTRVALID, node->name);
9938                 }
9939             }
9940             if (define->contModel != NULL) {
9941                 xmlRelaxNGValidStatePtr nstate, tmpstate = ctxt->state;
9942                 xmlRelaxNGStatesPtr tmpstates = ctxt->states;
9943                 xmlNodePtr nseq;
9944
9945                 nstate = xmlRelaxNGNewValidState(ctxt, node);
9946                 ctxt->state = nstate;
9947                 ctxt->states = NULL;
9948
9949                 tmp = xmlRelaxNGValidateCompiledContent(ctxt,
9950                                                         define->contModel,
9951                                                         ctxt->state->seq);
9952                 nseq = ctxt->state->seq;
9953                 ctxt->state = tmpstate;
9954                 ctxt->states = tmpstates;
9955                 xmlRelaxNGFreeValidState(ctxt, nstate);
9956
9957 #ifdef DEBUG_COMPILE
9958                 xmlGenericError(xmlGenericErrorContext,
9959                                 "Validating content of '%s' : %d\n",
9960                                 define->name, tmp);
9961 #endif
9962                 if (tmp != 0)
9963                     ret = -1;
9964
9965                 if (ctxt->states != NULL) {
9966                     tmp = -1;
9967
9968                     for (i = 0; i < ctxt->states->nbState; i++) {
9969                         state = ctxt->states->tabState[i];
9970                         ctxt->state = state;
9971                         ctxt->state->seq = nseq;
9972
9973                         if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
9974                             tmp = 0;
9975                             break;
9976                         }
9977                     }
9978                     if (tmp != 0) {
9979                         /*
9980                          * validation error, log the message for the "best" one
9981                          */
9982                         ctxt->flags |= FLAGS_IGNORABLE;
9983                         xmlRelaxNGLogBestError(ctxt);
9984                     }
9985                     for (i = 0; i < ctxt->states->nbState; i++) {
9986                         xmlRelaxNGFreeValidState(ctxt,
9987                                                  ctxt->states->
9988                                                  tabState[i]);
9989                     }
9990                     xmlRelaxNGFreeStates(ctxt, ctxt->states);
9991                     ctxt->flags = oldflags;
9992                     ctxt->states = NULL;
9993                     if ((ret == 0) && (tmp == -1))
9994                         ret = -1;
9995                 } else {
9996                     state = ctxt->state;
9997                     if (ctxt->state != NULL)
9998                         ctxt->state->seq = nseq;
9999                     if (ret == 0)
10000                         ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
10001                     xmlRelaxNGFreeValidState(ctxt, state);
10002                 }
10003             } else {
10004                 if (define->content != NULL) {
10005                     tmp = xmlRelaxNGValidateDefinitionList(ctxt,
10006                                                            define->
10007                                                            content);
10008                     if (tmp != 0) {
10009                         ret = -1;
10010                         if (ctxt->state == NULL) {
10011                             ctxt->state = oldstate;
10012                             VALID_ERR2(XML_RELAXNG_ERR_CONTENTVALID,
10013                                        node->name);
10014                             ctxt->state = NULL;
10015                         } else {
10016                             VALID_ERR2(XML_RELAXNG_ERR_CONTENTVALID,
10017                                        node->name);
10018                         }
10019
10020                     }
10021                 }
10022                 if (ctxt->states != NULL) {
10023                     tmp = -1;
10024
10025                     for (i = 0; i < ctxt->states->nbState; i++) {
10026                         state = ctxt->states->tabState[i];
10027                         ctxt->state = state;
10028
10029                         if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
10030                             tmp = 0;
10031                             break;
10032                         }
10033                     }
10034                     if (tmp != 0) {
10035                         /*
10036                          * validation error, log the message for the "best" one
10037                          */
10038                         ctxt->flags |= FLAGS_IGNORABLE;
10039                         xmlRelaxNGLogBestError(ctxt);
10040                     }
10041                     for (i = 0; i < ctxt->states->nbState; i++) {
10042                         xmlRelaxNGFreeValidState(ctxt,
10043                                                  ctxt->states->tabState[i]);
10044                         ctxt->states->tabState[i] = NULL;
10045                     }
10046                     xmlRelaxNGFreeStates(ctxt, ctxt->states);
10047                     ctxt->flags = oldflags;
10048                     ctxt->states = NULL;
10049                     if ((ret == 0) && (tmp == -1))
10050                         ret = -1;
10051                 } else {
10052                     state = ctxt->state;
10053                     if (ret == 0)
10054                         ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
10055                     xmlRelaxNGFreeValidState(ctxt, state);
10056                 }
10057             }
10058             if (ret == 0) {
10059                 node->psvi = define;
10060             }
10061             ctxt->flags = oldflags;
10062             ctxt->state = oldstate;
10063             if (oldstate != NULL)
10064                 oldstate->seq = xmlRelaxNGSkipIgnored(ctxt, node->next);
10065             if (ret != 0) {
10066                 if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
10067                     xmlRelaxNGDumpValidError(ctxt);
10068                     ret = 0;
10069 #if 0
10070                 } else {
10071                     ret = -2;
10072 #endif
10073                 }
10074             } else {
10075                 if (ctxt->errNr > errNr)
10076                     xmlRelaxNGPopErrors(ctxt, errNr);
10077             }
10078
10079 #ifdef DEBUG
10080             xmlGenericError(xmlGenericErrorContext,
10081                             "xmlRelaxNGValidateDefinition(): validated %s : %d",
10082                             node->name, ret);
10083             if (oldstate == NULL)
10084                 xmlGenericError(xmlGenericErrorContext, ": no state\n");
10085             else if (oldstate->seq == NULL)
10086                 xmlGenericError(xmlGenericErrorContext, ": done\n");
10087             else if (oldstate->seq->type == XML_ELEMENT_NODE)
10088                 xmlGenericError(xmlGenericErrorContext, ": next elem %s\n",
10089                                 oldstate->seq->name);
10090             else
10091                 xmlGenericError(xmlGenericErrorContext, ": next %s %d\n",
10092                                 oldstate->seq->name, oldstate->seq->type);
10093 #endif
10094             break;
10095         case XML_RELAXNG_OPTIONAL:{
10096                 errNr = ctxt->errNr;
10097                 oldflags = ctxt->flags;
10098                 ctxt->flags |= FLAGS_IGNORABLE;
10099                 oldstate = xmlRelaxNGCopyValidState(ctxt, ctxt->state);
10100                 ret =
10101                     xmlRelaxNGValidateDefinitionList(ctxt,
10102                                                      define->content);
10103                 if (ret != 0) {
10104                     if (ctxt->state != NULL)
10105                         xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10106                     ctxt->state = oldstate;
10107                     ctxt->flags = oldflags;
10108                     ret = 0;
10109                     if (ctxt->errNr > errNr)
10110                         xmlRelaxNGPopErrors(ctxt, errNr);
10111                     break;
10112                 }
10113                 if (ctxt->states != NULL) {
10114                     xmlRelaxNGAddStates(ctxt, ctxt->states, oldstate);
10115                 } else {
10116                     ctxt->states = xmlRelaxNGNewStates(ctxt, 1);
10117                     if (ctxt->states == NULL) {
10118                         xmlRelaxNGFreeValidState(ctxt, oldstate);
10119                         ctxt->flags = oldflags;
10120                         ret = -1;
10121                         if (ctxt->errNr > errNr)
10122                             xmlRelaxNGPopErrors(ctxt, errNr);
10123                         break;
10124                     }
10125                     xmlRelaxNGAddStates(ctxt, ctxt->states, oldstate);
10126                     xmlRelaxNGAddStates(ctxt, ctxt->states, ctxt->state);
10127                     ctxt->state = NULL;
10128                 }
10129                 ctxt->flags = oldflags;
10130                 ret = 0;
10131                 if (ctxt->errNr > errNr)
10132                     xmlRelaxNGPopErrors(ctxt, errNr);
10133                 break;
10134             }
10135         case XML_RELAXNG_ONEORMORE:
10136             errNr = ctxt->errNr;
10137             ret = xmlRelaxNGValidateDefinitionList(ctxt, define->content);
10138             if (ret != 0) {
10139                 break;
10140             }
10141             if (ctxt->errNr > errNr)
10142                 xmlRelaxNGPopErrors(ctxt, errNr);
10143             /* no break on purpose */
10144         case XML_RELAXNG_ZEROORMORE:{
10145                 int progress;
10146                 xmlRelaxNGStatesPtr states = NULL, res = NULL;
10147                 int base, j;
10148
10149                 errNr = ctxt->errNr;
10150                 res = xmlRelaxNGNewStates(ctxt, 1);
10151                 if (res == NULL) {
10152                     ret = -1;
10153                     break;
10154                 }
10155                 /*
10156                  * All the input states are also exit states
10157                  */
10158                 if (ctxt->state != NULL) {
10159                     xmlRelaxNGAddStates(ctxt, res,
10160                                         xmlRelaxNGCopyValidState(ctxt,
10161                                                                  ctxt->
10162                                                                  state));
10163                 } else {
10164                     for (j = 0; j < ctxt->states->nbState; j++) {
10165                         xmlRelaxNGAddStates(ctxt, res,
10166                             xmlRelaxNGCopyValidState(ctxt,
10167                                             ctxt->states->tabState[j]));
10168                     }
10169                 }
10170                 oldflags = ctxt->flags;
10171                 ctxt->flags |= FLAGS_IGNORABLE;
10172                 do {
10173                     progress = 0;
10174                     base = res->nbState;
10175
10176                     if (ctxt->states != NULL) {
10177                         states = ctxt->states;
10178                         for (i = 0; i < states->nbState; i++) {
10179                             ctxt->state = states->tabState[i];
10180                             ctxt->states = NULL;
10181                             ret = xmlRelaxNGValidateDefinitionList(ctxt,
10182                                                                    define->
10183                                                                    content);
10184                             if (ret == 0) {
10185                                 if (ctxt->state != NULL) {
10186                                     tmp = xmlRelaxNGAddStates(ctxt, res,
10187                                                               ctxt->state);
10188                                     ctxt->state = NULL;
10189                                     if (tmp == 1)
10190                                         progress = 1;
10191                                 } else if (ctxt->states != NULL) {
10192                                     for (j = 0; j < ctxt->states->nbState;
10193                                          j++) {
10194                                         tmp =
10195                                             xmlRelaxNGAddStates(ctxt, res,
10196                                                    ctxt->states->tabState[j]);
10197                                         if (tmp == 1)
10198                                             progress = 1;
10199                                     }
10200                                     xmlRelaxNGFreeStates(ctxt,
10201                                                          ctxt->states);
10202                                     ctxt->states = NULL;
10203                                 }
10204                             } else {
10205                                 if (ctxt->state != NULL) {
10206                                     xmlRelaxNGFreeValidState(ctxt,
10207                                                              ctxt->state);
10208                                     ctxt->state = NULL;
10209                                 }
10210                             }
10211                         }
10212                     } else {
10213                         ret = xmlRelaxNGValidateDefinitionList(ctxt,
10214                                                                define->
10215                                                                content);
10216                         if (ret != 0) {
10217                             xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10218                             ctxt->state = NULL;
10219                         } else {
10220                             base = res->nbState;
10221                             if (ctxt->state != NULL) {
10222                                 tmp = xmlRelaxNGAddStates(ctxt, res,
10223                                                           ctxt->state);
10224                                 ctxt->state = NULL;
10225                                 if (tmp == 1)
10226                                     progress = 1;
10227                             } else if (ctxt->states != NULL) {
10228                                 for (j = 0; j < ctxt->states->nbState; j++) {
10229                                     tmp = xmlRelaxNGAddStates(ctxt, res,
10230                                                ctxt->states->tabState[j]);
10231                                     if (tmp == 1)
10232                                         progress = 1;
10233                                 }
10234                                 if (states == NULL) {
10235                                     states = ctxt->states;
10236                                 } else {
10237                                     xmlRelaxNGFreeStates(ctxt,
10238                                                          ctxt->states);
10239                                 }
10240                                 ctxt->states = NULL;
10241                             }
10242                         }
10243                     }
10244                     if (progress) {
10245                         /*
10246                          * Collect all the new nodes added at that step
10247                          * and make them the new node set
10248                          */
10249                         if (res->nbState - base == 1) {
10250                             ctxt->state = xmlRelaxNGCopyValidState(ctxt,
10251                                                                    res->
10252                                                                    tabState
10253                                                                    [base]);
10254                         } else {
10255                             if (states == NULL) {
10256                                 xmlRelaxNGNewStates(ctxt,
10257                                                     res->nbState - base);
10258                                 states = ctxt->states;
10259                                 if (states == NULL) {
10260                                     progress = 0;
10261                                     break;
10262                                 }
10263                             }
10264                             states->nbState = 0;
10265                             for (i = base; i < res->nbState; i++)
10266                                 xmlRelaxNGAddStates(ctxt, states,
10267                                                     xmlRelaxNGCopyValidState
10268                                                     (ctxt, res->tabState[i]));
10269                             ctxt->states = states;
10270                         }
10271                     }
10272                 } while (progress == 1);
10273                 if (states != NULL) {
10274                     xmlRelaxNGFreeStates(ctxt, states);
10275                 }
10276                 ctxt->states = res;
10277                 ctxt->flags = oldflags;
10278 #if 0
10279                 /*
10280                  * errors may have to be propagated back...
10281                  */
10282                 if (ctxt->errNr > errNr)
10283                     xmlRelaxNGPopErrors(ctxt, errNr);
10284 #endif
10285                 ret = 0;
10286                 break;
10287             }
10288         case XML_RELAXNG_CHOICE:{
10289                 xmlRelaxNGDefinePtr list = NULL;
10290                 xmlRelaxNGStatesPtr states = NULL;
10291
10292                 node = xmlRelaxNGSkipIgnored(ctxt, node);
10293
10294                 errNr = ctxt->errNr;
10295                 if ((define->dflags & IS_TRIABLE) && (define->data != NULL) &&
10296                     (node != NULL)) {
10297                     /*
10298                      * node == NULL can't be optimized since IS_TRIABLE
10299                      * doesn't account for choice which may lead to
10300                      * only attributes.
10301                      */
10302                     xmlHashTablePtr triage =
10303                         (xmlHashTablePtr) define->data;
10304
10305                     /*
10306                      * Something we can optimize cleanly there is only one
10307                      * possble branch out !
10308                      */
10309                     if ((node->type == XML_TEXT_NODE) ||
10310                         (node->type == XML_CDATA_SECTION_NODE)) {
10311                         list =
10312                             xmlHashLookup2(triage, BAD_CAST "#text", NULL);
10313                     } else if (node->type == XML_ELEMENT_NODE) {
10314                         if (node->ns != NULL) {
10315                             list = xmlHashLookup2(triage, node->name,
10316                                                   node->ns->href);
10317                             if (list == NULL)
10318                                 list =
10319                                     xmlHashLookup2(triage, BAD_CAST "#any",
10320                                                    node->ns->href);
10321                         } else
10322                             list =
10323                                 xmlHashLookup2(triage, node->name, NULL);
10324                         if (list == NULL)
10325                             list =
10326                                 xmlHashLookup2(triage, BAD_CAST "#any",
10327                                                NULL);
10328                     }
10329                     if (list == NULL) {
10330                         ret = -1;
10331                         VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, node->name);
10332                         break;
10333                     }
10334                     ret = xmlRelaxNGValidateDefinition(ctxt, list);
10335                     if (ret == 0) {
10336                     }
10337                     break;
10338                 }
10339
10340                 list = define->content;
10341                 oldflags = ctxt->flags;
10342                 ctxt->flags |= FLAGS_IGNORABLE;
10343
10344                 while (list != NULL) {
10345                     oldstate = xmlRelaxNGCopyValidState(ctxt, ctxt->state);
10346                     ret = xmlRelaxNGValidateDefinition(ctxt, list);
10347                     if (ret == 0) {
10348                         if (states == NULL) {
10349                             states = xmlRelaxNGNewStates(ctxt, 1);
10350                         }
10351                         if (ctxt->state != NULL) {
10352                             xmlRelaxNGAddStates(ctxt, states, ctxt->state);
10353                         } else if (ctxt->states != NULL) {
10354                             for (i = 0; i < ctxt->states->nbState; i++) {
10355                                 xmlRelaxNGAddStates(ctxt, states,
10356                                                     ctxt->states->
10357                                                     tabState[i]);
10358                             }
10359                             xmlRelaxNGFreeStates(ctxt, ctxt->states);
10360                             ctxt->states = NULL;
10361                         }
10362                     } else {
10363                         xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10364                     }
10365                     ctxt->state = oldstate;
10366                     list = list->next;
10367                 }
10368                 if (states != NULL) {
10369                     xmlRelaxNGFreeValidState(ctxt, oldstate);
10370                     ctxt->states = states;
10371                     ctxt->state = NULL;
10372                     ret = 0;
10373                 } else {
10374                     ctxt->states = NULL;
10375                 }
10376                 ctxt->flags = oldflags;
10377                 if (ret != 0) {
10378                     if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
10379                         xmlRelaxNGDumpValidError(ctxt);
10380                     }
10381                 } else {
10382                     if (ctxt->errNr > errNr)
10383                         xmlRelaxNGPopErrors(ctxt, errNr);
10384                 }
10385                 break;
10386             }
10387         case XML_RELAXNG_DEF:
10388         case XML_RELAXNG_GROUP:
10389             ret = xmlRelaxNGValidateDefinitionList(ctxt, define->content);
10390             break;
10391         case XML_RELAXNG_INTERLEAVE:
10392             ret = xmlRelaxNGValidateInterleave(ctxt, define);
10393             break;
10394         case XML_RELAXNG_ATTRIBUTE:
10395             ret = xmlRelaxNGValidateAttribute(ctxt, define);
10396             break;
10397         case XML_RELAXNG_START:
10398         case XML_RELAXNG_NOOP:
10399         case XML_RELAXNG_REF:
10400         case XML_RELAXNG_EXTERNALREF:
10401         case XML_RELAXNG_PARENTREF:
10402             ret = xmlRelaxNGValidateDefinition(ctxt, define->content);
10403             break;
10404         case XML_RELAXNG_DATATYPE:{
10405                 xmlNodePtr child;
10406                 xmlChar *content = NULL;
10407
10408                 child = node;
10409                 while (child != NULL) {
10410                     if (child->type == XML_ELEMENT_NODE) {
10411                         VALID_ERR2(XML_RELAXNG_ERR_DATAELEM,
10412                                    node->parent->name);
10413                         ret = -1;
10414                         break;
10415                     } else if ((child->type == XML_TEXT_NODE) ||
10416                                (child->type == XML_CDATA_SECTION_NODE)) {
10417                         content = xmlStrcat(content, child->content);
10418                     }
10419                     /* TODO: handle entities ... */
10420                     child = child->next;
10421                 }
10422                 if (ret == -1) {
10423                     if (content != NULL)
10424                         xmlFree(content);
10425                     break;
10426                 }
10427                 if (content == NULL) {
10428                     content = xmlStrdup(BAD_CAST "");
10429                     if (content == NULL) {
10430                         xmlRngVErrMemory(ctxt, "validating\n");
10431                         ret = -1;
10432                         break;
10433                     }
10434                 }
10435                 ret = xmlRelaxNGValidateDatatype(ctxt, content, define,
10436                                                  ctxt->state->seq);
10437                 if (ret == -1) {
10438                     VALID_ERR2(XML_RELAXNG_ERR_DATATYPE, define->name);
10439                 } else if (ret == 0) {
10440                     ctxt->state->seq = NULL;
10441                 }
10442                 if (content != NULL)
10443                     xmlFree(content);
10444                 break;
10445             }
10446         case XML_RELAXNG_VALUE:{
10447                 xmlChar *content = NULL;
10448                 xmlChar *oldvalue;
10449                 xmlNodePtr child;
10450
10451                 child = node;
10452                 while (child != NULL) {
10453                     if (child->type == XML_ELEMENT_NODE) {
10454                         VALID_ERR2(XML_RELAXNG_ERR_VALELEM,
10455                                    node->parent->name);
10456                         ret = -1;
10457                         break;
10458                     } else if ((child->type == XML_TEXT_NODE) ||
10459                                (child->type == XML_CDATA_SECTION_NODE)) {
10460                         content = xmlStrcat(content, child->content);
10461                     }
10462                     /* TODO: handle entities ... */
10463                     child = child->next;
10464                 }
10465                 if (ret == -1) {
10466                     if (content != NULL)
10467                         xmlFree(content);
10468                     break;
10469                 }
10470                 if (content == NULL) {
10471                     content = xmlStrdup(BAD_CAST "");
10472                     if (content == NULL) {
10473                         xmlRngVErrMemory(ctxt, "validating\n");
10474                         ret = -1;
10475                         break;
10476                     }
10477                 }
10478                 oldvalue = ctxt->state->value;
10479                 ctxt->state->value = content;
10480                 ret = xmlRelaxNGValidateValue(ctxt, define);
10481                 ctxt->state->value = oldvalue;
10482                 if (ret == -1) {
10483                     VALID_ERR2(XML_RELAXNG_ERR_VALUE, define->name);
10484                 } else if (ret == 0) {
10485                     ctxt->state->seq = NULL;
10486                 }
10487                 if (content != NULL)
10488                     xmlFree(content);
10489                 break;
10490             }
10491         case XML_RELAXNG_LIST:{
10492                 xmlChar *content;
10493                 xmlNodePtr child;
10494                 xmlChar *oldvalue, *oldendvalue;
10495                 int len;
10496
10497                 /*
10498                  * Make sure it's only text nodes
10499                  */
10500
10501                 content = NULL;
10502                 child = node;
10503                 while (child != NULL) {
10504                     if (child->type == XML_ELEMENT_NODE) {
10505                         VALID_ERR2(XML_RELAXNG_ERR_LISTELEM,
10506                                    node->parent->name);
10507                         ret = -1;
10508                         break;
10509                     } else if ((child->type == XML_TEXT_NODE) ||
10510                                (child->type == XML_CDATA_SECTION_NODE)) {
10511                         content = xmlStrcat(content, child->content);
10512                     }
10513                     /* TODO: handle entities ... */
10514                     child = child->next;
10515                 }
10516                 if (ret == -1) {
10517                     if (content != NULL)
10518                         xmlFree(content);
10519                     break;
10520                 }
10521                 if (content == NULL) {
10522                     content = xmlStrdup(BAD_CAST "");
10523                     if (content == NULL) {
10524                         xmlRngVErrMemory(ctxt, "validating\n");
10525                         ret = -1;
10526                         break;
10527                     }
10528                 }
10529                 len = xmlStrlen(content);
10530                 oldvalue = ctxt->state->value;
10531                 oldendvalue = ctxt->state->endvalue;
10532                 ctxt->state->value = content;
10533                 ctxt->state->endvalue = content + len;
10534                 ret = xmlRelaxNGValidateValue(ctxt, define);
10535                 ctxt->state->value = oldvalue;
10536                 ctxt->state->endvalue = oldendvalue;
10537                 if (ret == -1) {
10538                     VALID_ERR(XML_RELAXNG_ERR_LIST);
10539                 } else if ((ret == 0) && (node != NULL)) {
10540                     ctxt->state->seq = node->next;
10541                 }
10542                 if (content != NULL)
10543                     xmlFree(content);
10544                 break;
10545             }
10546         case XML_RELAXNG_EXCEPT:
10547         case XML_RELAXNG_PARAM:
10548             TODO ret = -1;
10549             break;
10550     }
10551     ctxt->depth--;
10552 #ifdef DEBUG
10553     for (i = 0; i < ctxt->depth; i++)
10554         xmlGenericError(xmlGenericErrorContext, " ");
10555     xmlGenericError(xmlGenericErrorContext,
10556                     "Validating %s ", xmlRelaxNGDefName(define));
10557     if (define->name != NULL)
10558         xmlGenericError(xmlGenericErrorContext, "%s ", define->name);
10559     if (ret == 0)
10560         xmlGenericError(xmlGenericErrorContext, "suceeded\n");
10561     else
10562         xmlGenericError(xmlGenericErrorContext, "failed\n");
10563 #endif
10564     return (ret);
10565 }
10566
10567 /**
10568  * xmlRelaxNGValidateDefinition:
10569  * @ctxt:  a Relax-NG validation context
10570  * @define:  the definition to verify
10571  *
10572  * Validate the current node lists against the definition
10573  *
10574  * Returns 0 if the validation succeeded or an error code.
10575  */
10576 static int
10577 xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt,
10578                              xmlRelaxNGDefinePtr define)
10579 {
10580     xmlRelaxNGStatesPtr states, res;
10581     int i, j, k, ret, oldflags;
10582
10583     /*
10584      * We should NOT have both ctxt->state and ctxt->states
10585      */
10586     if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
10587         TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10588         ctxt->state = NULL;
10589     }
10590
10591     if ((ctxt->states == NULL) || (ctxt->states->nbState == 1)) {
10592         if (ctxt->states != NULL) {
10593             ctxt->state = ctxt->states->tabState[0];
10594             xmlRelaxNGFreeStates(ctxt, ctxt->states);
10595             ctxt->states = NULL;
10596         }
10597         ret = xmlRelaxNGValidateState(ctxt, define);
10598         if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
10599             TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10600             ctxt->state = NULL;
10601         }
10602         if ((ctxt->states != NULL) && (ctxt->states->nbState == 1)) {
10603             ctxt->state = ctxt->states->tabState[0];
10604             xmlRelaxNGFreeStates(ctxt, ctxt->states);
10605             ctxt->states = NULL;
10606         }
10607         return (ret);
10608     }
10609
10610     states = ctxt->states;
10611     ctxt->states = NULL;
10612     res = NULL;
10613     j = 0;
10614     oldflags = ctxt->flags;
10615     ctxt->flags |= FLAGS_IGNORABLE;
10616     for (i = 0; i < states->nbState; i++) {
10617         ctxt->state = states->tabState[i];
10618         ctxt->states = NULL;
10619         ret = xmlRelaxNGValidateState(ctxt, define);
10620         /*
10621          * We should NOT have both ctxt->state and ctxt->states
10622          */
10623         if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
10624             TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10625             ctxt->state = NULL;
10626         }
10627         if (ret == 0) {
10628             if (ctxt->states == NULL) {
10629                 if (res != NULL) {
10630                     /* add the state to the container */
10631                     xmlRelaxNGAddStates(ctxt, res, ctxt->state);
10632                     ctxt->state = NULL;
10633                 } else {
10634                     /* add the state directly in states */
10635                     states->tabState[j++] = ctxt->state;
10636                     ctxt->state = NULL;
10637                 }
10638             } else {
10639                 if (res == NULL) {
10640                     /* make it the new container and copy other results */
10641                     res = ctxt->states;
10642                     ctxt->states = NULL;
10643                     for (k = 0; k < j; k++)
10644                         xmlRelaxNGAddStates(ctxt, res,
10645                                             states->tabState[k]);
10646                 } else {
10647                     /* add all the new results to res and reff the container */
10648                     for (k = 0; k < ctxt->states->nbState; k++)
10649                         xmlRelaxNGAddStates(ctxt, res,
10650                                             ctxt->states->tabState[k]);
10651                     xmlRelaxNGFreeStates(ctxt, ctxt->states);
10652                     ctxt->states = NULL;
10653                 }
10654             }
10655         } else {
10656             if (ctxt->state != NULL) {
10657                 xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10658                 ctxt->state = NULL;
10659             } else if (ctxt->states != NULL) {
10660                 for (k = 0; k < ctxt->states->nbState; k++)
10661                     xmlRelaxNGFreeValidState(ctxt,
10662                                              ctxt->states->tabState[k]);
10663                 xmlRelaxNGFreeStates(ctxt, ctxt->states);
10664                 ctxt->states = NULL;
10665             }
10666         }
10667     }
10668     ctxt->flags = oldflags;
10669     if (res != NULL) {
10670         xmlRelaxNGFreeStates(ctxt, states);
10671         ctxt->states = res;
10672         ret = 0;
10673     } else if (j > 1) {
10674         states->nbState = j;
10675         ctxt->states = states;
10676         ret = 0;
10677     } else if (j == 1) {
10678         ctxt->state = states->tabState[0];
10679         xmlRelaxNGFreeStates(ctxt, states);
10680         ret = 0;
10681     } else {
10682         ret = -1;
10683         xmlRelaxNGFreeStates(ctxt, states);
10684         if (ctxt->states != NULL) {
10685             xmlRelaxNGFreeStates(ctxt, ctxt->states);
10686             ctxt->states = NULL;
10687         }
10688     }
10689     if ((ctxt->state != NULL) && (ctxt->states != NULL)) {
10690         TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10691         ctxt->state = NULL;
10692     }
10693     return (ret);
10694 }
10695
10696 /**
10697  * xmlRelaxNGValidateDocument:
10698  * @ctxt:  a Relax-NG validation context
10699  * @doc:  the document
10700  *
10701  * Validate the given document
10702  *
10703  * Returns 0 if the validation succeeded or an error code.
10704  */
10705 static int
10706 xmlRelaxNGValidateDocument(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc)
10707 {
10708     int ret;
10709     xmlRelaxNGPtr schema;
10710     xmlRelaxNGGrammarPtr grammar;
10711     xmlRelaxNGValidStatePtr state;
10712     xmlNodePtr node;
10713
10714     if ((ctxt == NULL) || (ctxt->schema == NULL) || (doc == NULL))
10715         return (-1);
10716
10717     ctxt->errNo = XML_RELAXNG_OK;
10718     schema = ctxt->schema;
10719     grammar = schema->topgrammar;
10720     if (grammar == NULL) {
10721         VALID_ERR(XML_RELAXNG_ERR_NOGRAMMAR);
10722         return (-1);
10723     }
10724     state = xmlRelaxNGNewValidState(ctxt, NULL);
10725     ctxt->state = state;
10726     ret = xmlRelaxNGValidateDefinition(ctxt, grammar->start);
10727     if ((ctxt->state != NULL) && (state->seq != NULL)) {
10728         state = ctxt->state;
10729         node = state->seq;
10730         node = xmlRelaxNGSkipIgnored(ctxt, node);
10731         if (node != NULL) {
10732             if (ret != -1) {
10733                 VALID_ERR(XML_RELAXNG_ERR_EXTRADATA);
10734                 ret = -1;
10735             }
10736         }
10737     } else if (ctxt->states != NULL) {
10738         int i;
10739         int tmp = -1;
10740
10741         for (i = 0; i < ctxt->states->nbState; i++) {
10742             state = ctxt->states->tabState[i];
10743             node = state->seq;
10744             node = xmlRelaxNGSkipIgnored(ctxt, node);
10745             if (node == NULL)
10746                 tmp = 0;
10747             xmlRelaxNGFreeValidState(ctxt, state);
10748         }
10749         if (tmp == -1) {
10750             if (ret != -1) {
10751                 VALID_ERR(XML_RELAXNG_ERR_EXTRADATA);
10752                 ret = -1;
10753             }
10754         }
10755     }
10756     if (ctxt->state != NULL) {
10757         xmlRelaxNGFreeValidState(ctxt, ctxt->state);
10758         ctxt->state = NULL;
10759     }
10760     if (ret != 0)
10761         xmlRelaxNGDumpValidError(ctxt);
10762 #ifdef DEBUG
10763     else if (ctxt->errNr != 0) {
10764         ctxt->error(ctxt->userData,
10765                     "%d Extra error messages left on stack !\n",
10766                     ctxt->errNr);
10767         xmlRelaxNGDumpValidError(ctxt);
10768     }
10769 #endif
10770 #ifdef LIBXML_VALID_ENABLED
10771     if (ctxt->idref == 1) {
10772         xmlValidCtxt vctxt;
10773
10774         memset(&vctxt, 0, sizeof(xmlValidCtxt));
10775         vctxt.valid = 1;
10776         vctxt.error = ctxt->error;
10777         vctxt.warning = ctxt->warning;
10778         vctxt.userData = ctxt->userData;
10779
10780         if (xmlValidateDocumentFinal(&vctxt, doc) != 1)
10781             ret = -1;
10782     }
10783 #endif /* LIBXML_VALID_ENABLED */
10784     if ((ret == 0) && (ctxt->errNo != XML_RELAXNG_OK))
10785         ret = -1;
10786
10787     return (ret);
10788 }
10789
10790 /**
10791  * xmlRelaxNGCleanPSVI:
10792  * @node:  an input element or document
10793  *
10794  * Call this routine to speed up XPath computation on static documents.
10795  * This stamps all the element nodes with the document order
10796  * Like for line information, the order is kept in the element->content
10797  * field, the value stored is actually - the node number (starting at -1)
10798  * to be able to differentiate from line numbers.
10799  *
10800  * Returns the number of elements found in the document or -1 in case
10801  *    of error.
10802  */
10803 static void
10804 xmlRelaxNGCleanPSVI(xmlNodePtr node) {
10805     xmlNodePtr cur;
10806
10807     if ((node == NULL) ||
10808         ((node->type != XML_ELEMENT_NODE) &&
10809          (node->type != XML_DOCUMENT_NODE) &&
10810          (node->type != XML_HTML_DOCUMENT_NODE)))
10811         return;
10812     if (node->type == XML_ELEMENT_NODE)
10813         node->psvi = NULL;
10814
10815     cur = node->children;
10816     while (cur != NULL) {
10817         if (cur->type == XML_ELEMENT_NODE) {
10818             cur->psvi = NULL;
10819             if (cur->children != NULL) {
10820                 cur = cur->children;
10821                 continue;
10822             }
10823         }
10824         if (cur->next != NULL) {
10825             cur = cur->next;
10826             continue;
10827         }
10828         do {
10829             cur = cur->parent;
10830             if (cur == NULL)
10831                 break;
10832             if (cur == node) {
10833                 cur = NULL;
10834                 break;
10835             }
10836             if (cur->next != NULL) {
10837                 cur = cur->next;
10838                 break;
10839             }
10840         } while (cur != NULL);
10841     }
10842     return;
10843 }
10844 /************************************************************************
10845  *                                                                      *
10846  *                      Validation interfaces                           *
10847  *                                                                      *
10848  ************************************************************************/
10849
10850 /**
10851  * xmlRelaxNGNewValidCtxt:
10852  * @schema:  a precompiled XML RelaxNGs
10853  *
10854  * Create an XML RelaxNGs validation context based on the given schema
10855  *
10856  * Returns the validation context or NULL in case of error
10857  */
10858 xmlRelaxNGValidCtxtPtr
10859 xmlRelaxNGNewValidCtxt(xmlRelaxNGPtr schema)
10860 {
10861     xmlRelaxNGValidCtxtPtr ret;
10862
10863     ret = (xmlRelaxNGValidCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGValidCtxt));
10864     if (ret == NULL) {
10865         xmlRngVErrMemory(NULL, "building context\n");
10866         return (NULL);
10867     }
10868     memset(ret, 0, sizeof(xmlRelaxNGValidCtxt));
10869     ret->schema = schema;
10870     ret->error = xmlGenericError;
10871     ret->userData = xmlGenericErrorContext;
10872     ret->errNr = 0;
10873     ret->errMax = 0;
10874     ret->err = NULL;
10875     ret->errTab = NULL;
10876     if (schema != NULL)
10877         ret->idref = schema->idref;
10878     ret->states = NULL;
10879     ret->freeState = NULL;
10880     ret->freeStates = NULL;
10881     ret->errNo = XML_RELAXNG_OK;
10882     return (ret);
10883 }
10884
10885 /**
10886  * xmlRelaxNGFreeValidCtxt:
10887  * @ctxt:  the schema validation context
10888  *
10889  * Free the resources associated to the schema validation context
10890  */
10891 void
10892 xmlRelaxNGFreeValidCtxt(xmlRelaxNGValidCtxtPtr ctxt)
10893 {
10894     int k;
10895
10896     if (ctxt == NULL)
10897         return;
10898     if (ctxt->states != NULL)
10899         xmlRelaxNGFreeStates(NULL, ctxt->states);
10900     if (ctxt->freeState != NULL) {
10901         for (k = 0; k < ctxt->freeState->nbState; k++) {
10902             xmlRelaxNGFreeValidState(NULL, ctxt->freeState->tabState[k]);
10903         }
10904         xmlRelaxNGFreeStates(NULL, ctxt->freeState);
10905     }
10906     if (ctxt->freeStates != NULL) {
10907         for (k = 0; k < ctxt->freeStatesNr; k++) {
10908             xmlRelaxNGFreeStates(NULL, ctxt->freeStates[k]);
10909         }
10910         xmlFree(ctxt->freeStates);
10911     }
10912     if (ctxt->errTab != NULL)
10913         xmlFree(ctxt->errTab);
10914     if (ctxt->elemTab != NULL) {
10915         xmlRegExecCtxtPtr exec;
10916
10917         exec = xmlRelaxNGElemPop(ctxt);
10918         while (exec != NULL) {
10919             xmlRegFreeExecCtxt(exec);
10920             exec = xmlRelaxNGElemPop(ctxt);
10921         }
10922         xmlFree(ctxt->elemTab);
10923     }
10924     xmlFree(ctxt);
10925 }
10926
10927 /**
10928  * xmlRelaxNGSetValidErrors:
10929  * @ctxt:  a Relax-NG validation context
10930  * @err:  the error function
10931  * @warn: the warning function
10932  * @ctx: the functions context
10933  *
10934  * Set the error and warning callback informations
10935  */
10936 void
10937 xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
10938                          xmlRelaxNGValidityErrorFunc err,
10939                          xmlRelaxNGValidityWarningFunc warn, void *ctx)
10940 {
10941     if (ctxt == NULL)
10942         return;
10943     ctxt->error = err;
10944     ctxt->warning = warn;
10945     ctxt->userData = ctx;
10946     ctxt->serror = NULL;
10947 }
10948
10949 /**
10950  * xmlRelaxNGSetValidStructuredErrors:
10951  * @ctxt:  a Relax-NG validation context
10952  * @serror:  the structured error function
10953  * @ctx: the functions context
10954  *
10955  * Set the structured error callback
10956  */
10957 void
10958 xmlRelaxNGSetValidStructuredErrors(xmlRelaxNGValidCtxtPtr ctxt,
10959                                    xmlStructuredErrorFunc serror, void *ctx)
10960 {
10961     if (ctxt == NULL)
10962         return;
10963     ctxt->serror = serror;
10964     ctxt->error = NULL;
10965     ctxt->warning = NULL;
10966     ctxt->userData = ctx;
10967 }
10968
10969 /**
10970  * xmlRelaxNGGetValidErrors:
10971  * @ctxt:  a Relax-NG validation context
10972  * @err:  the error function result
10973  * @warn: the warning function result
10974  * @ctx: the functions context result
10975  *
10976  * Get the error and warning callback informations
10977  *
10978  * Returns -1 in case of error and 0 otherwise
10979  */
10980 int
10981 xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
10982                          xmlRelaxNGValidityErrorFunc * err,
10983                          xmlRelaxNGValidityWarningFunc * warn, void **ctx)
10984 {
10985     if (ctxt == NULL)
10986         return (-1);
10987     if (err != NULL)
10988         *err = ctxt->error;
10989     if (warn != NULL)
10990         *warn = ctxt->warning;
10991     if (ctx != NULL)
10992         *ctx = ctxt->userData;
10993     return (0);
10994 }
10995
10996 /**
10997  * xmlRelaxNGValidateDoc:
10998  * @ctxt:  a Relax-NG validation context
10999  * @doc:  a parsed document tree
11000  *
11001  * Validate a document tree in memory.
11002  *
11003  * Returns 0 if the document is valid, a positive error code
11004  *     number otherwise and -1 in case of internal or API error.
11005  */
11006 int
11007 xmlRelaxNGValidateDoc(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc)
11008 {
11009     int ret;
11010
11011     if ((ctxt == NULL) || (doc == NULL))
11012         return (-1);
11013
11014     ctxt->doc = doc;
11015
11016     ret = xmlRelaxNGValidateDocument(ctxt, doc);
11017     /*
11018      * Remove all left PSVI
11019      */
11020     xmlRelaxNGCleanPSVI((xmlNodePtr) doc);
11021
11022     /*
11023      * TODO: build error codes
11024      */
11025     if (ret == -1)
11026         return (1);
11027     return (ret);
11028 }
11029
11030 #define bottom_relaxng
11031 #include "elfgcchack.h"
11032 #endif /* LIBXML_SCHEMAS_ENABLED */