valid.c

   1 /*
   2  * valid.c : part of the code use to do the DTD handling and the validity
   3  *           checking
   4  *
   5  * See Copyright for the status of this software.
   6  *
   7  * daniel@veillard.com
   8  */
   9
  10 #define IN_LIBXML
  11 #include "libxml.h"
  12
  13 #include <string.h>
  14
  15 #ifdef HAVE_STDLIB_H
  16 #include <stdlib.h>
  17 #endif
  18
  19 #include <libxml/xmlmemory.h>
  20 #include <libxml/hash.h>
  21 #include <libxml/uri.h>
  22 #include <libxml/valid.h>
  23 #include <libxml/parser.h>
  24 #include <libxml/parserInternals.h>
  25 #include <libxml/xmlerror.h>
  26 #include <libxml/list.h>
  27 #include <libxml/globals.h>
  28
  29 static xmlElementPtr xmlGetDtdElementDesc2(xmlDtdPtr dtd, const xmlChar *name,
  30                                    int create);
  31 /* #define DEBUG_VALID_ALGO */
  32 /* #define DEBUG_REGEXP_ALGO */
  33
  34 #define TODO                                                            \
  35     xmlGenericError(xmlGenericErrorContext,                             \
  36             "Unimplemented block at %s:%d\n",                           \
  37             __FILE__, __LINE__);
  38
  39 #ifdef LIBXML_VALID_ENABLED
  40 static int
  41 xmlValidateAttributeValueInternal(xmlDocPtr doc, xmlAttributeType type,
  42                                   const xmlChar *value);
  43 #endif
  44 /************************************************************************
  45  *                                                                      *
  46  *                      Error handling routines                         *
  47  *                                                                      *
  48  ************************************************************************/
  49
  50 /**
  51  * xmlVErrMemory:
  52  * @ctxt:  an XML validation parser context
  53  * @extra:  extra informations
  54  *
  55  * Handle an out of memory error
  56  */
  57 static void
  58 xmlVErrMemory(xmlValidCtxtPtr ctxt, const char *extra)
  59 {
  60     xmlGenericErrorFunc channel = NULL;
  61     xmlParserCtxtPtr pctxt = NULL;
  62     void *data = NULL;
  63
  64     if (ctxt != NULL) {
  65         channel = ctxt->error;
  66         data = ctxt->userData;
  67         /* Use the special values to detect if it is part of a parsing
  68            context */
  69         if ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
  70             (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1)) {
  71             long delta = (char *) ctxt - (char *) ctxt->userData;
  72             if ((delta > 0) && (delta < 250))
  73                 pctxt = ctxt->userData;
  74         }
  75     }
  76     if (extra)
  77         __xmlRaiseError(NULL, channel, data,
  78                         pctxt, NULL, XML_FROM_VALID, XML_ERR_NO_MEMORY,
  79                         XML_ERR_FATAL, NULL, 0, extra, NULL, NULL, 0, 0,
  80                         "Memory allocation failed : %s\n", extra);
  81     else
  82         __xmlRaiseError(NULL, channel, data,
  83                         pctxt, NULL, XML_FROM_VALID, XML_ERR_NO_MEMORY,
  84                         XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0,
  85                         "Memory allocation failed\n");
  86 }
  87
  88 /**
  89  * xmlErrValid:
  90  * @ctxt:  an XML validation parser context
  91  * @error:  the error number
  92  * @extra:  extra informations
  93  *
  94  * Handle a validation error
  95  */
  96 static void LIBXML_ATTR_FORMAT(3,0)
  97 xmlErrValid(xmlValidCtxtPtr ctxt, xmlParserErrors error,
  98             const char *msg, const char *extra)
  99 {
 100     xmlGenericErrorFunc channel = NULL;
 101     xmlParserCtxtPtr pctxt = NULL;
 102     void *data = NULL;
 103
 104     if (ctxt != NULL) {
 105         channel = ctxt->error;
 106         data = ctxt->userData;
 107         /* Use the special values to detect if it is part of a parsing
 108            context */
 109         if ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
 110             (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1)) {
 111             long delta = (char *) ctxt - (char *) ctxt->userData;
 112             if ((delta > 0) && (delta < 250))
 113                 pctxt = ctxt->userData;
 114         }
 115     }
 116     if (extra)
 117         __xmlRaiseError(NULL, channel, data,
 118                         pctxt, NULL, XML_FROM_VALID, error,
 119                         XML_ERR_ERROR, NULL, 0, extra, NULL, NULL, 0, 0,
 120                         msg, extra);
 121     else
 122         __xmlRaiseError(NULL, channel, data,
 123                         pctxt, NULL, XML_FROM_VALID, error,
 124                         XML_ERR_ERROR, NULL, 0, NULL, NULL, NULL, 0, 0,
 125                         "%s", msg);
 126 }
 127
 128 #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
 129 /**
 130  * xmlErrValidNode:
 131  * @ctxt:  an XML validation parser context
 132  * @node:  the node raising the error
 133  * @error:  the error number
 134  * @str1:  extra informations
 135  * @str2:  extra informations
 136  * @str3:  extra informations
 137  *
 138  * Handle a validation error, provide contextual informations
 139  */
 140 static void LIBXML_ATTR_FORMAT(4,0)
 141 xmlErrValidNode(xmlValidCtxtPtr ctxt,
 142                 xmlNodePtr node, xmlParserErrors error,
 143                 const char *msg, const xmlChar * str1,
 144                 const xmlChar * str2, const xmlChar * str3)
 145 {
 146     xmlStructuredErrorFunc schannel = NULL;
 147     xmlGenericErrorFunc channel = NULL;
 148     xmlParserCtxtPtr pctxt = NULL;
 149     void *data = NULL;
 150
 151     if (ctxt != NULL) {
 152         channel = ctxt->error;
 153         data = ctxt->userData;
 154         /* Use the special values to detect if it is part of a parsing
 155            context */
 156         if ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
 157             (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1)) {
 158             long delta = (char *) ctxt - (char *) ctxt->userData;
 159             if ((delta > 0) && (delta < 250))
 160                 pctxt = ctxt->userData;
 161         }
 162     }
 163     __xmlRaiseError(schannel, channel, data, pctxt, node, XML_FROM_VALID, error,
 164                     XML_ERR_ERROR, NULL, 0,
 165                     (const char *) str1,
 166                     (const char *) str1,
 167                     (const char *) str3, 0, 0, msg, str1, str2, str3);
 168 }
 169 #endif /* LIBXML_VALID_ENABLED or LIBXML_SCHEMAS_ENABLED */
 170
 171 #ifdef LIBXML_VALID_ENABLED
 172 /**
 173  * xmlErrValidNodeNr:
 174  * @ctxt:  an XML validation parser context
 175  * @node:  the node raising the error
 176  * @error:  the error number
 177  * @str1:  extra informations
 178  * @int2:  extra informations
 179  * @str3:  extra informations
 180  *
 181  * Handle a validation error, provide contextual informations
 182  */
 183 static void LIBXML_ATTR_FORMAT(4,0)
 184 xmlErrValidNodeNr(xmlValidCtxtPtr ctxt,
 185                 xmlNodePtr node, xmlParserErrors error,
 186                 const char *msg, const xmlChar * str1,
 187                 int int2, const xmlChar * str3)
 188 {
 189     xmlStructuredErrorFunc schannel = NULL;
 190     xmlGenericErrorFunc channel = NULL;
 191     xmlParserCtxtPtr pctxt = NULL;
 192     void *data = NULL;
 193
 194     if (ctxt != NULL) {
 195         channel = ctxt->error;
 196         data = ctxt->userData;
 197         /* Use the special values to detect if it is part of a parsing
 198            context */
 199         if ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
 200             (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1)) {
 201             long delta = (char *) ctxt - (char *) ctxt->userData;
 202             if ((delta > 0) && (delta < 250))
 203                 pctxt = ctxt->userData;
 204         }
 205     }
 206     __xmlRaiseError(schannel, channel, data, pctxt, node, XML_FROM_VALID, error,
 207                     XML_ERR_ERROR, NULL, 0,
 208                     (const char *) str1,
 209                     (const char *) str3,
 210                     NULL, int2, 0, msg, str1, int2, str3);
 211 }
 212
 213 /**
 214  * xmlErrValidWarning:
 215  * @ctxt:  an XML validation parser context
 216  * @node:  the node raising the error
 217  * @error:  the error number
 218  * @str1:  extra information
 219  * @str2:  extra information
 220  * @str3:  extra information
 221  *
 222  * Handle a validation error, provide contextual information
 223  */
 224 static void LIBXML_ATTR_FORMAT(4,0)
 225 xmlErrValidWarning(xmlValidCtxtPtr ctxt,
 226                 xmlNodePtr node, xmlParserErrors error,
 227                 const char *msg, const xmlChar * str1,
 228                 const xmlChar * str2, const xmlChar * str3)
 229 {
 230     xmlStructuredErrorFunc schannel = NULL;
 231     xmlGenericErrorFunc channel = NULL;
 232     xmlParserCtxtPtr pctxt = NULL;
 233     void *data = NULL;
 234
 235     if (ctxt != NULL) {
 236         channel = ctxt->warning;
 237         data = ctxt->userData;
 238         /* Use the special values to detect if it is part of a parsing
 239            context */
 240         if ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
 241             (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1)) {
 242             long delta = (char *) ctxt - (char *) ctxt->userData;
 243             if ((delta > 0) && (delta < 250))
 244                 pctxt = ctxt->userData;
 245         }
 246     }
 247     __xmlRaiseError(schannel, channel, data, pctxt, node, XML_FROM_VALID, error,
 248                     XML_ERR_WARNING, NULL, 0,
 249                     (const char *) str1,
 250                     (const char *) str1,
 251                     (const char *) str3, 0, 0, msg, str1, str2, str3);
 252 }
 253
 254
 255
 256 #ifdef LIBXML_REGEXP_ENABLED
 257 /*
 258  * If regexp are enabled we can do continuous validation without the
 259  * need of a tree to validate the content model. this is done in each
 260  * callbacks.
 261  * Each xmlValidState represent the validation state associated to the
 262  * set of nodes currently open from the document root to the current element.
 263  */
 264
 265
 266 typedef struct _xmlValidState {
 267     xmlElementPtr        elemDecl;      /* pointer to the content model */
 268     xmlNodePtr           node;          /* pointer to the current node */
 269     xmlRegExecCtxtPtr    exec;          /* regexp runtime */
 270 } _xmlValidState;
 271
 272
 273 static int
 274 vstateVPush(xmlValidCtxtPtr ctxt, xmlElementPtr elemDecl, xmlNodePtr node) {
 275     if ((ctxt->vstateMax == 0) || (ctxt->vstateTab == NULL)) {
 276         ctxt->vstateMax = 10;
 277         ctxt->vstateTab = (xmlValidState *) xmlMalloc(ctxt->vstateMax *
 278                               sizeof(ctxt->vstateTab[0]));
 279         if (ctxt->vstateTab == NULL) {
 280             xmlVErrMemory(ctxt, "malloc failed");
 281             return(-1);
 282         }
 283     }
 284
 285     if (ctxt->vstateNr >= ctxt->vstateMax) {
 286         xmlValidState *tmp;
 287
 288         tmp = (xmlValidState *) xmlRealloc(ctxt->vstateTab,
 289                      2 * ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
 290         if (tmp == NULL) {
 291             xmlVErrMemory(ctxt, "realloc failed");
 292             return(-1);
 293         }
 294         ctxt->vstateMax *= 2;
 295         ctxt->vstateTab = tmp;
 296     }
 297     ctxt->vstate = &ctxt->vstateTab[ctxt->vstateNr];
 298     ctxt->vstateTab[ctxt->vstateNr].elemDecl = elemDecl;
 299     ctxt->vstateTab[ctxt->vstateNr].node = node;
 300     if ((elemDecl != NULL) && (elemDecl->etype == XML_ELEMENT_TYPE_ELEMENT)) {
 301         if (elemDecl->contModel == NULL)
 302             xmlValidBuildContentModel(ctxt, elemDecl);
 303         if (elemDecl->contModel != NULL) {
 304             ctxt->vstateTab[ctxt->vstateNr].exec =
 305                 xmlRegNewExecCtxt(elemDecl->contModel, NULL, NULL);
 306         } else {
 307             ctxt->vstateTab[ctxt->vstateNr].exec = NULL;
 308             xmlErrValidNode(ctxt, (xmlNodePtr) elemDecl,
 309                             XML_ERR_INTERNAL_ERROR,
 310                             "Failed to build content model regexp for %s\n",
 311                             node->name, NULL, NULL);
 312         }
 313     }
 314     return(ctxt->vstateNr++);
 315 }
 316
 317 static int
 318 vstateVPop(xmlValidCtxtPtr ctxt) {
 319     xmlElementPtr elemDecl;
 320
 321     if (ctxt->vstateNr < 1) return(-1);
 322     ctxt->vstateNr--;
 323     elemDecl = ctxt->vstateTab[ctxt->vstateNr].elemDecl;
 324     ctxt->vstateTab[ctxt->vstateNr].elemDecl = NULL;
 325     ctxt->vstateTab[ctxt->vstateNr].node = NULL;
 326     if ((elemDecl != NULL) && (elemDecl->etype == XML_ELEMENT_TYPE_ELEMENT)) {
 327         xmlRegFreeExecCtxt(ctxt->vstateTab[ctxt->vstateNr].exec);
 328     }
 329     ctxt->vstateTab[ctxt->vstateNr].exec = NULL;
 330     if (ctxt->vstateNr >= 1)
 331         ctxt->vstate = &ctxt->vstateTab[ctxt->vstateNr - 1];
 332     else
 333         ctxt->vstate = NULL;
 334     return(ctxt->vstateNr);
 335 }
 336
 337 #else /* not LIBXML_REGEXP_ENABLED */
 338 /*
 339  * If regexp are not enabled, it uses a home made algorithm less
 340  * complex and easier to
 341  * debug/maintain than a generic NFA -> DFA state based algo. The
 342  * only restriction is on the deepness of the tree limited by the
 343  * size of the occurs bitfield
 344  *
 345  * this is the content of a saved state for rollbacks
 346  */
 347
 348 #define ROLLBACK_OR     0
 349 #define ROLLBACK_PARENT 1
 350
 351 typedef struct _xmlValidState {
 352     xmlElementContentPtr cont;  /* pointer to the content model subtree */
 353     xmlNodePtr           node;  /* pointer to the current node in the list */
 354     long                 occurs;/* bitfield for multiple occurrences */
 355     unsigned char        depth; /* current depth in the overall tree */
 356     unsigned char        state; /* ROLLBACK_XXX */
 357 } _xmlValidState;
 358
 359 #define MAX_RECURSE 25000
 360 #define MAX_DEPTH ((sizeof(_xmlValidState.occurs)) * 8)
 361 #define CONT ctxt->vstate->cont
 362 #define NODE ctxt->vstate->node
 363 #define DEPTH ctxt->vstate->depth
 364 #define OCCURS ctxt->vstate->occurs
 365 #define STATE ctxt->vstate->state
 366
 367 #define OCCURRENCE (ctxt->vstate->occurs & (1 << DEPTH))
 368 #define PARENT_OCCURRENCE (ctxt->vstate->occurs & ((1 << DEPTH) - 1))
 369
 370 #define SET_OCCURRENCE ctxt->vstate->occurs |= (1 << DEPTH)
 371 #define RESET_OCCURRENCE ctxt->vstate->occurs &= ((1 << DEPTH) - 1)
 372
 373 static int
 374 vstateVPush(xmlValidCtxtPtr ctxt, xmlElementContentPtr cont,
 375             xmlNodePtr node, unsigned char depth, long occurs,
 376             unsigned char state) {
 377     int i = ctxt->vstateNr - 1;
 378
 379     if (ctxt->vstateNr > MAX_RECURSE) {
 380         return(-1);
 381     }
 382     if (ctxt->vstateTab == NULL) {
 383         ctxt->vstateMax = 8;
 384         ctxt->vstateTab = (xmlValidState *) xmlMalloc(
 385                      ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
 386         if (ctxt->vstateTab == NULL) {
 387             xmlVErrMemory(ctxt, "malloc failed");
 388             return(-1);
 389         }
 390     }
 391     if (ctxt->vstateNr >= ctxt->vstateMax) {
 392         xmlValidState *tmp;
 393
 394         tmp = (xmlValidState *) xmlRealloc(ctxt->vstateTab,
 395                      2 * ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
 396         if (tmp == NULL) {
 397             xmlVErrMemory(ctxt, "malloc failed");
 398             return(-1);
 399         }
 400         ctxt->vstateMax *= 2;
 401         ctxt->vstateTab = tmp;
 402         ctxt->vstate = &ctxt->vstateTab[0];
 403     }
 404     /*
 405      * Don't push on the stack a state already here
 406      */
 407     if ((i >= 0) && (ctxt->vstateTab[i].cont == cont) &&
 408         (ctxt->vstateTab[i].node == node) &&
 409         (ctxt->vstateTab[i].depth == depth) &&
 410         (ctxt->vstateTab[i].occurs == occurs) &&
 411         (ctxt->vstateTab[i].state == state))
 412         return(ctxt->vstateNr);
 413     ctxt->vstateTab[ctxt->vstateNr].cont = cont;
 414     ctxt->vstateTab[ctxt->vstateNr].node = node;
 415     ctxt->vstateTab[ctxt->vstateNr].depth = depth;
 416     ctxt->vstateTab[ctxt->vstateNr].occurs = occurs;
 417     ctxt->vstateTab[ctxt->vstateNr].state = state;
 418     return(ctxt->vstateNr++);
 419 }
 420
 421 static int
 422 vstateVPop(xmlValidCtxtPtr ctxt) {
 423     if (ctxt->vstateNr <= 1) return(-1);
 424     ctxt->vstateNr--;
 425     ctxt->vstate = &ctxt->vstateTab[0];
 426     ctxt->vstate->cont =  ctxt->vstateTab[ctxt->vstateNr].cont;
 427     ctxt->vstate->node = ctxt->vstateTab[ctxt->vstateNr].node;
 428     ctxt->vstate->depth = ctxt->vstateTab[ctxt->vstateNr].depth;
 429     ctxt->vstate->occurs = ctxt->vstateTab[ctxt->vstateNr].occurs;
 430     ctxt->vstate->state = ctxt->vstateTab[ctxt->vstateNr].state;
 431     return(ctxt->vstateNr);
 432 }
 433
 434 #endif /* LIBXML_REGEXP_ENABLED */
 435
 436 static int
 437 nodeVPush(xmlValidCtxtPtr ctxt, xmlNodePtr value)
 438 {
 439     if (ctxt->nodeMax <= 0) {
 440         ctxt->nodeMax = 4;
 441         ctxt->nodeTab =
 442             (xmlNodePtr *) xmlMalloc(ctxt->nodeMax *
 443                                      sizeof(ctxt->nodeTab[0]));
 444         if (ctxt->nodeTab == NULL) {
 445             xmlVErrMemory(ctxt, "malloc failed");
 446             ctxt->nodeMax = 0;
 447             return (0);
 448         }
 449     }
 450     if (ctxt->nodeNr >= ctxt->nodeMax) {
 451         xmlNodePtr *tmp;
 452         tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
 453                               ctxt->nodeMax * 2 * sizeof(ctxt->nodeTab[0]));
 454         if (tmp == NULL) {
 455             xmlVErrMemory(ctxt, "realloc failed");
 456             return (0);
 457         }
 458         ctxt->nodeMax *= 2;
 459         ctxt->nodeTab = tmp;
 460     }
 461     ctxt->nodeTab[ctxt->nodeNr] = value;
 462     ctxt->node = value;
 463     return (ctxt->nodeNr++);
 464 }
 465 static xmlNodePtr
 466 nodeVPop(xmlValidCtxtPtr ctxt)
 467 {
 468     xmlNodePtr ret;
 469
 470     if (ctxt->nodeNr <= 0)
 471         return (NULL);
 472     ctxt->nodeNr--;
 473     if (ctxt->nodeNr > 0)
 474         ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
 475     else
 476         ctxt->node = NULL;
 477     ret = ctxt->nodeTab[ctxt->nodeNr];
 478     ctxt->nodeTab[ctxt->nodeNr] = NULL;
 479     return (ret);
 480 }
 481
 482 #ifdef DEBUG_VALID_ALGO
 483 static void
 484 xmlValidPrintNode(xmlNodePtr cur) {
 485     if (cur == NULL) {
 486         xmlGenericError(xmlGenericErrorContext, "null");
 487         return;
 488     }
 489     switch (cur->type) {
 490         case XML_ELEMENT_NODE:
 491             xmlGenericError(xmlGenericErrorContext, "%s ", cur->name);
 492             break;
 493         case XML_TEXT_NODE:
 494             xmlGenericError(xmlGenericErrorContext, "text ");
 495             break;
 496         case XML_CDATA_SECTION_NODE:
 497             xmlGenericError(xmlGenericErrorContext, "cdata ");
 498             break;
 499         case XML_ENTITY_REF_NODE:
 500             xmlGenericError(xmlGenericErrorContext, "&%s; ", cur->name);
 501             break;
 502         case XML_PI_NODE:
 503             xmlGenericError(xmlGenericErrorContext, "pi(%s) ", cur->name);
 504             break;
 505         case XML_COMMENT_NODE:
 506             xmlGenericError(xmlGenericErrorContext, "comment ");
 507             break;
 508         case XML_ATTRIBUTE_NODE:
 509             xmlGenericError(xmlGenericErrorContext, "?attr? ");
 510             break;
 511         case XML_ENTITY_NODE:
 512             xmlGenericError(xmlGenericErrorContext, "?ent? ");
 513             break;
 514         case XML_DOCUMENT_NODE:
 515             xmlGenericError(xmlGenericErrorContext, "?doc? ");
 516             break;
 517         case XML_DOCUMENT_TYPE_NODE:
 518             xmlGenericError(xmlGenericErrorContext, "?doctype? ");
 519             break;
 520         case XML_DOCUMENT_FRAG_NODE:
 521             xmlGenericError(xmlGenericErrorContext, "?frag? ");
 522             break;
 523         case XML_NOTATION_NODE:
 524             xmlGenericError(xmlGenericErrorContext, "?nota? ");
 525             break;
 526         case XML_HTML_DOCUMENT_NODE:
 527             xmlGenericError(xmlGenericErrorContext, "?html? ");
 528             break;
 529 #ifdef LIBXML_DOCB_ENABLED
 530         case XML_DOCB_DOCUMENT_NODE:
 531             xmlGenericError(xmlGenericErrorContext, "?docb? ");
 532             break;
 533 #endif
 534         case XML_DTD_NODE:
 535             xmlGenericError(xmlGenericErrorContext, "?dtd? ");
 536             break;
 537         case XML_ELEMENT_DECL:
 538             xmlGenericError(xmlGenericErrorContext, "?edecl? ");
 539             break;
 540         case XML_ATTRIBUTE_DECL:
 541             xmlGenericError(xmlGenericErrorContext, "?adecl? ");
 542             break;
 543         case XML_ENTITY_DECL:
 544             xmlGenericError(xmlGenericErrorContext, "?entdecl? ");
 545             break;
 546         case XML_NAMESPACE_DECL:
 547             xmlGenericError(xmlGenericErrorContext, "?nsdecl? ");
 548             break;
 549         case XML_XINCLUDE_START:
 550             xmlGenericError(xmlGenericErrorContext, "incstart ");
 551             break;
 552         case XML_XINCLUDE_END:
 553             xmlGenericError(xmlGenericErrorContext, "incend ");
 554             break;
 555     }
 556 }
 557
 558 static void
 559 xmlValidPrintNodeList(xmlNodePtr cur) {
 560     if (cur == NULL)
 561         xmlGenericError(xmlGenericErrorContext, "null ");
 562     while (cur != NULL) {
 563         xmlValidPrintNode(cur);
 564         cur = cur->next;
 565     }
 566 }
 567
 568 static void
 569 xmlValidDebug(xmlNodePtr cur, xmlElementContentPtr cont) {
 570     char expr[5000];
 571
 572     expr[0] = 0;
 573     xmlGenericError(xmlGenericErrorContext, "valid: ");
 574     xmlValidPrintNodeList(cur);
 575     xmlGenericError(xmlGenericErrorContext, "against ");
 576     xmlSnprintfElementContent(expr, 5000, cont, 1);
 577     xmlGenericError(xmlGenericErrorContext, "%s\n", expr);
 578 }
 579
 580 static void
 581 xmlValidDebugState(xmlValidStatePtr state) {
 582     xmlGenericError(xmlGenericErrorContext, "(");
 583     if (state->cont == NULL)
 584         xmlGenericError(xmlGenericErrorContext, "null,");
 585     else
 586         switch (state->cont->type) {
 587             case XML_ELEMENT_CONTENT_PCDATA:
 588                 xmlGenericError(xmlGenericErrorContext, "pcdata,");
 589                 break;
 590             case XML_ELEMENT_CONTENT_ELEMENT:
 591                 xmlGenericError(xmlGenericErrorContext, "%s,",
 592                                 state->cont->name);
 593                 break;
 594             case XML_ELEMENT_CONTENT_SEQ:
 595                 xmlGenericError(xmlGenericErrorContext, "seq,");
 596                 break;
 597             case XML_ELEMENT_CONTENT_OR:
 598                 xmlGenericError(xmlGenericErrorContext, "or,");
 599                 break;
 600         }
 601     xmlValidPrintNode(state->node);
 602     xmlGenericError(xmlGenericErrorContext, ",%d,%X,%d)",
 603             state->depth, state->occurs, state->state);
 604 }
 605
 606 static void
 607 xmlValidStateDebug(xmlValidCtxtPtr ctxt) {
 608     int i, j;
 609
 610     xmlGenericError(xmlGenericErrorContext, "state: ");
 611     xmlValidDebugState(ctxt->vstate);
 612     xmlGenericError(xmlGenericErrorContext, " stack: %d ",
 613             ctxt->vstateNr - 1);
 614     for (i = 0, j = ctxt->vstateNr - 1;(i < 3) && (j > 0);i++,j--)
 615         xmlValidDebugState(&ctxt->vstateTab[j]);
 616     xmlGenericError(xmlGenericErrorContext, "\n");
 617 }
 618
 619 /*****
 620 #define DEBUG_VALID_STATE(n,c) xmlValidDebug(n,c);
 621  *****/
 622
 623 #define DEBUG_VALID_STATE(n,c) xmlValidStateDebug(ctxt);
 624 #define DEBUG_VALID_MSG(m)                                      \
 625     xmlGenericError(xmlGenericErrorContext, "%s\n", m);
 626
 627 #else
 628 #define DEBUG_VALID_STATE(n,c)
 629 #define DEBUG_VALID_MSG(m)
 630 #endif
 631
 632 /* TODO: use hash table for accesses to elem and attribute definitions */
 633
 634
 635 #define CHECK_DTD                                               \
 636    if (doc == NULL) return(0);                                  \
 637    else if ((doc->intSubset == NULL) &&                         \
 638             (doc->extSubset == NULL)) return(0)
 639
 640 #ifdef LIBXML_REGEXP_ENABLED
 641
 642 /************************************************************************
 643  *                                                                      *
 644  *              Content model validation based on the regexps           *
 645  *                                                                      *
 646  ************************************************************************/
 647
 648 /**
 649  * xmlValidBuildAContentModel:
 650  * @content:  the content model
 651  * @ctxt:  the schema parser context
 652  * @name:  the element name whose content is being built
 653  *
 654  * Generate the automata sequence needed for that type
 655  *
 656  * Returns 1 if successful or 0 in case of error.
 657  */
 658 static int
 659 xmlValidBuildAContentModel(xmlElementContentPtr content,
 660                            xmlValidCtxtPtr ctxt,
 661                            const xmlChar *name) {
 662     if (content == NULL) {
 663         xmlErrValidNode(ctxt, NULL, XML_ERR_INTERNAL_ERROR,
 664                         "Found NULL content in content model of %s\n",
 665                         name, NULL, NULL);
 666         return(0);
 667     }
 668     switch (content->type) {
 669         case XML_ELEMENT_CONTENT_PCDATA:
 670             xmlErrValidNode(ctxt, NULL, XML_ERR_INTERNAL_ERROR,
 671                             "Found PCDATA in content model of %s\n",
 672                             name, NULL, NULL);
 673             return(0);
 674             break;
 675         case XML_ELEMENT_CONTENT_ELEMENT: {
 676             xmlAutomataStatePtr oldstate = ctxt->state;
 677             xmlChar fn[50];
 678             xmlChar *fullname;
 679
 680             fullname = xmlBuildQName(content->name, content->prefix, fn, 50);
 681             if (fullname == NULL) {
 682                 xmlVErrMemory(ctxt, "Building content model");
 683                 return(0);
 684             }
 685
 686             switch (content->ocur) {
 687                 case XML_ELEMENT_CONTENT_ONCE:
 688                     ctxt->state = xmlAutomataNewTransition(ctxt->am,
 689                             ctxt->state, NULL, fullname, NULL);
 690                     break;
 691                 case XML_ELEMENT_CONTENT_OPT:
 692                     ctxt->state = xmlAutomataNewTransition(ctxt->am,
 693                             ctxt->state, NULL, fullname, NULL);
 694                     xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
 695                     break;
 696                 case XML_ELEMENT_CONTENT_PLUS:
 697                     ctxt->state = xmlAutomataNewTransition(ctxt->am,
 698                             ctxt->state, NULL, fullname, NULL);
 699                     xmlAutomataNewTransition(ctxt->am, ctxt->state,
 700                                              ctxt->state, fullname, NULL);
 701                     break;
 702                 case XML_ELEMENT_CONTENT_MULT:
 703                     ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
 704                                             ctxt->state, NULL);
 705                     xmlAutomataNewTransition(ctxt->am,
 706                             ctxt->state, ctxt->state, fullname, NULL);
 707                     break;
 708             }
 709             if ((fullname != fn) && (fullname != content->name))
 710                 xmlFree(fullname);
 711             break;
 712         }
 713         case XML_ELEMENT_CONTENT_SEQ: {
 714             xmlAutomataStatePtr oldstate, oldend;
 715             xmlElementContentOccur ocur;
 716
 717             /*
 718              * Simply iterate over the content
 719              */
 720             oldstate = ctxt->state;
 721             ocur = content->ocur;
 722             if (ocur != XML_ELEMENT_CONTENT_ONCE) {
 723                 ctxt->state = xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
 724                 oldstate = ctxt->state;
 725             }
 726             do {
 727                 xmlValidBuildAContentModel(content->c1, ctxt, name);
 728                 content = content->c2;
 729             } while ((content->type == XML_ELEMENT_CONTENT_SEQ) &&
 730                      (content->ocur == XML_ELEMENT_CONTENT_ONCE));
 731             xmlValidBuildAContentModel(content, ctxt, name);
 732             oldend = ctxt->state;
 733             ctxt->state = xmlAutomataNewEpsilon(ctxt->am, oldend, NULL);
 734             switch (ocur) {
 735                 case XML_ELEMENT_CONTENT_ONCE:
 736                     break;
 737                 case XML_ELEMENT_CONTENT_OPT:
 738                     xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
 739                     break;
 740                 case XML_ELEMENT_CONTENT_MULT:
 741                     xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
 742                     xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
 743                     break;
 744                 case XML_ELEMENT_CONTENT_PLUS:
 745                     xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
 746                     break;
 747             }
 748             break;
 749         }
 750         case XML_ELEMENT_CONTENT_OR: {
 751             xmlAutomataStatePtr oldstate, oldend;
 752             xmlElementContentOccur ocur;
 753
 754             ocur = content->ocur;
 755             if ((ocur == XML_ELEMENT_CONTENT_PLUS) ||
 756                 (ocur == XML_ELEMENT_CONTENT_MULT)) {
 757                 ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
 758                         ctxt->state, NULL);
 759             }
 760             oldstate = ctxt->state;
 761             oldend = xmlAutomataNewState(ctxt->am);
 762
 763             /*
 764              * iterate over the subtypes and remerge the end with an
 765              * epsilon transition
 766              */
 767             do {
 768                 ctxt->state = oldstate;
 769                 xmlValidBuildAContentModel(content->c1, ctxt, name);
 770                 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldend);
 771                 content = content->c2;
 772             } while ((content->type == XML_ELEMENT_CONTENT_OR) &&
 773                      (content->ocur == XML_ELEMENT_CONTENT_ONCE));
 774             ctxt->state = oldstate;
 775             xmlValidBuildAContentModel(content, ctxt, name);
 776             xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldend);
 777             ctxt->state = xmlAutomataNewEpsilon(ctxt->am, oldend, NULL);
 778             switch (ocur) {
 779                 case XML_ELEMENT_CONTENT_ONCE:
 780                     break;
 781                 case XML_ELEMENT_CONTENT_OPT:
 782                     xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
 783                     break;
 784                 case XML_ELEMENT_CONTENT_MULT:
 785                     xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
 786                     xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
 787                     break;
 788                 case XML_ELEMENT_CONTENT_PLUS:
 789                     xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
 790                     break;
 791             }
 792             break;
 793         }
 794         default:
 795             xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
 796                         "ContentModel broken for element %s\n",
 797                         (const char *) name);
 798             return(0);
 799     }
 800     return(1);
 801 }
 802 /**
 803  * xmlValidBuildContentModel:
 804  * @ctxt:  a validation context
 805  * @elem:  an element declaration node
 806  *
 807  * (Re)Build the automata associated to the content model of this
 808  * element
 809  *
 810  * Returns 1 in case of success, 0 in case of error
 811  */
 812 int
 813 xmlValidBuildContentModel(xmlValidCtxtPtr ctxt, xmlElementPtr elem) {
 814
 815     if ((ctxt == NULL) || (elem == NULL))
 816         return(0);
 817     if (elem->type != XML_ELEMENT_DECL)
 818         return(0);
 819     if (elem->etype != XML_ELEMENT_TYPE_ELEMENT)
 820         return(1);
 821     /* TODO: should we rebuild in this case ? */
 822     if (elem->contModel != NULL) {
 823         if (!xmlRegexpIsDeterminist(elem->contModel)) {
 824             ctxt->valid = 0;
 825             return(0);
 826         }
 827         return(1);
 828     }
 829
 830     ctxt->am = xmlNewAutomata();
 831     if (ctxt->am == NULL) {
 832         xmlErrValidNode(ctxt, (xmlNodePtr) elem,
 833                         XML_ERR_INTERNAL_ERROR,
 834                         "Cannot create automata for element %s\n",
 835                         elem->name, NULL, NULL);
 836         return(0);
 837     }
 838     ctxt->state = xmlAutomataGetInitState(ctxt->am);
 839     xmlValidBuildAContentModel(elem->content, ctxt, elem->name);
 840     xmlAutomataSetFinalState(ctxt->am, ctxt->state);
 841     elem->contModel = xmlAutomataCompile(ctxt->am);
 842     if (xmlRegexpIsDeterminist(elem->contModel) != 1) {
 843         char expr[5000];
 844         expr[0] = 0;
 845         xmlSnprintfElementContent(expr, 5000, elem->content, 1);
 846         xmlErrValidNode(ctxt, (xmlNodePtr) elem,
 847                         XML_DTD_CONTENT_NOT_DETERMINIST,
 848                "Content model of %s is not determinist: %s\n",
 849                elem->name, BAD_CAST expr, NULL);
 850 #ifdef DEBUG_REGEXP_ALGO
 851         xmlRegexpPrint(stderr, elem->contModel);
 852 #endif
 853         ctxt->valid = 0;
 854         ctxt->state = NULL;
 855         xmlFreeAutomata(ctxt->am);
 856         ctxt->am = NULL;
 857         return(0);
 858     }
 859     ctxt->state = NULL;
 860     xmlFreeAutomata(ctxt->am);
 861     ctxt->am = NULL;
 862     return(1);
 863 }
 864
 865 #endif /* LIBXML_REGEXP_ENABLED */
 866
 867 /****************************************************************
 868  *                                                              *
 869  *      Util functions for data allocation/deallocation         *
 870  *                                                              *
 871  ****************************************************************/
 872
 873 /**
 874  * xmlNewValidCtxt:
 875  *
 876  * Allocate a validation context structure.
 877  *
 878  * Returns NULL if not, otherwise the new validation context structure
 879  */
 880 xmlValidCtxtPtr xmlNewValidCtxt(void) {
 881     xmlValidCtxtPtr ret;
 882
 883     if ((ret = xmlMalloc(sizeof (xmlValidCtxt))) == NULL) {
 884         xmlVErrMemory(NULL, "malloc failed");
 885         return (NULL);
 886     }
 887
 888     (void) memset(ret, 0, sizeof (xmlValidCtxt));
 889
 890     return (ret);
 891 }
 892
 893 /**
 894  * xmlFreeValidCtxt:
 895  * @cur:  the validation context to free
 896  *
 897  * Free a validation context structure.
 898  */
 899 void
 900 xmlFreeValidCtxt(xmlValidCtxtPtr cur) {
 901     if (cur->vstateTab != NULL)
 902         xmlFree(cur->vstateTab);
 903     if (cur->nodeTab != NULL)
 904         xmlFree(cur->nodeTab);
 905     xmlFree(cur);
 906 }
 907
 908 #endif /* LIBXML_VALID_ENABLED */
 909
 910 /**
 911  * xmlNewDocElementContent:
 912  * @doc:  the document
 913  * @name:  the subelement name or NULL
 914  * @type:  the type of element content decl
 915  *
 916  * Allocate an element content structure for the document.
 917  *
 918  * Returns NULL if not, otherwise the new element content structure
 919  */
 920 xmlElementContentPtr
 921 xmlNewDocElementContent(xmlDocPtr doc, const xmlChar *name,
 922                         xmlElementContentType type) {
 923     xmlElementContentPtr ret;
 924     xmlDictPtr dict = NULL;
 925
 926     if (doc != NULL)
 927         dict = doc->dict;
 928
 929     switch(type) {
 930         case XML_ELEMENT_CONTENT_ELEMENT:
 931             if (name == NULL) {
 932                 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
 933                         "xmlNewElementContent : name == NULL !\n",
 934                         NULL);
 935             }
 936             break;
 937         case XML_ELEMENT_CONTENT_PCDATA:
 938         case XML_ELEMENT_CONTENT_SEQ:
 939         case XML_ELEMENT_CONTENT_OR:
 940             if (name != NULL) {
 941                 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
 942                         "xmlNewElementContent : name != NULL !\n",
 943                         NULL);
 944             }
 945             break;
 946         default:
 947             xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
 948                     "Internal: ELEMENT content corrupted invalid type\n",
 949                     NULL);
 950             return(NULL);
 951     }
 952     ret = (xmlElementContentPtr) xmlMalloc(sizeof(xmlElementContent));
 953     if (ret == NULL) {
 954         xmlVErrMemory(NULL, "malloc failed");
 955         return(NULL);
 956     }
 957     memset(ret, 0, sizeof(xmlElementContent));
 958     ret->type = type;
 959     ret->ocur = XML_ELEMENT_CONTENT_ONCE;
 960     if (name != NULL) {
 961         int l;
 962         const xmlChar *tmp;
 963
 964         tmp = xmlSplitQName3(name, &l);
 965         if (tmp == NULL) {
 966             if (dict == NULL)
 967                 ret->name = xmlStrdup(name);
 968             else
 969                 ret->name = xmlDictLookup(dict, name, -1);
 970         } else {
 971             if (dict == NULL) {
 972                 ret->prefix = xmlStrndup(name, l);
 973                 ret->name = xmlStrdup(tmp);
 974             } else {
 975                 ret->prefix = xmlDictLookup(dict, name, l);
 976                 ret->name = xmlDictLookup(dict, tmp, -1);
 977             }
 978         }
 979     }
 980     return(ret);
 981 }
 982
 983 /**
 984  * xmlNewElementContent:
 985  * @name:  the subelement name or NULL
 986  * @type:  the type of element content decl
 987  *
 988  * Allocate an element content structure.
 989  * Deprecated in favor of xmlNewDocElementContent
 990  *
 991  * Returns NULL if not, otherwise the new element content structure
 992  */
 993 xmlElementContentPtr
 994 xmlNewElementContent(const xmlChar *name, xmlElementContentType type) {
 995     return(xmlNewDocElementContent(NULL, name, type));
 996 }
 997
 998 /**
 999  * xmlCopyDocElementContent:
1000  * @doc:  the document owning the element declaration
1001  * @cur:  An element content pointer.
1002  *
1003  * Build a copy of an element content description.
1004  *
1005  * Returns the new xmlElementContentPtr or NULL in case of error.
1006  */
1007 xmlElementContentPtr
1008 xmlCopyDocElementContent(xmlDocPtr doc, xmlElementContentPtr cur) {
1009     xmlElementContentPtr ret = NULL, prev = NULL, tmp;
1010     xmlDictPtr dict = NULL;
1011
1012     if (cur == NULL) return(NULL);
1013
1014     if (doc != NULL)
1015         dict = doc->dict;
1016
1017     ret = (xmlElementContentPtr) xmlMalloc(sizeof(xmlElementContent));
1018     if (ret == NULL) {
1019         xmlVErrMemory(NULL, "malloc failed");
1020         return(NULL);
1021     }
1022     memset(ret, 0, sizeof(xmlElementContent));
1023     ret->type = cur->type;
1024     ret->ocur = cur->ocur;
1025     if (cur->name != NULL) {
1026         if (dict)
1027             ret->name = xmlDictLookup(dict, cur->name, -1);
1028         else
1029             ret->name = xmlStrdup(cur->name);
1030     }
1031
1032     if (cur->prefix != NULL) {
1033         if (dict)
1034             ret->prefix = xmlDictLookup(dict, cur->prefix, -1);
1035         else
1036             ret->prefix = xmlStrdup(cur->prefix);
1037     }
1038     if (cur->c1 != NULL)
1039         ret->c1 = xmlCopyDocElementContent(doc, cur->c1);
1040     if (ret->c1 != NULL)
1041         ret->c1->parent = ret;
1042     if (cur->c2 != NULL) {
1043         prev = ret;
1044         cur = cur->c2;
1045         while (cur != NULL) {
1046             tmp = (xmlElementContentPtr) xmlMalloc(sizeof(xmlElementContent));
1047             if (tmp == NULL) {
1048                 xmlVErrMemory(NULL, "malloc failed");
1049                 return(ret);
1050             }
1051             memset(tmp, 0, sizeof(xmlElementContent));
1052             tmp->type = cur->type;
1053             tmp->ocur = cur->ocur;
1054             prev->c2 = tmp;
1055             if (cur->name != NULL) {
1056                 if (dict)
1057                     tmp->name = xmlDictLookup(dict, cur->name, -1);
1058                 else
1059                     tmp->name = xmlStrdup(cur->name);
1060             }
1061
1062             if (cur->prefix != NULL) {
1063                 if (dict)
1064                     tmp->prefix = xmlDictLookup(dict, cur->prefix, -1);
1065                 else
1066                     tmp->prefix = xmlStrdup(cur->prefix);
1067             }
1068             if (cur->c1 != NULL)
1069                 tmp->c1 = xmlCopyDocElementContent(doc,cur->c1);
1070             if (tmp->c1 != NULL)
1071                 tmp->c1->parent = ret;
1072             prev = tmp;
1073             cur = cur->c2;
1074         }
1075     }
1076     return(ret);
1077 }
1078
1079 /**
1080  * xmlCopyElementContent:
1081  * @cur:  An element content pointer.
1082  *
1083  * Build a copy of an element content description.
1084  * Deprecated, use xmlCopyDocElementContent instead
1085  *
1086  * Returns the new xmlElementContentPtr or NULL in case of error.
1087  */
1088 xmlElementContentPtr
1089 xmlCopyElementContent(xmlElementContentPtr cur) {
1090     return(xmlCopyDocElementContent(NULL, cur));
1091 }
1092
1093 /**
1094  * xmlFreeDocElementContent:
1095  * @doc: the document owning the element declaration
1096  * @cur:  the element content tree to free
1097  *
1098  * Free an element content structure. The whole subtree is removed.
1099  */
1100 void
1101 xmlFreeDocElementContent(xmlDocPtr doc, xmlElementContentPtr cur) {
1102     xmlElementContentPtr next;
1103     xmlDictPtr dict = NULL;
1104
1105     if (doc != NULL)
1106         dict = doc->dict;
1107
1108     while (cur != NULL) {
1109         next = cur->c2;
1110         switch (cur->type) {
1111             case XML_ELEMENT_CONTENT_PCDATA:
1112             case XML_ELEMENT_CONTENT_ELEMENT:
1113             case XML_ELEMENT_CONTENT_SEQ:
1114             case XML_ELEMENT_CONTENT_OR:
1115                 break;
1116             default:
1117                 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
1118                         "Internal: ELEMENT content corrupted invalid type\n",
1119                         NULL);
1120                 return;
1121         }
1122         if (cur->c1 != NULL) xmlFreeDocElementContent(doc, cur->c1);
1123         if (dict) {
1124             if ((cur->name != NULL) && (!xmlDictOwns(dict, cur->name)))
1125                 xmlFree((xmlChar *) cur->name);
1126             if ((cur->prefix != NULL) && (!xmlDictOwns(dict, cur->prefix)))
1127                 xmlFree((xmlChar *) cur->prefix);
1128         } else {
1129             if (cur->name != NULL) xmlFree((xmlChar *) cur->name);
1130             if (cur->prefix != NULL) xmlFree((xmlChar *) cur->prefix);
1131         }
1132         xmlFree(cur);
1133         cur = next;
1134     }
1135 }
1136
1137 /**
1138  * xmlFreeElementContent:
1139  * @cur:  the element content tree to free
1140  *
1141  * Free an element content structure. The whole subtree is removed.
1142  * Deprecated, use xmlFreeDocElementContent instead
1143  */
1144 void
1145 xmlFreeElementContent(xmlElementContentPtr cur) {
1146     xmlFreeDocElementContent(NULL, cur);
1147 }
1148
1149 #ifdef LIBXML_OUTPUT_ENABLED
1150 /**
1151  * xmlDumpElementContent:
1152  * @buf:  An XML buffer
1153  * @content:  An element table
1154  * @glob: 1 if one must print the englobing parenthesis, 0 otherwise
1155  *
1156  * This will dump the content of the element table as an XML DTD definition
1157  */
1158 static void
1159 xmlDumpElementContent(xmlBufferPtr buf, xmlElementContentPtr content, int glob) {
1160     if (content == NULL) return;
1161
1162     if (glob) xmlBufferWriteChar(buf, "(");
1163     switch (content->type) {
1164         case XML_ELEMENT_CONTENT_PCDATA:
1165             xmlBufferWriteChar(buf, "#PCDATA");
1166             break;
1167         case XML_ELEMENT_CONTENT_ELEMENT:
1168             if (content->prefix != NULL) {
1169                 xmlBufferWriteCHAR(buf, content->prefix);
1170                 xmlBufferWriteChar(buf, ":");
1171             }
1172             xmlBufferWriteCHAR(buf, content->name);
1173             break;
1174         case XML_ELEMENT_CONTENT_SEQ:
1175             if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1176                 (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
1177                 xmlDumpElementContent(buf, content->c1, 1);
1178             else
1179                 xmlDumpElementContent(buf, content->c1, 0);
1180             xmlBufferWriteChar(buf, " , ");
1181             if ((content->c2->type == XML_ELEMENT_CONTENT_OR) ||
1182                 ((content->c2->type == XML_ELEMENT_CONTENT_SEQ) &&
1183                  (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)))
1184                 xmlDumpElementContent(buf, content->c2, 1);
1185             else
1186                 xmlDumpElementContent(buf, content->c2, 0);
1187             break;
1188         case XML_ELEMENT_CONTENT_OR:
1189             if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1190                 (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
1191                 xmlDumpElementContent(buf, content->c1, 1);
1192             else
1193                 xmlDumpElementContent(buf, content->c1, 0);
1194             xmlBufferWriteChar(buf, " | ");
1195             if ((content->c2->type == XML_ELEMENT_CONTENT_SEQ) ||
1196                 ((content->c2->type == XML_ELEMENT_CONTENT_OR) &&
1197                  (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)))
1198                 xmlDumpElementContent(buf, content->c2, 1);
1199             else
1200                 xmlDumpElementContent(buf, content->c2, 0);
1201             break;
1202         default:
1203             xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
1204                     "Internal: ELEMENT content corrupted invalid type\n",
1205                     NULL);
1206     }
1207     if (glob)
1208         xmlBufferWriteChar(buf, ")");
1209     switch (content->ocur) {
1210         case XML_ELEMENT_CONTENT_ONCE:
1211             break;
1212         case XML_ELEMENT_CONTENT_OPT:
1213             xmlBufferWriteChar(buf, "?");
1214             break;
1215         case XML_ELEMENT_CONTENT_MULT:
1216             xmlBufferWriteChar(buf, "*");
1217             break;
1218         case XML_ELEMENT_CONTENT_PLUS:
1219             xmlBufferWriteChar(buf, "+");
1220             break;
1221     }
1222 }
1223
1224 /**
1225  * xmlSprintfElementContent:
1226  * @buf:  an output buffer
1227  * @content:  An element table
1228  * @englob: 1 if one must print the englobing parenthesis, 0 otherwise
1229  *
1230  * Deprecated, unsafe, use xmlSnprintfElementContent
1231  */
1232 void
1233 xmlSprintfElementContent(char *buf ATTRIBUTE_UNUSED,
1234                          xmlElementContentPtr content ATTRIBUTE_UNUSED,
1235                          int englob ATTRIBUTE_UNUSED) {
1236 }
1237 #endif /* LIBXML_OUTPUT_ENABLED */
1238
1239 /**
1240  * xmlSnprintfElementContent:
1241  * @buf:  an output buffer
1242  * @size:  the buffer size
1243  * @content:  An element table
1244  * @englob: 1 if one must print the englobing parenthesis, 0 otherwise
1245  *
1246  * This will dump the content of the element content definition
1247  * Intended just for the debug routine
1248  */
1249 void
1250 xmlSnprintfElementContent(char *buf, int size, xmlElementContentPtr content, int englob) {
1251     int len;
1252
1253     if (content == NULL) return;
1254     len = strlen(buf);
1255     if (size - len < 50) {
1256         if ((size - len > 4) && (buf[len - 1] != '.'))
1257             strcat(buf, " ...");
1258         return;
1259     }
1260     if (englob) strcat(buf, "(");
1261     switch (content->type) {
1262         case XML_ELEMENT_CONTENT_PCDATA:
1263             strcat(buf, "#PCDATA");
1264             break;
1265         case XML_ELEMENT_CONTENT_ELEMENT:
1266             if (content->prefix != NULL) {
1267                 if (size - len < xmlStrlen(content->prefix) + 10) {
1268                     strcat(buf, " ...");
1269                     return;
1270                 }
1271                 strcat(buf, (char *) content->prefix);
1272                 strcat(buf, ":");
1273             }
1274             if (size - len < xmlStrlen(content->name) + 10) {
1275                 strcat(buf, " ...");
1276                 return;
1277             }
1278             if (content->name != NULL)
1279                 strcat(buf, (char *) content->name);
1280             break;
1281         case XML_ELEMENT_CONTENT_SEQ:
1282             if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1283                 (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
1284                 xmlSnprintfElementContent(buf, size, content->c1, 1);
1285             else
1286                 xmlSnprintfElementContent(buf, size, content->c1, 0);
1287             len = strlen(buf);
1288             if (size - len < 50) {
1289                 if ((size - len > 4) && (buf[len - 1] != '.'))
1290                     strcat(buf, " ...");
1291                 return;
1292             }
1293             strcat(buf, " , ");
1294             if (((content->c2->type == XML_ELEMENT_CONTENT_OR) ||
1295                  (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)) &&
1296                 (content->c2->type != XML_ELEMENT_CONTENT_ELEMENT))
1297                 xmlSnprintfElementContent(buf, size, content->c2, 1);
1298             else
1299                 xmlSnprintfElementContent(buf, size, content->c2, 0);
1300             break;
1301         case XML_ELEMENT_CONTENT_OR:
1302             if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1303                 (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
1304                 xmlSnprintfElementContent(buf, size, content->c1, 1);
1305             else
1306                 xmlSnprintfElementContent(buf, size, content->c1, 0);
1307             len = strlen(buf);
1308             if (size - len < 50) {
1309                 if ((size - len > 4) && (buf[len - 1] != '.'))
1310                     strcat(buf, " ...");
1311                 return;
1312             }
1313             strcat(buf, " | ");
1314             if (((content->c2->type == XML_ELEMENT_CONTENT_SEQ) ||
1315                  (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)) &&
1316                 (content->c2->type != XML_ELEMENT_CONTENT_ELEMENT))
1317                 xmlSnprintfElementContent(buf, size, content->c2, 1);
1318             else
1319                 xmlSnprintfElementContent(buf, size, content->c2, 0);
1320             break;
1321     }
1322     if (englob)
1323         strcat(buf, ")");
1324     switch (content->ocur) {
1325         case XML_ELEMENT_CONTENT_ONCE:
1326             break;
1327         case XML_ELEMENT_CONTENT_OPT:
1328             strcat(buf, "?");
1329             break;
1330         case XML_ELEMENT_CONTENT_MULT:
1331             strcat(buf, "*");
1332             break;
1333         case XML_ELEMENT_CONTENT_PLUS:
1334             strcat(buf, "+");
1335             break;
1336     }
1337 }
1338
1339 /****************************************************************
1340  *                                                              *
1341  *      Registration of DTD declarations                        *
1342  *                                                              *
1343  ****************************************************************/
1344
1345 /**
1346  * xmlFreeElement:
1347  * @elem:  An element
1348  *
1349  * Deallocate the memory used by an element definition
1350  */
1351 static void
1352 xmlFreeElement(xmlElementPtr elem) {
1353     if (elem == NULL) return;
1354     xmlUnlinkNode((xmlNodePtr) elem);
1355     xmlFreeDocElementContent(elem->doc, elem->content);
1356     if (elem->name != NULL)
1357         xmlFree((xmlChar *) elem->name);
1358     if (elem->prefix != NULL)
1359         xmlFree((xmlChar *) elem->prefix);
1360 #ifdef LIBXML_REGEXP_ENABLED
1361     if (elem->contModel != NULL)
1362         xmlRegFreeRegexp(elem->contModel);
1363 #endif
1364     xmlFree(elem);
1365 }
1366
1367
1368 /**
1369  * xmlAddElementDecl:
1370  * @ctxt:  the validation context
1371  * @dtd:  pointer to the DTD
1372  * @name:  the entity name
1373  * @type:  the element type
1374  * @content:  the element content tree or NULL
1375  *
1376  * Register a new element declaration
1377  *
1378  * Returns NULL if not, otherwise the entity
1379  */
1380 xmlElementPtr
1381 xmlAddElementDecl(xmlValidCtxtPtr ctxt,
1382                   xmlDtdPtr dtd, const xmlChar *name,
1383                   xmlElementTypeVal type,
1384                   xmlElementContentPtr content) {
1385     xmlElementPtr ret;
1386     xmlElementTablePtr table;
1387     xmlAttributePtr oldAttributes = NULL;
1388     xmlChar *ns, *uqname;
1389
1390     if (dtd == NULL) {
1391         return(NULL);
1392     }
1393     if (name == NULL) {
1394         return(NULL);
1395     }
1396
1397     switch (type) {
1398         case XML_ELEMENT_TYPE_EMPTY:
1399             if (content != NULL) {
1400                 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1401                         "xmlAddElementDecl: content != NULL for EMPTY\n",
1402                         NULL);
1403                 return(NULL);
1404             }
1405             break;
1406         case XML_ELEMENT_TYPE_ANY:
1407             if (content != NULL) {
1408                 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1409                         "xmlAddElementDecl: content != NULL for ANY\n",
1410                         NULL);
1411                 return(NULL);
1412             }
1413             break;
1414         case XML_ELEMENT_TYPE_MIXED:
1415             if (content == NULL) {
1416                 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1417                         "xmlAddElementDecl: content == NULL for MIXED\n",
1418                         NULL);
1419                 return(NULL);
1420             }
1421             break;
1422         case XML_ELEMENT_TYPE_ELEMENT:
1423             if (content == NULL) {
1424                 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1425                         "xmlAddElementDecl: content == NULL for ELEMENT\n",
1426                         NULL);
1427                 return(NULL);
1428             }
1429             break;
1430         default:
1431             xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1432                     "Internal: ELEMENT decl corrupted invalid type\n",
1433                     NULL);
1434             return(NULL);
1435     }
1436
1437     /*
1438      * check if name is a QName
1439      */
1440     uqname = xmlSplitQName2(name, &ns);
1441     if (uqname != NULL)
1442         name = uqname;
1443
1444     /*
1445      * Create the Element table if needed.
1446      */
1447     table = (xmlElementTablePtr) dtd->elements;
1448     if (table == NULL) {
1449         xmlDictPtr dict = NULL;
1450
1451         if (dtd->doc != NULL)
1452             dict = dtd->doc->dict;
1453         table = xmlHashCreateDict(0, dict);
1454         dtd->elements = (void *) table;
1455     }
1456     if (table == NULL) {
1457         xmlVErrMemory(ctxt,
1458             "xmlAddElementDecl: Table creation failed!\n");
1459         if (uqname != NULL)
1460             xmlFree(uqname);
1461         if (ns != NULL)
1462             xmlFree(ns);
1463         return(NULL);
1464     }
1465
1466     /*
1467      * lookup old attributes inserted on an undefined element in the
1468      * internal subset.
1469      */
1470     if ((dtd->doc != NULL) && (dtd->doc->intSubset != NULL)) {
1471         ret = xmlHashLookup2(dtd->doc->intSubset->elements, name, ns);
1472         if ((ret != NULL) && (ret->etype == XML_ELEMENT_TYPE_UNDEFINED)) {
1473             oldAttributes = ret->attributes;
1474             ret->attributes = NULL;
1475             xmlHashRemoveEntry2(dtd->doc->intSubset->elements, name, ns, NULL);
1476             xmlFreeElement(ret);
1477         }
1478     }
1479
1480     /*
1481      * The element may already be present if one of its attribute
1482      * was registered first
1483      */
1484     ret = xmlHashLookup2(table, name, ns);
1485     if (ret != NULL) {
1486         if (ret->etype != XML_ELEMENT_TYPE_UNDEFINED) {
1487 #ifdef LIBXML_VALID_ENABLED
1488             /*
1489              * The element is already defined in this DTD.
1490              */
1491             xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ELEM_REDEFINED,
1492                             "Redefinition of element %s\n",
1493                             name, NULL, NULL);
1494 #endif /* LIBXML_VALID_ENABLED */
1495             if (uqname != NULL)
1496                 xmlFree(uqname);
1497             if (ns != NULL)
1498                 xmlFree(ns);
1499             return(NULL);
1500         }
1501         if (ns != NULL) {
1502             xmlFree(ns);
1503             ns = NULL;
1504         }
1505     } else {
1506         ret = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
1507         if (ret == NULL) {
1508             xmlVErrMemory(ctxt, "malloc failed");
1509             if (uqname != NULL)
1510                 xmlFree(uqname);
1511             if (ns != NULL)
1512                 xmlFree(ns);
1513             return(NULL);
1514         }
1515         memset(ret, 0, sizeof(xmlElement));
1516         ret->type = XML_ELEMENT_DECL;
1517
1518         /*
1519          * fill the structure.
1520          */
1521         ret->name = xmlStrdup(name);
1522         if (ret->name == NULL) {
1523             xmlVErrMemory(ctxt, "malloc failed");
1524             if (uqname != NULL)
1525                 xmlFree(uqname);
1526             if (ns != NULL)
1527                 xmlFree(ns);
1528             xmlFree(ret);
1529             return(NULL);
1530         }
1531         ret->prefix = ns;
1532
1533         /*
1534          * Validity Check:
1535          * Insertion must not fail
1536          */
1537         if (xmlHashAddEntry2(table, name, ns, ret)) {
1538 #ifdef LIBXML_VALID_ENABLED
1539             /*
1540              * The element is already defined in this DTD.
1541              */
1542             xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ELEM_REDEFINED,
1543                             "Redefinition of element %s\n",
1544                             name, NULL, NULL);
1545 #endif /* LIBXML_VALID_ENABLED */
1546             xmlFreeElement(ret);
1547             if (uqname != NULL)
1548                 xmlFree(uqname);
1549             return(NULL);
1550         }
1551         /*
1552          * For new element, may have attributes from earlier
1553          * definition in internal subset
1554          */
1555         ret->attributes = oldAttributes;
1556     }
1557
1558     /*
1559      * Finish to fill the structure.
1560      */
1561     ret->etype = type;
1562     /*
1563      * Avoid a stupid copy when called by the parser
1564      * and flag it by setting a special parent value
1565      * so the parser doesn't unallocate it.
1566      */
1567     if ((ctxt != NULL) &&
1568         ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
1569          (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1))) {
1570         ret->content = content;
1571         if (content != NULL)
1572             content->parent = (xmlElementContentPtr) 1;
1573     } else {
1574         ret->content = xmlCopyDocElementContent(dtd->doc, content);
1575     }
1576
1577     /*
1578      * Link it to the DTD
1579      */
1580     ret->parent = dtd;
1581     ret->doc = dtd->doc;
1582     if (dtd->last == NULL) {
1583         dtd->children = dtd->last = (xmlNodePtr) ret;
1584     } else {
1585         dtd->last->next = (xmlNodePtr) ret;
1586         ret->prev = dtd->last;
1587         dtd->last = (xmlNodePtr) ret;
1588     }
1589     if (uqname != NULL)
1590         xmlFree(uqname);
1591     return(ret);
1592 }
1593
1594 /**
1595  * xmlFreeElementTable:
1596  * @table:  An element table
1597  *
1598  * Deallocate the memory used by an element hash table.
1599  */
1600 void
1601 xmlFreeElementTable(xmlElementTablePtr table) {
1602     xmlHashFree(table, (xmlHashDeallocator) xmlFreeElement);
1603 }
1604
1605 #ifdef LIBXML_TREE_ENABLED
1606 /**
1607  * xmlCopyElement:
1608  * @elem:  An element
1609  *
1610  * Build a copy of an element.
1611  *
1612  * Returns the new xmlElementPtr or NULL in case of error.
1613  */
1614 static xmlElementPtr
1615 xmlCopyElement(xmlElementPtr elem) {
1616     xmlElementPtr cur;
1617
1618     cur = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
1619     if (cur == NULL) {
1620         xmlVErrMemory(NULL, "malloc failed");
1621         return(NULL);
1622     }
1623     memset(cur, 0, sizeof(xmlElement));
1624     cur->type = XML_ELEMENT_DECL;
1625     cur->etype = elem->etype;
1626     if (elem->name != NULL)
1627         cur->name = xmlStrdup(elem->name);
1628     else
1629         cur->name = NULL;
1630     if (elem->prefix != NULL)
1631         cur->prefix = xmlStrdup(elem->prefix);
1632     else
1633         cur->prefix = NULL;
1634     cur->content = xmlCopyElementContent(elem->content);
1635     /* TODO : rebuild the attribute list on the copy */
1636     cur->attributes = NULL;
1637     return(cur);
1638 }
1639
1640 /**
1641  * xmlCopyElementTable:
1642  * @table:  An element table
1643  *
1644  * Build a copy of an element table.
1645  *
1646  * Returns the new xmlElementTablePtr or NULL in case of error.
1647  */
1648 xmlElementTablePtr
1649 xmlCopyElementTable(xmlElementTablePtr table) {
1650     return((xmlElementTablePtr) xmlHashCopy(table,
1651                                             (xmlHashCopier) xmlCopyElement));
1652 }
1653 #endif /* LIBXML_TREE_ENABLED */
1654
1655 #ifdef LIBXML_OUTPUT_ENABLED
1656 /**
1657  * xmlDumpElementDecl:
1658  * @buf:  the XML buffer output
1659  * @elem:  An element table
1660  *
1661  * This will dump the content of the element declaration as an XML
1662  * DTD definition
1663  */
1664 void
1665 xmlDumpElementDecl(xmlBufferPtr buf, xmlElementPtr elem) {
1666     if ((buf == NULL) || (elem == NULL))
1667         return;
1668     switch (elem->etype) {
1669         case XML_ELEMENT_TYPE_EMPTY:
1670             xmlBufferWriteChar(buf, "<!ELEMENT ");
1671             if (elem->prefix != NULL) {
1672                 xmlBufferWriteCHAR(buf, elem->prefix);
1673                 xmlBufferWriteChar(buf, ":");
1674             }
1675             xmlBufferWriteCHAR(buf, elem->name);
1676             xmlBufferWriteChar(buf, " EMPTY>\n");
1677             break;
1678         case XML_ELEMENT_TYPE_ANY:
1679             xmlBufferWriteChar(buf, "<!ELEMENT ");
1680             if (elem->prefix != NULL) {
1681                 xmlBufferWriteCHAR(buf, elem->prefix);
1682                 xmlBufferWriteChar(buf, ":");
1683             }
1684             xmlBufferWriteCHAR(buf, elem->name);
1685             xmlBufferWriteChar(buf, " ANY>\n");
1686             break;
1687         case XML_ELEMENT_TYPE_MIXED:
1688             xmlBufferWriteChar(buf, "<!ELEMENT ");
1689             if (elem->prefix != NULL) {
1690                 xmlBufferWriteCHAR(buf, elem->prefix);
1691                 xmlBufferWriteChar(buf, ":");
1692             }
1693             xmlBufferWriteCHAR(buf, elem->name);
1694             xmlBufferWriteChar(buf, " ");
1695             xmlDumpElementContent(buf, elem->content, 1);
1696             xmlBufferWriteChar(buf, ">\n");
1697             break;
1698         case XML_ELEMENT_TYPE_ELEMENT:
1699             xmlBufferWriteChar(buf, "<!ELEMENT ");
1700             if (elem->prefix != NULL) {
1701                 xmlBufferWriteCHAR(buf, elem->prefix);
1702                 xmlBufferWriteChar(buf, ":");
1703             }
1704             xmlBufferWriteCHAR(buf, elem->name);
1705             xmlBufferWriteChar(buf, " ");
1706             xmlDumpElementContent(buf, elem->content, 1);
1707             xmlBufferWriteChar(buf, ">\n");
1708             break;
1709         default:
1710             xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
1711                     "Internal: ELEMENT struct corrupted invalid type\n",
1712                     NULL);
1713     }
1714 }
1715
1716 /**
1717  * xmlDumpElementDeclScan:
1718  * @elem:  An element table
1719  * @buf:  the XML buffer output
1720  *
1721  * This routine is used by the hash scan function.  It just reverses
1722  * the arguments.
1723  */
1724 static void
1725 xmlDumpElementDeclScan(xmlElementPtr elem, xmlBufferPtr buf) {
1726     xmlDumpElementDecl(buf, elem);
1727 }
1728
1729 /**
1730  * xmlDumpElementTable:
1731  * @buf:  the XML buffer output
1732  * @table:  An element table
1733  *
1734  * This will dump the content of the element table as an XML DTD definition
1735  */
1736 void
1737 xmlDumpElementTable(xmlBufferPtr buf, xmlElementTablePtr table) {
1738     if ((buf == NULL) || (table == NULL))
1739         return;
1740     xmlHashScan(table, (xmlHashScanner) xmlDumpElementDeclScan, buf);
1741 }
1742 #endif /* LIBXML_OUTPUT_ENABLED */
1743
1744 /**
1745  * xmlCreateEnumeration:
1746  * @name:  the enumeration name or NULL
1747  *
1748  * create and initialize an enumeration attribute node.
1749  *
1750  * Returns the xmlEnumerationPtr just created or NULL in case
1751  *                of error.
1752  */
1753 xmlEnumerationPtr
1754 xmlCreateEnumeration(const xmlChar *name) {
1755     xmlEnumerationPtr ret;
1756
1757     ret = (xmlEnumerationPtr) xmlMalloc(sizeof(xmlEnumeration));
1758     if (ret == NULL) {
1759         xmlVErrMemory(NULL, "malloc failed");
1760         return(NULL);
1761     }
1762     memset(ret, 0, sizeof(xmlEnumeration));
1763
1764     if (name != NULL)
1765         ret->name = xmlStrdup(name);
1766     return(ret);
1767 }
1768
1769 /**
1770  * xmlFreeEnumeration:
1771  * @cur:  the tree to free.
1772  *
1773  * free an enumeration attribute node (recursive).
1774  */
1775 void
1776 xmlFreeEnumeration(xmlEnumerationPtr cur) {
1777     if (cur == NULL) return;
1778
1779     if (cur->next != NULL) xmlFreeEnumeration(cur->next);
1780
1781     if (cur->name != NULL) xmlFree((xmlChar *) cur->name);
1782     xmlFree(cur);
1783 }
1784
1785 #ifdef LIBXML_TREE_ENABLED
1786 /**
1787  * xmlCopyEnumeration:
1788  * @cur:  the tree to copy.
1789  *
1790  * Copy an enumeration attribute node (recursive).
1791  *
1792  * Returns the xmlEnumerationPtr just created or NULL in case
1793  *                of error.
1794  */
1795 xmlEnumerationPtr
1796 xmlCopyEnumeration(xmlEnumerationPtr cur) {
1797     xmlEnumerationPtr ret;
1798
1799     if (cur == NULL) return(NULL);
1800     ret = xmlCreateEnumeration((xmlChar *) cur->name);
1801     if (ret == NULL) return(NULL);
1802
1803     if (cur->next != NULL) ret->next = xmlCopyEnumeration(cur->next);
1804     else ret->next = NULL;
1805
1806     return(ret);
1807 }
1808 #endif /* LIBXML_TREE_ENABLED */
1809
1810 #ifdef LIBXML_OUTPUT_ENABLED
1811 /**
1812  * xmlDumpEnumeration:
1813  * @buf:  the XML buffer output
1814  * @enum:  An enumeration
1815  *
1816  * This will dump the content of the enumeration
1817  */
1818 static void
1819 xmlDumpEnumeration(xmlBufferPtr buf, xmlEnumerationPtr cur) {
1820     if ((buf == NULL) || (cur == NULL))
1821         return;
1822
1823     xmlBufferWriteCHAR(buf, cur->name);
1824     if (cur->next == NULL)
1825         xmlBufferWriteChar(buf, ")");
1826     else {
1827         xmlBufferWriteChar(buf, " | ");
1828         xmlDumpEnumeration(buf, cur->next);
1829     }
1830 }
1831 #endif /* LIBXML_OUTPUT_ENABLED */
1832
1833 #ifdef LIBXML_VALID_ENABLED
1834 /**
1835  * xmlScanIDAttributeDecl:
1836  * @ctxt:  the validation context
1837  * @elem:  the element name
1838  * @err: whether to raise errors here
1839  *
1840  * Verify that the element don't have too many ID attributes
1841  * declared.
1842  *
1843  * Returns the number of ID attributes found.
1844  */
1845 static int
1846 xmlScanIDAttributeDecl(xmlValidCtxtPtr ctxt, xmlElementPtr elem, int err) {
1847     xmlAttributePtr cur;
1848     int ret = 0;
1849
1850     if (elem == NULL) return(0);
1851     cur = elem->attributes;
1852     while (cur != NULL) {
1853         if (cur->atype == XML_ATTRIBUTE_ID) {
1854             ret ++;
1855             if ((ret > 1) && (err))
1856                 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_MULTIPLE_ID,
1857                "Element %s has too many ID attributes defined : %s\n",
1858                        elem->name, cur->name, NULL);
1859         }
1860         cur = cur->nexth;
1861     }
1862     return(ret);
1863 }
1864 #endif /* LIBXML_VALID_ENABLED */
1865
1866 /**
1867  * xmlFreeAttribute:
1868  * @elem:  An attribute
1869  *
1870  * Deallocate the memory used by an attribute definition
1871  */
1872 static void
1873 xmlFreeAttribute(xmlAttributePtr attr) {
1874     xmlDictPtr dict;
1875
1876     if (attr == NULL) return;
1877     if (attr->doc != NULL)
1878         dict = attr->doc->dict;
1879     else
1880         dict = NULL;
1881     xmlUnlinkNode((xmlNodePtr) attr);
1882     if (attr->tree != NULL)
1883         xmlFreeEnumeration(attr->tree);
1884     if (dict) {
1885         if ((attr->elem != NULL) && (!xmlDictOwns(dict, attr->elem)))
1886             xmlFree((xmlChar *) attr->elem);
1887         if ((attr->name != NULL) && (!xmlDictOwns(dict, attr->name)))
1888             xmlFree((xmlChar *) attr->name);
1889         if ((attr->prefix != NULL) && (!xmlDictOwns(dict, attr->prefix)))
1890             xmlFree((xmlChar *) attr->prefix);
1891         if ((attr->defaultValue != NULL) &&
1892             (!xmlDictOwns(dict, attr->defaultValue)))
1893             xmlFree((xmlChar *) attr->defaultValue);
1894     } else {
1895         if (attr->elem != NULL)
1896             xmlFree((xmlChar *) attr->elem);
1897         if (attr->name != NULL)
1898             xmlFree((xmlChar *) attr->name);
1899         if (attr->defaultValue != NULL)
1900             xmlFree((xmlChar *) attr->defaultValue);
1901         if (attr->prefix != NULL)
1902             xmlFree((xmlChar *) attr->prefix);
1903     }
1904     xmlFree(attr);
1905 }
1906
1907
1908 /**
1909  * xmlAddAttributeDecl:
1910  * @ctxt:  the validation context
1911  * @dtd:  pointer to the DTD
1912  * @elem:  the element name
1913  * @name:  the attribute name
1914  * @ns:  the attribute namespace prefix
1915  * @type:  the attribute type
1916  * @def:  the attribute default type
1917  * @defaultValue:  the attribute default value
1918  * @tree:  if it's an enumeration, the associated list
1919  *
1920  * Register a new attribute declaration
1921  * Note that @tree becomes the ownership of the DTD
1922  *
1923  * Returns NULL if not new, otherwise the attribute decl
1924  */
1925 xmlAttributePtr
1926 xmlAddAttributeDecl(xmlValidCtxtPtr ctxt,
1927                     xmlDtdPtr dtd, const xmlChar *elem,
1928                     const xmlChar *name, const xmlChar *ns,
1929                     xmlAttributeType type, xmlAttributeDefault def,
1930                     const xmlChar *defaultValue, xmlEnumerationPtr tree) {
1931     xmlAttributePtr ret;
1932     xmlAttributeTablePtr table;
1933     xmlElementPtr elemDef;
1934     xmlDictPtr dict = NULL;
1935
1936     if (dtd == NULL) {
1937         xmlFreeEnumeration(tree);
1938         return(NULL);
1939     }
1940     if (name == NULL) {
1941         xmlFreeEnumeration(tree);
1942         return(NULL);
1943     }
1944     if (elem == NULL) {
1945         xmlFreeEnumeration(tree);
1946         return(NULL);
1947     }
1948     if (dtd->doc != NULL)
1949         dict = dtd->doc->dict;
1950
1951 #ifdef LIBXML_VALID_ENABLED
1952     /*
1953      * Check the type and possibly the default value.
1954      */
1955     switch (type) {
1956         case XML_ATTRIBUTE_CDATA:
1957             break;
1958         case XML_ATTRIBUTE_ID:
1959             break;
1960         case XML_ATTRIBUTE_IDREF:
1961             break;
1962         case XML_ATTRIBUTE_IDREFS:
1963             break;
1964         case XML_ATTRIBUTE_ENTITY:
1965             break;
1966         case XML_ATTRIBUTE_ENTITIES:
1967             break;
1968         case XML_ATTRIBUTE_NMTOKEN:
1969             break;
1970         case XML_ATTRIBUTE_NMTOKENS:
1971             break;
1972         case XML_ATTRIBUTE_ENUMERATION:
1973             break;
1974         case XML_ATTRIBUTE_NOTATION:
1975             break;
1976         default:
1977             xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1978                     "Internal: ATTRIBUTE struct corrupted invalid type\n",
1979                     NULL);
1980             xmlFreeEnumeration(tree);
1981             return(NULL);
1982     }
1983     if ((defaultValue != NULL) &&
1984         (!xmlValidateAttributeValueInternal(dtd->doc, type, defaultValue))) {
1985         xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ATTRIBUTE_DEFAULT,
1986                         "Attribute %s of %s: invalid default value\n",
1987                         elem, name, defaultValue);
1988         defaultValue = NULL;
1989         if (ctxt != NULL)
1990             ctxt->valid = 0;
1991     }
1992 #endif /* LIBXML_VALID_ENABLED */
1993
1994     /*
1995      * Check first that an attribute defined in the external subset wasn't
1996      * already defined in the internal subset
1997      */
1998     if ((dtd->doc != NULL) && (dtd->doc->extSubset == dtd) &&
1999         (dtd->doc->intSubset != NULL) &&
2000         (dtd->doc->intSubset->attributes != NULL)) {
2001         ret = xmlHashLookup3(dtd->doc->intSubset->attributes, name, ns, elem);
2002         if (ret != NULL) {
2003             xmlFreeEnumeration(tree);
2004             return(NULL);
2005         }
2006     }
2007
2008     /*
2009      * Create the Attribute table if needed.
2010      */
2011     table = (xmlAttributeTablePtr) dtd->attributes;
2012     if (table == NULL) {
2013         table = xmlHashCreateDict(0, dict);
2014         dtd->attributes = (void *) table;
2015     }
2016     if (table == NULL) {
2017         xmlVErrMemory(ctxt,
2018             "xmlAddAttributeDecl: Table creation failed!\n");
2019         xmlFreeEnumeration(tree);
2020         return(NULL);
2021     }
2022
2023
2024     ret = (xmlAttributePtr) xmlMalloc(sizeof(xmlAttribute));
2025     if (ret == NULL) {
2026         xmlVErrMemory(ctxt, "malloc failed");
2027         xmlFreeEnumeration(tree);
2028         return(NULL);
2029     }
2030     memset(ret, 0, sizeof(xmlAttribute));
2031     ret->type = XML_ATTRIBUTE_DECL;
2032
2033     /*
2034      * fill the structure.
2035      */
2036     ret->atype = type;
2037     /*
2038      * doc must be set before possible error causes call
2039      * to xmlFreeAttribute (because it's used to check on
2040      * dict use)
2041      */
2042     ret->doc = dtd->doc;
2043     if (dict) {
2044         ret->name = xmlDictLookup(dict, name, -1);
2045         ret->prefix = xmlDictLookup(dict, ns, -1);
2046         ret->elem = xmlDictLookup(dict, elem, -1);
2047     } else {
2048         ret->name = xmlStrdup(name);
2049         ret->prefix = xmlStrdup(ns);
2050         ret->elem = xmlStrdup(elem);
2051     }
2052     ret->def = def;
2053     ret->tree = tree;
2054     if (defaultValue != NULL) {
2055         if (dict)
2056             ret->defaultValue = xmlDictLookup(dict, defaultValue, -1);
2057         else
2058             ret->defaultValue = xmlStrdup(defaultValue);
2059     }
2060
2061     /*
2062      * Validity Check:
2063      * Search the DTD for previous declarations of the ATTLIST
2064      */
2065     if (xmlHashAddEntry3(table, ret->name, ret->prefix, ret->elem, ret) < 0) {
2066 #ifdef LIBXML_VALID_ENABLED
2067         /*
2068          * The attribute is already defined in this DTD.
2069          */
2070         xmlErrValidWarning(ctxt, (xmlNodePtr) dtd, XML_DTD_ATTRIBUTE_REDEFINED,
2071                  "Attribute %s of element %s: already defined\n",
2072                  name, elem, NULL);
2073 #endif /* LIBXML_VALID_ENABLED */
2074         xmlFreeAttribute(ret);
2075         return(NULL);
2076     }
2077
2078     /*
2079      * Validity Check:
2080      * Multiple ID per element
2081      */
2082     elemDef = xmlGetDtdElementDesc2(dtd, elem, 1);
2083     if (elemDef != NULL) {
2084
2085 #ifdef LIBXML_VALID_ENABLED
2086         if ((type == XML_ATTRIBUTE_ID) &&
2087             (xmlScanIDAttributeDecl(NULL, elemDef, 1) != 0)) {
2088             xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_MULTIPLE_ID,
2089            "Element %s has too may ID attributes defined : %s\n",
2090                    elem, name, NULL);
2091             if (ctxt != NULL)
2092                 ctxt->valid = 0;
2093         }
2094 #endif /* LIBXML_VALID_ENABLED */
2095
2096         /*
2097          * Insert namespace default def first they need to be
2098          * processed first.
2099          */
2100         if ((xmlStrEqual(ret->name, BAD_CAST "xmlns")) ||
2101             ((ret->prefix != NULL &&
2102              (xmlStrEqual(ret->prefix, BAD_CAST "xmlns"))))) {
2103             ret->nexth = elemDef->attributes;
2104             elemDef->attributes = ret;
2105         } else {
2106             xmlAttributePtr tmp = elemDef->attributes;
2107
2108             while ((tmp != NULL) &&
2109                    ((xmlStrEqual(tmp->name, BAD_CAST "xmlns")) ||
2110                     ((ret->prefix != NULL &&
2111                      (xmlStrEqual(ret->prefix, BAD_CAST "xmlns")))))) {
2112                 if (tmp->nexth == NULL)
2113                     break;
2114                 tmp = tmp->nexth;
2115             }
2116             if (tmp != NULL) {
2117                 ret->nexth = tmp->nexth;
2118                 tmp->nexth = ret;
2119             } else {
2120                 ret->nexth = elemDef->attributes;
2121                 elemDef->attributes = ret;
2122             }
2123         }
2124     }
2125
2126     /*
2127      * Link it to the DTD
2128      */
2129     ret->parent = dtd;
2130     if (dtd->last == NULL) {
2131         dtd->children = dtd->last = (xmlNodePtr) ret;
2132     } else {
2133         dtd->last->next = (xmlNodePtr) ret;
2134         ret->prev = dtd->last;
2135         dtd->last = (xmlNodePtr) ret;
2136     }
2137     return(ret);
2138 }
2139
2140 /**
2141  * xmlFreeAttributeTable:
2142  * @table:  An attribute table
2143  *
2144  * Deallocate the memory used by an entities hash table.
2145  */
2146 void
2147 xmlFreeAttributeTable(xmlAttributeTablePtr table) {
2148     xmlHashFree(table, (xmlHashDeallocator) xmlFreeAttribute);
2149 }
2150
2151 #ifdef LIBXML_TREE_ENABLED
2152 /**
2153  * xmlCopyAttribute:
2154  * @attr:  An attribute
2155  *
2156  * Build a copy of an attribute.
2157  *
2158  * Returns the new xmlAttributePtr or NULL in case of error.
2159  */
2160 static xmlAttributePtr
2161 xmlCopyAttribute(xmlAttributePtr attr) {
2162     xmlAttributePtr cur;
2163
2164     cur = (xmlAttributePtr) xmlMalloc(sizeof(xmlAttribute));
2165     if (cur == NULL) {
2166         xmlVErrMemory(NULL, "malloc failed");
2167         return(NULL);
2168     }
2169     memset(cur, 0, sizeof(xmlAttribute));
2170     cur->type = XML_ATTRIBUTE_DECL;
2171     cur->atype = attr->atype;
2172     cur->def = attr->def;
2173     cur->tree = xmlCopyEnumeration(attr->tree);
2174     if (attr->elem != NULL)
2175         cur->elem = xmlStrdup(attr->elem);
2176     if (attr->name != NULL)
2177         cur->name = xmlStrdup(attr->name);
2178     if (attr->prefix != NULL)
2179         cur->prefix = xmlStrdup(attr->prefix);
2180     if (attr->defaultValue != NULL)
2181         cur->defaultValue = xmlStrdup(attr->defaultValue);
2182     return(cur);
2183 }
2184
2185 /**
2186  * xmlCopyAttributeTable:
2187  * @table:  An attribute table
2188  *
2189  * Build a copy of an attribute table.
2190  *
2191  * Returns the new xmlAttributeTablePtr or NULL in case of error.
2192  */
2193 xmlAttributeTablePtr
2194 xmlCopyAttributeTable(xmlAttributeTablePtr table) {
2195     return((xmlAttributeTablePtr) xmlHashCopy(table,
2196                                     (xmlHashCopier) xmlCopyAttribute));
2197 }
2198 #endif /* LIBXML_TREE_ENABLED */
2199
2200 #ifdef LIBXML_OUTPUT_ENABLED
2201 /**
2202  * xmlDumpAttributeDecl:
2203  * @buf:  the XML buffer output
2204  * @attr:  An attribute declaration
2205  *
2206  * This will dump the content of the attribute declaration as an XML
2207  * DTD definition
2208  */
2209 void
2210 xmlDumpAttributeDecl(xmlBufferPtr buf, xmlAttributePtr attr) {
2211     if ((buf == NULL) || (attr == NULL))
2212         return;
2213     xmlBufferWriteChar(buf, "<!ATTLIST ");
2214     xmlBufferWriteCHAR(buf, attr->elem);
2215     xmlBufferWriteChar(buf, " ");
2216     if (attr->prefix != NULL) {
2217         xmlBufferWriteCHAR(buf, attr->prefix);
2218         xmlBufferWriteChar(buf, ":");
2219     }
2220     xmlBufferWriteCHAR(buf, attr->name);
2221     switch (attr->atype) {
2222         case XML_ATTRIBUTE_CDATA:
2223             xmlBufferWriteChar(buf, " CDATA");
2224             break;
2225         case XML_ATTRIBUTE_ID:
2226             xmlBufferWriteChar(buf, " ID");
2227             break;
2228         case XML_ATTRIBUTE_IDREF:
2229             xmlBufferWriteChar(buf, " IDREF");
2230             break;
2231         case XML_ATTRIBUTE_IDREFS:
2232             xmlBufferWriteChar(buf, " IDREFS");
2233             break;
2234         case XML_ATTRIBUTE_ENTITY:
2235             xmlBufferWriteChar(buf, " ENTITY");
2236             break;
2237         case XML_ATTRIBUTE_ENTITIES:
2238             xmlBufferWriteChar(buf, " ENTITIES");
2239             break;
2240         case XML_ATTRIBUTE_NMTOKEN:
2241             xmlBufferWriteChar(buf, " NMTOKEN");
2242             break;
2243         case XML_ATTRIBUTE_NMTOKENS:
2244             xmlBufferWriteChar(buf, " NMTOKENS");
2245             break;
2246         case XML_ATTRIBUTE_ENUMERATION:
2247             xmlBufferWriteChar(buf, " (");
2248             xmlDumpEnumeration(buf, attr->tree);
2249             break;
2250         case XML_ATTRIBUTE_NOTATION:
2251             xmlBufferWriteChar(buf, " NOTATION (");
2252             xmlDumpEnumeration(buf, attr->tree);
2253             break;
2254         default:
2255             xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2256                     "Internal: ATTRIBUTE struct corrupted invalid type\n",
2257                     NULL);
2258     }
2259     switch (attr->def) {
2260         case XML_ATTRIBUTE_NONE:
2261             break;
2262         case XML_ATTRIBUTE_REQUIRED:
2263             xmlBufferWriteChar(buf, " #REQUIRED");
2264             break;
2265         case XML_ATTRIBUTE_IMPLIED:
2266             xmlBufferWriteChar(buf, " #IMPLIED");
2267             break;
2268         case XML_ATTRIBUTE_FIXED:
2269             xmlBufferWriteChar(buf, " #FIXED");
2270             break;
2271         default:
2272             xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2273                     "Internal: ATTRIBUTE struct corrupted invalid def\n",
2274                     NULL);
2275     }
2276     if (attr->defaultValue != NULL) {
2277         xmlBufferWriteChar(buf, " ");
2278         xmlBufferWriteQuotedString(buf, attr->defaultValue);
2279     }
2280     xmlBufferWriteChar(buf, ">\n");
2281 }
2282
2283 /**
2284  * xmlDumpAttributeDeclScan:
2285  * @attr:  An attribute declaration
2286  * @buf:  the XML buffer output
2287  *
2288  * This is used with the hash scan function - just reverses arguments
2289  */
2290 static void
2291 xmlDumpAttributeDeclScan(xmlAttributePtr attr, xmlBufferPtr buf) {
2292     xmlDumpAttributeDecl(buf, attr);
2293 }
2294
2295 /**
2296  * xmlDumpAttributeTable:
2297  * @buf:  the XML buffer output
2298  * @table:  An attribute table
2299  *
2300  * This will dump the content of the attribute table as an XML DTD definition
2301  */
2302 void
2303 xmlDumpAttributeTable(xmlBufferPtr buf, xmlAttributeTablePtr table) {
2304     if ((buf == NULL) || (table == NULL))
2305         return;
2306     xmlHashScan(table, (xmlHashScanner) xmlDumpAttributeDeclScan, buf);
2307 }
2308 #endif /* LIBXML_OUTPUT_ENABLED */
2309
2310 /************************************************************************
2311  *                                                                      *
2312  *                              NOTATIONs                               *
2313  *                                                                      *
2314  ************************************************************************/
2315 /**
2316  * xmlFreeNotation:
2317  * @not:  A notation
2318  *
2319  * Deallocate the memory used by an notation definition
2320  */
2321 static void
2322 xmlFreeNotation(xmlNotationPtr nota) {
2323     if (nota == NULL) return;
2324     if (nota->name != NULL)
2325         xmlFree((xmlChar *) nota->name);
2326     if (nota->PublicID != NULL)
2327         xmlFree((xmlChar *) nota->PublicID);
2328     if (nota->SystemID != NULL)
2329         xmlFree((xmlChar *) nota->SystemID);
2330     xmlFree(nota);
2331 }
2332
2333
2334 /**
2335  * xmlAddNotationDecl:
2336  * @dtd:  pointer to the DTD
2337  * @ctxt:  the validation context
2338  * @name:  the entity name
2339  * @PublicID:  the public identifier or NULL
2340  * @SystemID:  the system identifier or NULL
2341  *
2342  * Register a new notation declaration
2343  *
2344  * Returns NULL if not, otherwise the entity
2345  */
2346 xmlNotationPtr
2347 xmlAddNotationDecl(xmlValidCtxtPtr ctxt, xmlDtdPtr dtd,
2348                    const xmlChar *name,
2349                    const xmlChar *PublicID, const xmlChar *SystemID) {
2350     xmlNotationPtr ret;
2351     xmlNotationTablePtr table;
2352
2353     if (dtd == NULL) {
2354         return(NULL);
2355     }
2356     if (name == NULL) {
2357         return(NULL);
2358     }
2359     if ((PublicID == NULL) && (SystemID == NULL)) {
2360         return(NULL);
2361     }
2362
2363     /*
2364      * Create the Notation table if needed.
2365      */
2366     table = (xmlNotationTablePtr) dtd->notations;
2367     if (table == NULL) {
2368         xmlDictPtr dict = NULL;
2369         if (dtd->doc != NULL)
2370             dict = dtd->doc->dict;
2371
2372         dtd->notations = table = xmlHashCreateDict(0, dict);
2373     }
2374     if (table == NULL) {
2375         xmlVErrMemory(ctxt,
2376                 "xmlAddNotationDecl: Table creation failed!\n");
2377         return(NULL);
2378     }
2379
2380     ret = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation));
2381     if (ret == NULL) {
2382         xmlVErrMemory(ctxt, "malloc failed");
2383         return(NULL);
2384     }
2385     memset(ret, 0, sizeof(xmlNotation));
2386
2387     /*
2388      * fill the structure.
2389      */
2390     ret->name = xmlStrdup(name);
2391     if (SystemID != NULL)
2392         ret->SystemID = xmlStrdup(SystemID);
2393     if (PublicID != NULL)
2394         ret->PublicID = xmlStrdup(PublicID);
2395
2396     /*
2397      * Validity Check:
2398      * Check the DTD for previous declarations of the ATTLIST
2399      */
2400     if (xmlHashAddEntry(table, name, ret)) {
2401 #ifdef LIBXML_VALID_ENABLED
2402         xmlErrValid(NULL, XML_DTD_NOTATION_REDEFINED,
2403                     "xmlAddNotationDecl: %s already defined\n",
2404                     (const char *) name);
2405 #endif /* LIBXML_VALID_ENABLED */
2406         xmlFreeNotation(ret);
2407         return(NULL);
2408     }
2409     return(ret);
2410 }
2411
2412 /**
2413  * xmlFreeNotationTable:
2414  * @table:  An notation table
2415  *
2416  * Deallocate the memory used by an entities hash table.
2417  */
2418 void
2419 xmlFreeNotationTable(xmlNotationTablePtr table) {
2420     xmlHashFree(table, (xmlHashDeallocator) xmlFreeNotation);
2421 }
2422
2423 #ifdef LIBXML_TREE_ENABLED
2424 /**
2425  * xmlCopyNotation:
2426  * @nota:  A notation
2427  *
2428  * Build a copy of a notation.
2429  *
2430  * Returns the new xmlNotationPtr or NULL in case of error.
2431  */
2432 static xmlNotationPtr
2433 xmlCopyNotation(xmlNotationPtr nota) {
2434     xmlNotationPtr cur;
2435
2436     cur = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation));
2437     if (cur == NULL) {
2438         xmlVErrMemory(NULL, "malloc failed");
2439         return(NULL);
2440     }
2441     if (nota->name != NULL)
2442         cur->name = xmlStrdup(nota->name);
2443     else
2444         cur->name = NULL;
2445     if (nota->PublicID != NULL)
2446         cur->PublicID = xmlStrdup(nota->PublicID);
2447     else
2448         cur->PublicID = NULL;
2449     if (nota->SystemID != NULL)
2450         cur->SystemID = xmlStrdup(nota->SystemID);
2451     else
2452         cur->SystemID = NULL;
2453     return(cur);
2454 }
2455
2456 /**
2457  * xmlCopyNotationTable:
2458  * @table:  A notation table
2459  *
2460  * Build a copy of a notation table.
2461  *
2462  * Returns the new xmlNotationTablePtr or NULL in case of error.
2463  */
2464 xmlNotationTablePtr
2465 xmlCopyNotationTable(xmlNotationTablePtr table) {
2466     return((xmlNotationTablePtr) xmlHashCopy(table,
2467                                     (xmlHashCopier) xmlCopyNotation));
2468 }
2469 #endif /* LIBXML_TREE_ENABLED */
2470
2471 #ifdef LIBXML_OUTPUT_ENABLED
2472 /**
2473  * xmlDumpNotationDecl:
2474  * @buf:  the XML buffer output
2475  * @nota:  A notation declaration
2476  *
2477  * This will dump the content the notation declaration as an XML DTD definition
2478  */
2479 void
2480 xmlDumpNotationDecl(xmlBufferPtr buf, xmlNotationPtr nota) {
2481     if ((buf == NULL) || (nota == NULL))
2482         return;
2483     xmlBufferWriteChar(buf, "<!NOTATION ");
2484     xmlBufferWriteCHAR(buf, nota->name);
2485     if (nota->PublicID != NULL) {
2486         xmlBufferWriteChar(buf, " PUBLIC ");
2487         xmlBufferWriteQuotedString(buf, nota->PublicID);
2488         if (nota->SystemID != NULL) {
2489             xmlBufferWriteChar(buf, " ");
2490             xmlBufferWriteQuotedString(buf, nota->SystemID);
2491         }
2492     } else {
2493         xmlBufferWriteChar(buf, " SYSTEM ");
2494         xmlBufferWriteQuotedString(buf, nota->SystemID);
2495     }
2496     xmlBufferWriteChar(buf, " >\n");
2497 }
2498
2499 /**
2500  * xmlDumpNotationDeclScan:
2501  * @nota:  A notation declaration
2502  * @buf:  the XML buffer output
2503  *
2504  * This is called with the hash scan function, and just reverses args
2505  */
2506 static void
2507 xmlDumpNotationDeclScan(xmlNotationPtr nota, xmlBufferPtr buf) {
2508     xmlDumpNotationDecl(buf, nota);
2509 }
2510
2511 /**
2512  * xmlDumpNotationTable:
2513  * @buf:  the XML buffer output
2514  * @table:  A notation table
2515  *
2516  * This will dump the content of the notation table as an XML DTD definition
2517  */
2518 void
2519 xmlDumpNotationTable(xmlBufferPtr buf, xmlNotationTablePtr table) {
2520     if ((buf == NULL) || (table == NULL))
2521         return;
2522     xmlHashScan(table, (xmlHashScanner) xmlDumpNotationDeclScan, buf);
2523 }
2524 #endif /* LIBXML_OUTPUT_ENABLED */
2525
2526 /************************************************************************
2527  *                                                                      *
2528  *                              IDs                                     *
2529  *                                                                      *
2530  ************************************************************************/
2531 /**
2532  * DICT_FREE:
2533  * @str:  a string
2534  *
2535  * Free a string if it is not owned by the "dict" dictionary in the
2536  * current scope
2537  */
2538 #define DICT_FREE(str)                                          \
2539         if ((str) && ((!dict) ||                                \
2540             (xmlDictOwns(dict, (const xmlChar *)(str)) == 0)))  \
2541             xmlFree((char *)(str));
2542
2543 /**
2544  * xmlFreeID:
2545  * @not:  A id
2546  *
2547  * Deallocate the memory used by an id definition
2548  */
2549 static void
2550 xmlFreeID(xmlIDPtr id) {
2551     xmlDictPtr dict = NULL;
2552
2553     if (id == NULL) return;
2554
2555     if (id->doc != NULL)
2556         dict = id->doc->dict;
2557
2558     if (id->value != NULL)
2559         DICT_FREE(id->value)
2560     if (id->name != NULL)
2561         DICT_FREE(id->name)
2562     xmlFree(id);
2563 }
2564
2565
2566 /**
2567  * xmlAddID:
2568  * @ctxt:  the validation context
2569  * @doc:  pointer to the document
2570  * @value:  the value name
2571  * @attr:  the attribute holding the ID
2572  *
2573  * Register a new id declaration
2574  *
2575  * Returns NULL if not, otherwise the new xmlIDPtr
2576  */
2577 xmlIDPtr
2578 xmlAddID(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value,
2579          xmlAttrPtr attr) {
2580     xmlIDPtr ret;
2581     xmlIDTablePtr table;
2582
2583     if (doc == NULL) {
2584         return(NULL);
2585     }
2586     if (value == NULL) {
2587         return(NULL);
2588     }
2589     if (attr == NULL) {
2590         return(NULL);
2591     }
2592
2593     /*
2594      * Create the ID table if needed.
2595      */
2596     table = (xmlIDTablePtr) doc->ids;
2597     if (table == NULL)  {
2598         doc->ids = table = xmlHashCreateDict(0, doc->dict);
2599     }
2600     if (table == NULL) {
2601         xmlVErrMemory(ctxt,
2602                 "xmlAddID: Table creation failed!\n");
2603         return(NULL);
2604     }
2605
2606     ret = (xmlIDPtr) xmlMalloc(sizeof(xmlID));
2607     if (ret == NULL) {
2608         xmlVErrMemory(ctxt, "malloc failed");
2609         return(NULL);
2610     }
2611
2612     /*
2613      * fill the structure.
2614      */
2615     ret->value = xmlStrdup(value);
2616     ret->doc = doc;
2617     if ((ctxt != NULL) && (ctxt->vstateNr != 0)) {
2618         /*
2619          * Operating in streaming mode, attr is gonna disapear
2620          */
2621         if (doc->dict != NULL)
2622             ret->name = xmlDictLookup(doc->dict, attr->name, -1);
2623         else
2624             ret->name = xmlStrdup(attr->name);
2625         ret->attr = NULL;
2626     } else {
2627         ret->attr = attr;
2628         ret->name = NULL;
2629     }
2630     ret->lineno = xmlGetLineNo(attr->parent);
2631
2632     if (xmlHashAddEntry(table, value, ret) < 0) {
2633 #ifdef LIBXML_VALID_ENABLED
2634         /*
2635          * The id is already defined in this DTD.
2636          */
2637         if (ctxt != NULL) {
2638             xmlErrValidNode(ctxt, attr->parent, XML_DTD_ID_REDEFINED,
2639                             "ID %s already defined\n", value, NULL, NULL);
2640         }
2641 #endif /* LIBXML_VALID_ENABLED */
2642         xmlFreeID(ret);
2643         return(NULL);
2644     }
2645     if (attr != NULL)
2646         attr->atype = XML_ATTRIBUTE_ID;
2647     return(ret);
2648 }
2649
2650 /**
2651  * xmlFreeIDTable:
2652  * @table:  An id table
2653  *
2654  * Deallocate the memory used by an ID hash table.
2655  */
2656 void
2657 xmlFreeIDTable(xmlIDTablePtr table) {
2658     xmlHashFree(table, (xmlHashDeallocator) xmlFreeID);
2659 }
2660
2661 /**
2662  * xmlIsID:
2663  * @doc:  the document
2664  * @elem:  the element carrying the attribute
2665  * @attr:  the attribute
2666  *
2667  * Determine whether an attribute is of type ID. In case we have DTD(s)
2668  * then this is done if DTD loading has been requested. In the case
2669  * of HTML documents parsed with the HTML parser, then ID detection is
2670  * done systematically.
2671  *
2672  * Returns 0 or 1 depending on the lookup result
2673  */
2674 int
2675 xmlIsID(xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr) {
2676     if ((attr == NULL) || (attr->name == NULL)) return(0);
2677     if ((attr->ns != NULL) && (attr->ns->prefix != NULL) &&
2678         (!strcmp((char *) attr->name, "id")) &&
2679         (!strcmp((char *) attr->ns->prefix, "xml")))
2680         return(1);
2681     if (doc == NULL) return(0);
2682     if ((doc->intSubset == NULL) && (doc->extSubset == NULL) &&
2683         (doc->type != XML_HTML_DOCUMENT_NODE)) {
2684         return(0);
2685     } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
2686         if ((xmlStrEqual(BAD_CAST "id", attr->name)) ||
2687             ((xmlStrEqual(BAD_CAST "name", attr->name)) &&
2688             ((elem == NULL) || (xmlStrEqual(elem->name, BAD_CAST "a")))))
2689             return(1);
2690         return(0);
2691     } else if (elem == NULL) {
2692         return(0);
2693     } else {
2694         xmlAttributePtr attrDecl = NULL;
2695
2696         xmlChar felem[50], fattr[50];
2697         xmlChar *fullelemname, *fullattrname;
2698
2699         fullelemname = (elem->ns != NULL && elem->ns->prefix != NULL) ?
2700             xmlBuildQName(elem->name, elem->ns->prefix, felem, 50) :
2701             (xmlChar *)elem->name;
2702
2703         fullattrname = (attr->ns != NULL && attr->ns->prefix != NULL) ?
2704             xmlBuildQName(attr->name, attr->ns->prefix, fattr, 50) :
2705             (xmlChar *)attr->name;
2706
2707         if (fullelemname != NULL && fullattrname != NULL) {
2708             attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullelemname,
2709                                          fullattrname);
2710             if ((attrDecl == NULL) && (doc->extSubset != NULL))
2711                 attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullelemname,
2712                                              fullattrname);
2713         }
2714
2715         if ((fullattrname != fattr) && (fullattrname != attr->name))
2716             xmlFree(fullattrname);
2717         if ((fullelemname != felem) && (fullelemname != elem->name))
2718             xmlFree(fullelemname);
2719
2720         if ((attrDecl != NULL) && (attrDecl->atype == XML_ATTRIBUTE_ID))
2721             return(1);
2722     }
2723     return(0);
2724 }
2725
2726 /**
2727  * xmlRemoveID:
2728  * @doc:  the document
2729  * @attr:  the attribute
2730  *
2731  * Remove the given attribute from the ID table maintained internally.
2732  *
2733  * Returns -1 if the lookup failed and 0 otherwise
2734  */
2735 int
2736 xmlRemoveID(xmlDocPtr doc, xmlAttrPtr attr) {
2737     xmlIDTablePtr table;
2738     xmlIDPtr id;
2739     xmlChar *ID;
2740
2741     if (doc == NULL) return(-1);
2742     if (attr == NULL) return(-1);
2743
2744     table = (xmlIDTablePtr) doc->ids;
2745     if (table == NULL)
2746         return(-1);
2747
2748     ID = xmlNodeListGetString(doc, attr->children, 1);
2749     if (ID == NULL)
2750         return(-1);
2751
2752     id = xmlHashLookup(table, ID);
2753     if (id == NULL || id->attr != attr) {
2754         xmlFree(ID);
2755         return(-1);
2756     }
2757
2758     xmlHashRemoveEntry(table, ID, (xmlHashDeallocator) xmlFreeID);
2759     xmlFree(ID);
2760     attr->atype = 0;
2761     return(0);
2762 }
2763
2764 /**
2765  * xmlGetID:
2766  * @doc:  pointer to the document
2767  * @ID:  the ID value
2768  *
2769  * Search the attribute declaring the given ID
2770  *
2771  * Returns NULL if not found, otherwise the xmlAttrPtr defining the ID
2772  */
2773 xmlAttrPtr
2774 xmlGetID(xmlDocPtr doc, const xmlChar *ID) {
2775     xmlIDTablePtr table;
2776     xmlIDPtr id;
2777
2778     if (doc == NULL) {
2779         return(NULL);
2780     }
2781
2782     if (ID == NULL) {
2783         return(NULL);
2784     }
2785
2786     table = (xmlIDTablePtr) doc->ids;
2787     if (table == NULL)
2788         return(NULL);
2789
2790     id = xmlHashLookup(table, ID);
2791     if (id == NULL)
2792         return(NULL);
2793     if (id->attr == NULL) {
2794         /*
2795          * We are operating on a stream, return a well known reference
2796          * since the attribute node doesn't exist anymore
2797          */
2798         return((xmlAttrPtr) doc);
2799     }
2800     return(id->attr);
2801 }
2802
2803 /************************************************************************
2804  *                                                                      *
2805  *                              Refs                                    *
2806  *                                                                      *
2807  ************************************************************************/
2808 typedef struct xmlRemoveMemo_t
2809 {
2810         xmlListPtr l;
2811         xmlAttrPtr ap;
2812 } xmlRemoveMemo;
2813
2814 typedef xmlRemoveMemo *xmlRemoveMemoPtr;
2815
2816 typedef struct xmlValidateMemo_t
2817 {
2818     xmlValidCtxtPtr ctxt;
2819     const xmlChar *name;
2820 } xmlValidateMemo;
2821
2822 typedef xmlValidateMemo *xmlValidateMemoPtr;
2823
2824 /**
2825  * xmlFreeRef:
2826  * @lk:  A list link
2827  *
2828  * Deallocate the memory used by a ref definition
2829  */
2830 static void
2831 xmlFreeRef(xmlLinkPtr lk) {
2832     xmlRefPtr ref = (xmlRefPtr)xmlLinkGetData(lk);
2833     if (ref == NULL) return;
2834     if (ref->value != NULL)
2835         xmlFree((xmlChar *)ref->value);
2836     if (ref->name != NULL)
2837         xmlFree((xmlChar *)ref->name);
2838     xmlFree(ref);
2839 }
2840
2841 /**
2842  * xmlFreeRefList:
2843  * @list_ref:  A list of references.
2844  *
2845  * Deallocate the memory used by a list of references
2846  */
2847 static void
2848 xmlFreeRefList(xmlListPtr list_ref) {
2849     if (list_ref == NULL) return;
2850     xmlListDelete(list_ref);
2851 }
2852
2853 /**
2854  * xmlWalkRemoveRef:
2855  * @data:  Contents of current link
2856  * @user:  Value supplied by the user
2857  *
2858  * Returns 0 to abort the walk or 1 to continue
2859  */
2860 static int
2861 xmlWalkRemoveRef(const void *data, const void *user)
2862 {
2863     xmlAttrPtr attr0 = ((xmlRefPtr)data)->attr;
2864     xmlAttrPtr attr1 = ((xmlRemoveMemoPtr)user)->ap;
2865     xmlListPtr ref_list = ((xmlRemoveMemoPtr)user)->l;
2866
2867     if (attr0 == attr1) { /* Matched: remove and terminate walk */
2868         xmlListRemoveFirst(ref_list, (void *)data);
2869         return 0;
2870     }
2871     return 1;
2872 }
2873
2874 /**
2875  * xmlDummyCompare
2876  * @data0:  Value supplied by the user
2877  * @data1:  Value supplied by the user
2878  *
2879  * Do nothing, return 0. Used to create unordered lists.
2880  */
2881 static int
2882 xmlDummyCompare(const void *data0 ATTRIBUTE_UNUSED,
2883                 const void *data1 ATTRIBUTE_UNUSED)
2884 {
2885     return (0);
2886 }
2887
2888 /**
2889  * xmlAddRef:
2890  * @ctxt:  the validation context
2891  * @doc:  pointer to the document
2892  * @value:  the value name
2893  * @attr:  the attribute holding the Ref
2894  *
2895  * Register a new ref declaration
2896  *
2897  * Returns NULL if not, otherwise the new xmlRefPtr
2898  */
2899 xmlRefPtr
2900 xmlAddRef(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value,
2901     xmlAttrPtr attr) {
2902     xmlRefPtr ret;
2903     xmlRefTablePtr table;
2904     xmlListPtr ref_list;
2905
2906     if (doc == NULL) {
2907         return(NULL);
2908     }
2909     if (value == NULL) {
2910         return(NULL);
2911     }
2912     if (attr == NULL) {
2913         return(NULL);
2914     }
2915
2916     /*
2917      * Create the Ref table if needed.
2918      */
2919     table = (xmlRefTablePtr) doc->refs;
2920     if (table == NULL) {
2921         doc->refs = table = xmlHashCreateDict(0, doc->dict);
2922     }
2923     if (table == NULL) {
2924         xmlVErrMemory(ctxt,
2925             "xmlAddRef: Table creation failed!\n");
2926         return(NULL);
2927     }
2928
2929     ret = (xmlRefPtr) xmlMalloc(sizeof(xmlRef));
2930     if (ret == NULL) {
2931         xmlVErrMemory(ctxt, "malloc failed");
2932         return(NULL);
2933     }
2934
2935     /*
2936      * fill the structure.
2937      */
2938     ret->value = xmlStrdup(value);
2939     if ((ctxt != NULL) && (ctxt->vstateNr != 0)) {
2940         /*
2941          * Operating in streaming mode, attr is gonna disapear
2942          */
2943         ret->name = xmlStrdup(attr->name);
2944         ret->attr = NULL;
2945     } else {
2946         ret->name = NULL;
2947         ret->attr = attr;
2948     }
2949     ret->lineno = xmlGetLineNo(attr->parent);
2950
2951     /* To add a reference :-
2952      * References are maintained as a list of references,
2953      * Lookup the entry, if no entry create new nodelist
2954      * Add the owning node to the NodeList
2955      * Return the ref
2956      */
2957
2958     if (NULL == (ref_list = xmlHashLookup(table, value))) {
2959         if (NULL == (ref_list = xmlListCreate(xmlFreeRef, xmlDummyCompare))) {
2960             xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2961                     "xmlAddRef: Reference list creation failed!\n",
2962                     NULL);
2963             goto failed;
2964         }
2965         if (xmlHashAddEntry(table, value, ref_list) < 0) {
2966             xmlListDelete(ref_list);
2967             xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2968                     "xmlAddRef: Reference list insertion failed!\n",
2969                     NULL);
2970             goto failed;
2971         }
2972     }
2973     if (xmlListAppend(ref_list, ret) != 0) {
2974         xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2975                     "xmlAddRef: Reference list insertion failed!\n",
2976                     NULL);
2977         goto failed;
2978     }
2979     return(ret);
2980 failed:
2981     if (ret != NULL) {
2982         if (ret->value != NULL)
2983             xmlFree((char *)ret->value);
2984         if (ret->name != NULL)
2985             xmlFree((char *)ret->name);
2986         xmlFree(ret);
2987     }
2988     return(NULL);
2989 }
2990
2991 /**
2992  * xmlFreeRefTable:
2993  * @table:  An ref table
2994  *
2995  * Deallocate the memory used by an Ref hash table.
2996  */
2997 void
2998 xmlFreeRefTable(xmlRefTablePtr table) {
2999     xmlHashFree(table, (xmlHashDeallocator) xmlFreeRefList);
3000 }
3001
3002 /**
3003  * xmlIsRef:
3004  * @doc:  the document
3005  * @elem:  the element carrying the attribute
3006  * @attr:  the attribute
3007  *
3008  * Determine whether an attribute is of type Ref. In case we have DTD(s)
3009  * then this is simple, otherwise we use an heuristic: name Ref (upper
3010  * or lowercase).
3011  *
3012  * Returns 0 or 1 depending on the lookup result
3013  */
3014 int
3015 xmlIsRef(xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr) {
3016     if (attr == NULL)
3017         return(0);
3018     if (doc == NULL) {
3019         doc = attr->doc;
3020         if (doc == NULL) return(0);
3021     }
3022
3023     if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
3024         return(0);
3025     } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
3026         /* TODO @@@ */
3027         return(0);
3028     } else {
3029         xmlAttributePtr attrDecl;
3030
3031         if (elem == NULL) return(0);
3032         attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, attr->name);
3033         if ((attrDecl == NULL) && (doc->extSubset != NULL))
3034             attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
3035                                          elem->name, attr->name);
3036
3037         if ((attrDecl != NULL) &&
3038             (attrDecl->atype == XML_ATTRIBUTE_IDREF ||
3039              attrDecl->atype == XML_ATTRIBUTE_IDREFS))
3040         return(1);
3041     }
3042     return(0);
3043 }
3044
3045 /**
3046  * xmlRemoveRef:
3047  * @doc:  the document
3048  * @attr:  the attribute
3049  *
3050  * Remove the given attribute from the Ref table maintained internally.
3051  *
3052  * Returns -1 if the lookup failed and 0 otherwise
3053  */
3054 int
3055 xmlRemoveRef(xmlDocPtr doc, xmlAttrPtr attr) {
3056     xmlListPtr ref_list;
3057     xmlRefTablePtr table;
3058     xmlChar *ID;
3059     xmlRemoveMemo target;
3060
3061     if (doc == NULL) return(-1);
3062     if (attr == NULL) return(-1);
3063
3064     table = (xmlRefTablePtr) doc->refs;
3065     if (table == NULL)
3066         return(-1);
3067
3068     ID = xmlNodeListGetString(doc, attr->children, 1);
3069     if (ID == NULL)
3070         return(-1);
3071
3072     ref_list = xmlHashLookup(table, ID);
3073     if(ref_list == NULL) {
3074         xmlFree(ID);
3075         return (-1);
3076     }
3077
3078     /* At this point, ref_list refers to a list of references which
3079      * have the same key as the supplied attr. Our list of references
3080      * is ordered by reference address and we don't have that information
3081      * here to use when removing. We'll have to walk the list and
3082      * check for a matching attribute, when we find one stop the walk
3083      * and remove the entry.
3084      * The list is ordered by reference, so that means we don't have the
3085      * key. Passing the list and the reference to the walker means we
3086      * will have enough data to be able to remove the entry.
3087      */
3088     target.l = ref_list;
3089     target.ap = attr;
3090
3091     /* Remove the supplied attr from our list */
3092     xmlListWalk(ref_list, xmlWalkRemoveRef, &target);
3093
3094     /*If the list is empty then remove the list entry in the hash */
3095     if (xmlListEmpty(ref_list))
3096         xmlHashUpdateEntry(table, ID, NULL, (xmlHashDeallocator)
3097         xmlFreeRefList);
3098     xmlFree(ID);
3099     return(0);
3100 }
3101
3102 /**
3103  * xmlGetRefs:
3104  * @doc:  pointer to the document
3105  * @ID:  the ID value
3106  *
3107  * Find the set of references for the supplied ID.
3108  *
3109  * Returns NULL if not found, otherwise node set for the ID.
3110  */
3111 xmlListPtr
3112 xmlGetRefs(xmlDocPtr doc, const xmlChar *ID) {
3113     xmlRefTablePtr table;
3114
3115     if (doc == NULL) {
3116         return(NULL);
3117     }
3118
3119     if (ID == NULL) {
3120         return(NULL);
3121     }
3122
3123     table = (xmlRefTablePtr) doc->refs;
3124     if (table == NULL)
3125         return(NULL);
3126
3127     return (xmlHashLookup(table, ID));
3128 }
3129
3130 /************************************************************************
3131  *                                                                      *
3132  *              Routines for validity checking                          *
3133  *                                                                      *
3134  ************************************************************************/
3135
3136 /**
3137  * xmlGetDtdElementDesc:
3138  * @dtd:  a pointer to the DtD to search
3139  * @name:  the element name
3140  *
3141  * Search the DTD for the description of this element
3142  *
3143  * returns the xmlElementPtr if found or NULL
3144  */
3145
3146 xmlElementPtr
3147 xmlGetDtdElementDesc(xmlDtdPtr dtd, const xmlChar *name) {
3148     xmlElementTablePtr table;
3149     xmlElementPtr cur;
3150     xmlChar *uqname = NULL, *prefix = NULL;
3151
3152     if ((dtd == NULL) || (name == NULL)) return(NULL);
3153     if (dtd->elements == NULL)
3154         return(NULL);
3155     table = (xmlElementTablePtr) dtd->elements;
3156
3157     uqname = xmlSplitQName2(name, &prefix);
3158     if (uqname != NULL)
3159         name = uqname;
3160     cur = xmlHashLookup2(table, name, prefix);
3161     if (prefix != NULL) xmlFree(prefix);
3162     if (uqname != NULL) xmlFree(uqname);
3163     return(cur);
3164 }
3165 /**
3166  * xmlGetDtdElementDesc2:
3167  * @dtd:  a pointer to the DtD to search
3168  * @name:  the element name
3169  * @create:  create an empty description if not found
3170  *
3171  * Search the DTD for the description of this element
3172  *
3173  * returns the xmlElementPtr if found or NULL
3174  */
3175
3176 static xmlElementPtr
3177 xmlGetDtdElementDesc2(xmlDtdPtr dtd, const xmlChar *name, int create) {
3178     xmlElementTablePtr table;
3179     xmlElementPtr cur;
3180     xmlChar *uqname = NULL, *prefix = NULL;
3181
3182     if (dtd == NULL) return(NULL);
3183     if (dtd->elements == NULL) {
3184         xmlDictPtr dict = NULL;
3185
3186         if (dtd->doc != NULL)
3187             dict = dtd->doc->dict;
3188
3189         if (!create)
3190             return(NULL);
3191         /*
3192          * Create the Element table if needed.
3193          */
3194         table = (xmlElementTablePtr) dtd->elements;
3195         if (table == NULL) {
3196             table = xmlHashCreateDict(0, dict);
3197             dtd->elements = (void *) table;
3198         }
3199         if (table == NULL) {
3200             xmlVErrMemory(NULL, "element table allocation failed");
3201             return(NULL);
3202         }
3203     }
3204     table = (xmlElementTablePtr) dtd->elements;
3205
3206     uqname = xmlSplitQName2(name, &prefix);
3207     if (uqname != NULL)
3208         name = uqname;
3209     cur = xmlHashLookup2(table, name, prefix);
3210     if ((cur == NULL) && (create)) {
3211         cur = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
3212         if (cur == NULL) {
3213             xmlVErrMemory(NULL, "malloc failed");
3214             return(NULL);
3215         }
3216         memset(cur, 0, sizeof(xmlElement));
3217         cur->type = XML_ELEMENT_DECL;
3218
3219         /*
3220          * fill the structure.
3221          */
3222         cur->name = xmlStrdup(name);
3223         cur->prefix = xmlStrdup(prefix);
3224         cur->etype = XML_ELEMENT_TYPE_UNDEFINED;
3225
3226         xmlHashAddEntry2(table, name, prefix, cur);
3227     }
3228     if (prefix != NULL) xmlFree(prefix);
3229     if (uqname != NULL) xmlFree(uqname);
3230     return(cur);
3231 }
3232
3233 /**
3234  * xmlGetDtdQElementDesc:
3235  * @dtd:  a pointer to the DtD to search
3236  * @name:  the element name
3237  * @prefix:  the element namespace prefix
3238  *
3239  * Search the DTD for the description of this element
3240  *
3241  * returns the xmlElementPtr if found or NULL
3242  */
3243
3244 xmlElementPtr
3245 xmlGetDtdQElementDesc(xmlDtdPtr dtd, const xmlChar *name,
3246                       const xmlChar *prefix) {
3247     xmlElementTablePtr table;
3248
3249     if (dtd == NULL) return(NULL);
3250     if (dtd->elements == NULL) return(NULL);
3251     table = (xmlElementTablePtr) dtd->elements;
3252
3253     return(xmlHashLookup2(table, name, prefix));
3254 }
3255
3256 /**
3257  * xmlGetDtdAttrDesc:
3258  * @dtd:  a pointer to the DtD to search
3259  * @elem:  the element name
3260  * @name:  the attribute name
3261  *
3262  * Search the DTD for the description of this attribute on
3263  * this element.
3264  *
3265  * returns the xmlAttributePtr if found or NULL
3266  */
3267
3268 xmlAttributePtr
3269 xmlGetDtdAttrDesc(xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name) {
3270     xmlAttributeTablePtr table;
3271     xmlAttributePtr cur;
3272     xmlChar *uqname = NULL, *prefix = NULL;
3273
3274     if (dtd == NULL) return(NULL);
3275     if (dtd->attributes == NULL) return(NULL);
3276
3277     table = (xmlAttributeTablePtr) dtd->attributes;
3278     if (table == NULL)
3279         return(NULL);
3280
3281     uqname = xmlSplitQName2(name, &prefix);
3282
3283     if (uqname != NULL) {
3284         cur = xmlHashLookup3(table, uqname, prefix, elem);
3285         if (prefix != NULL) xmlFree(prefix);
3286         if (uqname != NULL) xmlFree(uqname);
3287     } else
3288         cur = xmlHashLookup3(table, name, NULL, elem);
3289     return(cur);
3290 }
3291
3292 /**
3293  * xmlGetDtdQAttrDesc:
3294  * @dtd:  a pointer to the DtD to search
3295  * @elem:  the element name
3296  * @name:  the attribute name
3297  * @prefix:  the attribute namespace prefix
3298  *
3299  * Search the DTD for the description of this qualified attribute on
3300  * this element.
3301  *
3302  * returns the xmlAttributePtr if found or NULL
3303  */
3304
3305 xmlAttributePtr
3306 xmlGetDtdQAttrDesc(xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name,
3307                   const xmlChar *prefix) {
3308     xmlAttributeTablePtr table;
3309
3310     if (dtd == NULL) return(NULL);
3311     if (dtd->attributes == NULL) return(NULL);
3312     table = (xmlAttributeTablePtr) dtd->attributes;
3313
3314     return(xmlHashLookup3(table, name, prefix, elem));
3315 }
3316
3317 /**
3318  * xmlGetDtdNotationDesc:
3319  * @dtd:  a pointer to the DtD to search
3320  * @name:  the notation name
3321  *
3322  * Search the DTD for the description of this notation
3323  *
3324  * returns the xmlNotationPtr if found or NULL
3325  */
3326
3327 xmlNotationPtr
3328 xmlGetDtdNotationDesc(xmlDtdPtr dtd, const xmlChar *name) {
3329     xmlNotationTablePtr table;
3330
3331     if (dtd == NULL) return(NULL);
3332     if (dtd->notations == NULL) return(NULL);
3333     table = (xmlNotationTablePtr) dtd->notations;
3334
3335     return(xmlHashLookup(table, name));
3336 }
3337
3338 #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
3339 /**
3340  * xmlValidateNotationUse:
3341  * @ctxt:  the validation context
3342  * @doc:  the document
3343  * @notationName:  the notation name to check
3344  *
3345  * Validate that the given name match a notation declaration.
3346  * - [ VC: Notation Declared ]
3347  *
3348  * returns 1 if valid or 0 otherwise
3349  */
3350
3351 int
3352 xmlValidateNotationUse(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
3353                        const xmlChar *notationName) {
3354     xmlNotationPtr notaDecl;
3355     if ((doc == NULL) || (doc->intSubset == NULL) ||
3356         (notationName == NULL)) return(-1);
3357
3358     notaDecl = xmlGetDtdNotationDesc(doc->intSubset, notationName);
3359     if ((notaDecl == NULL) && (doc->extSubset != NULL))
3360         notaDecl = xmlGetDtdNotationDesc(doc->extSubset, notationName);
3361
3362     if ((notaDecl == NULL) && (ctxt != NULL)) {
3363         xmlErrValidNode(ctxt, (xmlNodePtr) doc, XML_DTD_UNKNOWN_NOTATION,
3364                         "NOTATION %s is not declared\n",
3365                         notationName, NULL, NULL);
3366         return(0);
3367     }
3368     return(1);
3369 }
3370 #endif /* LIBXML_VALID_ENABLED or LIBXML_SCHEMAS_ENABLED */
3371
3372 /**
3373  * xmlIsMixedElement:
3374  * @doc:  the document
3375  * @name:  the element name
3376  *
3377  * Search in the DtDs whether an element accept Mixed content (or ANY)
3378  * basically if it is supposed to accept text childs
3379  *
3380  * returns 0 if no, 1 if yes, and -1 if no element description is available
3381  */
3382
3383 int
3384 xmlIsMixedElement(xmlDocPtr doc, const xmlChar *name) {
3385     xmlElementPtr elemDecl;
3386
3387     if ((doc == NULL) || (doc->intSubset == NULL)) return(-1);
3388
3389     elemDecl = xmlGetDtdElementDesc(doc->intSubset, name);
3390     if ((elemDecl == NULL) && (doc->extSubset != NULL))
3391         elemDecl = xmlGetDtdElementDesc(doc->extSubset, name);
3392     if (elemDecl == NULL) return(-1);
3393     switch (elemDecl->etype) {
3394         case XML_ELEMENT_TYPE_UNDEFINED:
3395             return(-1);
3396         case XML_ELEMENT_TYPE_ELEMENT:
3397             return(0);
3398         case XML_ELEMENT_TYPE_EMPTY:
3399             /*
3400              * return 1 for EMPTY since we want VC error to pop up
3401              * on <empty>     </empty> for example
3402              */
3403         case XML_ELEMENT_TYPE_ANY:
3404         case XML_ELEMENT_TYPE_MIXED:
3405             return(1);
3406     }
3407     return(1);
3408 }
3409
3410 #ifdef LIBXML_VALID_ENABLED
3411
3412 static int
3413 xmlIsDocNameStartChar(xmlDocPtr doc, int c) {
3414     if ((doc == NULL) || (doc->properties & XML_DOC_OLD10) == 0) {
3415         /*
3416          * Use the new checks of production [4] [4a] amd [5] of the
3417          * Update 5 of XML-1.0
3418          */
3419         if (((c >= 'a') && (c <= 'z')) ||
3420             ((c >= 'A') && (c <= 'Z')) ||
3421             (c == '_') || (c == ':') ||
3422             ((c >= 0xC0) && (c <= 0xD6)) ||
3423             ((c >= 0xD8) && (c <= 0xF6)) ||
3424             ((c >= 0xF8) && (c <= 0x2FF)) ||
3425             ((c >= 0x370) && (c <= 0x37D)) ||
3426             ((c >= 0x37F) && (c <= 0x1FFF)) ||
3427             ((c >= 0x200C) && (c <= 0x200D)) ||
3428             ((c >= 0x2070) && (c <= 0x218F)) ||
3429             ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3430             ((c >= 0x3001) && (c <= 0xD7FF)) ||
3431             ((c >= 0xF900) && (c <= 0xFDCF)) ||
3432             ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3433             ((c >= 0x10000) && (c <= 0xEFFFF)))
3434             return(1);
3435     } else {
3436         if (IS_LETTER(c) || (c == '_') || (c == ':'))
3437             return(1);
3438     }
3439     return(0);
3440 }
3441
3442 static int
3443 xmlIsDocNameChar(xmlDocPtr doc, int c) {
3444     if ((doc == NULL) || (doc->properties & XML_DOC_OLD10) == 0) {
3445         /*
3446          * Use the new checks of production [4] [4a] amd [5] of the
3447          * Update 5 of XML-1.0
3448          */
3449         if (((c >= 'a') && (c <= 'z')) ||
3450             ((c >= 'A') && (c <= 'Z')) ||
3451             ((c >= '0') && (c <= '9')) || /* !start */
3452             (c == '_') || (c == ':') ||
3453             (c == '-') || (c == '.') || (c == 0xB7) || /* !start */
3454             ((c >= 0xC0) && (c <= 0xD6)) ||
3455             ((c >= 0xD8) && (c <= 0xF6)) ||
3456             ((c >= 0xF8) && (c <= 0x2FF)) ||
3457             ((c >= 0x300) && (c <= 0x36F)) || /* !start */
3458             ((c >= 0x370) && (c <= 0x37D)) ||
3459             ((c >= 0x37F) && (c <= 0x1FFF)) ||
3460             ((c >= 0x200C) && (c <= 0x200D)) ||
3461             ((c >= 0x203F) && (c <= 0x2040)) || /* !start */
3462             ((c >= 0x2070) && (c <= 0x218F)) ||
3463             ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3464             ((c >= 0x3001) && (c <= 0xD7FF)) ||
3465             ((c >= 0xF900) && (c <= 0xFDCF)) ||
3466             ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3467             ((c >= 0x10000) && (c <= 0xEFFFF)))
3468              return(1);
3469     } else {
3470         if ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
3471             (c == '.') || (c == '-') ||
3472             (c == '_') || (c == ':') ||
3473             (IS_COMBINING(c)) ||
3474             (IS_EXTENDER(c)))
3475             return(1);
3476     }
3477     return(0);
3478 }
3479
3480 /**
3481  * xmlValidateNameValue:
3482  * @doc:  pointer to the document or NULL
3483  * @value:  an Name value
3484  *
3485  * Validate that the given value match Name production
3486  *
3487  * returns 1 if valid or 0 otherwise
3488  */
3489
3490 static int
3491 xmlValidateNameValueInternal(xmlDocPtr doc, const xmlChar *value) {
3492     const xmlChar *cur;
3493     int val, len;
3494
3495     if (value == NULL) return(0);
3496     cur = value;
3497     val = xmlStringCurrentChar(NULL, cur, &len);
3498     cur += len;
3499     if (!xmlIsDocNameStartChar(doc, val))
3500         return(0);
3501
3502     val = xmlStringCurrentChar(NULL, cur, &len);
3503     cur += len;
3504     while (xmlIsDocNameChar(doc, val)) {
3505         val = xmlStringCurrentChar(NULL, cur, &len);
3506         cur += len;
3507     }
3508
3509     if (val != 0) return(0);
3510
3511     return(1);
3512 }
3513
3514 /**
3515  * xmlValidateNameValue:
3516  * @value:  an Name value
3517  *
3518  * Validate that the given value match Name production
3519  *
3520  * returns 1 if valid or 0 otherwise
3521  */
3522
3523 int
3524 xmlValidateNameValue(const xmlChar *value) {
3525     return(xmlValidateNameValueInternal(NULL, value));
3526 }
3527
3528 /**
3529  * xmlValidateNamesValueInternal:
3530  * @doc:  pointer to the document or NULL
3531  * @value:  an Names value
3532  *
3533  * Validate that the given value match Names production
3534  *
3535  * returns 1 if valid or 0 otherwise
3536  */
3537
3538 static int
3539 xmlValidateNamesValueInternal(xmlDocPtr doc, const xmlChar *value) {
3540     const xmlChar *cur;
3541     int val, len;
3542
3543     if (value == NULL) return(0);
3544     cur = value;
3545     val = xmlStringCurrentChar(NULL, cur, &len);
3546     cur += len;
3547
3548     if (!xmlIsDocNameStartChar(doc, val))
3549         return(0);
3550
3551     val = xmlStringCurrentChar(NULL, cur, &len);
3552     cur += len;
3553     while (xmlIsDocNameChar(doc, val)) {
3554         val = xmlStringCurrentChar(NULL, cur, &len);
3555         cur += len;
3556     }
3557
3558     /* Should not test IS_BLANK(val) here -- see erratum E20*/
3559     while (val == 0x20) {
3560         while (val == 0x20) {
3561             val = xmlStringCurrentChar(NULL, cur, &len);
3562             cur += len;
3563         }
3564
3565         if (!xmlIsDocNameStartChar(doc, val))
3566             return(0);
3567
3568         val = xmlStringCurrentChar(NULL, cur, &len);
3569         cur += len;
3570
3571         while (xmlIsDocNameChar(doc, val)) {
3572             val = xmlStringCurrentChar(NULL, cur, &len);
3573             cur += len;
3574         }
3575     }
3576
3577     if (val != 0) return(0);
3578
3579     return(1);
3580 }
3581
3582 /**
3583  * xmlValidateNamesValue:
3584  * @value:  an Names value
3585  *
3586  * Validate that the given value match Names production
3587  *
3588  * returns 1 if valid or 0 otherwise
3589  */
3590
3591 int
3592 xmlValidateNamesValue(const xmlChar *value) {
3593     return(xmlValidateNamesValueInternal(NULL, value));
3594 }
3595
3596 /**
3597  * xmlValidateNmtokenValueInternal:
3598  * @doc:  pointer to the document or NULL
3599  * @value:  an Nmtoken value
3600  *
3601  * Validate that the given value match Nmtoken production
3602  *
3603  * [ VC: Name Token ]
3604  *
3605  * returns 1 if valid or 0 otherwise
3606  */
3607
3608 static int
3609 xmlValidateNmtokenValueInternal(xmlDocPtr doc, const xmlChar *value) {
3610     const xmlChar *cur;
3611     int val, len;
3612
3613     if (value == NULL) return(0);
3614     cur = value;
3615     val = xmlStringCurrentChar(NULL, cur, &len);
3616     cur += len;
3617
3618     if (!xmlIsDocNameChar(doc, val))
3619         return(0);
3620
3621     val = xmlStringCurrentChar(NULL, cur, &len);
3622     cur += len;
3623     while (xmlIsDocNameChar(doc, val)) {
3624         val = xmlStringCurrentChar(NULL, cur, &len);
3625         cur += len;
3626     }
3627
3628     if (val != 0) return(0);
3629
3630     return(1);
3631 }
3632
3633 /**
3634  * xmlValidateNmtokenValue:
3635  * @value:  an Nmtoken value
3636  *
3637  * Validate that the given value match Nmtoken production
3638  *
3639  * [ VC: Name Token ]
3640  *
3641  * returns 1 if valid or 0 otherwise
3642  */
3643
3644 int
3645 xmlValidateNmtokenValue(const xmlChar *value) {
3646     return(xmlValidateNmtokenValueInternal(NULL, value));
3647 }
3648
3649 /**
3650  * xmlValidateNmtokensValueInternal:
3651  * @doc:  pointer to the document or NULL
3652  * @value:  an Nmtokens value
3653  *
3654  * Validate that the given value match Nmtokens production
3655  *
3656  * [ VC: Name Token ]
3657  *
3658  * returns 1 if valid or 0 otherwise
3659  */
3660
3661 static int
3662 xmlValidateNmtokensValueInternal(xmlDocPtr doc, const xmlChar *value) {
3663     const xmlChar *cur;
3664     int val, len;
3665
3666     if (value == NULL) return(0);
3667     cur = value;
3668     val = xmlStringCurrentChar(NULL, cur, &len);
3669     cur += len;
3670
3671     while (IS_BLANK(val)) {
3672         val = xmlStringCurrentChar(NULL, cur, &len);
3673         cur += len;
3674     }
3675
3676     if (!xmlIsDocNameChar(doc, val))
3677         return(0);
3678
3679     while (xmlIsDocNameChar(doc, val)) {
3680         val = xmlStringCurrentChar(NULL, cur, &len);
3681         cur += len;
3682     }
3683
3684     /* Should not test IS_BLANK(val) here -- see erratum E20*/
3685     while (val == 0x20) {
3686         while (val == 0x20) {
3687             val = xmlStringCurrentChar(NULL, cur, &len);
3688             cur += len;
3689         }
3690         if (val == 0) return(1);
3691
3692         if (!xmlIsDocNameChar(doc, val))
3693             return(0);
3694
3695         val = xmlStringCurrentChar(NULL, cur, &len);
3696         cur += len;
3697
3698         while (xmlIsDocNameChar(doc, val)) {
3699             val = xmlStringCurrentChar(NULL, cur, &len);
3700             cur += len;
3701         }
3702     }
3703
3704     if (val != 0) return(0);
3705
3706     return(1);
3707 }
3708
3709 /**
3710  * xmlValidateNmtokensValue:
3711  * @value:  an Nmtokens value
3712  *
3713  * Validate that the given value match Nmtokens production
3714  *
3715  * [ VC: Name Token ]
3716  *
3717  * returns 1 if valid or 0 otherwise
3718  */
3719
3720 int
3721 xmlValidateNmtokensValue(const xmlChar *value) {
3722     return(xmlValidateNmtokensValueInternal(NULL, value));
3723 }
3724
3725 /**
3726  * xmlValidateNotationDecl:
3727  * @ctxt:  the validation context
3728  * @doc:  a document instance
3729  * @nota:  a notation definition
3730  *
3731  * Try to validate a single notation definition
3732  * basically it does the following checks as described by the
3733  * XML-1.0 recommendation:
3734  *  - it seems that no validity constraint exists on notation declarations
3735  * But this function get called anyway ...
3736  *
3737  * returns 1 if valid or 0 otherwise
3738  */
3739
3740 int
3741 xmlValidateNotationDecl(xmlValidCtxtPtr ctxt ATTRIBUTE_UNUSED, xmlDocPtr doc ATTRIBUTE_UNUSED,
3742                          xmlNotationPtr nota ATTRIBUTE_UNUSED) {
3743     int ret = 1;
3744
3745     return(ret);
3746 }
3747
3748 /**
3749  * xmlValidateAttributeValueInternal:
3750  * @doc: the document
3751  * @type:  an attribute type
3752  * @value:  an attribute value
3753  *
3754  * Validate that the given attribute value match  the proper production
3755  *
3756  * returns 1 if valid or 0 otherwise
3757  */
3758
3759 static int
3760 xmlValidateAttributeValueInternal(xmlDocPtr doc, xmlAttributeType type,
3761                                   const xmlChar *value) {
3762     switch (type) {
3763         case XML_ATTRIBUTE_ENTITIES:
3764         case XML_ATTRIBUTE_IDREFS:
3765             return(xmlValidateNamesValueInternal(doc, value));
3766         case XML_ATTRIBUTE_ENTITY:
3767         case XML_ATTRIBUTE_IDREF:
3768         case XML_ATTRIBUTE_ID:
3769         case XML_ATTRIBUTE_NOTATION:
3770             return(xmlValidateNameValueInternal(doc, value));
3771         case XML_ATTRIBUTE_NMTOKENS:
3772         case XML_ATTRIBUTE_ENUMERATION:
3773             return(xmlValidateNmtokensValueInternal(doc, value));
3774         case XML_ATTRIBUTE_NMTOKEN:
3775             return(xmlValidateNmtokenValueInternal(doc, value));
3776         case XML_ATTRIBUTE_CDATA:
3777             break;
3778     }
3779     return(1);
3780 }
3781
3782 /**
3783  * xmlValidateAttributeValue:
3784  * @type:  an attribute type
3785  * @value:  an attribute value
3786  *
3787  * Validate that the given attribute value match  the proper production
3788  *
3789  * [ VC: ID ]
3790  * Values of type ID must match the Name production....
3791  *
3792  * [ VC: IDREF ]
3793  * Values of type IDREF must match the Name production, and values
3794  * of type IDREFS must match Names ...
3795  *
3796  * [ VC: Entity Name ]
3797  * Values of type ENTITY must match the Name production, values
3798  * of type ENTITIES must match Names ...
3799  *
3800  * [ VC: Name Token ]
3801  * Values of type NMTOKEN must match the Nmtoken production; values
3802  * of type NMTOKENS must match Nmtokens.
3803  *
3804  * returns 1 if valid or 0 otherwise
3805  */
3806 int
3807 xmlValidateAttributeValue(xmlAttributeType type, const xmlChar *value) {
3808     return(xmlValidateAttributeValueInternal(NULL, type, value));
3809 }
3810
3811 /**
3812  * xmlValidateAttributeValue2:
3813  * @ctxt:  the validation context
3814  * @doc:  the document
3815  * @name:  the attribute name (used for error reporting only)
3816  * @type:  the attribute type
3817  * @value:  the attribute value
3818  *
3819  * Validate that the given attribute value match a given type.
3820  * This typically cannot be done before having finished parsing
3821  * the subsets.
3822  *
3823  * [ VC: IDREF ]
3824  * Values of type IDREF must match one of the declared IDs
3825  * Values of type IDREFS must match a sequence of the declared IDs
3826  * each Name must match the value of an ID attribute on some element
3827  * in the XML document; i.e. IDREF values must match the value of
3828  * some ID attribute
3829  *
3830  * [ VC: Entity Name ]
3831  * Values of type ENTITY must match one declared entity
3832  * Values of type ENTITIES must match a sequence of declared entities
3833  *
3834  * [ VC: Notation Attributes ]
3835  * all notation names in the declaration must be declared.
3836  *
3837  * returns 1 if valid or 0 otherwise
3838  */
3839
3840 static int
3841 xmlValidateAttributeValue2(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
3842       const xmlChar *name, xmlAttributeType type, const xmlChar *value) {
3843     int ret = 1;
3844     switch (type) {
3845         case XML_ATTRIBUTE_IDREFS:
3846         case XML_ATTRIBUTE_IDREF:
3847         case XML_ATTRIBUTE_ID:
3848         case XML_ATTRIBUTE_NMTOKENS:
3849         case XML_ATTRIBUTE_ENUMERATION:
3850         case XML_ATTRIBUTE_NMTOKEN:
3851         case XML_ATTRIBUTE_CDATA:
3852             break;
3853         case XML_ATTRIBUTE_ENTITY: {
3854             xmlEntityPtr ent;
3855
3856             ent = xmlGetDocEntity(doc, value);
3857             /* yeah it's a bit messy... */
3858             if ((ent == NULL) && (doc->standalone == 1)) {
3859                 doc->standalone = 0;
3860                 ent = xmlGetDocEntity(doc, value);
3861             }
3862             if (ent == NULL) {
3863                 xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3864                                 XML_DTD_UNKNOWN_ENTITY,
3865    "ENTITY attribute %s reference an unknown entity \"%s\"\n",
3866                        name, value, NULL);
3867                 ret = 0;
3868             } else if (ent->etype != XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
3869                 xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3870                                 XML_DTD_ENTITY_TYPE,
3871    "ENTITY attribute %s reference an entity \"%s\" of wrong type\n",
3872                        name, value, NULL);
3873                 ret = 0;
3874             }
3875             break;
3876         }
3877         case XML_ATTRIBUTE_ENTITIES: {
3878             xmlChar *dup, *nam = NULL, *cur, save;
3879             xmlEntityPtr ent;
3880
3881             dup = xmlStrdup(value);
3882             if (dup == NULL)
3883                 return(0);
3884             cur = dup;
3885             while (*cur != 0) {
3886                 nam = cur;
3887                 while ((*cur != 0) && (!IS_BLANK_CH(*cur))) cur++;
3888                 save = *cur;
3889                 *cur = 0;
3890                 ent = xmlGetDocEntity(doc, nam);
3891                 if (ent == NULL) {
3892                     xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3893                                     XML_DTD_UNKNOWN_ENTITY,
3894        "ENTITIES attribute %s reference an unknown entity \"%s\"\n",
3895                            name, nam, NULL);
3896                     ret = 0;
3897                 } else if (ent->etype != XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
3898                     xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3899                                     XML_DTD_ENTITY_TYPE,
3900        "ENTITIES attribute %s reference an entity \"%s\" of wrong type\n",
3901                            name, nam, NULL);
3902                     ret = 0;
3903                 }
3904                 if (save == 0)
3905                     break;
3906                 *cur = save;
3907                 while (IS_BLANK_CH(*cur)) cur++;
3908             }
3909             xmlFree(dup);
3910             break;
3911         }
3912         case XML_ATTRIBUTE_NOTATION: {
3913             xmlNotationPtr nota;
3914
3915             nota = xmlGetDtdNotationDesc(doc->intSubset, value);
3916             if ((nota == NULL) && (doc->extSubset != NULL))
3917                 nota = xmlGetDtdNotationDesc(doc->extSubset, value);
3918
3919             if (nota == NULL) {
3920                 xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3921                                 XML_DTD_UNKNOWN_NOTATION,
3922        "NOTATION attribute %s reference an unknown notation \"%s\"\n",
3923                        name, value, NULL);
3924                 ret = 0;
3925             }
3926             break;
3927         }
3928     }
3929     return(ret);
3930 }
3931
3932 /**
3933  * xmlValidCtxtNormalizeAttributeValue:
3934  * @ctxt: the validation context
3935  * @doc:  the document
3936  * @elem:  the parent
3937  * @name:  the attribute name
3938  * @value:  the attribute value
3939  * @ctxt:  the validation context or NULL
3940  *
3941  * Does the validation related extra step of the normalization of attribute
3942  * values:
3943  *
3944  * If the declared value is not CDATA, then the XML processor must further
3945  * process the normalized attribute value by discarding any leading and
3946  * trailing space (#x20) characters, and by replacing sequences of space
3947  * (#x20) characters by single space (#x20) character.
3948  *
3949  * Also  check VC: Standalone Document Declaration in P32, and update
3950  *  ctxt->valid accordingly
3951  *
3952  * returns a new normalized string if normalization is needed, NULL otherwise
3953  *      the caller must free the returned value.
3954  */
3955
3956 xmlChar *
3957 xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
3958              xmlNodePtr elem, const xmlChar *name, const xmlChar *value) {
3959     xmlChar *ret, *dst;
3960     const xmlChar *src;
3961     xmlAttributePtr attrDecl = NULL;
3962     int extsubset = 0;
3963
3964     if (doc == NULL) return(NULL);
3965     if (elem == NULL) return(NULL);
3966     if (name == NULL) return(NULL);
3967     if (value == NULL) return(NULL);
3968
3969     if ((elem->ns != NULL) && (elem->ns->prefix != NULL)) {
3970         xmlChar fn[50];
3971         xmlChar *fullname;
3972
3973         fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
3974         if (fullname == NULL)
3975             return(NULL);
3976         attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname, name);
3977         if ((attrDecl == NULL) && (doc->extSubset != NULL)) {
3978             attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullname, name);
3979             if (attrDecl != NULL)
3980                 extsubset = 1;
3981         }
3982         if ((fullname != fn) && (fullname != elem->name))
3983             xmlFree(fullname);
3984     }
3985     if ((attrDecl == NULL) && (doc->intSubset != NULL))
3986         attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, name);
3987     if ((attrDecl == NULL) && (doc->extSubset != NULL)) {
3988         attrDecl = xmlGetDtdAttrDesc(doc->extSubset, elem->name, name);
3989         if (attrDecl != NULL)
3990             extsubset = 1;
3991     }
3992
3993     if (attrDecl == NULL)
3994         return(NULL);
3995     if (attrDecl->atype == XML_ATTRIBUTE_CDATA)
3996         return(NULL);
3997
3998     ret = xmlStrdup(value);
3999     if (ret == NULL)
4000         return(NULL);
4001     src = value;
4002     dst = ret;
4003     while (*src == 0x20) src++;
4004     while (*src != 0) {
4005         if (*src == 0x20) {
4006             while (*src == 0x20) src++;
4007             if (*src != 0)
4008                 *dst++ = 0x20;
4009         } else {
4010             *dst++ = *src++;
4011         }
4012     }
4013     *dst = 0;
4014     if ((doc->standalone) && (extsubset == 1) && (!xmlStrEqual(value, ret))) {
4015         xmlErrValidNode(ctxt, elem, XML_DTD_NOT_STANDALONE,
4016 "standalone: %s on %s value had to be normalized based on external subset declaration\n",
4017                name, elem->name, NULL);
4018         ctxt->valid = 0;
4019     }
4020     return(ret);
4021 }
4022
4023 /**
4024  * xmlValidNormalizeAttributeValue:
4025  * @doc:  the document
4026  * @elem:  the parent
4027  * @name:  the attribute name
4028  * @value:  the attribute value
4029  *
4030  * Does the validation related extra step of the normalization of attribute
4031  * values:
4032  *
4033  * If the declared value is not CDATA, then the XML processor must further
4034  * process the normalized attribute value by discarding any leading and
4035  * trailing space (#x20) characters, and by replacing sequences of space
4036  * (#x20) characters by single space (#x20) character.
4037  *
4038  * Returns a new normalized string if normalization is needed, NULL otherwise
4039  *      the caller must free the returned value.
4040  */
4041
4042 xmlChar *
4043 xmlValidNormalizeAttributeValue(xmlDocPtr doc, xmlNodePtr elem,
4044                                 const xmlChar *name, const xmlChar *value) {
4045     xmlChar *ret, *dst;
4046     const xmlChar *src;
4047     xmlAttributePtr attrDecl = NULL;
4048
4049     if (doc == NULL) return(NULL);
4050     if (elem == NULL) return(NULL);
4051     if (name == NULL) return(NULL);
4052     if (value == NULL) return(NULL);
4053
4054     if ((elem->ns != NULL) && (elem->ns->prefix != NULL)) {
4055         xmlChar fn[50];
4056         xmlChar *fullname;
4057
4058         fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
4059         if (fullname == NULL)
4060             return(NULL);
4061         if ((fullname != fn) && (fullname != elem->name))
4062             xmlFree(fullname);
4063     }
4064     attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, name);
4065     if ((attrDecl == NULL) && (doc->extSubset != NULL))
4066         attrDecl = xmlGetDtdAttrDesc(doc->extSubset, elem->name, name);
4067
4068     if (attrDecl == NULL)
4069         return(NULL);
4070     if (attrDecl->atype == XML_ATTRIBUTE_CDATA)
4071         return(NULL);
4072
4073     ret = xmlStrdup(value);
4074     if (ret == NULL)
4075         return(NULL);
4076     src = value;
4077     dst = ret;
4078     while (*src == 0x20) src++;
4079     while (*src != 0) {
4080         if (*src == 0x20) {
4081             while (*src == 0x20) src++;
4082             if (*src != 0)
4083                 *dst++ = 0x20;
4084         } else {
4085             *dst++ = *src++;
4086         }
4087     }
4088     *dst = 0;
4089     return(ret);
4090 }
4091
4092 static void
4093 xmlValidateAttributeIdCallback(xmlAttributePtr attr, int *count,
4094                                const xmlChar* name ATTRIBUTE_UNUSED) {
4095     if (attr->atype == XML_ATTRIBUTE_ID) (*count)++;
4096 }
4097
4098 /**
4099  * xmlValidateAttributeDecl:
4100  * @ctxt:  the validation context
4101  * @doc:  a document instance
4102  * @attr:  an attribute definition
4103  *
4104  * Try to validate a single attribute definition
4105  * basically it does the following checks as described by the
4106  * XML-1.0 recommendation:
4107  *  - [ VC: Attribute Default Legal ]
4108  *  - [ VC: Enumeration ]
4109  *  - [ VC: ID Attribute Default ]
4110  *
4111  * The ID/IDREF uniqueness and matching are done separately
4112  *
4113  * returns 1 if valid or 0 otherwise
4114  */
4115
4116 int
4117 xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4118                          xmlAttributePtr attr) {
4119     int ret = 1;
4120     int val;
4121     CHECK_DTD;
4122     if(attr == NULL) return(1);
4123
4124     /* Attribute Default Legal */
4125     /* Enumeration */
4126     if (attr->defaultValue != NULL) {
4127         val = xmlValidateAttributeValueInternal(doc, attr->atype,
4128                                                 attr->defaultValue);
4129         if (val == 0) {
4130             xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ATTRIBUTE_DEFAULT,
4131                "Syntax of default value for attribute %s of %s is not valid\n",
4132                    attr->name, attr->elem, NULL);
4133         }
4134         ret &= val;
4135     }
4136
4137     /* ID Attribute Default */
4138     if ((attr->atype == XML_ATTRIBUTE_ID)&&
4139         (attr->def != XML_ATTRIBUTE_IMPLIED) &&
4140         (attr->def != XML_ATTRIBUTE_REQUIRED)) {
4141         xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ID_FIXED,
4142           "ID attribute %s of %s is not valid must be #IMPLIED or #REQUIRED\n",
4143                attr->name, attr->elem, NULL);
4144         ret = 0;
4145     }
4146
4147     /* One ID per Element Type */
4148     if (attr->atype == XML_ATTRIBUTE_ID) {
4149         int nbId;
4150
4151         /* the trick is that we parse DtD as their own internal subset */
4152         xmlElementPtr elem = xmlGetDtdElementDesc(doc->intSubset,
4153                                                   attr->elem);
4154         if (elem != NULL) {
4155             nbId = xmlScanIDAttributeDecl(NULL, elem, 0);
4156         } else {
4157             xmlAttributeTablePtr table;
4158
4159             /*
4160              * The attribute may be declared in the internal subset and the
4161              * element in the external subset.
4162              */
4163             nbId = 0;
4164             if (doc->intSubset != NULL) {
4165                 table = (xmlAttributeTablePtr) doc->intSubset->attributes;
4166                 xmlHashScan3(table, NULL, NULL, attr->elem, (xmlHashScanner)
4167                              xmlValidateAttributeIdCallback, &nbId);
4168             }
4169         }
4170         if (nbId > 1) {
4171
4172             xmlErrValidNodeNr(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
4173        "Element %s has %d ID attribute defined in the internal subset : %s\n",
4174                    attr->elem, nbId, attr->name);
4175         } else if (doc->extSubset != NULL) {
4176             int extId = 0;
4177             elem = xmlGetDtdElementDesc(doc->extSubset, attr->elem);
4178             if (elem != NULL) {
4179                 extId = xmlScanIDAttributeDecl(NULL, elem, 0);
4180             }
4181             if (extId > 1) {
4182                 xmlErrValidNodeNr(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
4183        "Element %s has %d ID attribute defined in the external subset : %s\n",
4184                        attr->elem, extId, attr->name);
4185             } else if (extId + nbId > 1) {
4186                 xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
4187 "Element %s has ID attributes defined in the internal and external subset : %s\n",
4188                        attr->elem, attr->name, NULL);
4189             }
4190         }
4191     }
4192
4193     /* Validity Constraint: Enumeration */
4194     if ((attr->defaultValue != NULL) && (attr->tree != NULL)) {
4195         xmlEnumerationPtr tree = attr->tree;
4196         while (tree != NULL) {
4197             if (xmlStrEqual(tree->name, attr->defaultValue)) break;
4198             tree = tree->next;
4199         }
4200         if (tree == NULL) {
4201             xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ATTRIBUTE_VALUE,
4202 "Default value \"%s\" for attribute %s of %s is not among the enumerated set\n",
4203                    attr->defaultValue, attr->name, attr->elem);
4204             ret = 0;
4205         }
4206     }
4207
4208     return(ret);
4209 }
4210
4211 /**
4212  * xmlValidateElementDecl:
4213  * @ctxt:  the validation context
4214  * @doc:  a document instance
4215  * @elem:  an element definition
4216  *
4217  * Try to validate a single element definition
4218  * basically it does the following checks as described by the
4219  * XML-1.0 recommendation:
4220  *  - [ VC: One ID per Element Type ]
4221  *  - [ VC: No Duplicate Types ]
4222  *  - [ VC: Unique Element Type Declaration ]
4223  *
4224  * returns 1 if valid or 0 otherwise
4225  */
4226
4227 int
4228 xmlValidateElementDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4229                        xmlElementPtr elem) {
4230     int ret = 1;
4231     xmlElementPtr tst;
4232
4233     CHECK_DTD;
4234
4235     if (elem == NULL) return(1);
4236
4237 #if 0
4238 #ifdef LIBXML_REGEXP_ENABLED
4239     /* Build the regexp associated to the content model */
4240     ret = xmlValidBuildContentModel(ctxt, elem);
4241 #endif
4242 #endif
4243
4244     /* No Duplicate Types */
4245     if (elem->etype == XML_ELEMENT_TYPE_MIXED) {
4246         xmlElementContentPtr cur, next;
4247         const xmlChar *name;
4248
4249         cur = elem->content;
4250         while (cur != NULL) {
4251             if (cur->type != XML_ELEMENT_CONTENT_OR) break;
4252             if (cur->c1 == NULL) break;
4253             if (cur->c1->type == XML_ELEMENT_CONTENT_ELEMENT) {
4254                 name = cur->c1->name;
4255                 next = cur->c2;
4256                 while (next != NULL) {
4257                     if (next->type == XML_ELEMENT_CONTENT_ELEMENT) {
4258                         if ((xmlStrEqual(next->name, name)) &&
4259                             (xmlStrEqual(next->prefix, cur->c1->prefix))) {
4260                             if (cur->c1->prefix == NULL) {
4261                                 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
4262                    "Definition of %s has duplicate references of %s\n",
4263                                        elem->name, name, NULL);
4264                             } else {
4265                                 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
4266                    "Definition of %s has duplicate references of %s:%s\n",
4267                                        elem->name, cur->c1->prefix, name);
4268                             }
4269                             ret = 0;
4270                         }
4271                         break;
4272                     }
4273                     if (next->c1 == NULL) break;
4274                     if (next->c1->type != XML_ELEMENT_CONTENT_ELEMENT) break;
4275                     if ((xmlStrEqual(next->c1->name, name)) &&
4276                         (xmlStrEqual(next->c1->prefix, cur->c1->prefix))) {
4277                         if (cur->c1->prefix == NULL) {
4278                             xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
4279                "Definition of %s has duplicate references to %s\n",
4280                                    elem->name, name, NULL);
4281                         } else {
4282                             xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
4283                "Definition of %s has duplicate references to %s:%s\n",
4284                                    elem->name, cur->c1->prefix, name);
4285                         }
4286                         ret = 0;
4287                     }
4288                     next = next->c2;
4289                 }
4290             }
4291             cur = cur->c2;
4292         }
4293     }
4294
4295     /* VC: Unique Element Type Declaration */
4296     tst = xmlGetDtdElementDesc(doc->intSubset, elem->name);
4297     if ((tst != NULL ) && (tst != elem) &&
4298         ((tst->prefix == elem->prefix) ||
4299          (xmlStrEqual(tst->prefix, elem->prefix))) &&
4300         (tst->etype != XML_ELEMENT_TYPE_UNDEFINED)) {
4301         xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_ELEM_REDEFINED,
4302                         "Redefinition of element %s\n",
4303                        elem->name, NULL, NULL);
4304         ret = 0;
4305     }
4306     tst = xmlGetDtdElementDesc(doc->extSubset, elem->name);
4307     if ((tst != NULL ) && (tst != elem) &&
4308         ((tst->prefix == elem->prefix) ||
4309          (xmlStrEqual(tst->prefix, elem->prefix))) &&
4310         (tst->etype != XML_ELEMENT_TYPE_UNDEFINED)) {
4311         xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_ELEM_REDEFINED,
4312                         "Redefinition of element %s\n",
4313                        elem->name, NULL, NULL);
4314         ret = 0;
4315     }
4316     /* One ID per Element Type
4317      * already done when registering the attribute
4318     if (xmlScanIDAttributeDecl(ctxt, elem) > 1) {
4319         ret = 0;
4320     } */
4321     return(ret);
4322 }
4323
4324 /**
4325  * xmlValidateOneAttribute:
4326  * @ctxt:  the validation context
4327  * @doc:  a document instance
4328  * @elem:  an element instance
4329  * @attr:  an attribute instance
4330  * @value:  the attribute value (without entities processing)
4331  *
4332  * Try to validate a single attribute for an element
4333  * basically it does the following checks as described by the
4334  * XML-1.0 recommendation:
4335  *  - [ VC: Attribute Value Type ]
4336  *  - [ VC: Fixed Attribute Default ]
4337  *  - [ VC: Entity Name ]
4338  *  - [ VC: Name Token ]
4339  *  - [ VC: ID ]
4340  *  - [ VC: IDREF ]
4341  *  - [ VC: Entity Name ]
4342  *  - [ VC: Notation Attributes ]
4343  *
4344  * The ID/IDREF uniqueness and matching are done separately
4345  *
4346  * returns 1 if valid or 0 otherwise
4347  */
4348
4349 int
4350 xmlValidateOneAttribute(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4351                         xmlNodePtr elem, xmlAttrPtr attr, const xmlChar *value)
4352 {
4353     xmlAttributePtr attrDecl =  NULL;
4354     int val;
4355     int ret = 1;
4356
4357     CHECK_DTD;
4358     if ((elem == NULL) || (elem->name == NULL)) return(0);
4359     if ((attr == NULL) || (attr->name == NULL)) return(0);
4360
4361     if ((elem->ns != NULL) && (elem->ns->prefix != NULL)) {
4362         xmlChar fn[50];
4363         xmlChar *fullname;
4364
4365         fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
4366         if (fullname == NULL)
4367             return(0);
4368         if (attr->ns != NULL) {
4369             attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, fullname,
4370                                           attr->name, attr->ns->prefix);
4371             if ((attrDecl == NULL) && (doc->extSubset != NULL))
4372                 attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, fullname,
4373                                               attr->name, attr->ns->prefix);
4374         } else {
4375             attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname, attr->name);
4376             if ((attrDecl == NULL) && (doc->extSubset != NULL))
4377                 attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
4378                                              fullname, attr->name);
4379         }
4380         if ((fullname != fn) && (fullname != elem->name))
4381             xmlFree(fullname);
4382     }
4383     if (attrDecl == NULL) {
4384         if (attr->ns != NULL) {
4385             attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, elem->name,
4386                                           attr->name, attr->ns->prefix);
4387             if ((attrDecl == NULL) && (doc->extSubset != NULL))
4388                 attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, elem->name,
4389                                               attr->name, attr->ns->prefix);
4390         } else {
4391             attrDecl = xmlGetDtdAttrDesc(doc->intSubset,
4392                                          elem->name, attr->name);
4393             if ((attrDecl == NULL) && (doc->extSubset != NULL))
4394                 attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
4395                                              elem->name, attr->name);
4396         }
4397     }
4398
4399
4400     /* Validity Constraint: Attribute Value Type */
4401     if (attrDecl == NULL) {
4402         xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
4403                "No declaration for attribute %s of element %s\n",
4404                attr->name, elem->name, NULL);
4405         return(0);
4406     }
4407     attr->atype = attrDecl->atype;
4408
4409     val = xmlValidateAttributeValueInternal(doc, attrDecl->atype, value);
4410     if (val == 0) {
4411             xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4412            "Syntax of value for attribute %s of %s is not valid\n",
4413                attr->name, elem->name, NULL);
4414         ret = 0;
4415     }
4416
4417     /* Validity constraint: Fixed Attribute Default */
4418     if (attrDecl->def == XML_ATTRIBUTE_FIXED) {
4419         if (!xmlStrEqual(value, attrDecl->defaultValue)) {
4420             xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_DEFAULT,
4421            "Value for attribute %s of %s is different from default \"%s\"\n",
4422                    attr->name, elem->name, attrDecl->defaultValue);
4423             ret = 0;
4424         }
4425     }
4426
4427     /* Validity Constraint: ID uniqueness */
4428     if (attrDecl->atype == XML_ATTRIBUTE_ID) {
4429         if (xmlAddID(ctxt, doc, value, attr) == NULL)
4430             ret = 0;
4431     }
4432
4433     if ((attrDecl->atype == XML_ATTRIBUTE_IDREF) ||
4434         (attrDecl->atype == XML_ATTRIBUTE_IDREFS)) {
4435         if (xmlAddRef(ctxt, doc, value, attr) == NULL)
4436             ret = 0;
4437     }
4438
4439     /* Validity Constraint: Notation Attributes */
4440     if (attrDecl->atype == XML_ATTRIBUTE_NOTATION) {
4441         xmlEnumerationPtr tree = attrDecl->tree;
4442         xmlNotationPtr nota;
4443
4444         /* First check that the given NOTATION was declared */
4445         nota = xmlGetDtdNotationDesc(doc->intSubset, value);
4446         if (nota == NULL)
4447             nota = xmlGetDtdNotationDesc(doc->extSubset, value);
4448
4449         if (nota == NULL) {
4450             xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
4451        "Value \"%s\" for attribute %s of %s is not a declared Notation\n",
4452                    value, attr->name, elem->name);
4453             ret = 0;
4454         }
4455
4456         /* Second, verify that it's among the list */
4457         while (tree != NULL) {
4458             if (xmlStrEqual(tree->name, value)) break;
4459             tree = tree->next;
4460         }
4461         if (tree == NULL) {
4462             xmlErrValidNode(ctxt, elem, XML_DTD_NOTATION_VALUE,
4463 "Value \"%s\" for attribute %s of %s is not among the enumerated notations\n",
4464                    value, attr->name, elem->name);
4465             ret = 0;
4466         }
4467     }
4468
4469     /* Validity Constraint: Enumeration */
4470     if (attrDecl->atype == XML_ATTRIBUTE_ENUMERATION) {
4471         xmlEnumerationPtr tree = attrDecl->tree;
4472         while (tree != NULL) {
4473             if (xmlStrEqual(tree->name, value)) break;
4474             tree = tree->next;
4475         }
4476         if (tree == NULL) {
4477             xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4478        "Value \"%s\" for attribute %s of %s is not among the enumerated set\n",
4479                    value, attr->name, elem->name);
4480             ret = 0;
4481         }
4482     }
4483
4484     /* Fixed Attribute Default */
4485     if ((attrDecl->def == XML_ATTRIBUTE_FIXED) &&
4486         (!xmlStrEqual(attrDecl->defaultValue, value))) {
4487         xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4488            "Value for attribute %s of %s must be \"%s\"\n",
4489                attr->name, elem->name, attrDecl->defaultValue);
4490         ret = 0;
4491     }
4492
4493     /* Extra check for the attribute value */
4494     ret &= xmlValidateAttributeValue2(ctxt, doc, attr->name,
4495                                       attrDecl->atype, value);
4496
4497     return(ret);
4498 }
4499
4500 /**
4501  * xmlValidateOneNamespace:
4502  * @ctxt:  the validation context
4503  * @doc:  a document instance
4504  * @elem:  an element instance
4505  * @prefix:  the namespace prefix
4506  * @ns:  an namespace declaration instance
4507  * @value:  the attribute value (without entities processing)
4508  *
4509  * Try to validate a single namespace declaration for an element
4510  * basically it does the following checks as described by the
4511  * XML-1.0 recommendation:
4512  *  - [ VC: Attribute Value Type ]
4513  *  - [ VC: Fixed Attribute Default ]
4514  *  - [ VC: Entity Name ]
4515  *  - [ VC: Name Token ]
4516  *  - [ VC: ID ]
4517  *  - [ VC: IDREF ]
4518  *  - [ VC: Entity Name ]
4519  *  - [ VC: Notation Attributes ]
4520  *
4521  * The ID/IDREF uniqueness and matching are done separately
4522  *
4523  * returns 1 if valid or 0 otherwise
4524  */
4525
4526 int
4527 xmlValidateOneNamespace(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4528 xmlNodePtr elem, const xmlChar *prefix, xmlNsPtr ns, const xmlChar *value) {
4529     /* xmlElementPtr elemDecl; */
4530     xmlAttributePtr attrDecl =  NULL;
4531     int val;
4532     int ret = 1;
4533
4534     CHECK_DTD;
4535     if ((elem == NULL) || (elem->name == NULL)) return(0);
4536     if ((ns == NULL) || (ns->href == NULL)) return(0);
4537
4538     if (prefix != NULL) {
4539         xmlChar fn[50];
4540         xmlChar *fullname;
4541
4542         fullname = xmlBuildQName(elem->name, prefix, fn, 50);
4543         if (fullname == NULL) {
4544             xmlVErrMemory(ctxt, "Validating namespace");
4545             return(0);
4546         }
4547         if (ns->prefix != NULL) {
4548             attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, fullname,
4549                                           ns->prefix, BAD_CAST "xmlns");
4550             if ((attrDecl == NULL) && (doc->extSubset != NULL))
4551                 attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, fullname,
4552                                           ns->prefix, BAD_CAST "xmlns");
4553         } else {
4554             attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname,
4555                                          BAD_CAST "xmlns");
4556             if ((attrDecl == NULL) && (doc->extSubset != NULL))
4557                 attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullname,
4558                                          BAD_CAST "xmlns");
4559         }
4560         if ((fullname != fn) && (fullname != elem->name))
4561             xmlFree(fullname);
4562     }
4563     if (attrDecl == NULL) {
4564         if (ns->prefix != NULL) {
4565             attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, elem->name,
4566                                           ns->prefix, BAD_CAST "xmlns");
4567             if ((attrDecl == NULL) && (doc->extSubset != NULL))
4568                 attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, elem->name,
4569                                               ns->prefix, BAD_CAST "xmlns");
4570         } else {
4571             attrDecl = xmlGetDtdAttrDesc(doc->intSubset,
4572                                          elem->name, BAD_CAST "xmlns");
4573             if ((attrDecl == NULL) && (doc->extSubset != NULL))
4574                 attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
4575                                              elem->name, BAD_CAST "xmlns");
4576         }
4577     }
4578
4579
4580     /* Validity Constraint: Attribute Value Type */
4581     if (attrDecl == NULL) {
4582         if (ns->prefix != NULL) {
4583             xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
4584                    "No declaration for attribute xmlns:%s of element %s\n",
4585                    ns->prefix, elem->name, NULL);
4586         } else {
4587             xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
4588                    "No declaration for attribute xmlns of element %s\n",
4589                    elem->name, NULL, NULL);
4590         }
4591         return(0);
4592     }
4593
4594     val = xmlValidateAttributeValueInternal(doc, attrDecl->atype, value);
4595     if (val == 0) {
4596         if (ns->prefix != NULL) {
4597             xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_DEFAULT,
4598                "Syntax of value for attribute xmlns:%s of %s is not valid\n",
4599                    ns->prefix, elem->name, NULL);
4600         } else {
4601             xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_DEFAULT,
4602                "Syntax of value for attribute xmlns of %s is not valid\n",
4603                    elem->name, NULL, NULL);
4604         }
4605         ret = 0;
4606     }
4607
4608     /* Validity constraint: Fixed Attribute Default */
4609     if (attrDecl->def == XML_ATTRIBUTE_FIXED) {
4610         if (!xmlStrEqual(value, attrDecl->defaultValue)) {
4611             if (ns->prefix != NULL) {
4612                 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_DEFAULT,
4613        "Value for attribute xmlns:%s of %s is different from default \"%s\"\n",
4614                        ns->prefix, elem->name, attrDecl->defaultValue);
4615             } else {
4616                 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_DEFAULT,
4617        "Value for attribute xmlns of %s is different from default \"%s\"\n",
4618                        elem->name, attrDecl->defaultValue, NULL);
4619             }
4620             ret = 0;
4621         }
4622     }
4623
4624     /* Validity Constraint: ID uniqueness */
4625     if (attrDecl->atype == XML_ATTRIBUTE_ID) {
4626         if (xmlAddID(ctxt, doc, value, (xmlAttrPtr) ns) == NULL)
4627             ret = 0;
4628     }
4629
4630     if ((attrDecl->atype == XML_ATTRIBUTE_IDREF) ||
4631         (attrDecl->atype == XML_ATTRIBUTE_IDREFS)) {
4632         if (xmlAddRef(ctxt, doc, value, (xmlAttrPtr) ns) == NULL)
4633             ret = 0;
4634     }
4635
4636     /* Validity Constraint: Notation Attributes */
4637     if (attrDecl->atype == XML_ATTRIBUTE_NOTATION) {
4638         xmlEnumerationPtr tree = attrDecl->tree;
4639         xmlNotationPtr nota;
4640
4641         /* First check that the given NOTATION was declared */
4642         nota = xmlGetDtdNotationDesc(doc->intSubset, value);
4643         if (nota == NULL)
4644             nota = xmlGetDtdNotationDesc(doc->extSubset, value);
4645
4646         if (nota == NULL) {
4647             if (ns->prefix != NULL) {
4648                 xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
4649        "Value \"%s\" for attribute xmlns:%s of %s is not a declared Notation\n",
4650                        value, ns->prefix, elem->name);
4651             } else {
4652                 xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
4653        "Value \"%s\" for attribute xmlns of %s is not a declared Notation\n",
4654                        value, elem->name, NULL);
4655             }
4656             ret = 0;
4657         }
4658
4659         /* Second, verify that it's among the list */
4660         while (tree != NULL) {
4661             if (xmlStrEqual(tree->name, value)) break;
4662             tree = tree->next;
4663         }
4664         if (tree == NULL) {
4665             if (ns->prefix != NULL) {
4666                 xmlErrValidNode(ctxt, elem, XML_DTD_NOTATION_VALUE,
4667 "Value \"%s\" for attribute xmlns:%s of %s is not among the enumerated notations\n",
4668                        value, ns->prefix, elem->name);
4669             } else {
4670                 xmlErrValidNode(ctxt, elem, XML_DTD_NOTATION_VALUE,
4671 "Value \"%s\" for attribute xmlns of %s is not among the enumerated notations\n",
4672                        value, elem->name, NULL);
4673             }
4674             ret = 0;
4675         }
4676     }
4677
4678     /* Validity Constraint: Enumeration */
4679     if (attrDecl->atype == XML_ATTRIBUTE_ENUMERATION) {
4680         xmlEnumerationPtr tree = attrDecl->tree;
4681         while (tree != NULL) {
4682             if (xmlStrEqual(tree->name, value)) break;
4683             tree = tree->next;
4684         }
4685         if (tree == NULL) {
4686             if (ns->prefix != NULL) {
4687                 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4688 "Value \"%s\" for attribute xmlns:%s of %s is not among the enumerated set\n",
4689                        value, ns->prefix, elem->name);
4690             } else {
4691                 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4692 "Value \"%s\" for attribute xmlns of %s is not among the enumerated set\n",
4693                        value, elem->name, NULL);
4694             }
4695             ret = 0;
4696         }
4697     }
4698
4699     /* Fixed Attribute Default */
4700     if ((attrDecl->def == XML_ATTRIBUTE_FIXED) &&
4701         (!xmlStrEqual(attrDecl->defaultValue, value))) {
4702         if (ns->prefix != NULL) {
4703             xmlErrValidNode(ctxt, elem, XML_DTD_ELEM_NAMESPACE,
4704                    "Value for attribute xmlns:%s of %s must be \"%s\"\n",
4705                    ns->prefix, elem->name, attrDecl->defaultValue);
4706         } else {
4707             xmlErrValidNode(ctxt, elem, XML_DTD_ELEM_NAMESPACE,
4708                    "Value for attribute xmlns of %s must be \"%s\"\n",
4709                    elem->name, attrDecl->defaultValue, NULL);
4710         }
4711         ret = 0;
4712     }
4713
4714     /* Extra check for the attribute value */
4715     if (ns->prefix != NULL) {
4716         ret &= xmlValidateAttributeValue2(ctxt, doc, ns->prefix,
4717                                           attrDecl->atype, value);
4718     } else {
4719         ret &= xmlValidateAttributeValue2(ctxt, doc, BAD_CAST "xmlns",
4720                                           attrDecl->atype, value);
4721     }
4722
4723     return(ret);
4724 }
4725
4726 #ifndef  LIBXML_REGEXP_ENABLED
4727 /**
4728  * xmlValidateSkipIgnorable:
4729  * @ctxt:  the validation context
4730  * @child:  the child list
4731  *
4732  * Skip ignorable elements w.r.t. the validation process
4733  *
4734  * returns the first element to consider for validation of the content model
4735  */
4736
4737 static xmlNodePtr
4738 xmlValidateSkipIgnorable(xmlNodePtr child) {
4739     while (child != NULL) {
4740         switch (child->type) {
4741             /* These things are ignored (skipped) during validation.  */
4742             case XML_PI_NODE:
4743             case XML_COMMENT_NODE:
4744             case XML_XINCLUDE_START:
4745             case XML_XINCLUDE_END:
4746                 child = child->next;
4747                 break;
4748             case XML_TEXT_NODE:
4749                 if (xmlIsBlankNode(child))
4750                     child = child->next;
4751                 else
4752                     return(child);
4753                 break;
4754             /* keep current node */
4755             default:
4756                 return(child);
4757         }
4758     }
4759     return(child);
4760 }
4761
4762 /**
4763  * xmlValidateElementType:
4764  * @ctxt:  the validation context
4765  *
4766  * Try to validate the content model of an element internal function
4767  *
4768  * returns 1 if valid or 0 ,-1 in case of error, -2 if an entity
4769  *           reference is found and -3 if the validation succeeded but
4770  *           the content model is not determinist.
4771  */
4772
4773 static int
4774 xmlValidateElementType(xmlValidCtxtPtr ctxt) {
4775     int ret = -1;
4776     int determinist = 1;
4777
4778     NODE = xmlValidateSkipIgnorable(NODE);
4779     if ((NODE == NULL) && (CONT == NULL))
4780         return(1);
4781     if ((NODE == NULL) &&
4782         ((CONT->ocur == XML_ELEMENT_CONTENT_MULT) ||
4783          (CONT->ocur == XML_ELEMENT_CONTENT_OPT))) {
4784         return(1);
4785     }
4786     if (CONT == NULL) return(-1);
4787     if ((NODE != NULL) && (NODE->type == XML_ENTITY_REF_NODE))
4788         return(-2);
4789
4790     /*
4791      * We arrive here when more states need to be examined
4792      */
4793 cont:
4794
4795     /*
4796      * We just recovered from a rollback generated by a possible
4797      * epsilon transition, go directly to the analysis phase
4798      */
4799     if (STATE == ROLLBACK_PARENT) {
4800         DEBUG_VALID_MSG("restored parent branch");
4801         DEBUG_VALID_STATE(NODE, CONT)
4802         ret = 1;
4803         goto analyze;
4804     }
4805
4806     DEBUG_VALID_STATE(NODE, CONT)
4807     /*
4808      * we may have to save a backup state here. This is the equivalent
4809      * of handling epsilon transition in NFAs.
4810      */
4811     if ((CONT != NULL) &&
4812         ((CONT->parent == NULL) ||
4813          (CONT->parent->type != XML_ELEMENT_CONTENT_OR)) &&
4814         ((CONT->ocur == XML_ELEMENT_CONTENT_MULT) ||
4815          (CONT->ocur == XML_ELEMENT_CONTENT_OPT) ||
4816          ((CONT->ocur == XML_ELEMENT_CONTENT_PLUS) && (OCCURRENCE)))) {
4817         DEBUG_VALID_MSG("saving parent branch");
4818         if (vstateVPush(ctxt, CONT, NODE, DEPTH, OCCURS, ROLLBACK_PARENT) < 0)
4819             return(0);
4820     }
4821
4822
4823     /*
4824      * Check first if the content matches
4825      */
4826     switch (CONT->type) {
4827         case XML_ELEMENT_CONTENT_PCDATA:
4828             if (NODE == NULL) {
4829                 DEBUG_VALID_MSG("pcdata failed no node");
4830                 ret = 0;
4831                 break;
4832             }
4833             if (NODE->type == XML_TEXT_NODE) {
4834                 DEBUG_VALID_MSG("pcdata found, skip to next");
4835                 /*
4836                  * go to next element in the content model
4837                  * skipping ignorable elems
4838                  */
4839                 do {
4840                     NODE = NODE->next;
4841                     NODE = xmlValidateSkipIgnorable(NODE);
4842                     if ((NODE != NULL) &&
4843                         (NODE->type == XML_ENTITY_REF_NODE))
4844                         return(-2);
4845                 } while ((NODE != NULL) &&
4846                          ((NODE->type != XML_ELEMENT_NODE) &&
4847                           (NODE->type != XML_TEXT_NODE) &&
4848                           (NODE->type != XML_CDATA_SECTION_NODE)));
4849                 ret = 1;
4850                 break;
4851             } else {
4852                 DEBUG_VALID_MSG("pcdata failed");
4853                 ret = 0;
4854                 break;
4855             }
4856             break;
4857         case XML_ELEMENT_CONTENT_ELEMENT:
4858             if (NODE == NULL) {
4859                 DEBUG_VALID_MSG("element failed no node");
4860                 ret = 0;
4861                 break;
4862             }
4863             ret = ((NODE->type == XML_ELEMENT_NODE) &&
4864                    (xmlStrEqual(NODE->name, CONT->name)));
4865             if (ret == 1) {
4866                 if ((NODE->ns == NULL) || (NODE->ns->prefix == NULL)) {
4867                     ret = (CONT->prefix == NULL);
4868                 } else if (CONT->prefix == NULL) {
4869                     ret = 0;
4870                 } else {
4871                     ret = xmlStrEqual(NODE->ns->prefix, CONT->prefix);
4872                 }
4873             }
4874             if (ret == 1) {
4875                 DEBUG_VALID_MSG("element found, skip to next");
4876                 /*
4877                  * go to next element in the content model
4878                  * skipping ignorable elems
4879                  */
4880                 do {
4881                     NODE = NODE->next;
4882                     NODE = xmlValidateSkipIgnorable(NODE);
4883                     if ((NODE != NULL) &&
4884                         (NODE->type == XML_ENTITY_REF_NODE))
4885                         return(-2);
4886                 } while ((NODE != NULL) &&
4887                          ((NODE->type != XML_ELEMENT_NODE) &&
4888                           (NODE->type != XML_TEXT_NODE) &&
4889                           (NODE->type != XML_CDATA_SECTION_NODE)));
4890             } else {
4891                 DEBUG_VALID_MSG("element failed");
4892                 ret = 0;
4893                 break;
4894             }
4895             break;
4896         case XML_ELEMENT_CONTENT_OR:
4897             /*
4898              * Small optimization.
4899              */
4900             if (CONT->c1->type == XML_ELEMENT_CONTENT_ELEMENT) {
4901                 if ((NODE == NULL) ||
4902                     (!xmlStrEqual(NODE->name, CONT->c1->name))) {
4903                     DEPTH++;
4904                     CONT = CONT->c2;
4905                     goto cont;
4906                 }
4907                 if ((NODE->ns == NULL) || (NODE->ns->prefix == NULL)) {
4908                     ret = (CONT->c1->prefix == NULL);
4909                 } else if (CONT->c1->prefix == NULL) {
4910                     ret = 0;
4911                 } else {
4912                     ret = xmlStrEqual(NODE->ns->prefix, CONT->c1->prefix);
4913                 }
4914                 if (ret == 0) {
4915                     DEPTH++;
4916                     CONT = CONT->c2;
4917                     goto cont;
4918                 }
4919             }
4920
4921             /*
4922              * save the second branch 'or' branch
4923              */
4924             DEBUG_VALID_MSG("saving 'or' branch");
4925             if (vstateVPush(ctxt, CONT->c2, NODE, (unsigned char)(DEPTH + 1),
4926                             OCCURS, ROLLBACK_OR) < 0)
4927                 return(-1);
4928             DEPTH++;
4929             CONT = CONT->c1;
4930             goto cont;
4931         case XML_ELEMENT_CONTENT_SEQ:
4932             /*
4933              * Small optimization.
4934              */
4935             if ((CONT->c1->type == XML_ELEMENT_CONTENT_ELEMENT) &&
4936                 ((CONT->c1->ocur == XML_ELEMENT_CONTENT_OPT) ||
4937                  (CONT->c1->ocur == XML_ELEMENT_CONTENT_MULT))) {
4938                 if ((NODE == NULL) ||
4939                     (!xmlStrEqual(NODE->name, CONT->c1->name))) {
4940                     DEPTH++;
4941                     CONT = CONT->c2;
4942                     goto cont;
4943                 }
4944                 if ((NODE->ns == NULL) || (NODE->ns->prefix == NULL)) {
4945                     ret = (CONT->c1->prefix == NULL);
4946                 } else if (CONT->c1->prefix == NULL) {
4947                     ret = 0;
4948                 } else {
4949                     ret = xmlStrEqual(NODE->ns->prefix, CONT->c1->prefix);
4950                 }
4951                 if (ret == 0) {
4952                     DEPTH++;
4953                     CONT = CONT->c2;
4954                     goto cont;
4955                 }
4956             }
4957             DEPTH++;
4958             CONT = CONT->c1;
4959             goto cont;
4960     }
4961
4962     /*
4963      * At this point handle going up in the tree
4964      */
4965     if (ret == -1) {
4966         DEBUG_VALID_MSG("error found returning");
4967         return(ret);
4968     }
4969 analyze:
4970     while (CONT != NULL) {
4971         /*
4972          * First do the analysis depending on the occurrence model at
4973          * this level.
4974          */
4975         if (ret == 0) {
4976             switch (CONT->ocur) {
4977                 xmlNodePtr cur;
4978
4979                 case XML_ELEMENT_CONTENT_ONCE:
4980                     cur = ctxt->vstate->node;
4981                     DEBUG_VALID_MSG("Once branch failed, rollback");
4982                     if (vstateVPop(ctxt) < 0 ) {
4983                         DEBUG_VALID_MSG("exhaustion, failed");
4984                         return(0);
4985                     }
4986                     if (cur != ctxt->vstate->node)
4987                         determinist = -3;
4988                     goto cont;
4989                 case XML_ELEMENT_CONTENT_PLUS:
4990                     if (OCCURRENCE == 0) {
4991                         cur = ctxt->vstate->node;
4992                         DEBUG_VALID_MSG("Plus branch failed, rollback");
4993                         if (vstateVPop(ctxt) < 0 ) {
4994                             DEBUG_VALID_MSG("exhaustion, failed");
4995                             return(0);
4996                         }
4997                         if (cur != ctxt->vstate->node)
4998                             determinist = -3;
4999                         goto cont;
5000                     }
5001                     DEBUG_VALID_MSG("Plus branch found");
5002                     ret = 1;
5003                     break;
5004                 case XML_ELEMENT_CONTENT_MULT:
5005 #ifdef DEBUG_VALID_ALGO
5006                     if (OCCURRENCE == 0) {
5007                         DEBUG_VALID_MSG("Mult branch failed");
5008                     } else {
5009                         DEBUG_VALID_MSG("Mult branch found");
5010                     }
5011 #endif
5012                     ret = 1;
5013                     break;
5014                 case XML_ELEMENT_CONTENT_OPT:
5015                     DEBUG_VALID_MSG("Option branch failed");
5016                     ret = 1;
5017                     break;
5018             }
5019         } else {
5020             switch (CONT->ocur) {
5021                 case XML_ELEMENT_CONTENT_OPT:
5022                     DEBUG_VALID_MSG("Option branch succeeded");
5023                     ret = 1;
5024                     break;
5025                 case XML_ELEMENT_CONTENT_ONCE:
5026                     DEBUG_VALID_MSG("Once branch succeeded");
5027                     ret = 1;
5028                     break;
5029                 case XML_ELEMENT_CONTENT_PLUS:
5030                     if (STATE == ROLLBACK_PARENT) {
5031                         DEBUG_VALID_MSG("Plus branch rollback");
5032                         ret = 1;
5033                         break;
5034                     }
5035                     if (NODE == NULL) {
5036                         DEBUG_VALID_MSG("Plus branch exhausted");
5037                         ret = 1;
5038                         break;
5039                     }
5040                     DEBUG_VALID_MSG("Plus branch succeeded, continuing");
5041                     SET_OCCURRENCE;
5042                     goto cont;
5043                 case XML_ELEMENT_CONTENT_MULT:
5044                     if (STATE == ROLLBACK_PARENT) {
5045                         DEBUG_VALID_MSG("Mult branch rollback");
5046                         ret = 1;
5047                         break;
5048                     }
5049                     if (NODE == NULL) {
5050                         DEBUG_VALID_MSG("Mult branch exhausted");
5051                         ret = 1;
5052                         break;
5053                     }
5054                     DEBUG_VALID_MSG("Mult branch succeeded, continuing");
5055                     /* SET_OCCURRENCE; */
5056                     goto cont;
5057             }
5058         }
5059         STATE = 0;
5060
5061         /*
5062          * Then act accordingly at the parent level
5063          */
5064         RESET_OCCURRENCE;
5065         if (CONT->parent == NULL)
5066             break;
5067
5068         switch (CONT->parent->type) {
5069             case XML_ELEMENT_CONTENT_PCDATA:
5070                 DEBUG_VALID_MSG("Error: parent pcdata");
5071                 return(-1);
5072             case XML_ELEMENT_CONTENT_ELEMENT:
5073                 DEBUG_VALID_MSG("Error: parent element");
5074                 return(-1);
5075             case XML_ELEMENT_CONTENT_OR:
5076                 if (ret == 1) {
5077                     DEBUG_VALID_MSG("Or succeeded");
5078                     CONT = CONT->parent;
5079                     DEPTH--;
5080                 } else {
5081                     DEBUG_VALID_MSG("Or failed");
5082                     CONT = CONT->parent;
5083                     DEPTH--;
5084                 }
5085                 break;
5086             case XML_ELEMENT_CONTENT_SEQ:
5087                 if (ret == 0) {
5088                     DEBUG_VALID_MSG("Sequence failed");
5089                     CONT = CONT->parent;
5090                     DEPTH--;
5091                 } else if (CONT == CONT->parent->c1) {
5092                     DEBUG_VALID_MSG("Sequence testing 2nd branch");
5093                     CONT = CONT->parent->c2;
5094                     goto cont;
5095                 } else {
5096                     DEBUG_VALID_MSG("Sequence succeeded");
5097                     CONT = CONT->parent;
5098                     DEPTH--;
5099                 }
5100         }
5101     }
5102     if (NODE != NULL) {
5103         xmlNodePtr cur;
5104
5105         cur = ctxt->vstate->node;
5106         DEBUG_VALID_MSG("Failed, remaining input, rollback");
5107         if (vstateVPop(ctxt) < 0 ) {
5108             DEBUG_VALID_MSG("exhaustion, failed");
5109             return(0);
5110         }
5111         if (cur != ctxt->vstate->node)
5112             determinist = -3;
5113         goto cont;
5114     }
5115     if (ret == 0) {
5116         xmlNodePtr cur;
5117
5118         cur = ctxt->vstate->node;
5119         DEBUG_VALID_MSG("Failure, rollback");
5120         if (vstateVPop(ctxt) < 0 ) {
5121             DEBUG_VALID_MSG("exhaustion, failed");
5122             return(0);
5123         }
5124         if (cur != ctxt->vstate->node)
5125             determinist = -3;
5126         goto cont;
5127     }
5128     return(determinist);
5129 }
5130 #endif
5131
5132 /**
5133  * xmlSnprintfElements:
5134  * @buf:  an output buffer
5135  * @size:  the size of the buffer
5136  * @content:  An element
5137  * @glob: 1 if one must print the englobing parenthesis, 0 otherwise
5138  *
5139  * This will dump the list of elements to the buffer
5140  * Intended just for the debug routine
5141  */
5142 static void
5143 xmlSnprintfElements(char *buf, int size, xmlNodePtr node, int glob) {
5144     xmlNodePtr cur;
5145     int len;
5146
5147     if (node == NULL) return;
5148     if (glob) strcat(buf, "(");
5149     cur = node;
5150     while (cur != NULL) {
5151         len = strlen(buf);
5152         if (size - len < 50) {
5153             if ((size - len > 4) && (buf[len - 1] != '.'))
5154                 strcat(buf, " ...");
5155             return;
5156         }
5157         switch (cur->type) {
5158             case XML_ELEMENT_NODE:
5159                 if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
5160                     if (size - len < xmlStrlen(cur->ns->prefix) + 10) {
5161                         if ((size - len > 4) && (buf[len - 1] != '.'))
5162                             strcat(buf, " ...");
5163                         return;
5164                     }
5165                     strcat(buf, (char *) cur->ns->prefix);
5166                     strcat(buf, ":");
5167                 }
5168                 if (size - len < xmlStrlen(cur->name) + 10) {
5169                     if ((size - len > 4) && (buf[len - 1] != '.'))
5170                         strcat(buf, " ...");
5171                     return;
5172                 }
5173                 strcat(buf, (char *) cur->name);
5174                 if (cur->next != NULL)
5175                     strcat(buf, " ");
5176                 break;
5177             case XML_TEXT_NODE:
5178                 if (xmlIsBlankNode(cur))
5179                     break;
5180             case XML_CDATA_SECTION_NODE:
5181             case XML_ENTITY_REF_NODE:
5182                 strcat(buf, "CDATA");
5183                 if (cur->next != NULL)
5184                     strcat(buf, " ");
5185                 break;
5186             case XML_ATTRIBUTE_NODE:
5187             case XML_DOCUMENT_NODE:
5188 #ifdef LIBXML_DOCB_ENABLED
5189             case XML_DOCB_DOCUMENT_NODE:
5190 #endif
5191             case XML_HTML_DOCUMENT_NODE:
5192             case XML_DOCUMENT_TYPE_NODE:
5193             case XML_DOCUMENT_FRAG_NODE:
5194             case XML_NOTATION_NODE:
5195             case XML_NAMESPACE_DECL:
5196                 strcat(buf, "???");
5197                 if (cur->next != NULL)
5198                     strcat(buf, " ");
5199                 break;
5200             case XML_ENTITY_NODE:
5201             case XML_PI_NODE:
5202             case XML_DTD_NODE:
5203             case XML_COMMENT_NODE:
5204             case XML_ELEMENT_DECL:
5205             case XML_ATTRIBUTE_DECL:
5206             case XML_ENTITY_DECL:
5207             case XML_XINCLUDE_START:
5208             case XML_XINCLUDE_END:
5209                 break;
5210         }
5211         cur = cur->next;
5212     }
5213     if (glob) strcat(buf, ")");
5214 }
5215
5216 /**
5217  * xmlValidateElementContent:
5218  * @ctxt:  the validation context
5219  * @child:  the child list
5220  * @elemDecl:  pointer to the element declaration
5221  * @warn:  emit the error message
5222  * @parent: the parent element (for error reporting)
5223  *
5224  * Try to validate the content model of an element
5225  *
5226  * returns 1 if valid or 0 if not and -1 in case of error
5227  */
5228
5229 static int
5230 xmlValidateElementContent(xmlValidCtxtPtr ctxt, xmlNodePtr child,
5231        xmlElementPtr elemDecl, int warn, xmlNodePtr parent) {
5232     int ret = 1;
5233 #ifndef  LIBXML_REGEXP_ENABLED
5234     xmlNodePtr repl = NULL, last = NULL, tmp;
5235 #endif
5236     xmlNodePtr cur;
5237     xmlElementContentPtr cont;
5238     const xmlChar *name;
5239
5240     if ((elemDecl == NULL) || (parent == NULL) || (ctxt == NULL))
5241         return(-1);
5242     cont = elemDecl->content;
5243     name = elemDecl->name;
5244
5245 #ifdef LIBXML_REGEXP_ENABLED
5246     /* Build the regexp associated to the content model */
5247     if (elemDecl->contModel == NULL)
5248         ret = xmlValidBuildContentModel(ctxt, elemDecl);
5249     if (elemDecl->contModel == NULL) {
5250         return(-1);
5251     } else {
5252         xmlRegExecCtxtPtr exec;
5253
5254         if (!xmlRegexpIsDeterminist(elemDecl->contModel)) {
5255             return(-1);
5256         }
5257         ctxt->nodeMax = 0;
5258         ctxt->nodeNr = 0;
5259         ctxt->nodeTab = NULL;
5260         exec = xmlRegNewExecCtxt(elemDecl->contModel, NULL, NULL);
5261         if (exec != NULL) {
5262             cur = child;
5263             while (cur != NULL) {
5264                 switch (cur->type) {
5265                     case XML_ENTITY_REF_NODE:
5266                         /*
5267                          * Push the current node to be able to roll back
5268                          * and process within the entity
5269                          */
5270                         if ((cur->children != NULL) &&
5271                             (cur->children->children != NULL)) {
5272                             nodeVPush(ctxt, cur);
5273                             cur = cur->children->children;
5274                             continue;
5275                         }
5276                         break;
5277                     case XML_TEXT_NODE:
5278                         if (xmlIsBlankNode(cur))
5279                             break;
5280                         ret = 0;
5281                         goto fail;
5282                     case XML_CDATA_SECTION_NODE:
5283                         /* TODO */
5284                         ret = 0;
5285                         goto fail;
5286                     case XML_ELEMENT_NODE:
5287                         if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
5288                             xmlChar fn[50];
5289                             xmlChar *fullname;
5290
5291                             fullname = xmlBuildQName(cur->name,
5292                                                      cur->ns->prefix, fn, 50);
5293                             if (fullname == NULL) {
5294                                 ret = -1;
5295                                 goto fail;
5296                             }
5297                             ret = xmlRegExecPushString(exec, fullname, NULL);
5298                             if ((fullname != fn) && (fullname != cur->name))
5299                                 xmlFree(fullname);
5300                         } else {
5301                             ret = xmlRegExecPushString(exec, cur->name, NULL);
5302                         }
5303                         break;
5304                     default:
5305                         break;
5306                 }
5307                 /*
5308                  * Switch to next element
5309                  */
5310                 cur = cur->next;
5311                 while (cur == NULL) {
5312                     cur = nodeVPop(ctxt);
5313                     if (cur == NULL)
5314                         break;
5315                     cur = cur->next;
5316                 }
5317             }
5318             ret = xmlRegExecPushString(exec, NULL, NULL);
5319 fail:
5320             xmlRegFreeExecCtxt(exec);
5321         }
5322     }
5323 #else  /* LIBXML_REGEXP_ENABLED */
5324     /*
5325      * Allocate the stack
5326      */
5327     ctxt->vstateMax = 8;
5328     ctxt->vstateTab = (xmlValidState *) xmlMalloc(
5329                  ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
5330     if (ctxt->vstateTab == NULL) {
5331         xmlVErrMemory(ctxt, "malloc failed");
5332         return(-1);
5333     }
5334     /*
5335      * The first entry in the stack is reserved to the current state
5336      */
5337     ctxt->nodeMax = 0;
5338     ctxt->nodeNr = 0;
5339     ctxt->nodeTab = NULL;
5340     ctxt->vstate = &ctxt->vstateTab[0];
5341     ctxt->vstateNr = 1;
5342     CONT = cont;
5343     NODE = child;
5344     DEPTH = 0;
5345     OCCURS = 0;
5346     STATE = 0;
5347     ret = xmlValidateElementType(ctxt);
5348     if ((ret == -3) && (warn)) {
5349         xmlErrValidWarning(ctxt, child, XML_DTD_CONTENT_NOT_DETERMINIST,
5350                "Content model for Element %s is ambiguous\n",
5351                            name, NULL, NULL);
5352     } else if (ret == -2) {
5353         /*
5354          * An entities reference appeared at this level.
5355          * Buid a minimal representation of this node content
5356          * sufficient to run the validation process on it
5357          */
5358         DEBUG_VALID_MSG("Found an entity reference, linearizing");
5359         cur = child;
5360         while (cur != NULL) {
5361             switch (cur->type) {
5362                 case XML_ENTITY_REF_NODE:
5363                     /*
5364                      * Push the current node to be able to roll back
5365                      * and process within the entity
5366                      */
5367                     if ((cur->children != NULL) &&
5368                         (cur->children->children != NULL)) {
5369                         nodeVPush(ctxt, cur);
5370                         cur = cur->children->children;
5371                         continue;
5372                     }
5373                     break;
5374                 case XML_TEXT_NODE:
5375                     if (xmlIsBlankNode(cur))
5376                         break;
5377                     /* no break on purpose */
5378                 case XML_CDATA_SECTION_NODE:
5379                     /* no break on purpose */
5380                 case XML_ELEMENT_NODE:
5381                     /*
5382                      * Allocate a new node and minimally fills in
5383                      * what's required
5384                      */
5385                     tmp = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
5386                     if (tmp == NULL) {
5387                         xmlVErrMemory(ctxt, "malloc failed");
5388                         xmlFreeNodeList(repl);
5389                         ret = -1;
5390                         goto done;
5391                     }
5392                     tmp->type = cur->type;
5393                     tmp->name = cur->name;
5394                     tmp->ns = cur->ns;
5395                     tmp->next = NULL;
5396                     tmp->content = NULL;
5397                     if (repl == NULL)
5398                         repl = last = tmp;
5399                     else {
5400                         last->next = tmp;
5401                         last = tmp;
5402                     }
5403                     if (cur->type == XML_CDATA_SECTION_NODE) {
5404                         /*
5405                          * E59 spaces in CDATA does not match the
5406                          * nonterminal S
5407                          */
5408                         tmp->content = xmlStrdup(BAD_CAST "CDATA");
5409                     }
5410                     break;
5411                 default:
5412                     break;
5413             }
5414             /*
5415              * Switch to next element
5416              */
5417             cur = cur->next;
5418             while (cur == NULL) {
5419                 cur = nodeVPop(ctxt);
5420                 if (cur == NULL)
5421                     break;
5422                 cur = cur->next;
5423             }
5424         }
5425
5426         /*
5427          * Relaunch the validation
5428          */
5429         ctxt->vstate = &ctxt->vstateTab[0];
5430         ctxt->vstateNr = 1;
5431         CONT = cont;
5432         NODE = repl;
5433         DEPTH = 0;
5434         OCCURS = 0;
5435         STATE = 0;
5436         ret = xmlValidateElementType(ctxt);
5437     }
5438 #endif /* LIBXML_REGEXP_ENABLED */
5439     if ((warn) && ((ret != 1) && (ret != -3))) {
5440         if (ctxt != NULL) {
5441             char expr[5000];
5442             char list[5000];
5443
5444             expr[0] = 0;
5445             xmlSnprintfElementContent(&expr[0], 5000, cont, 1);
5446             list[0] = 0;
5447 #ifndef LIBXML_REGEXP_ENABLED
5448             if (repl != NULL)
5449                 xmlSnprintfElements(&list[0], 5000, repl, 1);
5450             else
5451 #endif /* LIBXML_REGEXP_ENABLED */
5452                 xmlSnprintfElements(&list[0], 5000, child, 1);
5453
5454             if (name != NULL) {
5455                 xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
5456            "Element %s content does not follow the DTD, expecting %s, got %s\n",
5457                        name, BAD_CAST expr, BAD_CAST list);
5458             } else {
5459                 xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
5460            "Element content does not follow the DTD, expecting %s, got %s\n",
5461                        BAD_CAST expr, BAD_CAST list, NULL);
5462             }
5463         } else {
5464             if (name != NULL) {
5465                 xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
5466                        "Element %s content does not follow the DTD\n",
5467                        name, NULL, NULL);
5468             } else {
5469                 xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
5470                        "Element content does not follow the DTD\n",
5471                                 NULL, NULL, NULL);
5472             }
5473         }
5474         ret = 0;
5475     }
5476     if (ret == -3)
5477         ret = 1;
5478
5479 #ifndef  LIBXML_REGEXP_ENABLED
5480 done:
5481     /*
5482      * Deallocate the copy if done, and free up the validation stack
5483      */
5484     while (repl != NULL) {
5485         tmp = repl->next;
5486         xmlFree(repl);
5487         repl = tmp;
5488     }
5489     ctxt->vstateMax = 0;
5490     if (ctxt->vstateTab != NULL) {
5491         xmlFree(ctxt->vstateTab);
5492         ctxt->vstateTab = NULL;
5493     }
5494 #endif
5495     ctxt->nodeMax = 0;
5496     ctxt->nodeNr = 0;
5497     if (ctxt->nodeTab != NULL) {
5498         xmlFree(ctxt->nodeTab);
5499         ctxt->nodeTab = NULL;
5500     }
5501     return(ret);
5502
5503 }
5504
5505 /**
5506  * xmlValidateCdataElement:
5507  * @ctxt:  the validation context
5508  * @doc:  a document instance
5509  * @elem:  an element instance
5510  *
5511  * Check that an element follows #CDATA
5512  *
5513  * returns 1 if valid or 0 otherwise
5514  */
5515 static int
5516 xmlValidateOneCdataElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5517                            xmlNodePtr elem) {
5518     int ret = 1;
5519     xmlNodePtr cur, child;
5520
5521     if ((ctxt == NULL) || (doc == NULL) || (elem == NULL) ||
5522         (elem->type != XML_ELEMENT_NODE))
5523         return(0);
5524
5525     child = elem->children;
5526
5527     cur = child;
5528     while (cur != NULL) {
5529         switch (cur->type) {
5530             case XML_ENTITY_REF_NODE:
5531                 /*
5532                  * Push the current node to be able to roll back
5533                  * and process within the entity
5534                  */
5535                 if ((cur->children != NULL) &&
5536                     (cur->children->children != NULL)) {
5537                     nodeVPush(ctxt, cur);
5538                     cur = cur->children->children;
5539                     continue;
5540                 }
5541                 break;
5542             case XML_COMMENT_NODE:
5543             case XML_PI_NODE:
5544             case XML_TEXT_NODE:
5545             case XML_CDATA_SECTION_NODE:
5546                 break;
5547             default:
5548                 ret = 0;
5549                 goto done;
5550         }
5551         /*
5552          * Switch to next element
5553          */
5554         cur = cur->next;
5555         while (cur == NULL) {
5556             cur = nodeVPop(ctxt);
5557             if (cur == NULL)
5558                 break;
5559             cur = cur->next;
5560         }
5561     }
5562 done:
5563     ctxt->nodeMax = 0;
5564     ctxt->nodeNr = 0;
5565     if (ctxt->nodeTab != NULL) {
5566         xmlFree(ctxt->nodeTab);
5567         ctxt->nodeTab = NULL;
5568     }
5569     return(ret);
5570 }
5571
5572 /**
5573  * xmlValidateCheckMixed:
5574  * @ctxt:  the validation context
5575  * @cont:  the mixed content model
5576  * @qname:  the qualified name as appearing in the serialization
5577  *
5578  * Check if the given node is part of the content model.
5579  *
5580  * Returns 1 if yes, 0 if no, -1 in case of error
5581  */
5582 static int
5583 xmlValidateCheckMixed(xmlValidCtxtPtr ctxt,
5584                       xmlElementContentPtr cont, const xmlChar *qname) {
5585     const xmlChar *name;
5586     int plen;
5587     name = xmlSplitQName3(qname, &plen);
5588
5589     if (name == NULL) {
5590         while (cont != NULL) {
5591             if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
5592                 if ((cont->prefix == NULL) && (xmlStrEqual(cont->name, qname)))
5593                     return(1);
5594             } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
5595                (cont->c1 != NULL) &&
5596                (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
5597                 if ((cont->c1->prefix == NULL) &&
5598                     (xmlStrEqual(cont->c1->name, qname)))
5599                     return(1);
5600             } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
5601                 (cont->c1 == NULL) ||
5602                 (cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
5603                 xmlErrValid(NULL, XML_DTD_MIXED_CORRUPT,
5604                         "Internal: MIXED struct corrupted\n",
5605                         NULL);
5606                 break;
5607             }
5608             cont = cont->c2;
5609         }
5610     } else {
5611         while (cont != NULL) {
5612             if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
5613                 if ((cont->prefix != NULL) &&
5614                     (xmlStrncmp(cont->prefix, qname, plen) == 0) &&
5615                     (xmlStrEqual(cont->name, name)))
5616                     return(1);
5617             } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
5618                (cont->c1 != NULL) &&
5619                (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
5620                 if ((cont->c1->prefix != NULL) &&
5621                     (xmlStrncmp(cont->c1->prefix, qname, plen) == 0) &&
5622                     (xmlStrEqual(cont->c1->name, name)))
5623                     return(1);
5624             } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
5625                 (cont->c1 == NULL) ||
5626                 (cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
5627                 xmlErrValid(ctxt, XML_DTD_MIXED_CORRUPT,
5628                         "Internal: MIXED struct corrupted\n",
5629                         NULL);
5630                 break;
5631             }
5632             cont = cont->c2;
5633         }
5634     }
5635     return(0);
5636 }
5637
5638 /**
5639  * xmlValidGetElemDecl:
5640  * @ctxt:  the validation context
5641  * @doc:  a document instance
5642  * @elem:  an element instance
5643  * @extsubset:  pointer, (out) indicate if the declaration was found
5644  *              in the external subset.
5645  *
5646  * Finds a declaration associated to an element in the document.
5647  *
5648  * returns the pointer to the declaration or NULL if not found.
5649  */
5650 static xmlElementPtr
5651 xmlValidGetElemDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5652                     xmlNodePtr elem, int *extsubset) {
5653     xmlElementPtr elemDecl = NULL;
5654     const xmlChar *prefix = NULL;
5655
5656     if ((ctxt == NULL) || (doc == NULL) ||
5657         (elem == NULL) || (elem->name == NULL))
5658         return(NULL);
5659     if (extsubset != NULL)
5660         *extsubset = 0;
5661
5662     /*
5663      * Fetch the declaration for the qualified name
5664      */
5665     if ((elem->ns != NULL) && (elem->ns->prefix != NULL))
5666         prefix = elem->ns->prefix;
5667
5668     if (prefix != NULL) {
5669         elemDecl = xmlGetDtdQElementDesc(doc->intSubset,
5670                                          elem->name, prefix);
5671         if ((elemDecl == NULL) && (doc->extSubset != NULL)) {
5672             elemDecl = xmlGetDtdQElementDesc(doc->extSubset,
5673                                              elem->name, prefix);
5674             if ((elemDecl != NULL) && (extsubset != NULL))
5675                 *extsubset = 1;
5676         }
5677     }
5678
5679     /*
5680      * Fetch the declaration for the non qualified name
5681      * This is "non-strict" validation should be done on the
5682      * full QName but in that case being flexible makes sense.
5683      */
5684     if (elemDecl == NULL) {
5685         elemDecl = xmlGetDtdElementDesc(doc->intSubset, elem->name);
5686         if ((elemDecl == NULL) && (doc->extSubset != NULL)) {
5687             elemDecl = xmlGetDtdElementDesc(doc->extSubset, elem->name);
5688             if ((elemDecl != NULL) && (extsubset != NULL))
5689                 *extsubset = 1;
5690         }
5691     }
5692     if (elemDecl == NULL) {
5693         xmlErrValidNode(ctxt, elem,
5694                         XML_DTD_UNKNOWN_ELEM,
5695                "No declaration for element %s\n",
5696                elem->name, NULL, NULL);
5697     }
5698     return(elemDecl);
5699 }
5700
5701 #ifdef LIBXML_REGEXP_ENABLED
5702 /**
5703  * xmlValidatePushElement:
5704  * @ctxt:  the validation context
5705  * @doc:  a document instance
5706  * @elem:  an element instance
5707  * @qname:  the qualified name as appearing in the serialization
5708  *
5709  * Push a new element start on the validation stack.
5710  *
5711  * returns 1 if no validation problem was found or 0 otherwise
5712  */
5713 int
5714 xmlValidatePushElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5715                        xmlNodePtr elem, const xmlChar *qname) {
5716     int ret = 1;
5717     xmlElementPtr eDecl;
5718     int extsubset = 0;
5719
5720     if (ctxt == NULL)
5721         return(0);
5722 /* printf("PushElem %s\n", qname); */
5723     if ((ctxt->vstateNr > 0) && (ctxt->vstate != NULL)) {
5724         xmlValidStatePtr state = ctxt->vstate;
5725         xmlElementPtr elemDecl;
5726
5727         /*
5728          * Check the new element agaisnt the content model of the new elem.
5729          */
5730         if (state->elemDecl != NULL) {
5731             elemDecl = state->elemDecl;
5732
5733             switch(elemDecl->etype) {
5734                 case XML_ELEMENT_TYPE_UNDEFINED:
5735                     ret = 0;
5736                     break;
5737                 case XML_ELEMENT_TYPE_EMPTY:
5738                     xmlErrValidNode(ctxt, state->node,
5739                                     XML_DTD_NOT_EMPTY,
5740                "Element %s was declared EMPTY this one has content\n",
5741                            state->node->name, NULL, NULL);
5742                     ret = 0;
5743                     break;
5744                 case XML_ELEMENT_TYPE_ANY:
5745                     /* I don't think anything is required then */
5746                     break;
5747                 case XML_ELEMENT_TYPE_MIXED:
5748                     /* simple case of declared as #PCDATA */
5749                     if ((elemDecl->content != NULL) &&
5750                         (elemDecl->content->type ==
5751                          XML_ELEMENT_CONTENT_PCDATA)) {
5752                         xmlErrValidNode(ctxt, state->node,
5753                                         XML_DTD_NOT_PCDATA,
5754                "Element %s was declared #PCDATA but contains non text nodes\n",
5755                                 state->node->name, NULL, NULL);
5756                         ret = 0;
5757                     } else {
5758                         ret = xmlValidateCheckMixed(ctxt, elemDecl->content,
5759                                                     qname);
5760                         if (ret != 1) {
5761                             xmlErrValidNode(ctxt, state->node,
5762                                             XML_DTD_INVALID_CHILD,
5763                "Element %s is not declared in %s list of possible children\n",
5764                                     qname, state->node->name, NULL);
5765                         }
5766                     }
5767                     break;
5768                 case XML_ELEMENT_TYPE_ELEMENT:
5769                     /*
5770                      * TODO:
5771                      * VC: Standalone Document Declaration
5772                      *     - element types with element content, if white space
5773                      *       occurs directly within any instance of those types.
5774                      */
5775                     if (state->exec != NULL) {
5776                         ret = xmlRegExecPushString(state->exec, qname, NULL);
5777                         if (ret < 0) {
5778                             xmlErrValidNode(ctxt, state->node,
5779                                             XML_DTD_CONTENT_MODEL,
5780                "Element %s content does not follow the DTD, Misplaced %s\n",
5781                                    state->node->name, qname, NULL);
5782                             ret = 0;
5783                         } else {
5784                             ret = 1;
5785                         }
5786                     }
5787                     break;
5788             }
5789         }
5790     }
5791     eDecl = xmlValidGetElemDecl(ctxt, doc, elem, &extsubset);
5792     vstateVPush(ctxt, eDecl, elem);
5793     return(ret);
5794 }
5795
5796 /**
5797  * xmlValidatePushCData:
5798  * @ctxt:  the validation context
5799  * @data:  some character data read
5800  * @len:  the length of the data
5801  *
5802  * check the CData parsed for validation in the current stack
5803  *
5804  * returns 1 if no validation problem was found or 0 otherwise
5805  */
5806 int
5807 xmlValidatePushCData(xmlValidCtxtPtr ctxt, const xmlChar *data, int len) {
5808     int ret = 1;
5809
5810 /* printf("CDATA %s %d\n", data, len); */
5811     if (ctxt == NULL)
5812         return(0);
5813     if (len <= 0)
5814         return(ret);
5815     if ((ctxt->vstateNr > 0) && (ctxt->vstate != NULL)) {
5816         xmlValidStatePtr state = ctxt->vstate;
5817         xmlElementPtr elemDecl;
5818
5819         /*
5820          * Check the new element agaisnt the content model of the new elem.
5821          */
5822         if (state->elemDecl != NULL) {
5823             elemDecl = state->elemDecl;
5824
5825             switch(elemDecl->etype) {
5826                 case XML_ELEMENT_TYPE_UNDEFINED:
5827                     ret = 0;
5828                     break;
5829                 case XML_ELEMENT_TYPE_EMPTY:
5830                     xmlErrValidNode(ctxt, state->node,
5831                                     XML_DTD_NOT_EMPTY,
5832                "Element %s was declared EMPTY this one has content\n",
5833                            state->node->name, NULL, NULL);
5834                     ret = 0;
5835                     break;
5836                 case XML_ELEMENT_TYPE_ANY:
5837                     break;
5838                 case XML_ELEMENT_TYPE_MIXED:
5839                     break;
5840                 case XML_ELEMENT_TYPE_ELEMENT:
5841                     if (len > 0) {
5842                         int i;
5843
5844                         for (i = 0;i < len;i++) {
5845                             if (!IS_BLANK_CH(data[i])) {
5846                                 xmlErrValidNode(ctxt, state->node,
5847                                                 XML_DTD_CONTENT_MODEL,
5848            "Element %s content does not follow the DTD, Text not allowed\n",
5849                                        state->node->name, NULL, NULL);
5850                                 ret = 0;
5851                                 goto done;
5852                             }
5853                         }
5854                         /*
5855                          * TODO:
5856                          * VC: Standalone Document Declaration
5857                          *  element types with element content, if white space
5858                          *  occurs directly within any instance of those types.
5859                          */
5860                     }
5861                     break;
5862             }
5863         }
5864     }
5865 done:
5866     return(ret);
5867 }
5868
5869 /**
5870  * xmlValidatePopElement:
5871  * @ctxt:  the validation context
5872  * @doc:  a document instance
5873  * @elem:  an element instance
5874  * @qname:  the qualified name as appearing in the serialization
5875  *
5876  * Pop the element end from the validation stack.
5877  *
5878  * returns 1 if no validation problem was found or 0 otherwise
5879  */
5880 int
5881 xmlValidatePopElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc ATTRIBUTE_UNUSED,
5882                       xmlNodePtr elem ATTRIBUTE_UNUSED,
5883                       const xmlChar *qname ATTRIBUTE_UNUSED) {
5884     int ret = 1;
5885
5886     if (ctxt == NULL)
5887         return(0);
5888 /* printf("PopElem %s\n", qname); */
5889     if ((ctxt->vstateNr > 0) && (ctxt->vstate != NULL)) {
5890         xmlValidStatePtr state = ctxt->vstate;
5891         xmlElementPtr elemDecl;
5892
5893         /*
5894          * Check the new element agaisnt the content model of the new elem.
5895          */
5896         if (state->elemDecl != NULL) {
5897             elemDecl = state->elemDecl;
5898
5899             if (elemDecl->etype == XML_ELEMENT_TYPE_ELEMENT) {
5900                 if (state->exec != NULL) {
5901                     ret = xmlRegExecPushString(state->exec, NULL, NULL);
5902                     if (ret == 0) {
5903                         xmlErrValidNode(ctxt, state->node,
5904                                         XML_DTD_CONTENT_MODEL,
5905            "Element %s content does not follow the DTD, Expecting more child\n",
5906                                state->node->name, NULL,NULL);
5907                     } else {
5908                         /*
5909                          * previous validation errors should not generate
5910                          * a new one here
5911                          */
5912                         ret = 1;
5913                     }
5914                 }
5915             }
5916         }
5917         vstateVPop(ctxt);
5918     }
5919     return(ret);
5920 }
5921 #endif /* LIBXML_REGEXP_ENABLED */
5922
5923 /**
5924  * xmlValidateOneElement:
5925  * @ctxt:  the validation context
5926  * @doc:  a document instance
5927  * @elem:  an element instance
5928  *
5929  * Try to validate a single element and it's attributes,
5930  * basically it does the following checks as described by the
5931  * XML-1.0 recommendation:
5932  *  - [ VC: Element Valid ]
5933  *  - [ VC: Required Attribute ]
5934  * Then call xmlValidateOneAttribute() for each attribute present.
5935  *
5936  * The ID/IDREF checkings are done separately
5937  *
5938  * returns 1 if valid or 0 otherwise
5939  */
5940
5941 int
5942 xmlValidateOneElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5943                       xmlNodePtr elem) {
5944     xmlElementPtr elemDecl = NULL;
5945     xmlElementContentPtr cont;
5946     xmlAttributePtr attr;
5947     xmlNodePtr child;
5948     int ret = 1, tmp;
5949     const xmlChar *name;
5950     int extsubset = 0;
5951
5952     CHECK_DTD;
5953
5954     if (elem == NULL) return(0);
5955     switch (elem->type) {
5956         case XML_ATTRIBUTE_NODE:
5957             xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5958                    "Attribute element not expected\n", NULL, NULL ,NULL);
5959             return(0);
5960         case XML_TEXT_NODE:
5961             if (elem->children != NULL) {
5962                 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5963                                 "Text element has children !\n",
5964                                 NULL,NULL,NULL);
5965                 return(0);
5966             }
5967             if (elem->ns != NULL) {
5968                 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5969                                 "Text element has namespace !\n",
5970                                 NULL,NULL,NULL);
5971                 return(0);
5972             }
5973             if (elem->content == NULL) {
5974                 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5975                                 "Text element has no content !\n",
5976                                 NULL,NULL,NULL);
5977                 return(0);
5978             }
5979             return(1);
5980         case XML_XINCLUDE_START:
5981         case XML_XINCLUDE_END:
5982             return(1);
5983         case XML_CDATA_SECTION_NODE:
5984         case XML_ENTITY_REF_NODE:
5985         case XML_PI_NODE:
5986         case XML_COMMENT_NODE:
5987             return(1);
5988         case XML_ENTITY_NODE:
5989             xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5990                    "Entity element not expected\n", NULL, NULL ,NULL);
5991             return(0);
5992         case XML_NOTATION_NODE:
5993             xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5994                    "Notation element not expected\n", NULL, NULL ,NULL);
5995             return(0);
5996         case XML_DOCUMENT_NODE:
5997         case XML_DOCUMENT_TYPE_NODE:
5998         case XML_DOCUMENT_FRAG_NODE:
5999             xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
6000                    "Document element not expected\n", NULL, NULL ,NULL);
6001             return(0);
6002         case XML_HTML_DOCUMENT_NODE:
6003             xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
6004                    "HTML Document not expected\n", NULL, NULL ,NULL);
6005             return(0);
6006         case XML_ELEMENT_NODE:
6007             break;
6008         default:
6009             xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
6010                    "unknown element type\n", NULL, NULL ,NULL);
6011             return(0);
6012     }
6013
6014     /*
6015      * Fetch the declaration
6016      */
6017     elemDecl = xmlValidGetElemDecl(ctxt, doc, elem, &extsubset);
6018     if (elemDecl == NULL)
6019         return(0);
6020
6021     /*
6022      * If vstateNr is not zero that means continuous validation is
6023      * activated, do not try to check the content model at that level.
6024      */
6025     if (ctxt->vstateNr == 0) {
6026     /* Check that the element content matches the definition */
6027     switch (elemDecl->etype) {
6028         case XML_ELEMENT_TYPE_UNDEFINED:
6029             xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ELEM,
6030                             "No declaration for element %s\n",
6031                    elem->name, NULL, NULL);
6032             return(0);
6033         case XML_ELEMENT_TYPE_EMPTY:
6034             if (elem->children != NULL) {
6035                 xmlErrValidNode(ctxt, elem, XML_DTD_NOT_EMPTY,
6036                "Element %s was declared EMPTY this one has content\n",
6037                        elem->name, NULL, NULL);
6038                 ret = 0;
6039             }
6040             break;
6041         case XML_ELEMENT_TYPE_ANY:
6042             /* I don't think anything is required then */
6043             break;
6044         case XML_ELEMENT_TYPE_MIXED:
6045
6046             /* simple case of declared as #PCDATA */
6047             if ((elemDecl->content != NULL) &&
6048                 (elemDecl->content->type == XML_ELEMENT_CONTENT_PCDATA)) {
6049                 ret = xmlValidateOneCdataElement(ctxt, doc, elem);
6050                 if (!ret) {
6051                     xmlErrValidNode(ctxt, elem, XML_DTD_NOT_PCDATA,
6052                "Element %s was declared #PCDATA but contains non text nodes\n",
6053                            elem->name, NULL, NULL);
6054                 }
6055                 break;
6056             }
6057             child = elem->children;
6058             /* Hum, this start to get messy */
6059             while (child != NULL) {
6060                 if (child->type == XML_ELEMENT_NODE) {
6061                     name = child->name;
6062                     if ((child->ns != NULL) && (child->ns->prefix != NULL)) {
6063                         xmlChar fn[50];
6064                         xmlChar *fullname;
6065
6066                         fullname = xmlBuildQName(child->name, child->ns->prefix,
6067                                                  fn, 50);
6068                         if (fullname == NULL)
6069                             return(0);
6070                         cont = elemDecl->content;
6071                         while (cont != NULL) {
6072                             if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
6073                                 if (xmlStrEqual(cont->name, fullname))
6074                                     break;
6075                             } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
6076                                (cont->c1 != NULL) &&
6077                                (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
6078                                 if (xmlStrEqual(cont->c1->name, fullname))
6079                                     break;
6080                             } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
6081                                 (cont->c1 == NULL) ||
6082                                 (cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
6083                                 xmlErrValid(NULL, XML_DTD_MIXED_CORRUPT,
6084                                         "Internal: MIXED struct corrupted\n",
6085                                         NULL);
6086                                 break;
6087                             }
6088                             cont = cont->c2;
6089                         }
6090                         if ((fullname != fn) && (fullname != child->name))
6091                             xmlFree(fullname);
6092                         if (cont != NULL)
6093                             goto child_ok;
6094                     }
6095                     cont = elemDecl->content;
6096                     while (cont != NULL) {
6097                         if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
6098                             if (xmlStrEqual(cont->name, name)) break;
6099                         } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
6100                            (cont->c1 != NULL) &&
6101                            (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)) {
6102                             if (xmlStrEqual(cont->c1->name, name)) break;
6103                         } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
6104                             (cont->c1 == NULL) ||
6105                             (cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)) {
6106                             xmlErrValid(ctxt, XML_DTD_MIXED_CORRUPT,
6107                                     "Internal: MIXED struct corrupted\n",
6108                                     NULL);
6109                             break;
6110                         }
6111                         cont = cont->c2;
6112                     }
6113                     if (cont == NULL) {
6114                         xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_CHILD,
6115                "Element %s is not declared in %s list of possible children\n",
6116                                name, elem->name, NULL);
6117                         ret = 0;
6118                     }
6119                 }
6120 child_ok:
6121                 child = child->next;
6122             }
6123             break;
6124         case XML_ELEMENT_TYPE_ELEMENT:
6125             if ((doc->standalone == 1) && (extsubset == 1)) {
6126                 /*
6127                  * VC: Standalone Document Declaration
6128                  *     - element types with element content, if white space
6129                  *       occurs directly within any instance of those types.
6130                  */
6131                 child = elem->children;
6132                 while (child != NULL) {
6133                     if (child->type == XML_TEXT_NODE) {
6134                         const xmlChar *content = child->content;
6135
6136                         while (IS_BLANK_CH(*content))
6137                             content++;
6138                         if (*content == 0) {
6139                             xmlErrValidNode(ctxt, elem,
6140                                             XML_DTD_STANDALONE_WHITE_SPACE,
6141 "standalone: %s declared in the external subset contains white spaces nodes\n",
6142                                    elem->name, NULL, NULL);
6143                             ret = 0;
6144                             break;
6145                         }
6146                     }
6147                     child =child->next;
6148                 }
6149             }
6150             child = elem->children;
6151             cont = elemDecl->content;
6152             tmp = xmlValidateElementContent(ctxt, child, elemDecl, 1, elem);
6153             if (tmp <= 0)
6154                 ret = tmp;
6155             break;
6156     }
6157     } /* not continuous */
6158
6159     /* [ VC: Required Attribute ] */
6160     attr = elemDecl->attributes;
6161     while (attr != NULL) {
6162         if (attr->def == XML_ATTRIBUTE_REQUIRED) {
6163             int qualified = -1;
6164
6165             if ((attr->prefix == NULL) &&
6166                 (xmlStrEqual(attr->name, BAD_CAST "xmlns"))) {
6167                 xmlNsPtr ns;
6168
6169                 ns = elem->nsDef;
6170                 while (ns != NULL) {
6171                     if (ns->prefix == NULL)
6172                         goto found;
6173                     ns = ns->next;
6174                 }
6175             } else if (xmlStrEqual(attr->prefix, BAD_CAST "xmlns")) {
6176                 xmlNsPtr ns;
6177
6178                 ns = elem->nsDef;
6179                 while (ns != NULL) {
6180                     if (xmlStrEqual(attr->name, ns->prefix))
6181                         goto found;
6182                     ns = ns->next;
6183                 }
6184             } else {
6185                 xmlAttrPtr attrib;
6186
6187                 attrib = elem->properties;
6188                 while (attrib != NULL) {
6189                     if (xmlStrEqual(attrib->name, attr->name)) {
6190                         if (attr->prefix != NULL) {
6191                             xmlNsPtr nameSpace = attrib->ns;
6192
6193                             if (nameSpace == NULL)
6194                                 nameSpace = elem->ns;
6195                             /*
6196                              * qualified names handling is problematic, having a
6197                              * different prefix should be possible but DTDs don't
6198                              * allow to define the URI instead of the prefix :-(
6199                              */
6200                             if (nameSpace == NULL) {
6201                                 if (qualified < 0)
6202                                     qualified = 0;
6203                             } else if (!xmlStrEqual(nameSpace->prefix,
6204                                                     attr->prefix)) {
6205                                 if (qualified < 1)
6206                                     qualified = 1;
6207                             } else
6208                                 goto found;
6209                         } else {
6210                             /*
6211                              * We should allow applications to define namespaces
6212                              * for their application even if the DTD doesn't
6213                              * carry one, otherwise, basically we would always
6214                              * break.
6215                              */
6216                             goto found;
6217                         }
6218                     }
6219                     attrib = attrib->next;
6220                 }
6221             }
6222             if (qualified == -1) {
6223                 if (attr->prefix == NULL) {
6224                     xmlErrValidNode(ctxt, elem, XML_DTD_MISSING_ATTRIBUTE,
6225                        "Element %s does not carry attribute %s\n",
6226                            elem->name, attr->name, NULL);
6227                     ret = 0;
6228                 } else {
6229                     xmlErrValidNode(ctxt, elem, XML_DTD_MISSING_ATTRIBUTE,
6230                        "Element %s does not carry attribute %s:%s\n",
6231                            elem->name, attr->prefix,attr->name);
6232                     ret = 0;
6233                 }
6234             } else if (qualified == 0) {
6235                 xmlErrValidWarning(ctxt, elem, XML_DTD_NO_PREFIX,
6236                    "Element %s required attribute %s:%s has no prefix\n",
6237                        elem->name, attr->prefix, attr->name);
6238             } else if (qualified == 1) {
6239                 xmlErrValidWarning(ctxt, elem, XML_DTD_DIFFERENT_PREFIX,
6240                    "Element %s required attribute %s:%s has different prefix\n",
6241                        elem->name, attr->prefix, attr->name);
6242             }
6243         } else if (attr->def == XML_ATTRIBUTE_FIXED) {
6244             /*
6245              * Special tests checking #FIXED namespace declarations
6246              * have the right value since this is not done as an
6247              * attribute checking
6248              */
6249             if ((attr->prefix == NULL) &&
6250                 (xmlStrEqual(attr->name, BAD_CAST "xmlns"))) {
6251                 xmlNsPtr ns;
6252
6253                 ns = elem->nsDef;
6254                 while (ns != NULL) {
6255                     if (ns->prefix == NULL) {
6256                         if (!xmlStrEqual(attr->defaultValue, ns->href)) {
6257                             xmlErrValidNode(ctxt, elem,
6258                                    XML_DTD_ELEM_DEFAULT_NAMESPACE,
6259    "Element %s namespace name for default namespace does not match the DTD\n",
6260                                    elem->name, NULL, NULL);
6261                             ret = 0;
6262                         }
6263                         goto found;
6264                     }
6265                     ns = ns->next;
6266                 }
6267             } else if (xmlStrEqual(attr->prefix, BAD_CAST "xmlns")) {
6268                 xmlNsPtr ns;
6269
6270                 ns = elem->nsDef;
6271                 while (ns != NULL) {
6272                     if (xmlStrEqual(attr->name, ns->prefix)) {
6273                         if (!xmlStrEqual(attr->defaultValue, ns->href)) {
6274                             xmlErrValidNode(ctxt, elem, XML_DTD_ELEM_NAMESPACE,
6275                    "Element %s namespace name for %s does not match the DTD\n",
6276                                    elem->name, ns->prefix, NULL);
6277                             ret = 0;
6278                         }
6279                         goto found;
6280                     }
6281                     ns = ns->next;
6282                 }
6283             }
6284         }
6285 found:
6286         attr = attr->nexth;
6287     }
6288     return(ret);
6289 }
6290
6291 /**
6292  * xmlValidateRoot:
6293  * @ctxt:  the validation context
6294  * @doc:  a document instance
6295  *
6296  * Try to validate a the root element
6297  * basically it does the following check as described by the
6298  * XML-1.0 recommendation:
6299  *  - [ VC: Root Element Type ]
6300  * it doesn't try to recurse or apply other check to the element
6301  *
6302  * returns 1 if valid or 0 otherwise
6303  */
6304
6305 int
6306 xmlValidateRoot(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6307     xmlNodePtr root;
6308     int ret;
6309
6310     if (doc == NULL) return(0);
6311
6312     root = xmlDocGetRootElement(doc);
6313     if ((root == NULL) || (root->name == NULL)) {
6314         xmlErrValid(ctxt, XML_DTD_NO_ROOT,
6315                     "no root element\n", NULL);
6316         return(0);
6317     }
6318
6319     /*
6320      * When doing post validation against a separate DTD, those may
6321      * no internal subset has been generated
6322      */
6323     if ((doc->intSubset != NULL) &&
6324         (doc->intSubset->name != NULL)) {
6325         /*
6326          * Check first the document root against the NQName
6327          */
6328         if (!xmlStrEqual(doc->intSubset->name, root->name)) {
6329             if ((root->ns != NULL) && (root->ns->prefix != NULL)) {
6330                 xmlChar fn[50];
6331                 xmlChar *fullname;
6332
6333                 fullname = xmlBuildQName(root->name, root->ns->prefix, fn, 50);
6334                 if (fullname == NULL) {
6335                     xmlVErrMemory(ctxt, NULL);
6336                     return(0);
6337                 }
6338                 ret = xmlStrEqual(doc->intSubset->name, fullname);
6339                 if ((fullname != fn) && (fullname != root->name))
6340                     xmlFree(fullname);
6341                 if (ret == 1)
6342                     goto name_ok;
6343             }
6344             if ((xmlStrEqual(doc->intSubset->name, BAD_CAST "HTML")) &&
6345                 (xmlStrEqual(root->name, BAD_CAST "html")))
6346                 goto name_ok;
6347             xmlErrValidNode(ctxt, root, XML_DTD_ROOT_NAME,
6348                    "root and DTD name do not match '%s' and '%s'\n",
6349                    root->name, doc->intSubset->name, NULL);
6350             return(0);
6351         }
6352     }
6353 name_ok:
6354     return(1);
6355 }
6356
6357
6358 /**
6359  * xmlValidateElement:
6360  * @ctxt:  the validation context
6361  * @doc:  a document instance
6362  * @elem:  an element instance
6363  *
6364  * Try to validate the subtree under an element
6365  *
6366  * returns 1 if valid or 0 otherwise
6367  */
6368
6369 int
6370 xmlValidateElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr elem) {
6371     xmlNodePtr child;
6372     xmlAttrPtr attr;
6373     xmlNsPtr ns;
6374     const xmlChar *value;
6375     int ret = 1;
6376
6377     if (elem == NULL) return(0);
6378
6379     /*
6380      * XInclude elements were added after parsing in the infoset,
6381      * they don't really mean anything validation wise.
6382      */
6383     if ((elem->type == XML_XINCLUDE_START) ||
6384         (elem->type == XML_XINCLUDE_END) ||
6385         (elem->type == XML_NAMESPACE_DECL))
6386         return(1);
6387
6388     CHECK_DTD;
6389
6390     /*
6391      * Entities references have to be handled separately
6392      */
6393     if (elem->type == XML_ENTITY_REF_NODE) {
6394         return(1);
6395     }
6396
6397     ret &= xmlValidateOneElement(ctxt, doc, elem);
6398     if (elem->type == XML_ELEMENT_NODE) {
6399         attr = elem->properties;
6400         while (attr != NULL) {
6401             value = xmlNodeListGetString(doc, attr->children, 0);
6402             ret &= xmlValidateOneAttribute(ctxt, doc, elem, attr, value);
6403             if (value != NULL)
6404                 xmlFree((char *)value);
6405             attr= attr->next;
6406         }
6407         ns = elem->nsDef;
6408         while (ns != NULL) {
6409             if (elem->ns == NULL)
6410                 ret &= xmlValidateOneNamespace(ctxt, doc, elem, NULL,
6411                                                ns, ns->href);
6412             else
6413                 ret &= xmlValidateOneNamespace(ctxt, doc, elem,
6414                                                elem->ns->prefix, ns, ns->href);
6415             ns = ns->next;
6416         }
6417     }
6418     child = elem->children;
6419     while (child != NULL) {
6420         ret &= xmlValidateElement(ctxt, doc, child);
6421         child = child->next;
6422     }
6423
6424     return(ret);
6425 }
6426
6427 /**
6428  * xmlValidateRef:
6429  * @ref:   A reference to be validated
6430  * @ctxt:  Validation context
6431  * @name:  Name of ID we are searching for
6432  *
6433  */
6434 static void
6435 xmlValidateRef(xmlRefPtr ref, xmlValidCtxtPtr ctxt,
6436                            const xmlChar *name) {
6437     xmlAttrPtr id;
6438     xmlAttrPtr attr;
6439
6440     if (ref == NULL)
6441         return;
6442     if ((ref->attr == NULL) && (ref->name == NULL))
6443         return;
6444     attr = ref->attr;
6445     if (attr == NULL) {
6446         xmlChar *dup, *str = NULL, *cur, save;
6447
6448         dup = xmlStrdup(name);
6449         if (dup == NULL) {
6450             ctxt->valid = 0;
6451             return;
6452         }
6453         cur = dup;
6454         while (*cur != 0) {
6455             str = cur;
6456             while ((*cur != 0) && (!IS_BLANK_CH(*cur))) cur++;
6457             save = *cur;
6458             *cur = 0;
6459             id = xmlGetID(ctxt->doc, str);
6460             if (id == NULL) {
6461                 xmlErrValidNodeNr(ctxt, NULL, XML_DTD_UNKNOWN_ID,
6462            "attribute %s line %d references an unknown ID \"%s\"\n",
6463                        ref->name, ref->lineno, str);
6464                 ctxt->valid = 0;
6465             }
6466             if (save == 0)
6467                 break;
6468             *cur = save;
6469             while (IS_BLANK_CH(*cur)) cur++;
6470         }
6471         xmlFree(dup);
6472     } else if (attr->atype == XML_ATTRIBUTE_IDREF) {
6473         id = xmlGetID(ctxt->doc, name);
6474         if (id == NULL) {
6475             xmlErrValidNode(ctxt, attr->parent, XML_DTD_UNKNOWN_ID,
6476            "IDREF attribute %s references an unknown ID \"%s\"\n",
6477                    attr->name, name, NULL);
6478             ctxt->valid = 0;
6479         }
6480     } else if (attr->atype == XML_ATTRIBUTE_IDREFS) {
6481         xmlChar *dup, *str = NULL, *cur, save;
6482
6483         dup = xmlStrdup(name);
6484         if (dup == NULL) {
6485             xmlVErrMemory(ctxt, "IDREFS split");
6486             ctxt->valid = 0;
6487             return;
6488         }
6489         cur = dup;
6490         while (*cur != 0) {
6491             str = cur;
6492             while ((*cur != 0) && (!IS_BLANK_CH(*cur))) cur++;
6493             save = *cur;
6494             *cur = 0;
6495             id = xmlGetID(ctxt->doc, str);
6496             if (id == NULL) {
6497                 xmlErrValidNode(ctxt, attr->parent, XML_DTD_UNKNOWN_ID,
6498            "IDREFS attribute %s references an unknown ID \"%s\"\n",
6499                              attr->name, str, NULL);
6500                 ctxt->valid = 0;
6501             }
6502             if (save == 0)
6503                 break;
6504             *cur = save;
6505             while (IS_BLANK_CH(*cur)) cur++;
6506         }
6507         xmlFree(dup);
6508     }
6509 }
6510
6511 /**
6512  * xmlWalkValidateList:
6513  * @data:  Contents of current link
6514  * @user:  Value supplied by the user
6515  *
6516  * Returns 0 to abort the walk or 1 to continue
6517  */
6518 static int
6519 xmlWalkValidateList(const void *data, const void *user)
6520 {
6521         xmlValidateMemoPtr memo = (xmlValidateMemoPtr)user;
6522         xmlValidateRef((xmlRefPtr)data, memo->ctxt, memo->name);
6523         return 1;
6524 }
6525
6526 /**
6527  * xmlValidateCheckRefCallback:
6528  * @ref_list:  List of references
6529  * @ctxt:  Validation context
6530  * @name:  Name of ID we are searching for
6531  *
6532  */
6533 static void
6534 xmlValidateCheckRefCallback(xmlListPtr ref_list, xmlValidCtxtPtr ctxt,
6535                            const xmlChar *name) {
6536     xmlValidateMemo memo;
6537
6538     if (ref_list == NULL)
6539         return;
6540     memo.ctxt = ctxt;
6541     memo.name = name;
6542
6543     xmlListWalk(ref_list, xmlWalkValidateList, &memo);
6544
6545 }
6546
6547 /**
6548  * xmlValidateDocumentFinal:
6549  * @ctxt:  the validation context
6550  * @doc:  a document instance
6551  *
6552  * Does the final step for the document validation once all the
6553  * incremental validation steps have been completed
6554  *
6555  * basically it does the following checks described by the XML Rec
6556  *
6557  * Check all the IDREF/IDREFS attributes definition for validity
6558  *
6559  * returns 1 if valid or 0 otherwise
6560  */
6561
6562 int
6563 xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6564     xmlRefTablePtr table;
6565     unsigned int save;
6566
6567     if (ctxt == NULL)
6568         return(0);
6569     if (doc == NULL) {
6570         xmlErrValid(ctxt, XML_DTD_NO_DOC,
6571                 "xmlValidateDocumentFinal: doc == NULL\n", NULL);
6572         return(0);
6573     }
6574
6575     /* trick to get correct line id report */
6576     save = ctxt->finishDtd;
6577     ctxt->finishDtd = 0;
6578
6579     /*
6580      * Check all the NOTATION/NOTATIONS attributes
6581      */
6582     /*
6583      * Check all the ENTITY/ENTITIES attributes definition for validity
6584      */
6585     /*
6586      * Check all the IDREF/IDREFS attributes definition for validity
6587      */
6588     table = (xmlRefTablePtr) doc->refs;
6589     ctxt->doc = doc;
6590     ctxt->valid = 1;
6591     xmlHashScan(table, (xmlHashScanner) xmlValidateCheckRefCallback, ctxt);
6592
6593     ctxt->finishDtd = save;
6594     return(ctxt->valid);
6595 }
6596
6597 /**
6598  * xmlValidateDtd:
6599  * @ctxt:  the validation context
6600  * @doc:  a document instance
6601  * @dtd:  a dtd instance
6602  *
6603  * Try to validate the document against the dtd instance
6604  *
6605  * Basically it does check all the definitions in the DtD.
6606  * Note the the internal subset (if present) is de-coupled
6607  * (i.e. not used), which could give problems if ID or IDREF
6608  * is present.
6609  *
6610  * returns 1 if valid or 0 otherwise
6611  */
6612
6613 int
6614 xmlValidateDtd(xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlDtdPtr dtd) {
6615     int ret;
6616     xmlDtdPtr oldExt, oldInt;
6617     xmlNodePtr root;
6618
6619     if (dtd == NULL) return(0);
6620     if (doc == NULL) return(0);
6621     oldExt = doc->extSubset;
6622     oldInt = doc->intSubset;
6623     doc->extSubset = dtd;
6624     doc->intSubset = NULL;
6625     ret = xmlValidateRoot(ctxt, doc);
6626     if (ret == 0) {
6627         doc->extSubset = oldExt;
6628         doc->intSubset = oldInt;
6629         return(ret);
6630     }
6631     if (doc->ids != NULL) {
6632           xmlFreeIDTable(doc->ids);
6633           doc->ids = NULL;
6634     }
6635     if (doc->refs != NULL) {
6636           xmlFreeRefTable(doc->refs);
6637           doc->refs = NULL;
6638     }
6639     root = xmlDocGetRootElement(doc);
6640     ret = xmlValidateElement(ctxt, doc, root);
6641     ret &= xmlValidateDocumentFinal(ctxt, doc);
6642     doc->extSubset = oldExt;
6643     doc->intSubset = oldInt;
6644     return(ret);
6645 }
6646
6647 static void
6648 xmlValidateNotationCallback(xmlEntityPtr cur, xmlValidCtxtPtr ctxt,
6649                             const xmlChar *name ATTRIBUTE_UNUSED) {
6650     if (cur == NULL)
6651         return;
6652     if (cur->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
6653         xmlChar *notation = cur->content;
6654
6655         if (notation != NULL) {
6656             int ret;
6657
6658             ret = xmlValidateNotationUse(ctxt, cur->doc, notation);
6659             if (ret != 1) {
6660                 ctxt->valid = 0;
6661             }
6662         }
6663     }
6664 }
6665
6666 static void
6667 xmlValidateAttributeCallback(xmlAttributePtr cur, xmlValidCtxtPtr ctxt,
6668                             const xmlChar *name ATTRIBUTE_UNUSED) {
6669     int ret;
6670     xmlDocPtr doc;
6671     xmlElementPtr elem = NULL;
6672
6673     if (cur == NULL)
6674         return;
6675     switch (cur->atype) {
6676         case XML_ATTRIBUTE_CDATA:
6677         case XML_ATTRIBUTE_ID:
6678         case XML_ATTRIBUTE_IDREF        :
6679         case XML_ATTRIBUTE_IDREFS:
6680         case XML_ATTRIBUTE_NMTOKEN:
6681         case XML_ATTRIBUTE_NMTOKENS:
6682         case XML_ATTRIBUTE_ENUMERATION:
6683             break;
6684         case XML_ATTRIBUTE_ENTITY:
6685         case XML_ATTRIBUTE_ENTITIES:
6686         case XML_ATTRIBUTE_NOTATION:
6687             if (cur->defaultValue != NULL) {
6688
6689                 ret = xmlValidateAttributeValue2(ctxt, ctxt->doc, cur->name,
6690                                                  cur->atype, cur->defaultValue);
6691                 if ((ret == 0) && (ctxt->valid == 1))
6692                     ctxt->valid = 0;
6693             }
6694             if (cur->tree != NULL) {
6695                 xmlEnumerationPtr tree = cur->tree;
6696                 while (tree != NULL) {
6697                     ret = xmlValidateAttributeValue2(ctxt, ctxt->doc,
6698                                     cur->name, cur->atype, tree->name);
6699                     if ((ret == 0) && (ctxt->valid == 1))
6700                         ctxt->valid = 0;
6701                     tree = tree->next;
6702                 }
6703             }
6704     }
6705     if (cur->atype == XML_ATTRIBUTE_NOTATION) {
6706         doc = cur->doc;
6707         if (cur->elem == NULL) {
6708             xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
6709                    "xmlValidateAttributeCallback(%s): internal error\n",
6710                    (const char *) cur->name);
6711             return;
6712         }
6713
6714         if (doc != NULL)
6715             elem = xmlGetDtdElementDesc(doc->intSubset, cur->elem);
6716         if ((elem == NULL) && (doc != NULL))
6717             elem = xmlGetDtdElementDesc(doc->extSubset, cur->elem);
6718         if ((elem == NULL) && (cur->parent != NULL) &&
6719             (cur->parent->type == XML_DTD_NODE))
6720             elem = xmlGetDtdElementDesc((xmlDtdPtr) cur->parent, cur->elem);
6721         if (elem == NULL) {
6722             xmlErrValidNode(ctxt, NULL, XML_DTD_UNKNOWN_ELEM,
6723                    "attribute %s: could not find decl for element %s\n",
6724                    cur->name, cur->elem, NULL);
6725             return;
6726         }
6727         if (elem->etype == XML_ELEMENT_TYPE_EMPTY) {
6728             xmlErrValidNode(ctxt, NULL, XML_DTD_EMPTY_NOTATION,
6729                    "NOTATION attribute %s declared for EMPTY element %s\n",
6730                    cur->name, cur->elem, NULL);
6731             ctxt->valid = 0;
6732         }
6733     }
6734 }
6735
6736 /**
6737  * xmlValidateDtdFinal:
6738  * @ctxt:  the validation context
6739  * @doc:  a document instance
6740  *
6741  * Does the final step for the dtds validation once all the
6742  * subsets have been parsed
6743  *
6744  * basically it does the following checks described by the XML Rec
6745  * - check that ENTITY and ENTITIES type attributes default or
6746  *   possible values matches one of the defined entities.
6747  * - check that NOTATION type attributes default or
6748  *   possible values matches one of the defined notations.
6749  *
6750  * returns 1 if valid or 0 if invalid and -1 if not well-formed
6751  */
6752
6753 int
6754 xmlValidateDtdFinal(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6755     xmlDtdPtr dtd;
6756     xmlAttributeTablePtr table;
6757     xmlEntitiesTablePtr entities;
6758
6759     if ((doc == NULL) || (ctxt == NULL)) return(0);
6760     if ((doc->intSubset == NULL) && (doc->extSubset == NULL))
6761         return(0);
6762     ctxt->doc = doc;
6763     ctxt->valid = 1;
6764     dtd = doc->intSubset;
6765     if ((dtd != NULL) && (dtd->attributes != NULL)) {
6766         table = (xmlAttributeTablePtr) dtd->attributes;
6767         xmlHashScan(table, (xmlHashScanner) xmlValidateAttributeCallback, ctxt);
6768     }
6769     if ((dtd != NULL) && (dtd->entities != NULL)) {
6770         entities = (xmlEntitiesTablePtr) dtd->entities;
6771         xmlHashScan(entities, (xmlHashScanner) xmlValidateNotationCallback,
6772                     ctxt);
6773     }
6774     dtd = doc->extSubset;
6775     if ((dtd != NULL) && (dtd->attributes != NULL)) {
6776         table = (xmlAttributeTablePtr) dtd->attributes;
6777         xmlHashScan(table, (xmlHashScanner) xmlValidateAttributeCallback, ctxt);
6778     }
6779     if ((dtd != NULL) && (dtd->entities != NULL)) {
6780         entities = (xmlEntitiesTablePtr) dtd->entities;
6781         xmlHashScan(entities, (xmlHashScanner) xmlValidateNotationCallback,
6782                     ctxt);
6783     }
6784     return(ctxt->valid);
6785 }
6786
6787 /**
6788  * xmlValidateDocument:
6789  * @ctxt:  the validation context
6790  * @doc:  a document instance
6791  *
6792  * Try to validate the document instance
6793  *
6794  * basically it does the all the checks described by the XML Rec
6795  * i.e. validates the internal and external subset (if present)
6796  * and validate the document tree.
6797  *
6798  * returns 1 if valid or 0 otherwise
6799  */
6800
6801 int
6802 xmlValidateDocument(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6803     int ret;
6804     xmlNodePtr root;
6805
6806     if (doc == NULL)
6807         return(0);
6808     if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
6809         xmlErrValid(ctxt, XML_DTD_NO_DTD,
6810                     "no DTD found!\n", NULL);
6811         return(0);
6812     }
6813     if ((doc->intSubset != NULL) && ((doc->intSubset->SystemID != NULL) ||
6814         (doc->intSubset->ExternalID != NULL)) && (doc->extSubset == NULL)) {
6815         xmlChar *sysID;
6816         if (doc->intSubset->SystemID != NULL) {
6817             sysID = xmlBuildURI(doc->intSubset->SystemID,
6818                         doc->URL);
6819             if (sysID == NULL) {
6820                 xmlErrValid(ctxt, XML_DTD_LOAD_ERROR,
6821                         "Could not build URI for external subset \"%s\"\n",
6822                         (const char *) doc->intSubset->SystemID);
6823                 return 0;
6824             }
6825         } else
6826             sysID = NULL;
6827         doc->extSubset = xmlParseDTD(doc->intSubset->ExternalID,
6828                         (const xmlChar *)sysID);
6829         if (sysID != NULL)
6830             xmlFree(sysID);
6831         if (doc->extSubset == NULL) {
6832             if (doc->intSubset->SystemID != NULL) {
6833                 xmlErrValid(ctxt, XML_DTD_LOAD_ERROR,
6834                        "Could not load the external subset \"%s\"\n",
6835                        (const char *) doc->intSubset->SystemID);
6836             } else {
6837                 xmlErrValid(ctxt, XML_DTD_LOAD_ERROR,
6838                        "Could not load the external subset \"%s\"\n",
6839                        (const char *) doc->intSubset->ExternalID);
6840             }
6841             return(0);
6842         }
6843     }
6844
6845     if (doc->ids != NULL) {
6846           xmlFreeIDTable(doc->ids);
6847           doc->ids = NULL;
6848     }
6849     if (doc->refs != NULL) {
6850           xmlFreeRefTable(doc->refs);
6851           doc->refs = NULL;
6852     }
6853     ret = xmlValidateDtdFinal(ctxt, doc);
6854     if (!xmlValidateRoot(ctxt, doc)) return(0);
6855
6856     root = xmlDocGetRootElement(doc);
6857     ret &= xmlValidateElement(ctxt, doc, root);
6858     ret &= xmlValidateDocumentFinal(ctxt, doc);
6859     return(ret);
6860 }
6861
6862 /************************************************************************
6863  *                                                                      *
6864  *              Routines for dynamic validation editing                 *
6865  *                                                                      *
6866  ************************************************************************/
6867
6868 /**
6869  * xmlValidGetPotentialChildren:
6870  * @ctree:  an element content tree
6871  * @names:  an array to store the list of child names
6872  * @len:  a pointer to the number of element in the list
6873  * @max:  the size of the array
6874  *
6875  * Build/extend a list of  potential children allowed by the content tree
6876  *
6877  * returns the number of element in the list, or -1 in case of error.
6878  */
6879
6880 int
6881 xmlValidGetPotentialChildren(xmlElementContent *ctree,
6882                              const xmlChar **names,
6883                              int *len, int max) {
6884     int i;
6885
6886     if ((ctree == NULL) || (names == NULL) || (len == NULL))
6887         return(-1);
6888     if (*len >= max) return(*len);
6889
6890     switch (ctree->type) {
6891         case XML_ELEMENT_CONTENT_PCDATA:
6892             for (i = 0; i < *len;i++)
6893                 if (xmlStrEqual(BAD_CAST "#PCDATA", names[i])) return(*len);
6894             names[(*len)++] = BAD_CAST "#PCDATA";
6895             break;
6896         case XML_ELEMENT_CONTENT_ELEMENT:
6897             for (i = 0; i < *len;i++)
6898                 if (xmlStrEqual(ctree->name, names[i])) return(*len);
6899             names[(*len)++] = ctree->name;
6900             break;
6901         case XML_ELEMENT_CONTENT_SEQ:
6902             xmlValidGetPotentialChildren(ctree->c1, names, len, max);
6903             xmlValidGetPotentialChildren(ctree->c2, names, len, max);
6904             break;
6905         case XML_ELEMENT_CONTENT_OR:
6906             xmlValidGetPotentialChildren(ctree->c1, names, len, max);
6907             xmlValidGetPotentialChildren(ctree->c2, names, len, max);
6908             break;
6909    }
6910
6911    return(*len);
6912 }
6913
6914 /*
6915  * Dummy function to suppress messages while we try out valid elements
6916  */
6917 static void XMLCDECL xmlNoValidityErr(void *ctx ATTRIBUTE_UNUSED,
6918                                 const char *msg ATTRIBUTE_UNUSED, ...) {
6919     return;
6920 }
6921
6922 /**
6923  * xmlValidGetValidElements:
6924  * @prev:  an element to insert after
6925  * @next:  an element to insert next
6926  * @names:  an array to store the list of child names
6927  * @max:  the size of the array
6928  *
6929  * This function returns the list of authorized children to insert
6930  * within an existing tree while respecting the validity constraints
6931  * forced by the Dtd. The insertion point is defined using @prev and
6932  * @next in the following ways:
6933  *  to insert before 'node': xmlValidGetValidElements(node->prev, node, ...
6934  *  to insert next 'node': xmlValidGetValidElements(node, node->next, ...
6935  *  to replace 'node': xmlValidGetValidElements(node->prev, node->next, ...
6936  *  to prepend a child to 'node': xmlValidGetValidElements(NULL, node->childs,
6937  *  to append a child to 'node': xmlValidGetValidElements(node->last, NULL, ...
6938  *
6939  * pointers to the element names are inserted at the beginning of the array
6940  * and do not need to be freed.
6941  *
6942  * returns the number of element in the list, or -1 in case of error. If
6943  *    the function returns the value @max the caller is invited to grow the
6944  *    receiving array and retry.
6945  */
6946
6947 int
6948 xmlValidGetValidElements(xmlNode *prev, xmlNode *next, const xmlChar **names,
6949                          int max) {
6950     xmlValidCtxt vctxt;
6951     int nb_valid_elements = 0;
6952     const xmlChar *elements[256]={0};
6953     int nb_elements = 0, i;
6954     const xmlChar *name;
6955
6956     xmlNode *ref_node;
6957     xmlNode *parent;
6958     xmlNode *test_node;
6959
6960     xmlNode *prev_next;
6961     xmlNode *next_prev;
6962     xmlNode *parent_childs;
6963     xmlNode *parent_last;
6964
6965     xmlElement *element_desc;
6966
6967     if (prev == NULL && next == NULL)
6968         return(-1);
6969
6970     if (names == NULL) return(-1);
6971     if (max <= 0) return(-1);
6972
6973     memset(&vctxt, 0, sizeof (xmlValidCtxt));
6974     vctxt.error = xmlNoValidityErr;     /* this suppresses err/warn output */
6975
6976     nb_valid_elements = 0;
6977     ref_node = prev ? prev : next;
6978     parent = ref_node->parent;
6979
6980     /*
6981      * Retrieves the parent element declaration
6982      */
6983     element_desc = xmlGetDtdElementDesc(parent->doc->intSubset,
6984                                          parent->name);
6985     if ((element_desc == NULL) && (parent->doc->extSubset != NULL))
6986         element_desc = xmlGetDtdElementDesc(parent->doc->extSubset,
6987                                              parent->name);
6988     if (element_desc == NULL) return(-1);
6989
6990     /*
6991      * Do a backup of the current tree structure
6992      */
6993     prev_next = prev ? prev->next : NULL;
6994     next_prev = next ? next->prev : NULL;
6995     parent_childs = parent->children;
6996     parent_last = parent->last;
6997
6998     /*
6999      * Creates a dummy node and insert it into the tree
7000      */
7001     test_node = xmlNewDocNode (ref_node->doc, NULL, BAD_CAST "<!dummy?>", NULL);
7002     if (test_node == NULL)
7003         return(-1);
7004
7005     test_node->parent = parent;
7006     test_node->prev = prev;
7007     test_node->next = next;
7008     name = test_node->name;
7009
7010     if (prev) prev->next = test_node;
7011     else parent->children = test_node;
7012
7013     if (next) next->prev = test_node;
7014     else parent->last = test_node;
7015
7016     /*
7017      * Insert each potential child node and check if the parent is
7018      * still valid
7019      */
7020     nb_elements = xmlValidGetPotentialChildren(element_desc->content,
7021                        elements, &nb_elements, 256);
7022
7023     for (i = 0;i < nb_elements;i++) {
7024         test_node->name = elements[i];
7025         if (xmlValidateOneElement(&vctxt, parent->doc, parent)) {
7026             int j;
7027
7028             for (j = 0; j < nb_valid_elements;j++)
7029                 if (xmlStrEqual(elements[i], names[j])) break;
7030             names[nb_valid_elements++] = elements[i];
7031             if (nb_valid_elements >= max) break;
7032         }
7033     }
7034
7035     /*
7036      * Restore the tree structure
7037      */
7038     if (prev) prev->next = prev_next;
7039     if (next) next->prev = next_prev;
7040     parent->children = parent_childs;
7041     parent->last = parent_last;
7042
7043     /*
7044      * Free up the dummy node
7045      */
7046     test_node->name = name;
7047     xmlFreeNode(test_node);
7048
7049     return(nb_valid_elements);
7050 }
7051 #endif /* LIBXML_VALID_ENABLED */
7052
7053 #define bottom_valid
7054 #include "elfgcchack.h"