[LIBXML2] Update to version 2.9.8. CORE-15280
[reactos.git] / sdk / lib / 3rdparty / libxml2 / 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 *) str2,
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 *) str2,
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 != NULL) &&
1176 ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1177 (content->c1->type == XML_ELEMENT_CONTENT_SEQ)))
1178 xmlDumpElementContent(buf, content->c1, 1);
1179 else
1180 xmlDumpElementContent(buf, content->c1, 0);
1181 xmlBufferWriteChar(buf, " , ");
1182 if ((content->c2 != NULL) &&
1183 ((content->c2->type == XML_ELEMENT_CONTENT_OR) ||
1184 ((content->c2->type == XML_ELEMENT_CONTENT_SEQ) &&
1185 (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE))))
1186 xmlDumpElementContent(buf, content->c2, 1);
1187 else
1188 xmlDumpElementContent(buf, content->c2, 0);
1189 break;
1190 case XML_ELEMENT_CONTENT_OR:
1191 if ((content->c1 != NULL) &&
1192 ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1193 (content->c1->type == XML_ELEMENT_CONTENT_SEQ)))
1194 xmlDumpElementContent(buf, content->c1, 1);
1195 else
1196 xmlDumpElementContent(buf, content->c1, 0);
1197 xmlBufferWriteChar(buf, " | ");
1198 if ((content->c2 != NULL) &&
1199 ((content->c2->type == XML_ELEMENT_CONTENT_SEQ) ||
1200 ((content->c2->type == XML_ELEMENT_CONTENT_OR) &&
1201 (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE))))
1202 xmlDumpElementContent(buf, content->c2, 1);
1203 else
1204 xmlDumpElementContent(buf, content->c2, 0);
1205 break;
1206 default:
1207 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
1208 "Internal: ELEMENT content corrupted invalid type\n",
1209 NULL);
1210 }
1211 if (glob)
1212 xmlBufferWriteChar(buf, ")");
1213 switch (content->ocur) {
1214 case XML_ELEMENT_CONTENT_ONCE:
1215 break;
1216 case XML_ELEMENT_CONTENT_OPT:
1217 xmlBufferWriteChar(buf, "?");
1218 break;
1219 case XML_ELEMENT_CONTENT_MULT:
1220 xmlBufferWriteChar(buf, "*");
1221 break;
1222 case XML_ELEMENT_CONTENT_PLUS:
1223 xmlBufferWriteChar(buf, "+");
1224 break;
1225 }
1226 }
1227
1228 /**
1229 * xmlSprintfElementContent:
1230 * @buf: an output buffer
1231 * @content: An element table
1232 * @englob: 1 if one must print the englobing parenthesis, 0 otherwise
1233 *
1234 * Deprecated, unsafe, use xmlSnprintfElementContent
1235 */
1236 void
1237 xmlSprintfElementContent(char *buf ATTRIBUTE_UNUSED,
1238 xmlElementContentPtr content ATTRIBUTE_UNUSED,
1239 int englob ATTRIBUTE_UNUSED) {
1240 }
1241 #endif /* LIBXML_OUTPUT_ENABLED */
1242
1243 /**
1244 * xmlSnprintfElementContent:
1245 * @buf: an output buffer
1246 * @size: the buffer size
1247 * @content: An element table
1248 * @englob: 1 if one must print the englobing parenthesis, 0 otherwise
1249 *
1250 * This will dump the content of the element content definition
1251 * Intended just for the debug routine
1252 */
1253 void
1254 xmlSnprintfElementContent(char *buf, int size, xmlElementContentPtr content, int englob) {
1255 int len;
1256
1257 if (content == NULL) return;
1258 len = strlen(buf);
1259 if (size - len < 50) {
1260 if ((size - len > 4) && (buf[len - 1] != '.'))
1261 strcat(buf, " ...");
1262 return;
1263 }
1264 if (englob) strcat(buf, "(");
1265 switch (content->type) {
1266 case XML_ELEMENT_CONTENT_PCDATA:
1267 strcat(buf, "#PCDATA");
1268 break;
1269 case XML_ELEMENT_CONTENT_ELEMENT: {
1270 int qnameLen = xmlStrlen(content->name);
1271
1272 if (content->prefix != NULL)
1273 qnameLen += xmlStrlen(content->prefix) + 1;
1274 if (size - len < qnameLen + 10) {
1275 strcat(buf, " ...");
1276 return;
1277 }
1278 if (content->prefix != NULL) {
1279 strcat(buf, (char *) content->prefix);
1280 strcat(buf, ":");
1281 }
1282 if (content->name != NULL)
1283 strcat(buf, (char *) content->name);
1284 break;
1285 }
1286 case XML_ELEMENT_CONTENT_SEQ:
1287 if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1288 (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
1289 xmlSnprintfElementContent(buf, size, content->c1, 1);
1290 else
1291 xmlSnprintfElementContent(buf, size, content->c1, 0);
1292 len = strlen(buf);
1293 if (size - len < 50) {
1294 if ((size - len > 4) && (buf[len - 1] != '.'))
1295 strcat(buf, " ...");
1296 return;
1297 }
1298 strcat(buf, " , ");
1299 if (((content->c2->type == XML_ELEMENT_CONTENT_OR) ||
1300 (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)) &&
1301 (content->c2->type != XML_ELEMENT_CONTENT_ELEMENT))
1302 xmlSnprintfElementContent(buf, size, content->c2, 1);
1303 else
1304 xmlSnprintfElementContent(buf, size, content->c2, 0);
1305 break;
1306 case XML_ELEMENT_CONTENT_OR:
1307 if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1308 (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
1309 xmlSnprintfElementContent(buf, size, content->c1, 1);
1310 else
1311 xmlSnprintfElementContent(buf, size, content->c1, 0);
1312 len = strlen(buf);
1313 if (size - len < 50) {
1314 if ((size - len > 4) && (buf[len - 1] != '.'))
1315 strcat(buf, " ...");
1316 return;
1317 }
1318 strcat(buf, " | ");
1319 if (((content->c2->type == XML_ELEMENT_CONTENT_SEQ) ||
1320 (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)) &&
1321 (content->c2->type != XML_ELEMENT_CONTENT_ELEMENT))
1322 xmlSnprintfElementContent(buf, size, content->c2, 1);
1323 else
1324 xmlSnprintfElementContent(buf, size, content->c2, 0);
1325 break;
1326 }
1327 if (size - strlen(buf) <= 2) return;
1328 if (englob)
1329 strcat(buf, ")");
1330 switch (content->ocur) {
1331 case XML_ELEMENT_CONTENT_ONCE:
1332 break;
1333 case XML_ELEMENT_CONTENT_OPT:
1334 strcat(buf, "?");
1335 break;
1336 case XML_ELEMENT_CONTENT_MULT:
1337 strcat(buf, "*");
1338 break;
1339 case XML_ELEMENT_CONTENT_PLUS:
1340 strcat(buf, "+");
1341 break;
1342 }
1343 }
1344
1345 /****************************************************************
1346 * *
1347 * Registration of DTD declarations *
1348 * *
1349 ****************************************************************/
1350
1351 /**
1352 * xmlFreeElement:
1353 * @elem: An element
1354 *
1355 * Deallocate the memory used by an element definition
1356 */
1357 static void
1358 xmlFreeElement(xmlElementPtr elem) {
1359 if (elem == NULL) return;
1360 xmlUnlinkNode((xmlNodePtr) elem);
1361 xmlFreeDocElementContent(elem->doc, elem->content);
1362 if (elem->name != NULL)
1363 xmlFree((xmlChar *) elem->name);
1364 if (elem->prefix != NULL)
1365 xmlFree((xmlChar *) elem->prefix);
1366 #ifdef LIBXML_REGEXP_ENABLED
1367 if (elem->contModel != NULL)
1368 xmlRegFreeRegexp(elem->contModel);
1369 #endif
1370 xmlFree(elem);
1371 }
1372
1373
1374 /**
1375 * xmlAddElementDecl:
1376 * @ctxt: the validation context
1377 * @dtd: pointer to the DTD
1378 * @name: the entity name
1379 * @type: the element type
1380 * @content: the element content tree or NULL
1381 *
1382 * Register a new element declaration
1383 *
1384 * Returns NULL if not, otherwise the entity
1385 */
1386 xmlElementPtr
1387 xmlAddElementDecl(xmlValidCtxtPtr ctxt,
1388 xmlDtdPtr dtd, const xmlChar *name,
1389 xmlElementTypeVal type,
1390 xmlElementContentPtr content) {
1391 xmlElementPtr ret;
1392 xmlElementTablePtr table;
1393 xmlAttributePtr oldAttributes = NULL;
1394 xmlChar *ns, *uqname;
1395
1396 if (dtd == NULL) {
1397 return(NULL);
1398 }
1399 if (name == NULL) {
1400 return(NULL);
1401 }
1402
1403 switch (type) {
1404 case XML_ELEMENT_TYPE_EMPTY:
1405 if (content != NULL) {
1406 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1407 "xmlAddElementDecl: content != NULL for EMPTY\n",
1408 NULL);
1409 return(NULL);
1410 }
1411 break;
1412 case XML_ELEMENT_TYPE_ANY:
1413 if (content != NULL) {
1414 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1415 "xmlAddElementDecl: content != NULL for ANY\n",
1416 NULL);
1417 return(NULL);
1418 }
1419 break;
1420 case XML_ELEMENT_TYPE_MIXED:
1421 if (content == NULL) {
1422 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1423 "xmlAddElementDecl: content == NULL for MIXED\n",
1424 NULL);
1425 return(NULL);
1426 }
1427 break;
1428 case XML_ELEMENT_TYPE_ELEMENT:
1429 if (content == NULL) {
1430 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1431 "xmlAddElementDecl: content == NULL for ELEMENT\n",
1432 NULL);
1433 return(NULL);
1434 }
1435 break;
1436 default:
1437 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1438 "Internal: ELEMENT decl corrupted invalid type\n",
1439 NULL);
1440 return(NULL);
1441 }
1442
1443 /*
1444 * check if name is a QName
1445 */
1446 uqname = xmlSplitQName2(name, &ns);
1447 if (uqname != NULL)
1448 name = uqname;
1449
1450 /*
1451 * Create the Element table if needed.
1452 */
1453 table = (xmlElementTablePtr) dtd->elements;
1454 if (table == NULL) {
1455 xmlDictPtr dict = NULL;
1456
1457 if (dtd->doc != NULL)
1458 dict = dtd->doc->dict;
1459 table = xmlHashCreateDict(0, dict);
1460 dtd->elements = (void *) table;
1461 }
1462 if (table == NULL) {
1463 xmlVErrMemory(ctxt,
1464 "xmlAddElementDecl: Table creation failed!\n");
1465 if (uqname != NULL)
1466 xmlFree(uqname);
1467 if (ns != NULL)
1468 xmlFree(ns);
1469 return(NULL);
1470 }
1471
1472 /*
1473 * lookup old attributes inserted on an undefined element in the
1474 * internal subset.
1475 */
1476 if ((dtd->doc != NULL) && (dtd->doc->intSubset != NULL)) {
1477 ret = xmlHashLookup2(dtd->doc->intSubset->elements, name, ns);
1478 if ((ret != NULL) && (ret->etype == XML_ELEMENT_TYPE_UNDEFINED)) {
1479 oldAttributes = ret->attributes;
1480 ret->attributes = NULL;
1481 xmlHashRemoveEntry2(dtd->doc->intSubset->elements, name, ns, NULL);
1482 xmlFreeElement(ret);
1483 }
1484 }
1485
1486 /*
1487 * The element may already be present if one of its attribute
1488 * was registered first
1489 */
1490 ret = xmlHashLookup2(table, name, ns);
1491 if (ret != NULL) {
1492 if (ret->etype != XML_ELEMENT_TYPE_UNDEFINED) {
1493 #ifdef LIBXML_VALID_ENABLED
1494 /*
1495 * The element is already defined in this DTD.
1496 */
1497 xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ELEM_REDEFINED,
1498 "Redefinition of element %s\n",
1499 name, NULL, NULL);
1500 #endif /* LIBXML_VALID_ENABLED */
1501 if (uqname != NULL)
1502 xmlFree(uqname);
1503 if (ns != NULL)
1504 xmlFree(ns);
1505 return(NULL);
1506 }
1507 if (ns != NULL) {
1508 xmlFree(ns);
1509 ns = NULL;
1510 }
1511 } else {
1512 ret = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
1513 if (ret == NULL) {
1514 xmlVErrMemory(ctxt, "malloc failed");
1515 if (uqname != NULL)
1516 xmlFree(uqname);
1517 if (ns != NULL)
1518 xmlFree(ns);
1519 return(NULL);
1520 }
1521 memset(ret, 0, sizeof(xmlElement));
1522 ret->type = XML_ELEMENT_DECL;
1523
1524 /*
1525 * fill the structure.
1526 */
1527 ret->name = xmlStrdup(name);
1528 if (ret->name == NULL) {
1529 xmlVErrMemory(ctxt, "malloc failed");
1530 if (uqname != NULL)
1531 xmlFree(uqname);
1532 if (ns != NULL)
1533 xmlFree(ns);
1534 xmlFree(ret);
1535 return(NULL);
1536 }
1537 ret->prefix = ns;
1538
1539 /*
1540 * Validity Check:
1541 * Insertion must not fail
1542 */
1543 if (xmlHashAddEntry2(table, name, ns, ret)) {
1544 #ifdef LIBXML_VALID_ENABLED
1545 /*
1546 * The element is already defined in this DTD.
1547 */
1548 xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ELEM_REDEFINED,
1549 "Redefinition of element %s\n",
1550 name, NULL, NULL);
1551 #endif /* LIBXML_VALID_ENABLED */
1552 xmlFreeElement(ret);
1553 if (uqname != NULL)
1554 xmlFree(uqname);
1555 return(NULL);
1556 }
1557 /*
1558 * For new element, may have attributes from earlier
1559 * definition in internal subset
1560 */
1561 ret->attributes = oldAttributes;
1562 }
1563
1564 /*
1565 * Finish to fill the structure.
1566 */
1567 ret->etype = type;
1568 /*
1569 * Avoid a stupid copy when called by the parser
1570 * and flag it by setting a special parent value
1571 * so the parser doesn't unallocate it.
1572 */
1573 if ((ctxt != NULL) &&
1574 ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
1575 (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1))) {
1576 ret->content = content;
1577 if (content != NULL)
1578 content->parent = (xmlElementContentPtr) 1;
1579 } else {
1580 ret->content = xmlCopyDocElementContent(dtd->doc, content);
1581 }
1582
1583 /*
1584 * Link it to the DTD
1585 */
1586 ret->parent = dtd;
1587 ret->doc = dtd->doc;
1588 if (dtd->last == NULL) {
1589 dtd->children = dtd->last = (xmlNodePtr) ret;
1590 } else {
1591 dtd->last->next = (xmlNodePtr) ret;
1592 ret->prev = dtd->last;
1593 dtd->last = (xmlNodePtr) ret;
1594 }
1595 if (uqname != NULL)
1596 xmlFree(uqname);
1597 return(ret);
1598 }
1599
1600 static void
1601 xmlFreeElementTableEntry(void *elem, const xmlChar *name ATTRIBUTE_UNUSED) {
1602 xmlFreeElement((xmlElementPtr) elem);
1603 }
1604
1605 /**
1606 * xmlFreeElementTable:
1607 * @table: An element table
1608 *
1609 * Deallocate the memory used by an element hash table.
1610 */
1611 void
1612 xmlFreeElementTable(xmlElementTablePtr table) {
1613 xmlHashFree(table, xmlFreeElementTableEntry);
1614 }
1615
1616 #ifdef LIBXML_TREE_ENABLED
1617 /**
1618 * xmlCopyElement:
1619 * @elem: An element
1620 *
1621 * Build a copy of an element.
1622 *
1623 * Returns the new xmlElementPtr or NULL in case of error.
1624 */
1625 static void *
1626 xmlCopyElement(void *payload, const xmlChar *name ATTRIBUTE_UNUSED) {
1627 xmlElementPtr elem = (xmlElementPtr) payload;
1628 xmlElementPtr cur;
1629
1630 cur = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
1631 if (cur == NULL) {
1632 xmlVErrMemory(NULL, "malloc failed");
1633 return(NULL);
1634 }
1635 memset(cur, 0, sizeof(xmlElement));
1636 cur->type = XML_ELEMENT_DECL;
1637 cur->etype = elem->etype;
1638 if (elem->name != NULL)
1639 cur->name = xmlStrdup(elem->name);
1640 else
1641 cur->name = NULL;
1642 if (elem->prefix != NULL)
1643 cur->prefix = xmlStrdup(elem->prefix);
1644 else
1645 cur->prefix = NULL;
1646 cur->content = xmlCopyElementContent(elem->content);
1647 /* TODO : rebuild the attribute list on the copy */
1648 cur->attributes = NULL;
1649 return(cur);
1650 }
1651
1652 /**
1653 * xmlCopyElementTable:
1654 * @table: An element table
1655 *
1656 * Build a copy of an element table.
1657 *
1658 * Returns the new xmlElementTablePtr or NULL in case of error.
1659 */
1660 xmlElementTablePtr
1661 xmlCopyElementTable(xmlElementTablePtr table) {
1662 return((xmlElementTablePtr) xmlHashCopy(table, xmlCopyElement));
1663 }
1664 #endif /* LIBXML_TREE_ENABLED */
1665
1666 #ifdef LIBXML_OUTPUT_ENABLED
1667 /**
1668 * xmlDumpElementDecl:
1669 * @buf: the XML buffer output
1670 * @elem: An element table
1671 *
1672 * This will dump the content of the element declaration as an XML
1673 * DTD definition
1674 */
1675 void
1676 xmlDumpElementDecl(xmlBufferPtr buf, xmlElementPtr elem) {
1677 if ((buf == NULL) || (elem == NULL))
1678 return;
1679 switch (elem->etype) {
1680 case XML_ELEMENT_TYPE_EMPTY:
1681 xmlBufferWriteChar(buf, "<!ELEMENT ");
1682 if (elem->prefix != NULL) {
1683 xmlBufferWriteCHAR(buf, elem->prefix);
1684 xmlBufferWriteChar(buf, ":");
1685 }
1686 xmlBufferWriteCHAR(buf, elem->name);
1687 xmlBufferWriteChar(buf, " EMPTY>\n");
1688 break;
1689 case XML_ELEMENT_TYPE_ANY:
1690 xmlBufferWriteChar(buf, "<!ELEMENT ");
1691 if (elem->prefix != NULL) {
1692 xmlBufferWriteCHAR(buf, elem->prefix);
1693 xmlBufferWriteChar(buf, ":");
1694 }
1695 xmlBufferWriteCHAR(buf, elem->name);
1696 xmlBufferWriteChar(buf, " ANY>\n");
1697 break;
1698 case XML_ELEMENT_TYPE_MIXED:
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 case XML_ELEMENT_TYPE_ELEMENT:
1710 xmlBufferWriteChar(buf, "<!ELEMENT ");
1711 if (elem->prefix != NULL) {
1712 xmlBufferWriteCHAR(buf, elem->prefix);
1713 xmlBufferWriteChar(buf, ":");
1714 }
1715 xmlBufferWriteCHAR(buf, elem->name);
1716 xmlBufferWriteChar(buf, " ");
1717 xmlDumpElementContent(buf, elem->content, 1);
1718 xmlBufferWriteChar(buf, ">\n");
1719 break;
1720 default:
1721 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
1722 "Internal: ELEMENT struct corrupted invalid type\n",
1723 NULL);
1724 }
1725 }
1726
1727 /**
1728 * xmlDumpElementDeclScan:
1729 * @elem: An element table
1730 * @buf: the XML buffer output
1731 *
1732 * This routine is used by the hash scan function. It just reverses
1733 * the arguments.
1734 */
1735 static void
1736 xmlDumpElementDeclScan(void *elem, void *buf,
1737 const xmlChar *name ATTRIBUTE_UNUSED) {
1738 xmlDumpElementDecl((xmlBufferPtr) buf, (xmlElementPtr) elem);
1739 }
1740
1741 /**
1742 * xmlDumpElementTable:
1743 * @buf: the XML buffer output
1744 * @table: An element table
1745 *
1746 * This will dump the content of the element table as an XML DTD definition
1747 */
1748 void
1749 xmlDumpElementTable(xmlBufferPtr buf, xmlElementTablePtr table) {
1750 if ((buf == NULL) || (table == NULL))
1751 return;
1752 xmlHashScan(table, xmlDumpElementDeclScan, buf);
1753 }
1754 #endif /* LIBXML_OUTPUT_ENABLED */
1755
1756 /**
1757 * xmlCreateEnumeration:
1758 * @name: the enumeration name or NULL
1759 *
1760 * create and initialize an enumeration attribute node.
1761 *
1762 * Returns the xmlEnumerationPtr just created or NULL in case
1763 * of error.
1764 */
1765 xmlEnumerationPtr
1766 xmlCreateEnumeration(const xmlChar *name) {
1767 xmlEnumerationPtr ret;
1768
1769 ret = (xmlEnumerationPtr) xmlMalloc(sizeof(xmlEnumeration));
1770 if (ret == NULL) {
1771 xmlVErrMemory(NULL, "malloc failed");
1772 return(NULL);
1773 }
1774 memset(ret, 0, sizeof(xmlEnumeration));
1775
1776 if (name != NULL)
1777 ret->name = xmlStrdup(name);
1778 return(ret);
1779 }
1780
1781 /**
1782 * xmlFreeEnumeration:
1783 * @cur: the tree to free.
1784 *
1785 * free an enumeration attribute node (recursive).
1786 */
1787 void
1788 xmlFreeEnumeration(xmlEnumerationPtr cur) {
1789 if (cur == NULL) return;
1790
1791 if (cur->next != NULL) xmlFreeEnumeration(cur->next);
1792
1793 if (cur->name != NULL) xmlFree((xmlChar *) cur->name);
1794 xmlFree(cur);
1795 }
1796
1797 #ifdef LIBXML_TREE_ENABLED
1798 /**
1799 * xmlCopyEnumeration:
1800 * @cur: the tree to copy.
1801 *
1802 * Copy an enumeration attribute node (recursive).
1803 *
1804 * Returns the xmlEnumerationPtr just created or NULL in case
1805 * of error.
1806 */
1807 xmlEnumerationPtr
1808 xmlCopyEnumeration(xmlEnumerationPtr cur) {
1809 xmlEnumerationPtr ret;
1810
1811 if (cur == NULL) return(NULL);
1812 ret = xmlCreateEnumeration((xmlChar *) cur->name);
1813 if (ret == NULL) return(NULL);
1814
1815 if (cur->next != NULL) ret->next = xmlCopyEnumeration(cur->next);
1816 else ret->next = NULL;
1817
1818 return(ret);
1819 }
1820 #endif /* LIBXML_TREE_ENABLED */
1821
1822 #ifdef LIBXML_OUTPUT_ENABLED
1823 /**
1824 * xmlDumpEnumeration:
1825 * @buf: the XML buffer output
1826 * @enum: An enumeration
1827 *
1828 * This will dump the content of the enumeration
1829 */
1830 static void
1831 xmlDumpEnumeration(xmlBufferPtr buf, xmlEnumerationPtr cur) {
1832 if ((buf == NULL) || (cur == NULL))
1833 return;
1834
1835 xmlBufferWriteCHAR(buf, cur->name);
1836 if (cur->next == NULL)
1837 xmlBufferWriteChar(buf, ")");
1838 else {
1839 xmlBufferWriteChar(buf, " | ");
1840 xmlDumpEnumeration(buf, cur->next);
1841 }
1842 }
1843 #endif /* LIBXML_OUTPUT_ENABLED */
1844
1845 #ifdef LIBXML_VALID_ENABLED
1846 /**
1847 * xmlScanIDAttributeDecl:
1848 * @ctxt: the validation context
1849 * @elem: the element name
1850 * @err: whether to raise errors here
1851 *
1852 * Verify that the element don't have too many ID attributes
1853 * declared.
1854 *
1855 * Returns the number of ID attributes found.
1856 */
1857 static int
1858 xmlScanIDAttributeDecl(xmlValidCtxtPtr ctxt, xmlElementPtr elem, int err) {
1859 xmlAttributePtr cur;
1860 int ret = 0;
1861
1862 if (elem == NULL) return(0);
1863 cur = elem->attributes;
1864 while (cur != NULL) {
1865 if (cur->atype == XML_ATTRIBUTE_ID) {
1866 ret ++;
1867 if ((ret > 1) && (err))
1868 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_MULTIPLE_ID,
1869 "Element %s has too many ID attributes defined : %s\n",
1870 elem->name, cur->name, NULL);
1871 }
1872 cur = cur->nexth;
1873 }
1874 return(ret);
1875 }
1876 #endif /* LIBXML_VALID_ENABLED */
1877
1878 /**
1879 * xmlFreeAttribute:
1880 * @elem: An attribute
1881 *
1882 * Deallocate the memory used by an attribute definition
1883 */
1884 static void
1885 xmlFreeAttribute(xmlAttributePtr attr) {
1886 xmlDictPtr dict;
1887
1888 if (attr == NULL) return;
1889 if (attr->doc != NULL)
1890 dict = attr->doc->dict;
1891 else
1892 dict = NULL;
1893 xmlUnlinkNode((xmlNodePtr) attr);
1894 if (attr->tree != NULL)
1895 xmlFreeEnumeration(attr->tree);
1896 if (dict) {
1897 if ((attr->elem != NULL) && (!xmlDictOwns(dict, attr->elem)))
1898 xmlFree((xmlChar *) attr->elem);
1899 if ((attr->name != NULL) && (!xmlDictOwns(dict, attr->name)))
1900 xmlFree((xmlChar *) attr->name);
1901 if ((attr->prefix != NULL) && (!xmlDictOwns(dict, attr->prefix)))
1902 xmlFree((xmlChar *) attr->prefix);
1903 if ((attr->defaultValue != NULL) &&
1904 (!xmlDictOwns(dict, attr->defaultValue)))
1905 xmlFree((xmlChar *) attr->defaultValue);
1906 } else {
1907 if (attr->elem != NULL)
1908 xmlFree((xmlChar *) attr->elem);
1909 if (attr->name != NULL)
1910 xmlFree((xmlChar *) attr->name);
1911 if (attr->defaultValue != NULL)
1912 xmlFree((xmlChar *) attr->defaultValue);
1913 if (attr->prefix != NULL)
1914 xmlFree((xmlChar *) attr->prefix);
1915 }
1916 xmlFree(attr);
1917 }
1918
1919
1920 /**
1921 * xmlAddAttributeDecl:
1922 * @ctxt: the validation context
1923 * @dtd: pointer to the DTD
1924 * @elem: the element name
1925 * @name: the attribute name
1926 * @ns: the attribute namespace prefix
1927 * @type: the attribute type
1928 * @def: the attribute default type
1929 * @defaultValue: the attribute default value
1930 * @tree: if it's an enumeration, the associated list
1931 *
1932 * Register a new attribute declaration
1933 * Note that @tree becomes the ownership of the DTD
1934 *
1935 * Returns NULL if not new, otherwise the attribute decl
1936 */
1937 xmlAttributePtr
1938 xmlAddAttributeDecl(xmlValidCtxtPtr ctxt,
1939 xmlDtdPtr dtd, const xmlChar *elem,
1940 const xmlChar *name, const xmlChar *ns,
1941 xmlAttributeType type, xmlAttributeDefault def,
1942 const xmlChar *defaultValue, xmlEnumerationPtr tree) {
1943 xmlAttributePtr ret;
1944 xmlAttributeTablePtr table;
1945 xmlElementPtr elemDef;
1946 xmlDictPtr dict = NULL;
1947
1948 if (dtd == NULL) {
1949 xmlFreeEnumeration(tree);
1950 return(NULL);
1951 }
1952 if (name == NULL) {
1953 xmlFreeEnumeration(tree);
1954 return(NULL);
1955 }
1956 if (elem == NULL) {
1957 xmlFreeEnumeration(tree);
1958 return(NULL);
1959 }
1960 if (dtd->doc != NULL)
1961 dict = dtd->doc->dict;
1962
1963 #ifdef LIBXML_VALID_ENABLED
1964 /*
1965 * Check the type and possibly the default value.
1966 */
1967 switch (type) {
1968 case XML_ATTRIBUTE_CDATA:
1969 break;
1970 case XML_ATTRIBUTE_ID:
1971 break;
1972 case XML_ATTRIBUTE_IDREF:
1973 break;
1974 case XML_ATTRIBUTE_IDREFS:
1975 break;
1976 case XML_ATTRIBUTE_ENTITY:
1977 break;
1978 case XML_ATTRIBUTE_ENTITIES:
1979 break;
1980 case XML_ATTRIBUTE_NMTOKEN:
1981 break;
1982 case XML_ATTRIBUTE_NMTOKENS:
1983 break;
1984 case XML_ATTRIBUTE_ENUMERATION:
1985 break;
1986 case XML_ATTRIBUTE_NOTATION:
1987 break;
1988 default:
1989 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1990 "Internal: ATTRIBUTE struct corrupted invalid type\n",
1991 NULL);
1992 xmlFreeEnumeration(tree);
1993 return(NULL);
1994 }
1995 if ((defaultValue != NULL) &&
1996 (!xmlValidateAttributeValueInternal(dtd->doc, type, defaultValue))) {
1997 xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ATTRIBUTE_DEFAULT,
1998 "Attribute %s of %s: invalid default value\n",
1999 elem, name, defaultValue);
2000 defaultValue = NULL;
2001 if (ctxt != NULL)
2002 ctxt->valid = 0;
2003 }
2004 #endif /* LIBXML_VALID_ENABLED */
2005
2006 /*
2007 * Check first that an attribute defined in the external subset wasn't
2008 * already defined in the internal subset
2009 */
2010 if ((dtd->doc != NULL) && (dtd->doc->extSubset == dtd) &&
2011 (dtd->doc->intSubset != NULL) &&
2012 (dtd->doc->intSubset->attributes != NULL)) {
2013 ret = xmlHashLookup3(dtd->doc->intSubset->attributes, name, ns, elem);
2014 if (ret != NULL) {
2015 xmlFreeEnumeration(tree);
2016 return(NULL);
2017 }
2018 }
2019
2020 /*
2021 * Create the Attribute table if needed.
2022 */
2023 table = (xmlAttributeTablePtr) dtd->attributes;
2024 if (table == NULL) {
2025 table = xmlHashCreateDict(0, dict);
2026 dtd->attributes = (void *) table;
2027 }
2028 if (table == NULL) {
2029 xmlVErrMemory(ctxt,
2030 "xmlAddAttributeDecl: Table creation failed!\n");
2031 xmlFreeEnumeration(tree);
2032 return(NULL);
2033 }
2034
2035
2036 ret = (xmlAttributePtr) xmlMalloc(sizeof(xmlAttribute));
2037 if (ret == NULL) {
2038 xmlVErrMemory(ctxt, "malloc failed");
2039 xmlFreeEnumeration(tree);
2040 return(NULL);
2041 }
2042 memset(ret, 0, sizeof(xmlAttribute));
2043 ret->type = XML_ATTRIBUTE_DECL;
2044
2045 /*
2046 * fill the structure.
2047 */
2048 ret->atype = type;
2049 /*
2050 * doc must be set before possible error causes call
2051 * to xmlFreeAttribute (because it's used to check on
2052 * dict use)
2053 */
2054 ret->doc = dtd->doc;
2055 if (dict) {
2056 ret->name = xmlDictLookup(dict, name, -1);
2057 ret->prefix = xmlDictLookup(dict, ns, -1);
2058 ret->elem = xmlDictLookup(dict, elem, -1);
2059 } else {
2060 ret->name = xmlStrdup(name);
2061 ret->prefix = xmlStrdup(ns);
2062 ret->elem = xmlStrdup(elem);
2063 }
2064 ret->def = def;
2065 ret->tree = tree;
2066 if (defaultValue != NULL) {
2067 if (dict)
2068 ret->defaultValue = xmlDictLookup(dict, defaultValue, -1);
2069 else
2070 ret->defaultValue = xmlStrdup(defaultValue);
2071 }
2072
2073 /*
2074 * Validity Check:
2075 * Search the DTD for previous declarations of the ATTLIST
2076 */
2077 if (xmlHashAddEntry3(table, ret->name, ret->prefix, ret->elem, ret) < 0) {
2078 #ifdef LIBXML_VALID_ENABLED
2079 /*
2080 * The attribute is already defined in this DTD.
2081 */
2082 xmlErrValidWarning(ctxt, (xmlNodePtr) dtd, XML_DTD_ATTRIBUTE_REDEFINED,
2083 "Attribute %s of element %s: already defined\n",
2084 name, elem, NULL);
2085 #endif /* LIBXML_VALID_ENABLED */
2086 xmlFreeAttribute(ret);
2087 return(NULL);
2088 }
2089
2090 /*
2091 * Validity Check:
2092 * Multiple ID per element
2093 */
2094 elemDef = xmlGetDtdElementDesc2(dtd, elem, 1);
2095 if (elemDef != NULL) {
2096
2097 #ifdef LIBXML_VALID_ENABLED
2098 if ((type == XML_ATTRIBUTE_ID) &&
2099 (xmlScanIDAttributeDecl(NULL, elemDef, 1) != 0)) {
2100 xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_MULTIPLE_ID,
2101 "Element %s has too may ID attributes defined : %s\n",
2102 elem, name, NULL);
2103 if (ctxt != NULL)
2104 ctxt->valid = 0;
2105 }
2106 #endif /* LIBXML_VALID_ENABLED */
2107
2108 /*
2109 * Insert namespace default def first they need to be
2110 * processed first.
2111 */
2112 if ((xmlStrEqual(ret->name, BAD_CAST "xmlns")) ||
2113 ((ret->prefix != NULL &&
2114 (xmlStrEqual(ret->prefix, BAD_CAST "xmlns"))))) {
2115 ret->nexth = elemDef->attributes;
2116 elemDef->attributes = ret;
2117 } else {
2118 xmlAttributePtr tmp = elemDef->attributes;
2119
2120 while ((tmp != NULL) &&
2121 ((xmlStrEqual(tmp->name, BAD_CAST "xmlns")) ||
2122 ((ret->prefix != NULL &&
2123 (xmlStrEqual(ret->prefix, BAD_CAST "xmlns")))))) {
2124 if (tmp->nexth == NULL)
2125 break;
2126 tmp = tmp->nexth;
2127 }
2128 if (tmp != NULL) {
2129 ret->nexth = tmp->nexth;
2130 tmp->nexth = ret;
2131 } else {
2132 ret->nexth = elemDef->attributes;
2133 elemDef->attributes = ret;
2134 }
2135 }
2136 }
2137
2138 /*
2139 * Link it to the DTD
2140 */
2141 ret->parent = dtd;
2142 if (dtd->last == NULL) {
2143 dtd->children = dtd->last = (xmlNodePtr) ret;
2144 } else {
2145 dtd->last->next = (xmlNodePtr) ret;
2146 ret->prev = dtd->last;
2147 dtd->last = (xmlNodePtr) ret;
2148 }
2149 return(ret);
2150 }
2151
2152 static void
2153 xmlFreeAttributeTableEntry(void *attr, const xmlChar *name ATTRIBUTE_UNUSED) {
2154 xmlFreeAttribute((xmlAttributePtr) attr);
2155 }
2156
2157 /**
2158 * xmlFreeAttributeTable:
2159 * @table: An attribute table
2160 *
2161 * Deallocate the memory used by an entities hash table.
2162 */
2163 void
2164 xmlFreeAttributeTable(xmlAttributeTablePtr table) {
2165 xmlHashFree(table, xmlFreeAttributeTableEntry);
2166 }
2167
2168 #ifdef LIBXML_TREE_ENABLED
2169 /**
2170 * xmlCopyAttribute:
2171 * @attr: An attribute
2172 *
2173 * Build a copy of an attribute.
2174 *
2175 * Returns the new xmlAttributePtr or NULL in case of error.
2176 */
2177 static void *
2178 xmlCopyAttribute(void *payload, const xmlChar *name ATTRIBUTE_UNUSED) {
2179 xmlAttributePtr attr = (xmlAttributePtr) payload;
2180 xmlAttributePtr cur;
2181
2182 cur = (xmlAttributePtr) xmlMalloc(sizeof(xmlAttribute));
2183 if (cur == NULL) {
2184 xmlVErrMemory(NULL, "malloc failed");
2185 return(NULL);
2186 }
2187 memset(cur, 0, sizeof(xmlAttribute));
2188 cur->type = XML_ATTRIBUTE_DECL;
2189 cur->atype = attr->atype;
2190 cur->def = attr->def;
2191 cur->tree = xmlCopyEnumeration(attr->tree);
2192 if (attr->elem != NULL)
2193 cur->elem = xmlStrdup(attr->elem);
2194 if (attr->name != NULL)
2195 cur->name = xmlStrdup(attr->name);
2196 if (attr->prefix != NULL)
2197 cur->prefix = xmlStrdup(attr->prefix);
2198 if (attr->defaultValue != NULL)
2199 cur->defaultValue = xmlStrdup(attr->defaultValue);
2200 return(cur);
2201 }
2202
2203 /**
2204 * xmlCopyAttributeTable:
2205 * @table: An attribute table
2206 *
2207 * Build a copy of an attribute table.
2208 *
2209 * Returns the new xmlAttributeTablePtr or NULL in case of error.
2210 */
2211 xmlAttributeTablePtr
2212 xmlCopyAttributeTable(xmlAttributeTablePtr table) {
2213 return((xmlAttributeTablePtr) xmlHashCopy(table, xmlCopyAttribute));
2214 }
2215 #endif /* LIBXML_TREE_ENABLED */
2216
2217 #ifdef LIBXML_OUTPUT_ENABLED
2218 /**
2219 * xmlDumpAttributeDecl:
2220 * @buf: the XML buffer output
2221 * @attr: An attribute declaration
2222 *
2223 * This will dump the content of the attribute declaration as an XML
2224 * DTD definition
2225 */
2226 void
2227 xmlDumpAttributeDecl(xmlBufferPtr buf, xmlAttributePtr attr) {
2228 if ((buf == NULL) || (attr == NULL))
2229 return;
2230 xmlBufferWriteChar(buf, "<!ATTLIST ");
2231 xmlBufferWriteCHAR(buf, attr->elem);
2232 xmlBufferWriteChar(buf, " ");
2233 if (attr->prefix != NULL) {
2234 xmlBufferWriteCHAR(buf, attr->prefix);
2235 xmlBufferWriteChar(buf, ":");
2236 }
2237 xmlBufferWriteCHAR(buf, attr->name);
2238 switch (attr->atype) {
2239 case XML_ATTRIBUTE_CDATA:
2240 xmlBufferWriteChar(buf, " CDATA");
2241 break;
2242 case XML_ATTRIBUTE_ID:
2243 xmlBufferWriteChar(buf, " ID");
2244 break;
2245 case XML_ATTRIBUTE_IDREF:
2246 xmlBufferWriteChar(buf, " IDREF");
2247 break;
2248 case XML_ATTRIBUTE_IDREFS:
2249 xmlBufferWriteChar(buf, " IDREFS");
2250 break;
2251 case XML_ATTRIBUTE_ENTITY:
2252 xmlBufferWriteChar(buf, " ENTITY");
2253 break;
2254 case XML_ATTRIBUTE_ENTITIES:
2255 xmlBufferWriteChar(buf, " ENTITIES");
2256 break;
2257 case XML_ATTRIBUTE_NMTOKEN:
2258 xmlBufferWriteChar(buf, " NMTOKEN");
2259 break;
2260 case XML_ATTRIBUTE_NMTOKENS:
2261 xmlBufferWriteChar(buf, " NMTOKENS");
2262 break;
2263 case XML_ATTRIBUTE_ENUMERATION:
2264 xmlBufferWriteChar(buf, " (");
2265 xmlDumpEnumeration(buf, attr->tree);
2266 break;
2267 case XML_ATTRIBUTE_NOTATION:
2268 xmlBufferWriteChar(buf, " NOTATION (");
2269 xmlDumpEnumeration(buf, attr->tree);
2270 break;
2271 default:
2272 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2273 "Internal: ATTRIBUTE struct corrupted invalid type\n",
2274 NULL);
2275 }
2276 switch (attr->def) {
2277 case XML_ATTRIBUTE_NONE:
2278 break;
2279 case XML_ATTRIBUTE_REQUIRED:
2280 xmlBufferWriteChar(buf, " #REQUIRED");
2281 break;
2282 case XML_ATTRIBUTE_IMPLIED:
2283 xmlBufferWriteChar(buf, " #IMPLIED");
2284 break;
2285 case XML_ATTRIBUTE_FIXED:
2286 xmlBufferWriteChar(buf, " #FIXED");
2287 break;
2288 default:
2289 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2290 "Internal: ATTRIBUTE struct corrupted invalid def\n",
2291 NULL);
2292 }
2293 if (attr->defaultValue != NULL) {
2294 xmlBufferWriteChar(buf, " ");
2295 xmlBufferWriteQuotedString(buf, attr->defaultValue);
2296 }
2297 xmlBufferWriteChar(buf, ">\n");
2298 }
2299
2300 /**
2301 * xmlDumpAttributeDeclScan:
2302 * @attr: An attribute declaration
2303 * @buf: the XML buffer output
2304 *
2305 * This is used with the hash scan function - just reverses arguments
2306 */
2307 static void
2308 xmlDumpAttributeDeclScan(void *attr, void *buf,
2309 const xmlChar *name ATTRIBUTE_UNUSED) {
2310 xmlDumpAttributeDecl((xmlBufferPtr) buf, (xmlAttributePtr) attr);
2311 }
2312
2313 /**
2314 * xmlDumpAttributeTable:
2315 * @buf: the XML buffer output
2316 * @table: An attribute table
2317 *
2318 * This will dump the content of the attribute table as an XML DTD definition
2319 */
2320 void
2321 xmlDumpAttributeTable(xmlBufferPtr buf, xmlAttributeTablePtr table) {
2322 if ((buf == NULL) || (table == NULL))
2323 return;
2324 xmlHashScan(table, xmlDumpAttributeDeclScan, buf);
2325 }
2326 #endif /* LIBXML_OUTPUT_ENABLED */
2327
2328 /************************************************************************
2329 * *
2330 * NOTATIONs *
2331 * *
2332 ************************************************************************/
2333 /**
2334 * xmlFreeNotation:
2335 * @not: A notation
2336 *
2337 * Deallocate the memory used by an notation definition
2338 */
2339 static void
2340 xmlFreeNotation(xmlNotationPtr nota) {
2341 if (nota == NULL) return;
2342 if (nota->name != NULL)
2343 xmlFree((xmlChar *) nota->name);
2344 if (nota->PublicID != NULL)
2345 xmlFree((xmlChar *) nota->PublicID);
2346 if (nota->SystemID != NULL)
2347 xmlFree((xmlChar *) nota->SystemID);
2348 xmlFree(nota);
2349 }
2350
2351
2352 /**
2353 * xmlAddNotationDecl:
2354 * @dtd: pointer to the DTD
2355 * @ctxt: the validation context
2356 * @name: the entity name
2357 * @PublicID: the public identifier or NULL
2358 * @SystemID: the system identifier or NULL
2359 *
2360 * Register a new notation declaration
2361 *
2362 * Returns NULL if not, otherwise the entity
2363 */
2364 xmlNotationPtr
2365 xmlAddNotationDecl(xmlValidCtxtPtr ctxt, xmlDtdPtr dtd,
2366 const xmlChar *name,
2367 const xmlChar *PublicID, const xmlChar *SystemID) {
2368 xmlNotationPtr ret;
2369 xmlNotationTablePtr table;
2370
2371 if (dtd == NULL) {
2372 return(NULL);
2373 }
2374 if (name == NULL) {
2375 return(NULL);
2376 }
2377 if ((PublicID == NULL) && (SystemID == NULL)) {
2378 return(NULL);
2379 }
2380
2381 /*
2382 * Create the Notation table if needed.
2383 */
2384 table = (xmlNotationTablePtr) dtd->notations;
2385 if (table == NULL) {
2386 xmlDictPtr dict = NULL;
2387 if (dtd->doc != NULL)
2388 dict = dtd->doc->dict;
2389
2390 dtd->notations = table = xmlHashCreateDict(0, dict);
2391 }
2392 if (table == NULL) {
2393 xmlVErrMemory(ctxt,
2394 "xmlAddNotationDecl: Table creation failed!\n");
2395 return(NULL);
2396 }
2397
2398 ret = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation));
2399 if (ret == NULL) {
2400 xmlVErrMemory(ctxt, "malloc failed");
2401 return(NULL);
2402 }
2403 memset(ret, 0, sizeof(xmlNotation));
2404
2405 /*
2406 * fill the structure.
2407 */
2408 ret->name = xmlStrdup(name);
2409 if (SystemID != NULL)
2410 ret->SystemID = xmlStrdup(SystemID);
2411 if (PublicID != NULL)
2412 ret->PublicID = xmlStrdup(PublicID);
2413
2414 /*
2415 * Validity Check:
2416 * Check the DTD for previous declarations of the ATTLIST
2417 */
2418 if (xmlHashAddEntry(table, name, ret)) {
2419 #ifdef LIBXML_VALID_ENABLED
2420 xmlErrValid(NULL, XML_DTD_NOTATION_REDEFINED,
2421 "xmlAddNotationDecl: %s already defined\n",
2422 (const char *) name);
2423 #endif /* LIBXML_VALID_ENABLED */
2424 xmlFreeNotation(ret);
2425 return(NULL);
2426 }
2427 return(ret);
2428 }
2429
2430 static void
2431 xmlFreeNotationTableEntry(void *nota, const xmlChar *name ATTRIBUTE_UNUSED) {
2432 xmlFreeNotation((xmlNotationPtr) nota);
2433 }
2434
2435 /**
2436 * xmlFreeNotationTable:
2437 * @table: An notation table
2438 *
2439 * Deallocate the memory used by an entities hash table.
2440 */
2441 void
2442 xmlFreeNotationTable(xmlNotationTablePtr table) {
2443 xmlHashFree(table, xmlFreeNotationTableEntry);
2444 }
2445
2446 #ifdef LIBXML_TREE_ENABLED
2447 /**
2448 * xmlCopyNotation:
2449 * @nota: A notation
2450 *
2451 * Build a copy of a notation.
2452 *
2453 * Returns the new xmlNotationPtr or NULL in case of error.
2454 */
2455 static void *
2456 xmlCopyNotation(void *payload, const xmlChar *name ATTRIBUTE_UNUSED) {
2457 xmlNotationPtr nota = (xmlNotationPtr) payload;
2458 xmlNotationPtr cur;
2459
2460 cur = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation));
2461 if (cur == NULL) {
2462 xmlVErrMemory(NULL, "malloc failed");
2463 return(NULL);
2464 }
2465 if (nota->name != NULL)
2466 cur->name = xmlStrdup(nota->name);
2467 else
2468 cur->name = NULL;
2469 if (nota->PublicID != NULL)
2470 cur->PublicID = xmlStrdup(nota->PublicID);
2471 else
2472 cur->PublicID = NULL;
2473 if (nota->SystemID != NULL)
2474 cur->SystemID = xmlStrdup(nota->SystemID);
2475 else
2476 cur->SystemID = NULL;
2477 return(cur);
2478 }
2479
2480 /**
2481 * xmlCopyNotationTable:
2482 * @table: A notation table
2483 *
2484 * Build a copy of a notation table.
2485 *
2486 * Returns the new xmlNotationTablePtr or NULL in case of error.
2487 */
2488 xmlNotationTablePtr
2489 xmlCopyNotationTable(xmlNotationTablePtr table) {
2490 return((xmlNotationTablePtr) xmlHashCopy(table, xmlCopyNotation));
2491 }
2492 #endif /* LIBXML_TREE_ENABLED */
2493
2494 #ifdef LIBXML_OUTPUT_ENABLED
2495 /**
2496 * xmlDumpNotationDecl:
2497 * @buf: the XML buffer output
2498 * @nota: A notation declaration
2499 *
2500 * This will dump the content the notation declaration as an XML DTD definition
2501 */
2502 void
2503 xmlDumpNotationDecl(xmlBufferPtr buf, xmlNotationPtr nota) {
2504 if ((buf == NULL) || (nota == NULL))
2505 return;
2506 xmlBufferWriteChar(buf, "<!NOTATION ");
2507 xmlBufferWriteCHAR(buf, nota->name);
2508 if (nota->PublicID != NULL) {
2509 xmlBufferWriteChar(buf, " PUBLIC ");
2510 xmlBufferWriteQuotedString(buf, nota->PublicID);
2511 if (nota->SystemID != NULL) {
2512 xmlBufferWriteChar(buf, " ");
2513 xmlBufferWriteQuotedString(buf, nota->SystemID);
2514 }
2515 } else {
2516 xmlBufferWriteChar(buf, " SYSTEM ");
2517 xmlBufferWriteQuotedString(buf, nota->SystemID);
2518 }
2519 xmlBufferWriteChar(buf, " >\n");
2520 }
2521
2522 /**
2523 * xmlDumpNotationDeclScan:
2524 * @nota: A notation declaration
2525 * @buf: the XML buffer output
2526 *
2527 * This is called with the hash scan function, and just reverses args
2528 */
2529 static void
2530 xmlDumpNotationDeclScan(void *nota, void *buf,
2531 const xmlChar *name ATTRIBUTE_UNUSED) {
2532 xmlDumpNotationDecl((xmlBufferPtr) buf, (xmlNotationPtr) nota);
2533 }
2534
2535 /**
2536 * xmlDumpNotationTable:
2537 * @buf: the XML buffer output
2538 * @table: A notation table
2539 *
2540 * This will dump the content of the notation table as an XML DTD definition
2541 */
2542 void
2543 xmlDumpNotationTable(xmlBufferPtr buf, xmlNotationTablePtr table) {
2544 if ((buf == NULL) || (table == NULL))
2545 return;
2546 xmlHashScan(table, xmlDumpNotationDeclScan, buf);
2547 }
2548 #endif /* LIBXML_OUTPUT_ENABLED */
2549
2550 /************************************************************************
2551 * *
2552 * IDs *
2553 * *
2554 ************************************************************************/
2555 /**
2556 * DICT_FREE:
2557 * @str: a string
2558 *
2559 * Free a string if it is not owned by the "dict" dictionary in the
2560 * current scope
2561 */
2562 #define DICT_FREE(str) \
2563 if ((str) && ((!dict) || \
2564 (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \
2565 xmlFree((char *)(str));
2566
2567 /**
2568 * xmlFreeID:
2569 * @not: A id
2570 *
2571 * Deallocate the memory used by an id definition
2572 */
2573 static void
2574 xmlFreeID(xmlIDPtr id) {
2575 xmlDictPtr dict = NULL;
2576
2577 if (id == NULL) return;
2578
2579 if (id->doc != NULL)
2580 dict = id->doc->dict;
2581
2582 if (id->value != NULL)
2583 DICT_FREE(id->value)
2584 if (id->name != NULL)
2585 DICT_FREE(id->name)
2586 xmlFree(id);
2587 }
2588
2589
2590 /**
2591 * xmlAddID:
2592 * @ctxt: the validation context
2593 * @doc: pointer to the document
2594 * @value: the value name
2595 * @attr: the attribute holding the ID
2596 *
2597 * Register a new id declaration
2598 *
2599 * Returns NULL if not, otherwise the new xmlIDPtr
2600 */
2601 xmlIDPtr
2602 xmlAddID(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value,
2603 xmlAttrPtr attr) {
2604 xmlIDPtr ret;
2605 xmlIDTablePtr table;
2606
2607 if (doc == NULL) {
2608 return(NULL);
2609 }
2610 if (value == NULL) {
2611 return(NULL);
2612 }
2613 if (attr == NULL) {
2614 return(NULL);
2615 }
2616
2617 /*
2618 * Create the ID table if needed.
2619 */
2620 table = (xmlIDTablePtr) doc->ids;
2621 if (table == NULL) {
2622 doc->ids = table = xmlHashCreateDict(0, doc->dict);
2623 }
2624 if (table == NULL) {
2625 xmlVErrMemory(ctxt,
2626 "xmlAddID: Table creation failed!\n");
2627 return(NULL);
2628 }
2629
2630 ret = (xmlIDPtr) xmlMalloc(sizeof(xmlID));
2631 if (ret == NULL) {
2632 xmlVErrMemory(ctxt, "malloc failed");
2633 return(NULL);
2634 }
2635
2636 /*
2637 * fill the structure.
2638 */
2639 ret->value = xmlStrdup(value);
2640 ret->doc = doc;
2641 if ((ctxt != NULL) && (ctxt->vstateNr != 0)) {
2642 /*
2643 * Operating in streaming mode, attr is gonna disapear
2644 */
2645 if (doc->dict != NULL)
2646 ret->name = xmlDictLookup(doc->dict, attr->name, -1);
2647 else
2648 ret->name = xmlStrdup(attr->name);
2649 ret->attr = NULL;
2650 } else {
2651 ret->attr = attr;
2652 ret->name = NULL;
2653 }
2654 ret->lineno = xmlGetLineNo(attr->parent);
2655
2656 if (xmlHashAddEntry(table, value, ret) < 0) {
2657 #ifdef LIBXML_VALID_ENABLED
2658 /*
2659 * The id is already defined in this DTD.
2660 */
2661 if (ctxt != NULL) {
2662 xmlErrValidNode(ctxt, attr->parent, XML_DTD_ID_REDEFINED,
2663 "ID %s already defined\n", value, NULL, NULL);
2664 }
2665 #endif /* LIBXML_VALID_ENABLED */
2666 xmlFreeID(ret);
2667 return(NULL);
2668 }
2669 if (attr != NULL)
2670 attr->atype = XML_ATTRIBUTE_ID;
2671 return(ret);
2672 }
2673
2674 static void
2675 xmlFreeIDTableEntry(void *id, const xmlChar *name ATTRIBUTE_UNUSED) {
2676 xmlFreeID((xmlIDPtr) id);
2677 }
2678
2679 /**
2680 * xmlFreeIDTable:
2681 * @table: An id table
2682 *
2683 * Deallocate the memory used by an ID hash table.
2684 */
2685 void
2686 xmlFreeIDTable(xmlIDTablePtr table) {
2687 xmlHashFree(table, xmlFreeIDTableEntry);
2688 }
2689
2690 /**
2691 * xmlIsID:
2692 * @doc: the document
2693 * @elem: the element carrying the attribute
2694 * @attr: the attribute
2695 *
2696 * Determine whether an attribute is of type ID. In case we have DTD(s)
2697 * then this is done if DTD loading has been requested. In the case
2698 * of HTML documents parsed with the HTML parser, then ID detection is
2699 * done systematically.
2700 *
2701 * Returns 0 or 1 depending on the lookup result
2702 */
2703 int
2704 xmlIsID(xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr) {
2705 if ((attr == NULL) || (attr->name == NULL)) return(0);
2706 if ((attr->ns != NULL) && (attr->ns->prefix != NULL) &&
2707 (!strcmp((char *) attr->name, "id")) &&
2708 (!strcmp((char *) attr->ns->prefix, "xml")))
2709 return(1);
2710 if (doc == NULL) return(0);
2711 if ((doc->intSubset == NULL) && (doc->extSubset == NULL) &&
2712 (doc->type != XML_HTML_DOCUMENT_NODE)) {
2713 return(0);
2714 } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
2715 if ((xmlStrEqual(BAD_CAST "id", attr->name)) ||
2716 ((xmlStrEqual(BAD_CAST "name", attr->name)) &&
2717 ((elem == NULL) || (xmlStrEqual(elem->name, BAD_CAST "a")))))
2718 return(1);
2719 return(0);
2720 } else if (elem == NULL) {
2721 return(0);
2722 } else {
2723 xmlAttributePtr attrDecl = NULL;
2724
2725 xmlChar felem[50], fattr[50];
2726 xmlChar *fullelemname, *fullattrname;
2727
2728 fullelemname = (elem->ns != NULL && elem->ns->prefix != NULL) ?
2729 xmlBuildQName(elem->name, elem->ns->prefix, felem, 50) :
2730 (xmlChar *)elem->name;
2731
2732 fullattrname = (attr->ns != NULL && attr->ns->prefix != NULL) ?
2733 xmlBuildQName(attr->name, attr->ns->prefix, fattr, 50) :
2734 (xmlChar *)attr->name;
2735
2736 if (fullelemname != NULL && fullattrname != NULL) {
2737 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullelemname,
2738 fullattrname);
2739 if ((attrDecl == NULL) && (doc->extSubset != NULL))
2740 attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullelemname,
2741 fullattrname);
2742 }
2743
2744 if ((fullattrname != fattr) && (fullattrname != attr->name))
2745 xmlFree(fullattrname);
2746 if ((fullelemname != felem) && (fullelemname != elem->name))
2747 xmlFree(fullelemname);
2748
2749 if ((attrDecl != NULL) && (attrDecl->atype == XML_ATTRIBUTE_ID))
2750 return(1);
2751 }
2752 return(0);
2753 }
2754
2755 /**
2756 * xmlRemoveID:
2757 * @doc: the document
2758 * @attr: the attribute
2759 *
2760 * Remove the given attribute from the ID table maintained internally.
2761 *
2762 * Returns -1 if the lookup failed and 0 otherwise
2763 */
2764 int
2765 xmlRemoveID(xmlDocPtr doc, xmlAttrPtr attr) {
2766 xmlIDTablePtr table;
2767 xmlIDPtr id;
2768 xmlChar *ID;
2769
2770 if (doc == NULL) return(-1);
2771 if (attr == NULL) return(-1);
2772
2773 table = (xmlIDTablePtr) doc->ids;
2774 if (table == NULL)
2775 return(-1);
2776
2777 ID = xmlNodeListGetString(doc, attr->children, 1);
2778 if (ID == NULL)
2779 return(-1);
2780
2781 id = xmlHashLookup(table, ID);
2782 if (id == NULL || id->attr != attr) {
2783 xmlFree(ID);
2784 return(-1);
2785 }
2786
2787 xmlHashRemoveEntry(table, ID, xmlFreeIDTableEntry);
2788 xmlFree(ID);
2789 attr->atype = 0;
2790 return(0);
2791 }
2792
2793 /**
2794 * xmlGetID:
2795 * @doc: pointer to the document
2796 * @ID: the ID value
2797 *
2798 * Search the attribute declaring the given ID
2799 *
2800 * Returns NULL if not found, otherwise the xmlAttrPtr defining the ID
2801 */
2802 xmlAttrPtr
2803 xmlGetID(xmlDocPtr doc, const xmlChar *ID) {
2804 xmlIDTablePtr table;
2805 xmlIDPtr id;
2806
2807 if (doc == NULL) {
2808 return(NULL);
2809 }
2810
2811 if (ID == NULL) {
2812 return(NULL);
2813 }
2814
2815 table = (xmlIDTablePtr) doc->ids;
2816 if (table == NULL)
2817 return(NULL);
2818
2819 id = xmlHashLookup(table, ID);
2820 if (id == NULL)
2821 return(NULL);
2822 if (id->attr == NULL) {
2823 /*
2824 * We are operating on a stream, return a well known reference
2825 * since the attribute node doesn't exist anymore
2826 */
2827 return((xmlAttrPtr) doc);
2828 }
2829 return(id->attr);
2830 }
2831
2832 /************************************************************************
2833 * *
2834 * Refs *
2835 * *
2836 ************************************************************************/
2837 typedef struct xmlRemoveMemo_t
2838 {
2839 xmlListPtr l;
2840 xmlAttrPtr ap;
2841 } xmlRemoveMemo;
2842
2843 typedef xmlRemoveMemo *xmlRemoveMemoPtr;
2844
2845 typedef struct xmlValidateMemo_t
2846 {
2847 xmlValidCtxtPtr ctxt;
2848 const xmlChar *name;
2849 } xmlValidateMemo;
2850
2851 typedef xmlValidateMemo *xmlValidateMemoPtr;
2852
2853 /**
2854 * xmlFreeRef:
2855 * @lk: A list link
2856 *
2857 * Deallocate the memory used by a ref definition
2858 */
2859 static void
2860 xmlFreeRef(xmlLinkPtr lk) {
2861 xmlRefPtr ref = (xmlRefPtr)xmlLinkGetData(lk);
2862 if (ref == NULL) return;
2863 if (ref->value != NULL)
2864 xmlFree((xmlChar *)ref->value);
2865 if (ref->name != NULL)
2866 xmlFree((xmlChar *)ref->name);
2867 xmlFree(ref);
2868 }
2869
2870 /**
2871 * xmlFreeRefTableEntry:
2872 * @list_ref: A list of references.
2873 *
2874 * Deallocate the memory used by a list of references
2875 */
2876 static void
2877 xmlFreeRefTableEntry(void *payload, const xmlChar *name ATTRIBUTE_UNUSED) {
2878 xmlListPtr list_ref = (xmlListPtr) payload;
2879 if (list_ref == NULL) return;
2880 xmlListDelete(list_ref);
2881 }
2882
2883 /**
2884 * xmlWalkRemoveRef:
2885 * @data: Contents of current link
2886 * @user: Value supplied by the user
2887 *
2888 * Returns 0 to abort the walk or 1 to continue
2889 */
2890 static int
2891 xmlWalkRemoveRef(const void *data, void *user)
2892 {
2893 xmlAttrPtr attr0 = ((xmlRefPtr)data)->attr;
2894 xmlAttrPtr attr1 = ((xmlRemoveMemoPtr)user)->ap;
2895 xmlListPtr ref_list = ((xmlRemoveMemoPtr)user)->l;
2896
2897 if (attr0 == attr1) { /* Matched: remove and terminate walk */
2898 xmlListRemoveFirst(ref_list, (void *)data);
2899 return 0;
2900 }
2901 return 1;
2902 }
2903
2904 /**
2905 * xmlDummyCompare
2906 * @data0: Value supplied by the user
2907 * @data1: Value supplied by the user
2908 *
2909 * Do nothing, return 0. Used to create unordered lists.
2910 */
2911 static int
2912 xmlDummyCompare(const void *data0 ATTRIBUTE_UNUSED,
2913 const void *data1 ATTRIBUTE_UNUSED)
2914 {
2915 return (0);
2916 }
2917
2918 /**
2919 * xmlAddRef:
2920 * @ctxt: the validation context
2921 * @doc: pointer to the document
2922 * @value: the value name
2923 * @attr: the attribute holding the Ref
2924 *
2925 * Register a new ref declaration
2926 *
2927 * Returns NULL if not, otherwise the new xmlRefPtr
2928 */
2929 xmlRefPtr
2930 xmlAddRef(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value,
2931 xmlAttrPtr attr) {
2932 xmlRefPtr ret;
2933 xmlRefTablePtr table;
2934 xmlListPtr ref_list;
2935
2936 if (doc == NULL) {
2937 return(NULL);
2938 }
2939 if (value == NULL) {
2940 return(NULL);
2941 }
2942 if (attr == NULL) {
2943 return(NULL);
2944 }
2945
2946 /*
2947 * Create the Ref table if needed.
2948 */
2949 table = (xmlRefTablePtr) doc->refs;
2950 if (table == NULL) {
2951 doc->refs = table = xmlHashCreateDict(0, doc->dict);
2952 }
2953 if (table == NULL) {
2954 xmlVErrMemory(ctxt,
2955 "xmlAddRef: Table creation failed!\n");
2956 return(NULL);
2957 }
2958
2959 ret = (xmlRefPtr) xmlMalloc(sizeof(xmlRef));
2960 if (ret == NULL) {
2961 xmlVErrMemory(ctxt, "malloc failed");
2962 return(NULL);
2963 }
2964
2965 /*
2966 * fill the structure.
2967 */
2968 ret->value = xmlStrdup(value);
2969 if ((ctxt != NULL) && (ctxt->vstateNr != 0)) {
2970 /*
2971 * Operating in streaming mode, attr is gonna disapear
2972 */
2973 ret->name = xmlStrdup(attr->name);
2974 ret->attr = NULL;
2975 } else {
2976 ret->name = NULL;
2977 ret->attr = attr;
2978 }
2979 ret->lineno = xmlGetLineNo(attr->parent);
2980
2981 /* To add a reference :-
2982 * References are maintained as a list of references,
2983 * Lookup the entry, if no entry create new nodelist
2984 * Add the owning node to the NodeList
2985 * Return the ref
2986 */
2987
2988 if (NULL == (ref_list = xmlHashLookup(table, value))) {
2989 if (NULL == (ref_list = xmlListCreate(xmlFreeRef, xmlDummyCompare))) {
2990 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2991 "xmlAddRef: Reference list creation failed!\n",
2992 NULL);
2993 goto failed;
2994 }
2995 if (xmlHashAddEntry(table, value, ref_list) < 0) {
2996 xmlListDelete(ref_list);
2997 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2998 "xmlAddRef: Reference list insertion failed!\n",
2999 NULL);
3000 goto failed;
3001 }
3002 }
3003 if (xmlListAppend(ref_list, ret) != 0) {
3004 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
3005 "xmlAddRef: Reference list insertion failed!\n",
3006 NULL);
3007 goto failed;
3008 }
3009 return(ret);
3010 failed:
3011 if (ret != NULL) {
3012 if (ret->value != NULL)
3013 xmlFree((char *)ret->value);
3014 if (ret->name != NULL)
3015 xmlFree((char *)ret->name);
3016 xmlFree(ret);
3017 }
3018 return(NULL);
3019 }
3020
3021 /**
3022 * xmlFreeRefTable:
3023 * @table: An ref table
3024 *
3025 * Deallocate the memory used by an Ref hash table.
3026 */
3027 void
3028 xmlFreeRefTable(xmlRefTablePtr table) {
3029 xmlHashFree(table, xmlFreeRefTableEntry);
3030 }
3031
3032 /**
3033 * xmlIsRef:
3034 * @doc: the document
3035 * @elem: the element carrying the attribute
3036 * @attr: the attribute
3037 *
3038 * Determine whether an attribute is of type Ref. In case we have DTD(s)
3039 * then this is simple, otherwise we use an heuristic: name Ref (upper
3040 * or lowercase).
3041 *
3042 * Returns 0 or 1 depending on the lookup result
3043 */
3044 int
3045 xmlIsRef(xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr) {
3046 if (attr == NULL)
3047 return(0);
3048 if (doc == NULL) {
3049 doc = attr->doc;
3050 if (doc == NULL) return(0);
3051 }
3052
3053 if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
3054 return(0);
3055 } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
3056 /* TODO @@@ */
3057 return(0);
3058 } else {
3059 xmlAttributePtr attrDecl;
3060
3061 if (elem == NULL) return(0);
3062 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, attr->name);
3063 if ((attrDecl == NULL) && (doc->extSubset != NULL))
3064 attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
3065 elem->name, attr->name);
3066
3067 if ((attrDecl != NULL) &&
3068 (attrDecl->atype == XML_ATTRIBUTE_IDREF ||
3069 attrDecl->atype == XML_ATTRIBUTE_IDREFS))
3070 return(1);
3071 }
3072 return(0);
3073 }
3074
3075 /**
3076 * xmlRemoveRef:
3077 * @doc: the document
3078 * @attr: the attribute
3079 *
3080 * Remove the given attribute from the Ref table maintained internally.
3081 *
3082 * Returns -1 if the lookup failed and 0 otherwise
3083 */
3084 int
3085 xmlRemoveRef(xmlDocPtr doc, xmlAttrPtr attr) {
3086 xmlListPtr ref_list;
3087 xmlRefTablePtr table;
3088 xmlChar *ID;
3089 xmlRemoveMemo target;
3090
3091 if (doc == NULL) return(-1);
3092 if (attr == NULL) return(-1);
3093
3094 table = (xmlRefTablePtr) doc->refs;
3095 if (table == NULL)
3096 return(-1);
3097
3098 ID = xmlNodeListGetString(doc, attr->children, 1);
3099 if (ID == NULL)
3100 return(-1);
3101
3102 ref_list = xmlHashLookup(table, ID);
3103 if(ref_list == NULL) {
3104 xmlFree(ID);
3105 return (-1);
3106 }
3107
3108 /* At this point, ref_list refers to a list of references which
3109 * have the same key as the supplied attr. Our list of references
3110 * is ordered by reference address and we don't have that information
3111 * here to use when removing. We'll have to walk the list and
3112 * check for a matching attribute, when we find one stop the walk
3113 * and remove the entry.
3114 * The list is ordered by reference, so that means we don't have the
3115 * key. Passing the list and the reference to the walker means we
3116 * will have enough data to be able to remove the entry.
3117 */
3118 target.l = ref_list;
3119 target.ap = attr;
3120
3121 /* Remove the supplied attr from our list */
3122 xmlListWalk(ref_list, xmlWalkRemoveRef, &target);
3123
3124 /*If the list is empty then remove the list entry in the hash */
3125 if (xmlListEmpty(ref_list))
3126 xmlHashUpdateEntry(table, ID, NULL, xmlFreeRefTableEntry);
3127 xmlFree(ID);
3128 return(0);
3129 }
3130
3131 /**
3132 * xmlGetRefs:
3133 * @doc: pointer to the document
3134 * @ID: the ID value
3135 *
3136 * Find the set of references for the supplied ID.
3137 *
3138 * Returns NULL if not found, otherwise node set for the ID.
3139 */
3140 xmlListPtr
3141 xmlGetRefs(xmlDocPtr doc, const xmlChar *ID) {
3142 xmlRefTablePtr table;
3143
3144 if (doc == NULL) {
3145 return(NULL);
3146 }
3147
3148 if (ID == NULL) {
3149 return(NULL);
3150 }
3151
3152 table = (xmlRefTablePtr) doc->refs;
3153 if (table == NULL)
3154 return(NULL);
3155
3156 return (xmlHashLookup(table, ID));
3157 }
3158
3159 /************************************************************************
3160 * *
3161 * Routines for validity checking *
3162 * *
3163 ************************************************************************/
3164
3165 /**
3166 * xmlGetDtdElementDesc:
3167 * @dtd: a pointer to the DtD to search
3168 * @name: the element name
3169 *
3170 * Search the DTD for the description of this element
3171 *
3172 * returns the xmlElementPtr if found or NULL
3173 */
3174
3175 xmlElementPtr
3176 xmlGetDtdElementDesc(xmlDtdPtr dtd, const xmlChar *name) {
3177 xmlElementTablePtr table;
3178 xmlElementPtr cur;
3179 xmlChar *uqname = NULL, *prefix = NULL;
3180
3181 if ((dtd == NULL) || (name == NULL)) return(NULL);
3182 if (dtd->elements == NULL)
3183 return(NULL);
3184 table = (xmlElementTablePtr) dtd->elements;
3185
3186 uqname = xmlSplitQName2(name, &prefix);
3187 if (uqname != NULL)
3188 name = uqname;
3189 cur = xmlHashLookup2(table, name, prefix);
3190 if (prefix != NULL) xmlFree(prefix);
3191 if (uqname != NULL) xmlFree(uqname);
3192 return(cur);
3193 }
3194 /**
3195