valid.c@ 84439

Last change on this file since 84439 was 65950, checked in by vboxsync, 8 years ago
libxml 2.9.4: fix export
Property svn:eol-style set to `native`
File size: 188.4 KB

Line
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	* [email protected]
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"

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/libxml2-2.9.4/valid.c@ 84439

Download in other formats: