valid.c@ 58072

最後變更在這個檔案從58072是 58072,由 vboxsync 提交於 9 年前
libxml 2.9.2 unmodified
屬性 svn:eol-style 設為 `native`
檔案大小: 188.3 KB

行
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
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
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
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
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" dictionnary 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	xmlErrValidNode(ctxt, attr->parent, XML_DTD_ID_REDEFINED,
2638	"ID %s already defined\n", value, NULL, NULL);
2639	#endif /* LIBXML_VALID_ENABLED */
2640	xmlFreeID(ret);
2641	return(NULL);
2642	}
2643	if (attr != NULL)
2644	attr->atype = XML_ATTRIBUTE_ID;
2645	return(ret);
2646	}
2647
2648	/**
2649	* xmlFreeIDTable:
2650	* @table: An id table
2651	*
2652	* Deallocate the memory used by an ID hash table.
2653	*/
2654	void
2655	xmlFreeIDTable(xmlIDTablePtr table) {
2656	xmlHashFree(table, (xmlHashDeallocator) xmlFreeID);
2657	}
2658
2659	/**
2660	* xmlIsID:
2661	* @doc: the document
2662	* @elem: the element carrying the attribute
2663	* @attr: the attribute
2664	*
2665	* Determine whether an attribute is of type ID. In case we have DTD(s)
2666	* then this is done if DTD loading has been requested. In the case
2667	* of HTML documents parsed with the HTML parser, then ID detection is
2668	* done systematically.
2669	*
2670	* Returns 0 or 1 depending on the lookup result
2671	*/
2672	int
2673	xmlIsID(xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr) {
2674	if ((attr == NULL) \|\| (attr->name == NULL)) return(0);
2675	if ((attr->ns != NULL) && (attr->ns->prefix != NULL) &&
2676	(!strcmp((char *) attr->name, "id")) &&
2677	(!strcmp((char *) attr->ns->prefix, "xml")))
2678	return(1);
2679	if (doc == NULL) return(0);
2680	if ((doc->intSubset == NULL) && (doc->extSubset == NULL) &&
2681	(doc->type != XML_HTML_DOCUMENT_NODE)) {
2682	return(0);
2683	} else if (doc->type == XML_HTML_DOCUMENT_NODE) {
2684	if ((xmlStrEqual(BAD_CAST "id", attr->name)) \|\|
2685	((xmlStrEqual(BAD_CAST "name", attr->name)) &&
2686	((elem == NULL) \|\| (xmlStrEqual(elem->name, BAD_CAST "a")))))
2687	return(1);
2688	return(0);
2689	} else if (elem == NULL) {
2690	return(0);
2691	} else {
2692	xmlAttributePtr attrDecl = NULL;
2693
2694	xmlChar felem[50], fattr[50];
2695	xmlChar fullelemname, fullattrname;
2696
2697	fullelemname = (elem->ns != NULL && elem->ns->prefix != NULL) ?
2698	xmlBuildQName(elem->name, elem->ns->prefix, felem, 50) :
2699	(xmlChar *)elem->name;
2700
2701	fullattrname = (attr->ns != NULL && attr->ns->prefix != NULL) ?
2702	xmlBuildQName(attr->name, attr->ns->prefix, fattr, 50) :
2703	(xmlChar *)attr->name;
2704
2705	if (fullelemname != NULL && fullattrname != NULL) {
2706	attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullelemname,
2707	fullattrname);
2708	if ((attrDecl == NULL) && (doc->extSubset != NULL))
2709	attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullelemname,
2710	fullattrname);
2711	}
2712
2713	if ((fullattrname != fattr) && (fullattrname != attr->name))
2714	xmlFree(fullattrname);
2715	if ((fullelemname != felem) && (fullelemname != elem->name))
2716	xmlFree(fullelemname);
2717
2718	if ((attrDecl != NULL) && (attrDecl->atype == XML_ATTRIBUTE_ID))
2719	return(1);
2720	}
2721	return(0);
2722	}
2723
2724	/**
2725	* xmlRemoveID:
2726	* @doc: the document
2727	* @attr: the attribute
2728	*
2729	* Remove the given attribute from the ID table maintained internally.
2730	*
2731	* Returns -1 if the lookup failed and 0 otherwise
2732	*/
2733	int
2734	xmlRemoveID(xmlDocPtr doc, xmlAttrPtr attr) {
2735	xmlIDTablePtr table;
2736	xmlIDPtr id;
2737	xmlChar *ID;
2738
2739	if (doc == NULL) return(-1);
2740	if (attr == NULL) return(-1);
2741
2742	table = (xmlIDTablePtr) doc->ids;
2743	if (table == NULL)
2744	return(-1);
2745
2746	ID = xmlNodeListGetString(doc, attr->children, 1);
2747	if (ID == NULL)
2748	return(-1);
2749
2750	id = xmlHashLookup(table, ID);
2751	if (id == NULL \|\| id->attr != attr) {
2752	xmlFree(ID);
2753	return(-1);
2754	}
2755
2756	xmlHashRemoveEntry(table, ID, (xmlHashDeallocator) xmlFreeID);
2757	xmlFree(ID);
2758	attr->atype = 0;
2759	return(0);
2760	}
2761
2762	/**
2763	* xmlGetID:
2764	* @doc: pointer to the document
2765	* @ID: the ID value
2766	*
2767	* Search the attribute declaring the given ID
2768	*
2769	* Returns NULL if not found, otherwise the xmlAttrPtr defining the ID
2770	*/
2771	xmlAttrPtr
2772	xmlGetID(xmlDocPtr doc, const xmlChar *ID) {
2773	xmlIDTablePtr table;
2774	xmlIDPtr id;
2775
2776	if (doc == NULL) {
2777	return(NULL);
2778	}
2779
2780	if (ID == NULL) {
2781	return(NULL);
2782	}
2783
2784	table = (xmlIDTablePtr) doc->ids;
2785	if (table == NULL)
2786	return(NULL);
2787
2788	id = xmlHashLookup(table, ID);
2789	if (id == NULL)
2790	return(NULL);
2791	if (id->attr == NULL) {
2792	/*
2793	* We are operating on a stream, return a well known reference
2794	* since the attribute node doesn't exist anymore
2795	*/
2796	return((xmlAttrPtr) doc);
2797	}
2798	return(id->attr);
2799	}
2800
2801	/************************************************************************
2802	* *
2803	* Refs *
2804	* *
2805	************************************************************************/
2806	typedef struct xmlRemoveMemo_t
2807	{
2808	xmlListPtr l;
2809	xmlAttrPtr ap;
2810	} xmlRemoveMemo;
2811
2812	typedef xmlRemoveMemo *xmlRemoveMemoPtr;
2813
2814	typedef struct xmlValidateMemo_t
2815	{
2816	xmlValidCtxtPtr ctxt;
2817	const xmlChar *name;
2818	} xmlValidateMemo;
2819
2820	typedef xmlValidateMemo *xmlValidateMemoPtr;
2821
2822	/**
2823	* xmlFreeRef:
2824	* @lk: A list link
2825	*
2826	* Deallocate the memory used by a ref definition
2827	*/
2828	static void
2829	xmlFreeRef(xmlLinkPtr lk) {
2830	xmlRefPtr ref = (xmlRefPtr)xmlLinkGetData(lk);
2831	if (ref == NULL) return;
2832	if (ref->value != NULL)
2833	xmlFree((xmlChar *)ref->value);
2834	if (ref->name != NULL)
2835	xmlFree((xmlChar *)ref->name);
2836	xmlFree(ref);
2837	}
2838
2839	/**
2840	* xmlFreeRefList:
2841	* @list_ref: A list of references.
2842	*
2843	* Deallocate the memory used by a list of references
2844	*/
2845	static void
2846	xmlFreeRefList(xmlListPtr list_ref) {
2847	if (list_ref == NULL) return;
2848	xmlListDelete(list_ref);
2849	}
2850
2851	/**
2852	* xmlWalkRemoveRef:
2853	* @data: Contents of current link
2854	* @user: Value supplied by the user
2855	*
2856	* Returns 0 to abort the walk or 1 to continue
2857	*/
2858	static int
2859	xmlWalkRemoveRef(const void data, const void user)
2860	{
2861	xmlAttrPtr attr0 = ((xmlRefPtr)data)->attr;
2862	xmlAttrPtr attr1 = ((xmlRemoveMemoPtr)user)->ap;
2863	xmlListPtr ref_list = ((xmlRemoveMemoPtr)user)->l;
2864
2865	if (attr0 == attr1) { /* Matched: remove and terminate walk */
2866	xmlListRemoveFirst(ref_list, (void *)data);
2867	return 0;
2868	}
2869	return 1;
2870	}
2871
2872	/**
2873	* xmlDummyCompare
2874	* @data0: Value supplied by the user
2875	* @data1: Value supplied by the user
2876	*
2877	* Do nothing, return 0. Used to create unordered lists.
2878	*/
2879	static int
2880	xmlDummyCompare(const void *data0 ATTRIBUTE_UNUSED,
2881	const void *data1 ATTRIBUTE_UNUSED)
2882	{
2883	return (0);
2884	}
2885
2886	/**
2887	* xmlAddRef:
2888	* @ctxt: the validation context
2889	* @doc: pointer to the document
2890	* @value: the value name
2891	* @attr: the attribute holding the Ref
2892	*
2893	* Register a new ref declaration
2894	*
2895	* Returns NULL if not, otherwise the new xmlRefPtr
2896	*/
2897	xmlRefPtr
2898	xmlAddRef(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value,
2899	xmlAttrPtr attr) {
2900	xmlRefPtr ret;
2901	xmlRefTablePtr table;
2902	xmlListPtr ref_list;
2903
2904	if (doc == NULL) {
2905	return(NULL);
2906	}
2907	if (value == NULL) {
2908	return(NULL);
2909	}
2910	if (attr == NULL) {
2911	return(NULL);
2912	}
2913
2914	/*
2915	* Create the Ref table if needed.
2916	*/
2917	table = (xmlRefTablePtr) doc->refs;
2918	if (table == NULL) {
2919	doc->refs = table = xmlHashCreateDict(0, doc->dict);
2920	}
2921	if (table == NULL) {
2922	xmlVErrMemory(ctxt,
2923	"xmlAddRef: Table creation failed!\n");
2924	return(NULL);
2925	}
2926
2927	ret = (xmlRefPtr) xmlMalloc(sizeof(xmlRef));
2928	if (ret == NULL) {
2929	xmlVErrMemory(ctxt, "malloc failed");
2930	return(NULL);
2931	}
2932
2933	/*
2934	* fill the structure.
2935	*/
2936	ret->value = xmlStrdup(value);
2937	if ((ctxt != NULL) && (ctxt->vstateNr != 0)) {
2938	/*
2939	* Operating in streaming mode, attr is gonna disapear
2940	*/
2941	ret->name = xmlStrdup(attr->name);
2942	ret->attr = NULL;
2943	} else {
2944	ret->name = NULL;
2945	ret->attr = attr;
2946	}
2947	ret->lineno = xmlGetLineNo(attr->parent);
2948
2949	/* To add a reference :-
2950	* References are maintained as a list of references,
2951	* Lookup the entry, if no entry create new nodelist
2952	* Add the owning node to the NodeList
2953	* Return the ref
2954	*/
2955
2956	if (NULL == (ref_list = xmlHashLookup(table, value))) {
2957	if (NULL == (ref_list = xmlListCreate(xmlFreeRef, xmlDummyCompare))) {
2958	xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2959	"xmlAddRef: Reference list creation failed!\n",
2960	NULL);
2961	goto failed;
2962	}
2963	if (xmlHashAddEntry(table, value, ref_list) < 0) {
2964	xmlListDelete(ref_list);
2965	xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2966	"xmlAddRef: Reference list insertion failed!\n",
2967	NULL);
2968	goto failed;
2969	}
2970	}
2971	if (xmlListAppend(ref_list, ret) != 0) {
2972	xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2973	"xmlAddRef: Reference list insertion failed!\n",
2974	NULL);
2975	goto failed;
2976	}
2977	return(ret);
2978	failed:
2979	if (ret != NULL) {
2980	if (ret->value != NULL)
2981	xmlFree((char *)ret->value);
2982	if (ret->name != NULL)
2983	xmlFree((char *)ret->name);
2984	xmlFree(ret);
2985	}
2986	return(NULL);
2987	}
2988
2989	/**
2990	* xmlFreeRefTable:
2991	* @table: An ref table
2992	*
2993	* Deallocate the memory used by an Ref hash table.
2994	*/
2995	void
2996	xmlFreeRefTable(xmlRefTablePtr table) {
2997	xmlHashFree(table, (xmlHashDeallocator) xmlFreeRefList);
2998	}
2999
3000	/**
3001	* xmlIsRef:
3002	* @doc: the document
3003	* @elem: the element carrying the attribute
3004	* @attr: the attribute
3005	*
3006	* Determine whether an attribute is of type Ref. In case we have DTD(s)
3007	* then this is simple, otherwise we use an heuristic: name Ref (upper
3008	* or lowercase).
3009	*
3010	* Returns 0 or 1 depending on the lookup result
3011	*/
3012	int
3013	xmlIsRef(xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr) {
3014	if (attr == NULL)
3015	return(0);
3016	if (doc == NULL) {
3017	doc = attr->doc;
3018	if (doc == NULL) return(0);
3019	}
3020
3021	if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
3022	return(0);
3023	} else if (doc->type == XML_HTML_DOCUMENT_NODE) {
3024	/* TODO @@@ */
3025	return(0);
3026	} else {
3027	xmlAttributePtr attrDecl;
3028
3029	if (elem == NULL) return(0);
3030	attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, attr->name);
3031	if ((attrDecl == NULL) && (doc->extSubset != NULL))
3032	attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
3033	elem->name, attr->name);
3034
3035	if ((attrDecl != NULL) &&
3036	(attrDecl->atype == XML_ATTRIBUTE_IDREF \|\|
3037	attrDecl->atype == XML_ATTRIBUTE_IDREFS))
3038	return(1);
3039	}
3040	return(0);
3041	}
3042
3043	/**
3044	* xmlRemoveRef:
3045	* @doc: the document
3046	* @attr: the attribute
3047	*
3048	* Remove the given attribute from the Ref table maintained internally.
3049	*
3050	* Returns -1 if the lookup failed and 0 otherwise
3051	*/
3052	int
3053	xmlRemoveRef(xmlDocPtr doc, xmlAttrPtr attr) {
3054	xmlListPtr ref_list;
3055	xmlRefTablePtr table;
3056	xmlChar *ID;
3057	xmlRemoveMemo target;
3058
3059	if (doc == NULL) return(-1);
3060	if (attr == NULL) return(-1);
3061
3062	table = (xmlRefTablePtr) doc->refs;
3063	if (table == NULL)
3064	return(-1);
3065
3066	ID = xmlNodeListGetString(doc, attr->children, 1);
3067	if (ID == NULL)
3068	return(-1);
3069
3070	ref_list = xmlHashLookup(table, ID);
3071	if(ref_list == NULL) {
3072	xmlFree(ID);
3073	return (-1);
3074	}
3075
3076	/* At this point, ref_list refers to a list of references which
3077	* have the same key as the supplied attr. Our list of references
3078	* is ordered by reference address and we don't have that information
3079	* here to use when removing. We'll have to walk the list and
3080	* check for a matching attribute, when we find one stop the walk
3081	* and remove the entry.
3082	* The list is ordered by reference, so that means we don't have the
3083	* key. Passing the list and the reference to the walker means we
3084	* will have enough data to be able to remove the entry.
3085	*/
3086	target.l = ref_list;
3087	target.ap = attr;
3088
3089	/* Remove the supplied attr from our list */
3090	xmlListWalk(ref_list, xmlWalkRemoveRef, &target);
3091
3092	/If the list is empty then remove the list entry in the hash /
3093	if (xmlListEmpty(ref_list))
3094	xmlHashUpdateEntry(table, ID, NULL, (xmlHashDeallocator)
3095	xmlFreeRefList);
3096	xmlFree(ID);
3097	return(0);
3098	}
3099
3100	/**
3101	* xmlGetRefs:
3102	* @doc: pointer to the document
3103	* @ID: the ID value
3104	*
3105	* Find the set of references for the supplied ID.
3106	*
3107	* Returns NULL if not found, otherwise node set for the ID.
3108	*/
3109	xmlListPtr
3110	xmlGetRefs(xmlDocPtr doc, const xmlChar *ID) {
3111	xmlRefTablePtr table;
3112
3113	if (doc == NULL) {
3114	return(NULL);
3115	}
3116
3117	if (ID == NULL) {
3118	return(NULL);
3119	}
3120
3121	table = (xmlRefTablePtr) doc->refs;
3122	if (table == NULL)
3123	return(NULL);
3124
3125	return (xmlHashLookup(table, ID));
3126	}
3127
3128	/************************************************************************
3129	* *
3130	* Routines for validity checking *
3131	* *
3132	************************************************************************/
3133
3134	/**
3135	* xmlGetDtdElementDesc:
3136	* @dtd: a pointer to the DtD to search
3137	* @name: the element name
3138	*
3139	* Search the DTD for the description of this element
3140	*
3141	* returns the xmlElementPtr if found or NULL
3142	*/
3143
3144	xmlElementPtr
3145	xmlGetDtdElementDesc(xmlDtdPtr dtd, const xmlChar *name) {
3146	xmlElementTablePtr table;
3147	xmlElementPtr cur;
3148	xmlChar uqname = NULL, prefix = NULL;
3149
3150	if ((dtd == NULL) \|\| (name == NULL)) return(NULL);
3151	if (dtd->elements == NULL)
3152	return(NULL);
3153	table = (xmlElementTablePtr) dtd->elements;
3154
3155	uqname = xmlSplitQName2(name, &prefix);
3156	if (uqname != NULL)
3157	name = uqname;
3158	cur = xmlHashLookup2(table, name, prefix);
3159	if (prefix != NULL) xmlFree(prefix);
3160	if (uqname != NULL) xmlFree(uqname);
3161	return(cur);
3162	}
3163	/**
3164	* xmlGetDtdElementDesc2:
3165	* @dtd: a pointer to the DtD to search
3166	* @name: the element name
3167	* @create: create an empty description if not found
3168	*
3169	* Search the DTD for the description of this element
3170	*
3171	* returns the xmlElementPtr if found or NULL
3172	*/
3173
3174	static xmlElementPtr
3175	xmlGetDtdElementDesc2(xmlDtdPtr dtd, const xmlChar *name, int create) {
3176	xmlElementTablePtr table;
3177	xmlElementPtr cur;
3178	xmlChar uqname = NULL, prefix = NULL;
3179
3180	if (dtd == NULL) return(NULL);
3181	if (dtd->elements == NULL) {
3182	xmlDictPtr dict = NULL;
3183
3184	if (dtd->doc != NULL)
3185	dict = dtd->doc->dict;
3186
3187	if (!create)
3188	return(NULL);
3189	/*
3190	* Create the Element table if needed.
3191	*/
3192	table = (xmlElementTablePtr) dtd->elements;
3193	if (table == NULL) {
3194	table = xmlHashCreateDict(0, dict);
3195	dtd->elements = (void *) table;
3196	}
3197	if (table == NULL) {
3198	xmlVErrMemory(NULL, "element table allocation failed");
3199	return(NULL);
3200	}
3201	}
3202	table = (xmlElementTablePtr) dtd->elements;
3203
3204	uqname = xmlSplitQName2(name, &prefix);
3205	if (uqname != NULL)
3206	name = uqname;
3207	cur = xmlHashLookup2(table, name, prefix);
3208	if ((cur == NULL) && (create)) {
3209	cur = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
3210	if (cur == NULL) {
3211	xmlVErrMemory(NULL, "malloc failed");
3212	return(NULL);
3213	}
3214	memset(cur, 0, sizeof(xmlElement));
3215	cur->type = XML_ELEMENT_DECL;
3216
3217	/*
3218	* fill the structure.
3219	*/
3220	cur->name = xmlStrdup(name);
3221	cur->prefix = xmlStrdup(prefix);
3222	cur->etype = XML_ELEMENT_TYPE_UNDEFINED;
3223
3224	xmlHashAddEntry2(table, name, prefix, cur);
3225	}
3226	if (prefix != NULL) xmlFree(prefix);
3227	if (uqname != NULL) xmlFree(uqname);
3228	return(cur);
3229	}
3230
3231	/**
3232	* xmlGetDtdQElementDesc:
3233	* @dtd: a pointer to the DtD to search
3234	* @name: the element name
3235	* @prefix: the element namespace prefix
3236	*
3237	* Search the DTD for the description of this element
3238	*
3239	* returns the xmlElementPtr if found or NULL
3240	*/
3241
3242	xmlElementPtr
3243	xmlGetDtdQElementDesc(xmlDtdPtr dtd, const xmlChar *name,
3244	const xmlChar *prefix) {
3245	xmlElementTablePtr table;
3246
3247	if (dtd == NULL) return(NULL);
3248	if (dtd->elements == NULL) return(NULL);
3249	table = (xmlElementTablePtr) dtd->elements;
3250
3251	return(xmlHashLookup2(table, name, prefix));
3252	}
3253
3254	/**
3255	* xmlGetDtdAttrDesc:
3256	* @dtd: a pointer to the DtD to search
3257	* @elem: the element name
3258	* @name: the attribute name
3259	*
3260	* Search the DTD for the description of this attribute on
3261	* this element.
3262	*
3263	* returns the xmlAttributePtr if found or NULL
3264	*/
3265
3266	xmlAttributePtr
3267	xmlGetDtdAttrDesc(xmlDtdPtr dtd, const xmlChar elem, const xmlChar name) {
3268	xmlAttributeTablePtr table;
3269	xmlAttributePtr cur;
3270	xmlChar uqname = NULL, prefix = NULL;
3271
3272	if (dtd == NULL) return(NULL);
3273	if (dtd->attributes == NULL) return(NULL);
3274
3275	table = (xmlAttributeTablePtr) dtd->attributes;
3276	if (table == NULL)
3277	return(NULL);
3278
3279	uqname = xmlSplitQName2(name, &prefix);
3280
3281	if (uqname != NULL) {
3282	cur = xmlHashLookup3(table, uqname, prefix, elem);
3283	if (prefix != NULL) xmlFree(prefix);
3284	if (uqname != NULL) xmlFree(uqname);
3285	} else
3286	cur = xmlHashLookup3(table, name, NULL, elem);
3287	return(cur);
3288	}
3289
3290	/**
3291	* xmlGetDtdQAttrDesc:
3292	* @dtd: a pointer to the DtD to search
3293	* @elem: the element name
3294	* @name: the attribute name
3295	* @prefix: the attribute namespace prefix
3296	*
3297	* Search the DTD for the description of this qualified attribute on
3298	* this element.
3299	*
3300	* returns the xmlAttributePtr if found or NULL
3301	*/
3302
3303	xmlAttributePtr
3304	xmlGetDtdQAttrDesc(xmlDtdPtr dtd, const xmlChar elem, const xmlChar name,
3305	const xmlChar *prefix) {
3306	xmlAttributeTablePtr table;
3307
3308	if (dtd == NULL) return(NULL);
3309	if (dtd->attributes == NULL) return(NULL);
3310	table = (xmlAttributeTablePtr) dtd->attributes;
3311
3312	return(xmlHashLookup3(table, name, prefix, elem));
3313	}
3314
3315	/**
3316	* xmlGetDtdNotationDesc:
3317	* @dtd: a pointer to the DtD to search
3318	* @name: the notation name
3319	*
3320	* Search the DTD for the description of this notation
3321	*
3322	* returns the xmlNotationPtr if found or NULL
3323	*/
3324
3325	xmlNotationPtr
3326	xmlGetDtdNotationDesc(xmlDtdPtr dtd, const xmlChar *name) {
3327	xmlNotationTablePtr table;
3328
3329	if (dtd == NULL) return(NULL);
3330	if (dtd->notations == NULL) return(NULL);
3331	table = (xmlNotationTablePtr) dtd->notations;
3332
3333	return(xmlHashLookup(table, name));
3334	}
3335
3336	#if defined(LIBXML_VALID_ENABLED) \|\| defined(LIBXML_SCHEMAS_ENABLED)
3337	/**
3338	* xmlValidateNotationUse:
3339	* @ctxt: the validation context
3340	* @doc: the document
3341	* @notationName: the notation name to check
3342	*
3343	* Validate that the given name match a notation declaration.
3344	* - [ VC: Notation Declared ]
3345	*
3346	* returns 1 if valid or 0 otherwise
3347	*/
3348
3349	int
3350	xmlValidateNotationUse(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
3351	const xmlChar *notationName) {
3352	xmlNotationPtr notaDecl;
3353	if ((doc == NULL) \|\| (doc->intSubset == NULL) \|\|
3354	(notationName == NULL)) return(-1);
3355
3356	notaDecl = xmlGetDtdNotationDesc(doc->intSubset, notationName);
3357	if ((notaDecl == NULL) && (doc->extSubset != NULL))
3358	notaDecl = xmlGetDtdNotationDesc(doc->extSubset, notationName);
3359
3360	if ((notaDecl == NULL) && (ctxt != NULL)) {
3361	xmlErrValidNode(ctxt, (xmlNodePtr) doc, XML_DTD_UNKNOWN_NOTATION,
3362	"NOTATION %s is not declared\n",
3363	notationName, NULL, NULL);
3364	return(0);
3365	}
3366	return(1);
3367	}
3368	#endif /* LIBXML_VALID_ENABLED or LIBXML_SCHEMAS_ENABLED */
3369
3370	/**
3371	* xmlIsMixedElement:
3372	* @doc: the document
3373	* @name: the element name
3374	*
3375	* Search in the DtDs whether an element accept Mixed content (or ANY)
3376	* basically if it is supposed to accept text childs
3377	*
3378	* returns 0 if no, 1 if yes, and -1 if no element description is available
3379	*/
3380
3381	int
3382	xmlIsMixedElement(xmlDocPtr doc, const xmlChar *name) {
3383	xmlElementPtr elemDecl;
3384
3385	if ((doc == NULL) \|\| (doc->intSubset == NULL)) return(-1);
3386
3387	elemDecl = xmlGetDtdElementDesc(doc->intSubset, name);
3388	if ((elemDecl == NULL) && (doc->extSubset != NULL))
3389	elemDecl = xmlGetDtdElementDesc(doc->extSubset, name);
3390	if (elemDecl == NULL) return(-1);
3391	switch (elemDecl->etype) {
3392	case XML_ELEMENT_TYPE_UNDEFINED:
3393	return(-1);
3394	case XML_ELEMENT_TYPE_ELEMENT:
3395	return(0);
3396	case XML_ELEMENT_TYPE_EMPTY:
3397	/*
3398	* return 1 for EMPTY since we want VC error to pop up
3399	* on <empty> </empty> for example
3400	*/
3401	case XML_ELEMENT_TYPE_ANY:
3402	case XML_ELEMENT_TYPE_MIXED:
3403	return(1);
3404	}
3405	return(1);
3406	}
3407
3408	#ifdef LIBXML_VALID_ENABLED
3409
3410	static int
3411	xmlIsDocNameStartChar(xmlDocPtr doc, int c) {
3412	if ((doc == NULL) \|\| (doc->properties & XML_DOC_OLD10) == 0) {
3413	/*
3414	* Use the new checks of production [4] [4a] amd [5] of the
3415	* Update 5 of XML-1.0
3416	*/
3417	if (((c >= 'a') && (c <= 'z')) \|\|
3418	((c >= 'A') && (c <= 'Z')) \|\|
3419	(c == '_') \|\| (c == ':') \|\|
3420	((c >= 0xC0) && (c <= 0xD6)) \|\|
3421	((c >= 0xD8) && (c <= 0xF6)) \|\|
3422	((c >= 0xF8) && (c <= 0x2FF)) \|\|
3423	((c >= 0x370) && (c <= 0x37D)) \|\|
3424	((c >= 0x37F) && (c <= 0x1FFF)) \|\|
3425	((c >= 0x200C) && (c <= 0x200D)) \|\|
3426	((c >= 0x2070) && (c <= 0x218F)) \|\|
3427	((c >= 0x2C00) && (c <= 0x2FEF)) \|\|
3428	((c >= 0x3001) && (c <= 0xD7FF)) \|\|
3429	((c >= 0xF900) && (c <= 0xFDCF)) \|\|
3430	((c >= 0xFDF0) && (c <= 0xFFFD)) \|\|
3431	((c >= 0x10000) && (c <= 0xEFFFF)))
3432	return(1);
3433	} else {
3434	if (IS_LETTER(c) \|\| (c == '_') \|\| (c == ':'))
3435	return(1);
3436	}
3437	return(0);
3438	}
3439
3440	static int
3441	xmlIsDocNameChar(xmlDocPtr doc, int c) {
3442	if ((doc == NULL) \|\| (doc->properties & XML_DOC_OLD10) == 0) {
3443	/*
3444	* Use the new checks of production [4] [4a] amd [5] of the
3445	* Update 5 of XML-1.0
3446	*/
3447	if (((c >= 'a') && (c <= 'z')) \|\|
3448	((c >= 'A') && (c <= 'Z')) \|\|
3449	((c >= '0') && (c <= '9')) \|\| /* !start */
3450	(c == '_') \|\| (c == ':') \|\|
3451	(c == '-') \|\| (c == '.') \|\| (c == 0xB7) \|\| /* !start */
3452	((c >= 0xC0) && (c <= 0xD6)) \|\|
3453	((c >= 0xD8) && (c <= 0xF6)) \|\|
3454	((c >= 0xF8) && (c <= 0x2FF)) \|\|
3455	((c >= 0x300) && (c <= 0x36F)) \|\| /* !start */
3456	((c >= 0x370) && (c <= 0x37D)) \|\|
3457	((c >= 0x37F) && (c <= 0x1FFF)) \|\|
3458	((c >= 0x200C) && (c <= 0x200D)) \|\|
3459	((c >= 0x203F) && (c <= 0x2040)) \|\| /* !start */
3460	((c >= 0x2070) && (c <= 0x218F)) \|\|
3461	((c >= 0x2C00) && (c <= 0x2FEF)) \|\|
3462	((c >= 0x3001) && (c <= 0xD7FF)) \|\|
3463	((c >= 0xF900) && (c <= 0xFDCF)) \|\|
3464	((c >= 0xFDF0) && (c <= 0xFFFD)) \|\|
3465	((c >= 0x10000) && (c <= 0xEFFFF)))
3466	return(1);
3467	} else {
3468	if ((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\|
3469	(c == '.') \|\| (c == '-') \|\|
3470	(c == '_') \|\| (c == ':') \|\|
3471	(IS_COMBINING(c)) \|\|
3472	(IS_EXTENDER(c)))
3473	return(1);
3474	}
3475	return(0);
3476	}
3477
3478	/**
3479	* xmlValidateNameValue:
3480	* @doc: pointer to the document or NULL
3481	* @value: an Name value
3482	*
3483	* Validate that the given value match Name production
3484	*
3485	* returns 1 if valid or 0 otherwise
3486	*/
3487
3488	static int
3489	xmlValidateNameValueInternal(xmlDocPtr doc, const xmlChar *value) {
3490	const xmlChar *cur;
3491	int val, len;
3492
3493	if (value == NULL) return(0);
3494	cur = value;
3495	val = xmlStringCurrentChar(NULL, cur, &len);
3496	cur += len;
3497	if (!xmlIsDocNameStartChar(doc, val))
3498	return(0);
3499
3500	val = xmlStringCurrentChar(NULL, cur, &len);
3501	cur += len;
3502	while (xmlIsDocNameChar(doc, val)) {
3503	val = xmlStringCurrentChar(NULL, cur, &len);
3504	cur += len;
3505	}
3506
3507	if (val != 0) return(0);
3508
3509	return(1);
3510	}
3511
3512	/**
3513	* xmlValidateNameValue:
3514	* @value: an Name value
3515	*
3516	* Validate that the given value match Name production
3517	*
3518	* returns 1 if valid or 0 otherwise
3519	*/
3520
3521	int
3522	xmlValidateNameValue(const xmlChar *value) {
3523	return(xmlValidateNameValueInternal(NULL, value));
3524	}
3525
3526	/**
3527	* xmlValidateNamesValueInternal:
3528	* @doc: pointer to the document or NULL
3529	* @value: an Names value
3530	*
3531	* Validate that the given value match Names production
3532	*
3533	* returns 1 if valid or 0 otherwise
3534	*/
3535
3536	static int
3537	xmlValidateNamesValueInternal(xmlDocPtr doc, const xmlChar *value) {
3538	const xmlChar *cur;
3539	int val, len;
3540
3541	if (value == NULL) return(0);
3542	cur = value;
3543	val = xmlStringCurrentChar(NULL, cur, &len);
3544	cur += len;
3545
3546	if (!xmlIsDocNameStartChar(doc, val))
3547	return(0);
3548
3549	val = xmlStringCurrentChar(NULL, cur, &len);
3550	cur += len;
3551	while (xmlIsDocNameChar(doc, val)) {
3552	val = xmlStringCurrentChar(NULL, cur, &len);
3553	cur += len;
3554	}
3555
3556	/* Should not test IS_BLANK(val) here -- see erratum E20*/
3557	while (val == 0x20) {
3558	while (val == 0x20) {
3559	val = xmlStringCurrentChar(NULL, cur, &len);
3560	cur += len;
3561	}
3562
3563	if (!xmlIsDocNameStartChar(doc, val))
3564	return(0);
3565
3566	val = xmlStringCurrentChar(NULL, cur, &len);
3567	cur += len;
3568
3569	while (xmlIsDocNameChar(doc, val)) {
3570	val = xmlStringCurrentChar(NULL, cur, &len);
3571	cur += len;
3572	}
3573	}
3574
3575	if (val != 0) return(0);
3576
3577	return(1);
3578	}
3579
3580	/**
3581	* xmlValidateNamesValue:
3582	* @value: an Names value
3583	*
3584	* Validate that the given value match Names production
3585	*
3586	* returns 1 if valid or 0 otherwise
3587	*/
3588
3589	int
3590	xmlValidateNamesValue(const xmlChar *value) {
3591	return(xmlValidateNamesValueInternal(NULL, value));
3592	}
3593
3594	/**
3595	* xmlValidateNmtokenValueInternal:
3596	* @doc: pointer to the document or NULL
3597	* @value: an Nmtoken value
3598	*
3599	* Validate that the given value match Nmtoken production
3600	*
3601	* [ VC: Name Token ]
3602	*
3603	* returns 1 if valid or 0 otherwise
3604	*/
3605
3606	static int
3607	xmlValidateNmtokenValueInternal(xmlDocPtr doc, const xmlChar *value) {
3608	const xmlChar *cur;
3609	int val, len;
3610
3611	if (value == NULL) return(0);
3612	cur = value;
3613	val = xmlStringCurrentChar(NULL, cur, &len);
3614	cur += len;
3615
3616	if (!xmlIsDocNameChar(doc, val))
3617	return(0);
3618
3619	val = xmlStringCurrentChar(NULL, cur, &len);
3620	cur += len;
3621	while (xmlIsDocNameChar(doc, val)) {
3622	val = xmlStringCurrentChar(NULL, cur, &len);
3623	cur += len;
3624	}
3625
3626	if (val != 0) return(0);
3627
3628	return(1);
3629	}
3630
3631	/**
3632	* xmlValidateNmtokenValue:
3633	* @value: an Nmtoken value
3634	*
3635	* Validate that the given value match Nmtoken production
3636	*
3637	* [ VC: Name Token ]
3638	*
3639	* returns 1 if valid or 0 otherwise
3640	*/
3641
3642	int
3643	xmlValidateNmtokenValue(const xmlChar *value) {
3644	return(xmlValidateNmtokenValueInternal(NULL, value));
3645	}
3646
3647	/**
3648	* xmlValidateNmtokensValueInternal:
3649	* @doc: pointer to the document or NULL
3650	* @value: an Nmtokens value
3651	*
3652	* Validate that the given value match Nmtokens production
3653	*
3654	* [ VC: Name Token ]
3655	*
3656	* returns 1 if valid or 0 otherwise
3657	*/
3658
3659	static int
3660	xmlValidateNmtokensValueInternal(xmlDocPtr doc, const xmlChar *value) {
3661	const xmlChar *cur;
3662	int val, len;
3663
3664	if (value == NULL) return(0);
3665	cur = value;
3666	val = xmlStringCurrentChar(NULL, cur, &len);
3667	cur += len;
3668
3669	while (IS_BLANK(val)) {
3670	val = xmlStringCurrentChar(NULL, cur, &len);
3671	cur += len;
3672	}
3673
3674	if (!xmlIsDocNameChar(doc, val))
3675	return(0);
3676
3677	while (xmlIsDocNameChar(doc, val)) {
3678	val = xmlStringCurrentChar(NULL, cur, &len);
3679	cur += len;
3680	}
3681
3682	/* Should not test IS_BLANK(val) here -- see erratum E20*/
3683	while (val == 0x20) {
3684	while (val == 0x20) {
3685	val = xmlStringCurrentChar(NULL, cur, &len);
3686	cur += len;
3687	}
3688	if (val == 0) return(1);
3689
3690	if (!xmlIsDocNameChar(doc, val))
3691	return(0);
3692
3693	val = xmlStringCurrentChar(NULL, cur, &len);
3694	cur += len;
3695
3696	while (xmlIsDocNameChar(doc, val)) {
3697	val = xmlStringCurrentChar(NULL, cur, &len);
3698	cur += len;
3699	}
3700	}
3701
3702	if (val != 0) return(0);
3703
3704	return(1);
3705	}
3706
3707	/**
3708	* xmlValidateNmtokensValue:
3709	* @value: an Nmtokens value
3710	*
3711	* Validate that the given value match Nmtokens production
3712	*
3713	* [ VC: Name Token ]
3714	*
3715	* returns 1 if valid or 0 otherwise
3716	*/
3717
3718	int
3719	xmlValidateNmtokensValue(const xmlChar *value) {
3720	return(xmlValidateNmtokensValueInternal(NULL, value));
3721	}
3722
3723	/**
3724	* xmlValidateNotationDecl:
3725	* @ctxt: the validation context
3726	* @doc: a document instance
3727	* @nota: a notation definition
3728	*
3729	* Try to validate a single notation definition
3730	* basically it does the following checks as described by the
3731	* XML-1.0 recommendation:
3732	* - it seems that no validity constraint exists on notation declarations
3733	* But this function get called anyway ...
3734	*
3735	* returns 1 if valid or 0 otherwise
3736	*/
3737
3738	int
3739	xmlValidateNotationDecl(xmlValidCtxtPtr ctxt ATTRIBUTE_UNUSED, xmlDocPtr doc ATTRIBUTE_UNUSED,
3740	xmlNotationPtr nota ATTRIBUTE_UNUSED) {
3741	int ret = 1;
3742
3743	return(ret);
3744	}
3745
3746	/**
3747	* xmlValidateAttributeValueInternal:
3748	* @doc: the document
3749	* @type: an attribute type
3750	* @value: an attribute value
3751	*
3752	* Validate that the given attribute value match the proper production
3753	*
3754	* returns 1 if valid or 0 otherwise
3755	*/
3756
3757	static int
3758	xmlValidateAttributeValueInternal(xmlDocPtr doc, xmlAttributeType type,
3759	const xmlChar *value) {
3760	switch (type) {
3761	case XML_ATTRIBUTE_ENTITIES:
3762	case XML_ATTRIBUTE_IDREFS:
3763	return(xmlValidateNamesValueInternal(doc, value));
3764	case XML_ATTRIBUTE_ENTITY:
3765	case XML_ATTRIBUTE_IDREF:
3766	case XML_ATTRIBUTE_ID:
3767	case XML_ATTRIBUTE_NOTATION:
3768	return(xmlValidateNameValueInternal(doc, value));
3769	case XML_ATTRIBUTE_NMTOKENS:
3770	case XML_ATTRIBUTE_ENUMERATION:
3771	return(xmlValidateNmtokensValueInternal(doc, value));
3772	case XML_ATTRIBUTE_NMTOKEN:
3773	return(xmlValidateNmtokenValueInternal(doc, value));
3774	case XML_ATTRIBUTE_CDATA:
3775	break;
3776	}
3777	return(1);
3778	}
3779
3780	/**
3781	* xmlValidateAttributeValue:
3782	* @type: an attribute type
3783	* @value: an attribute value
3784	*
3785	* Validate that the given attribute value match the proper production
3786	*
3787	* [ VC: ID ]
3788	* Values of type ID must match the Name production....
3789	*
3790	* [ VC: IDREF ]
3791	* Values of type IDREF must match the Name production, and values
3792	* of type IDREFS must match Names ...
3793	*
3794	* [ VC: Entity Name ]
3795	* Values of type ENTITY must match the Name production, values
3796	* of type ENTITIES must match Names ...
3797	*
3798	* [ VC: Name Token ]
3799	* Values of type NMTOKEN must match the Nmtoken production; values
3800	* of type NMTOKENS must match Nmtokens.
3801	*
3802	* returns 1 if valid or 0 otherwise
3803	*/
3804	int
3805	xmlValidateAttributeValue(xmlAttributeType type, const xmlChar *value) {
3806	return(xmlValidateAttributeValueInternal(NULL, type, value));
3807	}
3808
3809	/**
3810	* xmlValidateAttributeValue2:
3811	* @ctxt: the validation context
3812	* @doc: the document
3813	* @name: the attribute name (used for error reporting only)
3814	* @type: the attribute type
3815	* @value: the attribute value
3816	*
3817	* Validate that the given attribute value match a given type.
3818	* This typically cannot be done before having finished parsing
3819	* the subsets.
3820	*
3821	* [ VC: IDREF ]
3822	* Values of type IDREF must match one of the declared IDs
3823	* Values of type IDREFS must match a sequence of the declared IDs
3824	* each Name must match the value of an ID attribute on some element
3825	* in the XML document; i.e. IDREF values must match the value of
3826	* some ID attribute
3827	*
3828	* [ VC: Entity Name ]
3829	* Values of type ENTITY must match one declared entity
3830	* Values of type ENTITIES must match a sequence of declared entities
3831	*
3832	* [ VC: Notation Attributes ]
3833	* all notation names in the declaration must be declared.
3834	*
3835	* returns 1 if valid or 0 otherwise
3836	*/
3837
3838	static int
3839	xmlValidateAttributeValue2(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
3840	const xmlChar name, xmlAttributeType type, const xmlChar value) {
3841	int ret = 1;
3842	switch (type) {
3843	case XML_ATTRIBUTE_IDREFS:
3844	case XML_ATTRIBUTE_IDREF:
3845	case XML_ATTRIBUTE_ID:
3846	case XML_ATTRIBUTE_NMTOKENS:
3847	case XML_ATTRIBUTE_ENUMERATION:
3848	case XML_ATTRIBUTE_NMTOKEN:
3849	case XML_ATTRIBUTE_CDATA:
3850	break;
3851	case XML_ATTRIBUTE_ENTITY: {
3852	xmlEntityPtr ent;
3853
3854	ent = xmlGetDocEntity(doc, value);
3855	/* yeah it's a bit messy... */
3856	if ((ent == NULL) && (doc->standalone == 1)) {
3857	doc->standalone = 0;
3858	ent = xmlGetDocEntity(doc, value);
3859	}
3860	if (ent == NULL) {
3861	xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3862	XML_DTD_UNKNOWN_ENTITY,
3863	"ENTITY attribute %s reference an unknown entity \"%s\"\n",
3864	name, value, NULL);
3865	ret = 0;
3866	} else if (ent->etype != XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
3867	xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3868	XML_DTD_ENTITY_TYPE,
3869	"ENTITY attribute %s reference an entity \"%s\" of wrong type\n",
3870	name, value, NULL);
3871	ret = 0;
3872	}
3873	break;
3874	}
3875	case XML_ATTRIBUTE_ENTITIES: {
3876	xmlChar dup, nam = NULL, *cur, save;
3877	xmlEntityPtr ent;
3878
3879	dup = xmlStrdup(value);
3880	if (dup == NULL)
3881	return(0);
3882	cur = dup;
3883	while (*cur != 0) {
3884	nam = cur;
3885	while ((cur != 0) && (!IS_BLANK_CH(cur))) cur++;
3886	save = *cur;
3887	*cur = 0;
3888	ent = xmlGetDocEntity(doc, nam);
3889	if (ent == NULL) {
3890	xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3891	XML_DTD_UNKNOWN_ENTITY,
3892	"ENTITIES attribute %s reference an unknown entity \"%s\"\n",
3893	name, nam, NULL);
3894	ret = 0;
3895	} else if (ent->etype != XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
3896	xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3897	XML_DTD_ENTITY_TYPE,
3898	"ENTITIES attribute %s reference an entity \"%s\" of wrong type\n",
3899	name, nam, NULL);
3900	ret = 0;
3901	}
3902	if (save == 0)
3903	break;
3904	*cur = save;
3905	while (IS_BLANK_CH(*cur)) cur++;
3906	}
3907	xmlFree(dup);
3908	break;
3909	}
3910	case XML_ATTRIBUTE_NOTATION: {
3911	xmlNotationPtr nota;
3912
3913	nota = xmlGetDtdNotationDesc(doc->intSubset, value);
3914	if ((nota == NULL) && (doc->extSubset != NULL))
3915	nota = xmlGetDtdNotationDesc(doc->extSubset, value);
3916
3917	if (nota == NULL) {
3918	xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3919	XML_DTD_UNKNOWN_NOTATION,
3920	"NOTATION attribute %s reference an unknown notation \"%s\"\n",
3921	name, value, NULL);
3922	ret = 0;
3923	}
3924	break;
3925	}
3926	}
3927	return(ret);
3928	}
3929
3930	/**
3931	* xmlValidCtxtNormalizeAttributeValue:
3932	* @ctxt: the validation context
3933	* @doc: the document
3934	* @elem: the parent
3935	* @name: the attribute name
3936	* @value: the attribute value
3937	* @ctxt: the validation context or NULL
3938	*
3939	* Does the validation related extra step of the normalization of attribute
3940	* values:
3941	*
3942	* If the declared value is not CDATA, then the XML processor must further
3943	* process the normalized attribute value by discarding any leading and
3944	* trailing space (#x20) characters, and by replacing sequences of space
3945	* (#x20) characters by single space (#x20) character.
3946	*
3947	* Also check VC: Standalone Document Declaration in P32, and update
3948	* ctxt->valid accordingly
3949	*
3950	* returns a new normalized string if normalization is needed, NULL otherwise
3951	* the caller must free the returned value.
3952	*/
3953
3954	xmlChar *
3955	xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
3956	xmlNodePtr elem, const xmlChar name, const xmlChar value) {
3957	xmlChar ret, dst;
3958	const xmlChar *src;
3959	xmlAttributePtr attrDecl = NULL;
3960	int extsubset = 0;
3961
3962	if (doc == NULL) return(NULL);
3963	if (elem == NULL) return(NULL);
3964	if (name == NULL) return(NULL);
3965	if (value == NULL) return(NULL);
3966
3967	if ((elem->ns != NULL) && (elem->ns->prefix != NULL)) {
3968	xmlChar fn[50];
3969	xmlChar *fullname;
3970
3971	fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
3972	if (fullname == NULL)
3973	return(NULL);
3974	attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname, name);
3975	if ((attrDecl == NULL) && (doc->extSubset != NULL)) {
3976	attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullname, name);
3977	if (attrDecl != NULL)
3978	extsubset = 1;
3979	}
3980	if ((fullname != fn) && (fullname != elem->name))
3981	xmlFree(fullname);
3982	}
3983	if ((attrDecl == NULL) && (doc->intSubset != NULL))
3984	attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, name);
3985	if ((attrDecl == NULL) && (doc->extSubset != NULL)) {
3986	attrDecl = xmlGetDtdAttrDesc(doc->extSubset, elem->name, name);
3987	if (attrDecl != NULL)
3988	extsubset = 1;
3989	}
3990
3991	if (attrDecl == NULL)
3992	return(NULL);
3993	if (attrDecl->atype == XML_ATTRIBUTE_CDATA)
3994	return(NULL);
3995
3996	ret = xmlStrdup(value);
3997	if (ret == NULL)
3998	return(NULL);
3999	src = value;
4000	dst = ret;
4001	while (*src == 0x20) src++;
4002	while (*src != 0) {
4003	if (*src == 0x20) {
4004	while (*src == 0x20) src++;
4005	if (*src != 0)
4006	*dst++ = 0x20;
4007	} else {
4008	dst++ = src++;
4009	}
4010	}
4011	*dst = 0;
4012	if ((doc->standalone) && (extsubset == 1) && (!xmlStrEqual(value, ret))) {
4013	xmlErrValidNode(ctxt, elem, XML_DTD_NOT_STANDALONE,
4014	"standalone: %s on %s value had to be normalized based on external subset declaration\n",
4015	name, elem->name, NULL);
4016	ctxt->valid = 0;
4017	}
4018	return(ret);
4019	}
4020
4021	/**
4022	* xmlValidNormalizeAttributeValue:
4023	* @doc: the document
4024	* @elem: the parent
4025	* @name: the attribute name
4026	* @value: the attribute value
4027	*
4028	* Does the validation related extra step of the normalization of attribute
4029	* values:
4030	*
4031	* If the declared value is not CDATA, then the XML processor must further
4032	* process the normalized attribute value by discarding any leading and
4033	* trailing space (#x20) characters, and by replacing sequences of space
4034	* (#x20) characters by single space (#x20) character.
4035	*
4036	* Returns a new normalized string if normalization is needed, NULL otherwise
4037	* the caller must free the returned value.
4038	*/
4039
4040	xmlChar *
4041	xmlValidNormalizeAttributeValue(xmlDocPtr doc, xmlNodePtr elem,
4042	const xmlChar name, const xmlChar value) {
4043	xmlChar ret, dst;
4044	const xmlChar *src;
4045	xmlAttributePtr attrDecl = NULL;
4046
4047	if (doc == NULL) return(NULL);
4048	if (elem == NULL) return(NULL);
4049	if (name == NULL) return(NULL);
4050	if (value == NULL) return(NULL);
4051
4052	if ((elem->ns != NULL) && (elem->ns->prefix != NULL)) {
4053	xmlChar fn[50];
4054	xmlChar *fullname;
4055
4056	fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
4057	if (fullname == NULL)
4058	return(NULL);
4059	if ((fullname != fn) && (fullname != elem->name))
4060	xmlFree(fullname);
4061	}
4062	attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, name);
4063	if ((attrDecl == NULL) && (doc->extSubset != NULL))
4064	attrDecl = xmlGetDtdAttrDesc(doc->extSubset, elem->name, name);
4065
4066	if (attrDecl == NULL)
4067	return(NULL);
4068	if (attrDecl->atype == XML_ATTRIBUTE_CDATA)
4069	return(NULL);
4070
4071	ret = xmlStrdup(value);
4072	if (ret == NULL)
4073	return(NULL);
4074	src = value;
4075	dst = ret;
4076	while (*src == 0x20) src++;
4077	while (*src != 0) {
4078	if (*src == 0x20) {
4079	while (*src == 0x20) src++;
4080	if (*src != 0)
4081	*dst++ = 0x20;
4082	} else {
4083	dst++ = src++;
4084	}
4085	}
4086	*dst = 0;
4087	return(ret);
4088	}
4089
4090	static void
4091	xmlValidateAttributeIdCallback(xmlAttributePtr attr, int *count,
4092	const xmlChar* name ATTRIBUTE_UNUSED) {
4093	if (attr->atype == XML_ATTRIBUTE_ID) (*count)++;
4094	}
4095
4096	/**
4097	* xmlValidateAttributeDecl:
4098	* @ctxt: the validation context
4099	* @doc: a document instance
4100	* @attr: an attribute definition
4101	*
4102	* Try to validate a single attribute definition
4103	* basically it does the following checks as described by the
4104	* XML-1.0 recommendation:
4105	* - [ VC: Attribute Default Legal ]
4106	* - [ VC: Enumeration ]
4107	* - [ VC: ID Attribute Default ]
4108	*
4109	* The ID/IDREF uniqueness and matching are done separately
4110	*
4111	* returns 1 if valid or 0 otherwise
4112	*/
4113
4114	int
4115	xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4116	xmlAttributePtr attr) {
4117	int ret = 1;
4118	int val;
4119	CHECK_DTD;
4120	if(attr == NULL) return(1);
4121
4122	/* Attribute Default Legal */
4123	/* Enumeration */
4124	if (attr->defaultValue != NULL) {
4125	val = xmlValidateAttributeValueInternal(doc, attr->atype,
4126	attr->defaultValue);
4127	if (val == 0) {
4128	xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ATTRIBUTE_DEFAULT,
4129	"Syntax of default value for attribute %s of %s is not valid\n",
4130	attr->name, attr->elem, NULL);
4131	}
4132	ret &= val;
4133	}
4134
4135	/* ID Attribute Default */
4136	if ((attr->atype == XML_ATTRIBUTE_ID)&&
4137	(attr->def != XML_ATTRIBUTE_IMPLIED) &&
4138	(attr->def != XML_ATTRIBUTE_REQUIRED)) {
4139	xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ID_FIXED,
4140	"ID attribute %s of %s is not valid must be #IMPLIED or #REQUIRED\n",
4141	attr->name, attr->elem, NULL);
4142	ret = 0;
4143	}
4144
4145	/* One ID per Element Type */
4146	if (attr->atype == XML_ATTRIBUTE_ID) {
4147	int nbId;
4148
4149	/* the trick is that we parse DtD as their own internal subset */
4150	xmlElementPtr elem = xmlGetDtdElementDesc(doc->intSubset,
4151	attr->elem);
4152	if (elem != NULL) {
4153	nbId = xmlScanIDAttributeDecl(NULL, elem, 0);
4154	} else {
4155	xmlAttributeTablePtr table;
4156
4157	/*
4158	* The attribute may be declared in the internal subset and the
4159	* element in the external subset.
4160	*/
4161	nbId = 0;
4162	if (doc->intSubset != NULL) {
4163	table = (xmlAttributeTablePtr) doc->intSubset->attributes;
4164	xmlHashScan3(table, NULL, NULL, attr->elem, (xmlHashScanner)
4165	xmlValidateAttributeIdCallback, &nbId);
4166	}
4167	}
4168	if (nbId > 1) {
4169
4170	xmlErrValidNodeNr(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
4171	"Element %s has %d ID attribute defined in the internal subset : %s\n",
4172	attr->elem, nbId, attr->name);
4173	} else if (doc->extSubset != NULL) {
4174	int extId = 0;
4175	elem = xmlGetDtdElementDesc(doc->extSubset, attr->elem);
4176	if (elem != NULL) {
4177	extId = xmlScanIDAttributeDecl(NULL, elem, 0);
4178	}
4179	if (extId > 1) {
4180	xmlErrValidNodeNr(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
4181	"Element %s has %d ID attribute defined in the external subset : %s\n",
4182	attr->elem, extId, attr->name);
4183	} else if (extId + nbId > 1) {
4184	xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
4185	"Element %s has ID attributes defined in the internal and external subset : %s\n",
4186	attr->elem, attr->name, NULL);
4187	}
4188	}
4189	}
4190
4191	/* Validity Constraint: Enumeration */
4192	if ((attr->defaultValue != NULL) && (attr->tree != NULL)) {
4193	xmlEnumerationPtr tree = attr->tree;
4194	while (tree != NULL) {
4195	if (xmlStrEqual(tree->name, attr->defaultValue)) break;
4196	tree = tree->next;
4197	}
4198	if (tree == NULL) {
4199	xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ATTRIBUTE_VALUE,
4200	"Default value \"%s\" for attribute %s of %s is not among the enumerated set\n",
4201	attr->defaultValue, attr->name, attr->elem);
4202	ret = 0;
4203	}
4204	}
4205
4206	return(ret);
4207	}
4208
4209	/**
4210	* xmlValidateElementDecl:
4211	* @ctxt: the validation context
4212	* @doc: a document instance
4213	* @elem: an element definition
4214	*
4215	* Try to validate a single element definition
4216	* basically it does the following checks as described by the
4217	* XML-1.0 recommendation:
4218	* - [ VC: One ID per Element Type ]
4219	* - [ VC: No Duplicate Types ]
4220	* - [ VC: Unique Element Type Declaration ]
4221	*
4222	* returns 1 if valid or 0 otherwise
4223	*/
4224
4225	int
4226	xmlValidateElementDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4227	xmlElementPtr elem) {
4228	int ret = 1;
4229	xmlElementPtr tst;
4230
4231	CHECK_DTD;
4232
4233	if (elem == NULL) return(1);
4234
4235	#if 0
4236	#ifdef LIBXML_REGEXP_ENABLED
4237	/* Build the regexp associated to the content model */
4238	ret = xmlValidBuildContentModel(ctxt, elem);
4239	#endif
4240	#endif
4241
4242	/* No Duplicate Types */
4243	if (elem->etype == XML_ELEMENT_TYPE_MIXED) {
4244	xmlElementContentPtr cur, next;
4245	const xmlChar *name;
4246
4247	cur = elem->content;
4248	while (cur != NULL) {
4249	if (cur->type != XML_ELEMENT_CONTENT_OR) break;
4250	if (cur->c1 == NULL) break;
4251	if (cur->c1->type == XML_ELEMENT_CONTENT_ELEMENT) {
4252	name = cur->c1->name;
4253	next = cur->c2;
4254	while (next != NULL) {
4255	if (next->type == XML_ELEMENT_CONTENT_ELEMENT) {
4256	if ((xmlStrEqual(next->name, name)) &&
4257	(xmlStrEqual(next->prefix, cur->c1->prefix))) {
4258	if (cur->c1->prefix == NULL) {
4259	xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
4260	"Definition of %s has duplicate references of %s\n",
4261	elem->name, name, NULL);
4262	} else {
4263	xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
4264	"Definition of %s has duplicate references of %s:%s\n",
4265	elem->name, cur->c1->prefix, name);
4266	}
4267	ret = 0;
4268	}
4269	break;
4270	}
4271	if (next->c1 == NULL) break;
4272	if (next->c1->type != XML_ELEMENT_CONTENT_ELEMENT) break;
4273	if ((xmlStrEqual(next->c1->name, name)) &&
4274	(xmlStrEqual(next->c1->prefix, cur->c1->prefix))) {
4275	if (cur->c1->prefix == NULL) {
4276	xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
4277	"Definition of %s has duplicate references to %s\n",
4278	elem->name, name, NULL);
4279	} else {
4280	xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
4281	"Definition of %s has duplicate references to %s:%s\n",
4282	elem->name, cur->c1->prefix, name);
4283	}
4284	ret = 0;
4285	}
4286	next = next->c2;
4287	}
4288	}
4289	cur = cur->c2;
4290	}
4291	}
4292
4293	/* VC: Unique Element Type Declaration */
4294	tst = xmlGetDtdElementDesc(doc->intSubset, elem->name);
4295	if ((tst != NULL ) && (tst != elem) &&
4296	((tst->prefix == elem->prefix) \|\|
4297	(xmlStrEqual(tst->prefix, elem->prefix))) &&
4298	(tst->etype != XML_ELEMENT_TYPE_UNDEFINED)) {
4299	xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_ELEM_REDEFINED,
4300	"Redefinition of element %s\n",
4301	elem->name, NULL, NULL);
4302	ret = 0;
4303	}
4304	tst = xmlGetDtdElementDesc(doc->extSubset, elem->name);
4305	if ((tst != NULL ) && (tst != elem) &&
4306	((tst->prefix == elem->prefix) \|\|
4307	(xmlStrEqual(tst->prefix, elem->prefix))) &&
4308	(tst->etype != XML_ELEMENT_TYPE_UNDEFINED)) {
4309	xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_ELEM_REDEFINED,
4310	"Redefinition of element %s\n",
4311	elem->name, NULL, NULL);
4312	ret = 0;
4313	}
4314	/* One ID per Element Type
4315	* already done when registering the attribute
4316	if (xmlScanIDAttributeDecl(ctxt, elem) > 1) {
4317	ret = 0;
4318	} */
4319	return(ret);
4320	}
4321
4322	/**
4323	* xmlValidateOneAttribute:
4324	* @ctxt: the validation context
4325	* @doc: a document instance
4326	* @elem: an element instance
4327	* @attr: an attribute instance
4328	* @value: the attribute value (without entities processing)
4329	*
4330	* Try to validate a single attribute for an element
4331	* basically it does the following checks as described by the
4332	* XML-1.0 recommendation:
4333	* - [ VC: Attribute Value Type ]
4334	* - [ VC: Fixed Attribute Default ]
4335	* - [ VC: Entity Name ]
4336	* - [ VC: Name Token ]
4337	* - [ VC: ID ]
4338	* - [ VC: IDREF ]
4339	* - [ VC: Entity Name ]
4340	* - [ VC: Notation Attributes ]
4341	*
4342	* The ID/IDREF uniqueness and matching are done separately
4343	*
4344	* returns 1 if valid or 0 otherwise
4345	*/
4346
4347	int
4348	xmlValidateOneAttribute(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4349	xmlNodePtr elem, xmlAttrPtr attr, const xmlChar *value)
4350	{
4351	xmlAttributePtr attrDecl = NULL;
4352	int val;
4353	int ret = 1;
4354
4355	CHECK_DTD;
4356	if ((elem == NULL) \|\| (elem->name == NULL)) return(0);
4357	if ((attr == NULL) \|\| (attr->name == NULL)) return(0);
4358
4359	if ((elem->ns != NULL) && (elem->ns->prefix != NULL)) {
4360	xmlChar fn[50];
4361	xmlChar *fullname;
4362
4363	fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
4364	if (fullname == NULL)
4365	return(0);
4366	if (attr->ns != NULL) {
4367	attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, fullname,
4368	attr->name, attr->ns->prefix);
4369	if ((attrDecl == NULL) && (doc->extSubset != NULL))
4370	attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, fullname,
4371	attr->name, attr->ns->prefix);
4372	} else {
4373	attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname, attr->name);
4374	if ((attrDecl == NULL) && (doc->extSubset != NULL))
4375	attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
4376	fullname, attr->name);
4377	}
4378	if ((fullname != fn) && (fullname != elem->name))
4379	xmlFree(fullname);
4380	}
4381	if (attrDecl == NULL) {
4382	if (attr->ns != NULL) {
4383	attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, elem->name,
4384	attr->name, attr->ns->prefix);
4385	if ((attrDecl == NULL) && (doc->extSubset != NULL))
4386	attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, elem->name,
4387	attr->name, attr->ns->prefix);
4388	} else {
4389	attrDecl = xmlGetDtdAttrDesc(doc->intSubset,
4390	elem->name, attr->name);
4391	if ((attrDecl == NULL) && (doc->extSubset != NULL))
4392	attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
4393	elem->name, attr->name);
4394	}
4395	}
4396
4397
4398	/* Validity Constraint: Attribute Value Type */
4399	if (attrDecl == NULL) {
4400	xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
4401	"No declaration for attribute %s of element %s\n",
4402	attr->name, elem->name, NULL);
4403	return(0);
4404	}
4405	attr->atype = attrDecl->atype;
4406
4407	val = xmlValidateAttributeValueInternal(doc, attrDecl->atype, value);
4408	if (val == 0) {
4409	xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4410	"Syntax of value for attribute %s of %s is not valid\n",
4411	attr->name, elem->name, NULL);
4412	ret = 0;
4413	}
4414
4415	/* Validity constraint: Fixed Attribute Default */
4416	if (attrDecl->def == XML_ATTRIBUTE_FIXED) {
4417	if (!xmlStrEqual(value, attrDecl->defaultValue)) {
4418	xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_DEFAULT,
4419	"Value for attribute %s of %s is different from default \"%s\"\n",
4420	attr->name, elem->name, attrDecl->defaultValue);
4421	ret = 0;
4422	}
4423	}
4424
4425	/* Validity Constraint: ID uniqueness */
4426	if (attrDecl->atype == XML_ATTRIBUTE_ID) {
4427	if (xmlAddID(ctxt, doc, value, attr) == NULL)
4428	ret = 0;
4429	}
4430
4431	if ((attrDecl->atype == XML_ATTRIBUTE_IDREF) \|\|
4432	(attrDecl->atype == XML_ATTRIBUTE_IDREFS)) {
4433	if (xmlAddRef(ctxt, doc, value, attr) == NULL)
4434	ret = 0;
4435	}
4436
4437	/* Validity Constraint: Notation Attributes */
4438	if (attrDecl->atype == XML_ATTRIBUTE_NOTATION) {
4439	xmlEnumerationPtr tree = attrDecl->tree;
4440	xmlNotationPtr nota;
4441
4442	/* First check that the given NOTATION was declared */
4443	nota = xmlGetDtdNotationDesc(doc->intSubset, value);
4444	if (nota == NULL)
4445	nota = xmlGetDtdNotationDesc(doc->extSubset, value);
4446
4447	if (nota == NULL) {
4448	xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
4449	"Value \"%s\" for attribute %s of %s is not a declared Notation\n",
4450	value, attr->name, elem->name);
4451	ret = 0;
4452	}
4453
4454	/* Second, verify that it's among the list */
4455	while (tree != NULL) {
4456	if (xmlStrEqual(tree->name, value)) break;
4457	tree = tree->next;
4458	}
4459	if (tree == NULL) {
4460	xmlErrValidNode(ctxt, elem, XML_DTD_NOTATION_VALUE,
4461	"Value \"%s\" for attribute %s of %s is not among the enumerated notations\n",
4462	value, attr->name, elem->name);
4463	ret = 0;
4464	}
4465	}
4466
4467	/* Validity Constraint: Enumeration */
4468	if (attrDecl->atype == XML_ATTRIBUTE_ENUMERATION) {
4469	xmlEnumerationPtr tree = attrDecl->tree;
4470	while (tree != NULL) {
4471	if (xmlStrEqual(tree->name, value)) break;
4472	tree = tree->next;
4473	}
4474	if (tree == NULL) {
4475	xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4476	"Value \"%s\" for attribute %s of %s is not among the enumerated set\n",
4477	value, attr->name, elem->name);
4478	ret = 0;
4479	}
4480	}
4481
4482	/* Fixed Attribute Default */
4483	if ((attrDecl->def == XML_ATTRIBUTE_FIXED) &&
4484	(!xmlStrEqual(attrDecl->defaultValue, value))) {
4485	xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4486	"Value for attribute %s of %s must be \"%s\"\n",
4487	attr->name, elem->name, attrDecl->defaultValue);
4488	ret = 0;
4489	}
4490
4491	/* Extra check for the attribute value */
4492	ret &= xmlValidateAttributeValue2(ctxt, doc, attr->name,
4493	attrDecl->atype, value);
4494
4495	return(ret);
4496	}
4497
4498	/**
4499	* xmlValidateOneNamespace:
4500	* @ctxt: the validation context
4501	* @doc: a document instance
4502	* @elem: an element instance
4503	* @prefix: the namespace prefix
4504	* @ns: an namespace declaration instance
4505	* @value: the attribute value (without entities processing)
4506	*
4507	* Try to validate a single namespace declaration for an element
4508	* basically it does the following checks as described by the
4509	* XML-1.0 recommendation:
4510	* - [ VC: Attribute Value Type ]
4511	* - [ VC: Fixed Attribute Default ]
4512	* - [ VC: Entity Name ]
4513	* - [ VC: Name Token ]
4514	* - [ VC: ID ]
4515	* - [ VC: IDREF ]
4516	* - [ VC: Entity Name ]
4517	* - [ VC: Notation Attributes ]
4518	*
4519	* The ID/IDREF uniqueness and matching are done separately
4520	*
4521	* returns 1 if valid or 0 otherwise
4522	*/
4523
4524	int
4525	xmlValidateOneNamespace(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4526	xmlNodePtr elem, const xmlChar prefix, xmlNsPtr ns, const xmlChar value) {
4527	/* xmlElementPtr elemDecl; */
4528	xmlAttributePtr attrDecl = NULL;
4529	int val;
4530	int ret = 1;
4531
4532	CHECK_DTD;
4533	if ((elem == NULL) \|\| (elem->name == NULL)) return(0);
4534	if ((ns == NULL) \|\| (ns->href == NULL)) return(0);
4535
4536	if (prefix != NULL) {
4537	xmlChar fn[50];
4538	xmlChar *fullname;
4539
4540	fullname = xmlBuildQName(elem->name, prefix, fn, 50);
4541	if (fullname == NULL) {
4542	xmlVErrMemory(ctxt, "Validating namespace");
4543	return(0);
4544	}
4545	if (ns->prefix != NULL) {
4546	attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, fullname,
4547	ns->prefix, BAD_CAST "xmlns");
4548	if ((attrDecl == NULL) && (doc->extSubset != NULL))
4549	attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, fullname,
4550	ns->prefix, BAD_CAST "xmlns");
4551	} else {
4552	attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname,
4553	BAD_CAST "xmlns");
4554	if ((attrDecl == NULL) && (doc->extSubset != NULL))
4555	attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullname,
4556	BAD_CAST "xmlns");
4557	}
4558	if ((fullname != fn) && (fullname != elem->name))
4559	xmlFree(fullname);
4560	}
4561	if (attrDecl == NULL) {
4562	if (ns->prefix != NULL) {
4563	attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, elem->name,
4564	ns->prefix, BAD_CAST "xmlns");
4565	if ((attrDecl == NULL) && (doc->extSubset != NULL))
4566	attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, elem->name,
4567	ns->prefix, BAD_CAST "xmlns");
4568	} else {
4569	attrDecl = xmlGetDtdAttrDesc(doc->intSubset,
4570	elem->name, BAD_CAST "xmlns");
4571	if ((attrDecl == NULL) && (doc->extSubset != NULL))
4572	attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
4573	elem->name, BAD_CAST "xmlns");
4574	}
4575	}
4576
4577
4578	/* Validity Constraint: Attribute Value Type */
4579	if (attrDecl == NULL) {
4580	if (ns->prefix != NULL) {
4581	xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
4582	"No declaration for attribute xmlns:%s of element %s\n",
4583	ns->prefix, elem->name, NULL);
4584	} else {
4585	xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
4586	"No declaration for attribute xmlns of element %s\n",
4587	elem->name, NULL, NULL);
4588	}
4589	return(0);
4590	}
4591
4592	val = xmlValidateAttributeValueInternal(doc, attrDecl->atype, value);
4593	if (val == 0) {
4594	if (ns->prefix != NULL) {
4595	xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_DEFAULT,
4596	"Syntax of value for attribute xmlns:%s of %s is not valid\n",
4597	ns->prefix, elem->name, NULL);
4598	} else {
4599	xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_DEFAULT,
4600	"Syntax of value for attribute xmlns of %s is not valid\n",
4601	elem->name, NULL, NULL);
4602	}
4603	ret = 0;
4604	}
4605
4606	/* Validity constraint: Fixed Attribute Default */
4607	if (attrDecl->def == XML_ATTRIBUTE_FIXED) {
4608	if (!xmlStrEqual(value, attrDecl->defaultValue)) {
4609	if (ns->prefix != NULL) {
4610	xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_DEFAULT,
4611	"Value for attribute xmlns:%s of %s is different from default \"%s\"\n",
4612	ns->prefix, elem->name, attrDecl->defaultValue);
4613	} else {
4614	xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_DEFAULT,
4615	"Value for attribute xmlns of %s is different from default \"%s\"\n",
4616	elem->name, attrDecl->defaultValue, NULL);
4617	}
4618	ret = 0;
4619	}
4620	}
4621
4622	/* Validity Constraint: ID uniqueness */
4623	if (attrDecl->atype == XML_ATTRIBUTE_ID) {
4624	if (xmlAddID(ctxt, doc, value, (xmlAttrPtr) ns) == NULL)
4625	ret = 0;
4626	}
4627
4628	if ((attrDecl->atype == XML_ATTRIBUTE_IDREF) \|\|
4629	(attrDecl->atype == XML_ATTRIBUTE_IDREFS)) {
4630	if (xmlAddRef(ctxt, doc, value, (xmlAttrPtr) ns) == NULL)
4631	ret = 0;
4632	}
4633
4634	/* Validity Constraint: Notation Attributes */
4635	if (attrDecl->atype == XML_ATTRIBUTE_NOTATION) {
4636	xmlEnumerationPtr tree = attrDecl->tree;
4637	xmlNotationPtr nota;
4638
4639	/* First check that the given NOTATION was declared */
4640	nota = xmlGetDtdNotationDesc(doc->intSubset, value);
4641	if (nota == NULL)
4642	nota = xmlGetDtdNotationDesc(doc->extSubset, value);
4643
4644	if (nota == NULL) {
4645	if (ns->prefix != NULL) {
4646	xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
4647	"Value \"%s\" for attribute xmlns:%s of %s is not a declared Notation\n",
4648	value, ns->prefix, elem->name);
4649	} else {
4650	xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
4651	"Value \"%s\" for attribute xmlns of %s is not a declared Notation\n",
4652	value, elem->name, NULL);
4653	}
4654	ret = 0;
4655	}
4656
4657	/* Second, verify that it's among the list */
4658	while (tree != NULL) {
4659	if (xmlStrEqual(tree->name, value)) break;
4660	tree = tree->next;
4661	}
4662	if (tree == NULL) {
4663	if (ns->prefix != NULL) {
4664	xmlErrValidNode(ctxt, elem, XML_DTD_NOTATION_VALUE,
4665	"Value \"%s\" for attribute xmlns:%s of %s is not among the enumerated notations\n",
4666	value, ns->prefix, elem->name);
4667	} else {
4668	xmlErrValidNode(ctxt, elem, XML_DTD_NOTATION_VALUE,
4669	"Value \"%s\" for attribute xmlns of %s is not among the enumerated notations\n",
4670	value, elem->name, NULL);
4671	}
4672	ret = 0;
4673	}
4674	}
4675
4676	/* Validity Constraint: Enumeration */
4677	if (attrDecl->atype == XML_ATTRIBUTE_ENUMERATION) {
4678	xmlEnumerationPtr tree = attrDecl->tree;
4679	while (tree != NULL) {
4680	if (xmlStrEqual(tree->name, value)) break;
4681	tree = tree->next;
4682	}
4683	if (tree == NULL) {
4684	if (ns->prefix != NULL) {
4685	xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4686	"Value \"%s\" for attribute xmlns:%s of %s is not among the enumerated set\n",
4687	value, ns->prefix, elem->name);
4688	} else {
4689	xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4690	"Value \"%s\" for attribute xmlns of %s is not among the enumerated set\n",
4691	value, elem->name, NULL);
4692	}
4693	ret = 0;
4694	}
4695	}
4696
4697	/* Fixed Attribute Default */
4698	if ((attrDecl->def == XML_ATTRIBUTE_FIXED) &&
4699	(!xmlStrEqual(attrDecl->defaultValue, value))) {
4700	if (ns->prefix != NULL) {
4701	xmlErrValidNode(ctxt, elem, XML_DTD_ELEM_NAMESPACE,
4702	"Value for attribute xmlns:%s of %s must be \"%s\"\n",
4703	ns->prefix, elem->name, attrDecl->defaultValue);
4704	} else {
4705	xmlErrValidNode(ctxt, elem, XML_DTD_ELEM_NAMESPACE,
4706	"Value for attribute xmlns of %s must be \"%s\"\n",
4707	elem->name, attrDecl->defaultValue, NULL);
4708	}
4709	ret = 0;
4710	}
4711
4712	/* Extra check for the attribute value */
4713	if (ns->prefix != NULL) {
4714	ret &= xmlValidateAttributeValue2(ctxt, doc, ns->prefix,
4715	attrDecl->atype, value);
4716	} else {
4717	ret &= xmlValidateAttributeValue2(ctxt, doc, BAD_CAST "xmlns",
4718	attrDecl->atype, value);
4719	}
4720
4721	return(ret);
4722	}
4723
4724	#ifndef LIBXML_REGEXP_ENABLED
4725	/**
4726	* xmlValidateSkipIgnorable:
4727	* @ctxt: the validation context
4728	* @child: the child list
4729	*
4730	* Skip ignorable elements w.r.t. the validation process
4731	*
4732	* returns the first element to consider for validation of the content model
4733	*/
4734
4735	static xmlNodePtr
4736	xmlValidateSkipIgnorable(xmlNodePtr child) {
4737	while (child != NULL) {
4738	switch (child->type) {
4739	/* These things are ignored (skipped) during validation. */
4740	case XML_PI_NODE:
4741	case XML_COMMENT_NODE:
4742	case XML_XINCLUDE_START:
4743	case XML_XINCLUDE_END:
4744	child = child->next;
4745	break;
4746	case XML_TEXT_NODE:
4747	if (xmlIsBlankNode(child))
4748	child = child->next;
4749	else
4750	return(child);
4751	break;
4752	/* keep current node */
4753	default:
4754	return(child);
4755	}
4756	}
4757	return(child);
4758	}
4759
4760	/**
4761	* xmlValidateElementType:
4762	* @ctxt: the validation context
4763	*
4764	* Try to validate the content model of an element internal function
4765	*
4766	* returns 1 if valid or 0 ,-1 in case of error, -2 if an entity
4767	* reference is found and -3 if the validation succeeded but
4768	* the content model is not determinist.
4769	*/
4770
4771	static int
4772	xmlValidateElementType(xmlValidCtxtPtr ctxt) {
4773	int ret = -1;
4774	int determinist = 1;
4775
4776	NODE = xmlValidateSkipIgnorable(NODE);
4777	if ((NODE == NULL) && (CONT == NULL))
4778	return(1);
4779	if ((NODE == NULL) &&
4780	((CONT->ocur == XML_ELEMENT_CONTENT_MULT) \|\|
4781	(CONT->ocur == XML_ELEMENT_CONTENT_OPT))) {
4782	return(1);
4783	}
4784	if (CONT == NULL) return(-1);
4785	if ((NODE != NULL) && (NODE->type == XML_ENTITY_REF_NODE))
4786	return(-2);
4787
4788	/*
4789	* We arrive here when more states need to be examined
4790	*/
4791	cont:
4792
4793	/*
4794	* We just recovered from a rollback generated by a possible
4795	* epsilon transition, go directly to the analysis phase
4796	*/
4797	if (STATE == ROLLBACK_PARENT) {
4798	DEBUG_VALID_MSG("restored parent branch");
4799	DEBUG_VALID_STATE(NODE, CONT)
4800	ret = 1;
4801	goto analyze;
4802	}
4803
4804	DEBUG_VALID_STATE(NODE, CONT)
4805	/*
4806	* we may have to save a backup state here. This is the equivalent
4807	* of handling epsilon transition in NFAs.
4808	*/
4809	if ((CONT != NULL) &&
4810	((CONT->parent == NULL) \|\|
4811	(CONT->parent->type != XML_ELEMENT_CONTENT_OR)) &&
4812	((CONT->ocur == XML_ELEMENT_CONTENT_MULT) \|\|
4813	(CONT->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
4814	((CONT->ocur == XML_ELEMENT_CONTENT_PLUS) && (OCCURRENCE)))) {
4815	DEBUG_VALID_MSG("saving parent branch");
4816	if (vstateVPush(ctxt, CONT, NODE, DEPTH, OCCURS, ROLLBACK_PARENT) < 0)
4817	return(0);
4818	}
4819
4820
4821	/*
4822	* Check first if the content matches
4823	*/
4824	switch (CONT->type) {
4825	case XML_ELEMENT_CONTENT_PCDATA:
4826	if (NODE == NULL) {
4827	DEBUG_VALID_MSG("pcdata failed no node");
4828	ret = 0;
4829	break;
4830	}
4831	if (NODE->type == XML_TEXT_NODE) {
4832	DEBUG_VALID_MSG("pcdata found, skip to next");
4833	/*
4834	* go to next element in the content model
4835	* skipping ignorable elems
4836	*/
4837	do {
4838	NODE = NODE->next;
4839	NODE = xmlValidateSkipIgnorable(NODE);
4840	if ((NODE != NULL) &&
4841	(NODE->type == XML_ENTITY_REF_NODE))
4842	return(-2);
4843	} while ((NODE != NULL) &&
4844	((NODE->type != XML_ELEMENT_NODE) &&
4845	(NODE->type != XML_TEXT_NODE) &&
4846	(NODE->type != XML_CDATA_SECTION_NODE)));
4847	ret = 1;
4848	break;
4849	} else {
4850	DEBUG_VALID_MSG("pcdata failed");
4851	ret = 0;
4852	break;
4853	}
4854	break;
4855	case XML_ELEMENT_CONTENT_ELEMENT:
4856	if (NODE == NULL) {
4857	DEBUG_VALID_MSG("element failed no node");
4858	ret = 0;
4859	break;
4860	}
4861	ret = ((NODE->type == XML_ELEMENT_NODE) &&
4862	(xmlStrEqual(NODE->name, CONT->name)));
4863	if (ret == 1) {
4864	if ((NODE->ns == NULL) \|\| (NODE->ns->prefix == NULL)) {
4865	ret = (CONT->prefix == NULL);
4866	} else if (CONT->prefix == NULL) {
4867	ret = 0;
4868	} else {
4869	ret = xmlStrEqual(NODE->ns->prefix, CONT->prefix);
4870	}
4871	}
4872	if (ret == 1) {
4873	DEBUG_VALID_MSG("element found, skip to next");
4874	/*
4875	* go to next element in the content model
4876	* skipping ignorable elems
4877	*/
4878	do {
4879	NODE = NODE->next;
4880	NODE = xmlValidateSkipIgnorable(NODE);
4881	if ((NODE != NULL) &&
4882	(NODE->type == XML_ENTITY_REF_NODE))
4883	return(-2);
4884	} while ((NODE != NULL) &&
4885	((NODE->type != XML_ELEMENT_NODE) &&
4886	(NODE->type != XML_TEXT_NODE) &&
4887	(NODE->type != XML_CDATA_SECTION_NODE)));
4888	} else {
4889	DEBUG_VALID_MSG("element failed");
4890	ret = 0;
4891	break;
4892	}
4893	break;
4894	case XML_ELEMENT_CONTENT_OR:
4895	/*
4896	* Small optimization.
4897	*/
4898	if (CONT->c1->type == XML_ELEMENT_CONTENT_ELEMENT) {
4899	if ((NODE == NULL) \|\|
4900	(!xmlStrEqual(NODE->name, CONT->c1->name))) {
4901	DEPTH++;
4902	CONT = CONT->c2;
4903	goto cont;
4904	}
4905	if ((NODE->ns == NULL) \|\| (NODE->ns->prefix == NULL)) {
4906	ret = (CONT->c1->prefix == NULL);
4907	} else if (CONT->c1->prefix == NULL) {
4908	ret = 0;
4909	} else {
4910	ret = xmlStrEqual(NODE->ns->prefix, CONT->c1->prefix);
4911	}
4912	if (ret == 0) {
4913	DEPTH++;
4914	CONT = CONT->c2;
4915	goto cont;
4916	}
4917	}
4918
4919	/*
4920	* save the second branch 'or' branch
4921	*/
4922	DEBUG_VALID_MSG("saving 'or' branch");
4923	if (vstateVPush(ctxt, CONT->c2, NODE, (unsigned char)(DEPTH + 1),
4924	OCCURS, ROLLBACK_OR) < 0)
4925	return(-1);
4926	DEPTH++;
4927	CONT = CONT->c1;
4928	goto cont;
4929	case XML_ELEMENT_CONTENT_SEQ:
4930	/*
4931	* Small optimization.
4932	*/
4933	if ((CONT->c1->type == XML_ELEMENT_CONTENT_ELEMENT) &&
4934	((CONT->c1->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
4935	(CONT->c1->ocur == XML_ELEMENT_CONTENT_MULT))) {
4936	if ((NODE == NULL) \|\|
4937	(!xmlStrEqual(NODE->name, CONT->c1->name))) {
4938	DEPTH++;
4939	CONT = CONT->c2;
4940	goto cont;
4941	}
4942	if ((NODE->ns == NULL) \|\| (NODE->ns->prefix == NULL)) {
4943	ret = (CONT->c1->prefix == NULL);
4944	} else if (CONT->c1->prefix == NULL) {
4945	ret = 0;
4946	} else {
4947	ret = xmlStrEqual(NODE->ns->prefix, CONT->c1->prefix);
4948	}
4949	if (ret == 0) {
4950	DEPTH++;
4951	CONT = CONT->c2;
4952	goto cont;
4953	}
4954	}
4955	DEPTH++;
4956	CONT = CONT->c1;
4957	goto cont;
4958	}
4959
4960	/*
4961	* At this point handle going up in the tree
4962	*/
4963	if (ret == -1) {
4964	DEBUG_VALID_MSG("error found returning");
4965	return(ret);
4966	}
4967	analyze:
4968	while (CONT != NULL) {
4969	/*
4970	* First do the analysis depending on the occurrence model at
4971	* this level.
4972	*/
4973	if (ret == 0) {
4974	switch (CONT->ocur) {
4975	xmlNodePtr cur;
4976
4977	case XML_ELEMENT_CONTENT_ONCE:
4978	cur = ctxt->vstate->node;
4979	DEBUG_VALID_MSG("Once branch failed, rollback");
4980	if (vstateVPop(ctxt) < 0 ) {
4981	DEBUG_VALID_MSG("exhaustion, failed");
4982	return(0);
4983	}
4984	if (cur != ctxt->vstate->node)
4985	determinist = -3;
4986	goto cont;
4987	case XML_ELEMENT_CONTENT_PLUS:
4988	if (OCCURRENCE == 0) {
4989	cur = ctxt->vstate->node;
4990	DEBUG_VALID_MSG("Plus branch failed, rollback");
4991	if (vstateVPop(ctxt) < 0 ) {
4992	DEBUG_VALID_MSG("exhaustion, failed");
4993	return(0);
4994	}
4995	if (cur != ctxt->vstate->node)
4996	determinist = -3;
4997	goto cont;
4998	}
4999	DEBUG_VALID_MSG("Plus branch found");
5000	ret = 1;
5001	break;
5002	case XML_ELEMENT_CONTENT_MULT:
5003	#ifdef DEBUG_VALID_ALGO
5004	if (OCCURRENCE == 0) {
5005	DEBUG_VALID_MSG("Mult branch failed");
5006	} else {
5007	DEBUG_VALID_MSG("Mult branch found");
5008	}
5009	#endif
5010	ret = 1;
5011	break;
5012	case XML_ELEMENT_CONTENT_OPT:
5013	DEBUG_VALID_MSG("Option branch failed");
5014	ret = 1;
5015	break;
5016	}
5017	} else {
5018	switch (CONT->ocur) {
5019	case XML_ELEMENT_CONTENT_OPT:
5020	DEBUG_VALID_MSG("Option branch succeeded");
5021	ret = 1;
5022	break;
5023	case XML_ELEMENT_CONTENT_ONCE:
5024	DEBUG_VALID_MSG("Once branch succeeded");
5025	ret = 1;
5026	break;
5027	case XML_ELEMENT_CONTENT_PLUS:
5028	if (STATE == ROLLBACK_PARENT) {
5029	DEBUG_VALID_MSG("Plus branch rollback");
5030	ret = 1;
5031	break;
5032	}
5033	if (NODE == NULL) {
5034	DEBUG_VALID_MSG("Plus branch exhausted");
5035	ret = 1;
5036	break;
5037	}
5038	DEBUG_VALID_MSG("Plus branch succeeded, continuing");
5039	SET_OCCURRENCE;
5040	goto cont;
5041	case XML_ELEMENT_CONTENT_MULT:
5042	if (STATE == ROLLBACK_PARENT) {
5043	DEBUG_VALID_MSG("Mult branch rollback");
5044	ret = 1;
5045	break;
5046	}
5047	if (NODE == NULL) {
5048	DEBUG_VALID_MSG("Mult branch exhausted");
5049	ret = 1;
5050	break;
5051	}
5052	DEBUG_VALID_MSG("Mult branch succeeded, continuing");
5053	/* SET_OCCURRENCE; */
5054	goto cont;
5055	}
5056	}
5057	STATE = 0;
5058
5059	/*
5060	* Then act accordingly at the parent level
5061	*/
5062	RESET_OCCURRENCE;
5063	if (CONT->parent == NULL)
5064	break;
5065
5066	switch (CONT->parent->type) {
5067	case XML_ELEMENT_CONTENT_PCDATA:
5068	DEBUG_VALID_MSG("Error: parent pcdata");
5069	return(-1);
5070	case XML_ELEMENT_CONTENT_ELEMENT:
5071	DEBUG_VALID_MSG("Error: parent element");
5072	return(-1);
5073	case XML_ELEMENT_CONTENT_OR:
5074	if (ret == 1) {
5075	DEBUG_VALID_MSG("Or succeeded");
5076	CONT = CONT->parent;
5077	DEPTH--;
5078	} else {
5079	DEBUG_VALID_MSG("Or failed");
5080	CONT = CONT->parent;
5081	DEPTH--;
5082	}
5083	break;
5084	case XML_ELEMENT_CONTENT_SEQ:
5085	if (ret == 0) {
5086	DEBUG_VALID_MSG("Sequence failed");
5087	CONT = CONT->parent;
5088	DEPTH--;
5089	} else if (CONT == CONT->parent->c1) {
5090	DEBUG_VALID_MSG("Sequence testing 2nd branch");
5091	CONT = CONT->parent->c2;
5092	goto cont;
5093	} else {
5094	DEBUG_VALID_MSG("Sequence succeeded");
5095	CONT = CONT->parent;
5096	DEPTH--;
5097	}
5098	}
5099	}
5100	if (NODE != NULL) {
5101	xmlNodePtr cur;
5102
5103	cur = ctxt->vstate->node;
5104	DEBUG_VALID_MSG("Failed, remaining input, rollback");
5105	if (vstateVPop(ctxt) < 0 ) {
5106	DEBUG_VALID_MSG("exhaustion, failed");
5107	return(0);
5108	}
5109	if (cur != ctxt->vstate->node)
5110	determinist = -3;
5111	goto cont;
5112	}
5113	if (ret == 0) {
5114	xmlNodePtr cur;
5115
5116	cur = ctxt->vstate->node;
5117	DEBUG_VALID_MSG("Failure, rollback");
5118	if (vstateVPop(ctxt) < 0 ) {
5119	DEBUG_VALID_MSG("exhaustion, failed");
5120	return(0);
5121	}
5122	if (cur != ctxt->vstate->node)
5123	determinist = -3;
5124	goto cont;
5125	}
5126	return(determinist);
5127	}
5128	#endif
5129
5130	/**
5131	* xmlSnprintfElements:
5132	* @buf: an output buffer
5133	* @size: the size of the buffer
5134	* @content: An element
5135	* @glob: 1 if one must print the englobing parenthesis, 0 otherwise
5136	*
5137	* This will dump the list of elements to the buffer
5138	* Intended just for the debug routine
5139	*/
5140	static void
5141	xmlSnprintfElements(char *buf, int size, xmlNodePtr node, int glob) {
5142	xmlNodePtr cur;
5143	int len;
5144
5145	if (node == NULL) return;
5146	if (glob) strcat(buf, "(");
5147	cur = node;
5148	while (cur != NULL) {
5149	len = strlen(buf);
5150	if (size - len < 50) {
5151	if ((size - len > 4) && (buf[len - 1] != '.'))
5152	strcat(buf, " ...");
5153	return;
5154	}
5155	switch (cur->type) {
5156	case XML_ELEMENT_NODE:
5157	if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
5158	if (size - len < xmlStrlen(cur->ns->prefix) + 10) {
5159	if ((size - len > 4) && (buf[len - 1] != '.'))
5160	strcat(buf, " ...");
5161	return;
5162	}
5163	strcat(buf, (char *) cur->ns->prefix);
5164	strcat(buf, ":");
5165	}
5166	if (size - len < xmlStrlen(cur->name) + 10) {
5167	if ((size - len > 4) && (buf[len - 1] != '.'))
5168	strcat(buf, " ...");
5169	return;
5170	}
5171	strcat(buf, (char *) cur->name);
5172	if (cur->next != NULL)
5173	strcat(buf, " ");
5174	break;
5175	case XML_TEXT_NODE:
5176	if (xmlIsBlankNode(cur))
5177	break;
5178	case XML_CDATA_SECTION_NODE:
5179	case XML_ENTITY_REF_NODE:
5180	strcat(buf, "CDATA");
5181	if (cur->next != NULL)
5182	strcat(buf, " ");
5183	break;
5184	case XML_ATTRIBUTE_NODE:
5185	case XML_DOCUMENT_NODE:
5186	#ifdef LIBXML_DOCB_ENABLED
5187	case XML_DOCB_DOCUMENT_NODE:
5188	#endif
5189	case XML_HTML_DOCUMENT_NODE:
5190	case XML_DOCUMENT_TYPE_NODE:
5191	case XML_DOCUMENT_FRAG_NODE:
5192	case XML_NOTATION_NODE:
5193	case XML_NAMESPACE_DECL:
5194	strcat(buf, "???");
5195	if (cur->next != NULL)
5196	strcat(buf, " ");
5197	break;
5198	case XML_ENTITY_NODE:
5199	case XML_PI_NODE:
5200	case XML_DTD_NODE:
5201	case XML_COMMENT_NODE:
5202	case XML_ELEMENT_DECL:
5203	case XML_ATTRIBUTE_DECL:
5204	case XML_ENTITY_DECL:
5205	case XML_XINCLUDE_START:
5206	case XML_XINCLUDE_END:
5207	break;
5208	}
5209	cur = cur->next;
5210	}
5211	if (glob) strcat(buf, ")");
5212	}
5213
5214	/**
5215	* xmlValidateElementContent:
5216	* @ctxt: the validation context
5217	* @child: the child list
5218	* @elemDecl: pointer to the element declaration
5219	* @warn: emit the error message
5220	* @parent: the parent element (for error reporting)
5221	*
5222	* Try to validate the content model of an element
5223	*
5224	* returns 1 if valid or 0 if not and -1 in case of error
5225	*/
5226
5227	static int
5228	xmlValidateElementContent(xmlValidCtxtPtr ctxt, xmlNodePtr child,
5229	xmlElementPtr elemDecl, int warn, xmlNodePtr parent) {
5230	int ret = 1;
5231	#ifndef LIBXML_REGEXP_ENABLED
5232	xmlNodePtr repl = NULL, last = NULL, tmp;
5233	#endif
5234	xmlNodePtr cur;
5235	xmlElementContentPtr cont;
5236	const xmlChar *name;
5237
5238	if ((elemDecl == NULL) \|\| (parent == NULL) \|\| (ctxt == NULL))
5239	return(-1);
5240	cont = elemDecl->content;
5241	name = elemDecl->name;
5242
5243	#ifdef LIBXML_REGEXP_ENABLED
5244	/* Build the regexp associated to the content model */
5245	if (elemDecl->contModel == NULL)
5246	ret = xmlValidBuildContentModel(ctxt, elemDecl);
5247	if (elemDecl->contModel == NULL) {
5248	return(-1);
5249	} else {
5250	xmlRegExecCtxtPtr exec;
5251
5252	if (!xmlRegexpIsDeterminist(elemDecl->contModel)) {
5253	return(-1);
5254	}
5255	ctxt->nodeMax = 0;
5256	ctxt->nodeNr = 0;
5257	ctxt->nodeTab = NULL;
5258	exec = xmlRegNewExecCtxt(elemDecl->contModel, NULL, NULL);
5259	if (exec != NULL) {
5260	cur = child;
5261	while (cur != NULL) {
5262	switch (cur->type) {
5263	case XML_ENTITY_REF_NODE:
5264	/*
5265	* Push the current node to be able to roll back
5266	* and process within the entity
5267	*/
5268	if ((cur->children != NULL) &&
5269	(cur->children->children != NULL)) {
5270	nodeVPush(ctxt, cur);
5271	cur = cur->children->children;
5272	continue;
5273	}
5274	break;
5275	case XML_TEXT_NODE:
5276	if (xmlIsBlankNode(cur))
5277	break;
5278	ret = 0;
5279	goto fail;
5280	case XML_CDATA_SECTION_NODE:
5281	/* TODO */
5282	ret = 0;
5283	goto fail;
5284	case XML_ELEMENT_NODE:
5285	if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
5286	xmlChar fn[50];
5287	xmlChar *fullname;
5288
5289	fullname = xmlBuildQName(cur->name,
5290	cur->ns->prefix, fn, 50);
5291	if (fullname == NULL) {
5292	ret = -1;
5293	goto fail;
5294	}
5295	ret = xmlRegExecPushString(exec, fullname, NULL);
5296	if ((fullname != fn) && (fullname != cur->name))
5297	xmlFree(fullname);
5298	} else {
5299	ret = xmlRegExecPushString(exec, cur->name, NULL);
5300	}
5301	break;
5302	default:
5303	break;
5304	}
5305	/*
5306	* Switch to next element
5307	*/
5308	cur = cur->next;
5309	while (cur == NULL) {
5310	cur = nodeVPop(ctxt);
5311	if (cur == NULL)
5312	break;
5313	cur = cur->next;
5314	}
5315	}
5316	ret = xmlRegExecPushString(exec, NULL, NULL);
5317	fail:
5318	xmlRegFreeExecCtxt(exec);
5319	}
5320	}
5321	#else /* LIBXML_REGEXP_ENABLED */
5322	/*
5323	* Allocate the stack
5324	*/
5325	ctxt->vstateMax = 8;
5326	ctxt->vstateTab = (xmlValidState *) xmlMalloc(
5327	ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
5328	if (ctxt->vstateTab == NULL) {
5329	xmlVErrMemory(ctxt, "malloc failed");
5330	return(-1);
5331	}
5332	/*
5333	* The first entry in the stack is reserved to the current state
5334	*/
5335	ctxt->nodeMax = 0;
5336	ctxt->nodeNr = 0;
5337	ctxt->nodeTab = NULL;
5338	ctxt->vstate = &ctxt->vstateTab[0];
5339	ctxt->vstateNr = 1;
5340	CONT = cont;
5341	NODE = child;
5342	DEPTH = 0;
5343	OCCURS = 0;
5344	STATE = 0;
5345	ret = xmlValidateElementType(ctxt);
5346	if ((ret == -3) && (warn)) {
5347	xmlErrValidWarning(ctxt, child, XML_DTD_CONTENT_NOT_DETERMINIST,
5348	"Content model for Element %s is ambiguous\n",
5349	name, NULL, NULL);
5350	} else if (ret == -2) {
5351	/*
5352	* An entities reference appeared at this level.
5353	* Buid a minimal representation of this node content
5354	* sufficient to run the validation process on it
5355	*/
5356	DEBUG_VALID_MSG("Found an entity reference, linearizing");
5357	cur = child;
5358	while (cur != NULL) {
5359	switch (cur->type) {
5360	case XML_ENTITY_REF_NODE:
5361	/*
5362	* Push the current node to be able to roll back
5363	* and process within the entity
5364	*/
5365	if ((cur->children != NULL) &&
5366	(cur->children->children != NULL)) {
5367	nodeVPush(ctxt, cur);
5368	cur = cur->children->children;
5369	continue;
5370	}
5371	break;
5372	case XML_TEXT_NODE:
5373	if (xmlIsBlankNode(cur))
5374	break;
5375	/* no break on purpose */
5376	case XML_CDATA_SECTION_NODE:
5377	/* no break on purpose */
5378	case XML_ELEMENT_NODE:
5379	/*
5380	* Allocate a new node and minimally fills in
5381	* what's required
5382	*/
5383	tmp = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
5384	if (tmp == NULL) {
5385	xmlVErrMemory(ctxt, "malloc failed");
5386	xmlFreeNodeList(repl);
5387	ret = -1;
5388	goto done;
5389	}
5390	tmp->type = cur->type;
5391	tmp->name = cur->name;
5392	tmp->ns = cur->ns;
5393	tmp->next = NULL;
5394	tmp->content = NULL;
5395	if (repl == NULL)
5396	repl = last = tmp;
5397	else {
5398	last->next = tmp;
5399	last = tmp;
5400	}
5401	if (cur->type == XML_CDATA_SECTION_NODE) {
5402	/*
5403	* E59 spaces in CDATA does not match the
5404	* nonterminal S
5405	*/
5406	tmp->content = xmlStrdup(BAD_CAST "CDATA");
5407	}
5408	break;
5409	default:
5410	break;
5411	}
5412	/*
5413	* Switch to next element
5414	*/
5415	cur = cur->next;
5416	while (cur == NULL) {
5417	cur = nodeVPop(ctxt);
5418	if (cur == NULL)
5419	break;
5420	cur = cur->next;
5421	}
5422	}
5423
5424	/*
5425	* Relaunch the validation
5426	*/
5427	ctxt->vstate = &ctxt->vstateTab[0];
5428	ctxt->vstateNr = 1;
5429	CONT = cont;
5430	NODE = repl;
5431	DEPTH = 0;
5432	OCCURS = 0;
5433	STATE = 0;
5434	ret = xmlValidateElementType(ctxt);
5435	}
5436	#endif /* LIBXML_REGEXP_ENABLED */
5437	if ((warn) && ((ret != 1) && (ret != -3))) {
5438	if (ctxt != NULL) {
5439	char expr[5000];
5440	char list[5000];
5441
5442	expr[0] = 0;
5443	xmlSnprintfElementContent(&expr[0], 5000, cont, 1);
5444	list[0] = 0;
5445	#ifndef LIBXML_REGEXP_ENABLED
5446	if (repl != NULL)
5447	xmlSnprintfElements(&list[0], 5000, repl, 1);
5448	else
5449	#endif /* LIBXML_REGEXP_ENABLED */
5450	xmlSnprintfElements(&list[0], 5000, child, 1);
5451
5452	if (name != NULL) {
5453	xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
5454	"Element %s content does not follow the DTD, expecting %s, got %s\n",
5455	name, BAD_CAST expr, BAD_CAST list);
5456	} else {
5457	xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
5458	"Element content does not follow the DTD, expecting %s, got %s\n",
5459	BAD_CAST expr, BAD_CAST list, NULL);
5460	}
5461	} else {
5462	if (name != NULL) {
5463	xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
5464	"Element %s content does not follow the DTD\n",
5465	name, NULL, NULL);
5466	} else {
5467	xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
5468	"Element content does not follow the DTD\n",
5469	NULL, NULL, NULL);
5470	}
5471	}
5472	ret = 0;
5473	}
5474	if (ret == -3)
5475	ret = 1;
5476
5477	#ifndef LIBXML_REGEXP_ENABLED
5478	done:
5479	/*
5480	* Deallocate the copy if done, and free up the validation stack
5481	*/
5482	while (repl != NULL) {
5483	tmp = repl->next;
5484	xmlFree(repl);
5485	repl = tmp;
5486	}
5487	ctxt->vstateMax = 0;
5488	if (ctxt->vstateTab != NULL) {
5489	xmlFree(ctxt->vstateTab);
5490	ctxt->vstateTab = NULL;
5491	}
5492	#endif
5493	ctxt->nodeMax = 0;
5494	ctxt->nodeNr = 0;
5495	if (ctxt->nodeTab != NULL) {
5496	xmlFree(ctxt->nodeTab);
5497	ctxt->nodeTab = NULL;
5498	}
5499	return(ret);
5500
5501	}
5502
5503	/**
5504	* xmlValidateCdataElement:
5505	* @ctxt: the validation context
5506	* @doc: a document instance
5507	* @elem: an element instance
5508	*
5509	* Check that an element follows #CDATA
5510	*
5511	* returns 1 if valid or 0 otherwise
5512	*/
5513	static int
5514	xmlValidateOneCdataElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5515	xmlNodePtr elem) {
5516	int ret = 1;
5517	xmlNodePtr cur, child;
5518
5519	if ((ctxt == NULL) \|\| (doc == NULL) \|\| (elem == NULL) \|\|
5520	(elem->type != XML_ELEMENT_NODE))
5521	return(0);
5522
5523	child = elem->children;
5524
5525	cur = child;
5526	while (cur != NULL) {
5527	switch (cur->type) {
5528	case XML_ENTITY_REF_NODE:
5529	/*
5530	* Push the current node to be able to roll back
5531	* and process within the entity
5532	*/
5533	if ((cur->children != NULL) &&
5534	(cur->children->children != NULL)) {
5535	nodeVPush(ctxt, cur);
5536	cur = cur->children->children;
5537	continue;
5538	}
5539	break;
5540	case XML_COMMENT_NODE:
5541	case XML_PI_NODE:
5542	case XML_TEXT_NODE:
5543	case XML_CDATA_SECTION_NODE:
5544	break;
5545	default:
5546	ret = 0;
5547	goto done;
5548	}
5549	/*
5550	* Switch to next element
5551	*/
5552	cur = cur->next;
5553	while (cur == NULL) {
5554	cur = nodeVPop(ctxt);
5555	if (cur == NULL)
5556	break;
5557	cur = cur->next;
5558	}
5559	}
5560	done:
5561	ctxt->nodeMax = 0;
5562	ctxt->nodeNr = 0;
5563	if (ctxt->nodeTab != NULL) {
5564	xmlFree(ctxt->nodeTab);
5565	ctxt->nodeTab = NULL;
5566	}
5567	return(ret);
5568	}
5569
5570	/**
5571	* xmlValidateCheckMixed:
5572	* @ctxt: the validation context
5573	* @cont: the mixed content model
5574	* @qname: the qualified name as appearing in the serialization
5575	*
5576	* Check if the given node is part of the content model.
5577	*
5578	* Returns 1 if yes, 0 if no, -1 in case of error
5579	*/
5580	static int
5581	xmlValidateCheckMixed(xmlValidCtxtPtr ctxt,
5582	xmlElementContentPtr cont, const xmlChar *qname) {
5583	const xmlChar *name;
5584	int plen;
5585	name = xmlSplitQName3(qname, &plen);
5586
5587	if (name == NULL) {
5588	while (cont != NULL) {
5589	if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
5590	if ((cont->prefix == NULL) && (xmlStrEqual(cont->name, qname)))
5591	return(1);
5592	} else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
5593	(cont->c1 != NULL) &&
5594	(cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
5595	if ((cont->c1->prefix == NULL) &&
5596	(xmlStrEqual(cont->c1->name, qname)))
5597	return(1);
5598	} else if ((cont->type != XML_ELEMENT_CONTENT_OR) \|\|
5599	(cont->c1 == NULL) \|\|
5600	(cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
5601	xmlErrValid(NULL, XML_DTD_MIXED_CORRUPT,
5602	"Internal: MIXED struct corrupted\n",
5603	NULL);
5604	break;
5605	}
5606	cont = cont->c2;
5607	}
5608	} else {
5609	while (cont != NULL) {
5610	if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
5611	if ((cont->prefix != NULL) &&
5612	(xmlStrncmp(cont->prefix, qname, plen) == 0) &&
5613	(xmlStrEqual(cont->name, name)))
5614	return(1);
5615	} else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
5616	(cont->c1 != NULL) &&
5617	(cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
5618	if ((cont->c1->prefix != NULL) &&
5619	(xmlStrncmp(cont->c1->prefix, qname, plen) == 0) &&
5620	(xmlStrEqual(cont->c1->name, name)))
5621	return(1);
5622	} else if ((cont->type != XML_ELEMENT_CONTENT_OR) \|\|
5623	(cont->c1 == NULL) \|\|
5624	(cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
5625	xmlErrValid(ctxt, XML_DTD_MIXED_CORRUPT,
5626	"Internal: MIXED struct corrupted\n",
5627	NULL);
5628	break;
5629	}
5630	cont = cont->c2;
5631	}
5632	}
5633	return(0);
5634	}
5635
5636	/**
5637	* xmlValidGetElemDecl:
5638	* @ctxt: the validation context
5639	* @doc: a document instance
5640	* @elem: an element instance
5641	* @extsubset: pointer, (out) indicate if the declaration was found
5642	* in the external subset.
5643	*
5644	* Finds a declaration associated to an element in the document.
5645	*
5646	* returns the pointer to the declaration or NULL if not found.
5647	*/
5648	static xmlElementPtr
5649	xmlValidGetElemDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5650	xmlNodePtr elem, int *extsubset) {
5651	xmlElementPtr elemDecl = NULL;
5652	const xmlChar *prefix = NULL;
5653
5654	if ((ctxt == NULL) \|\| (doc == NULL) \|\|
5655	(elem == NULL) \|\| (elem->name == NULL))
5656	return(NULL);
5657	if (extsubset != NULL)
5658	*extsubset = 0;
5659
5660	/*
5661	* Fetch the declaration for the qualified name
5662	*/
5663	if ((elem->ns != NULL) && (elem->ns->prefix != NULL))
5664	prefix = elem->ns->prefix;
5665
5666	if (prefix != NULL) {
5667	elemDecl = xmlGetDtdQElementDesc(doc->intSubset,
5668	elem->name, prefix);
5669	if ((elemDecl == NULL) && (doc->extSubset != NULL)) {
5670	elemDecl = xmlGetDtdQElementDesc(doc->extSubset,
5671	elem->name, prefix);
5672	if ((elemDecl != NULL) && (extsubset != NULL))
5673	*extsubset = 1;
5674	}
5675	}
5676
5677	/*
5678	* Fetch the declaration for the non qualified name
5679	* This is "non-strict" validation should be done on the
5680	* full QName but in that case being flexible makes sense.
5681	*/
5682	if (elemDecl == NULL) {
5683	elemDecl = xmlGetDtdElementDesc(doc->intSubset, elem->name);
5684	if ((elemDecl == NULL) && (doc->extSubset != NULL)) {
5685	elemDecl = xmlGetDtdElementDesc(doc->extSubset, elem->name);
5686	if ((elemDecl != NULL) && (extsubset != NULL))
5687	*extsubset = 1;
5688	}
5689	}
5690	if (elemDecl == NULL) {
5691	xmlErrValidNode(ctxt, elem,
5692	XML_DTD_UNKNOWN_ELEM,
5693	"No declaration for element %s\n",
5694	elem->name, NULL, NULL);
5695	}
5696	return(elemDecl);
5697	}
5698
5699	#ifdef LIBXML_REGEXP_ENABLED
5700	/**
5701	* xmlValidatePushElement:
5702	* @ctxt: the validation context
5703	* @doc: a document instance
5704	* @elem: an element instance
5705	* @qname: the qualified name as appearing in the serialization
5706	*
5707	* Push a new element start on the validation stack.
5708	*
5709	* returns 1 if no validation problem was found or 0 otherwise
5710	*/
5711	int
5712	xmlValidatePushElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5713	xmlNodePtr elem, const xmlChar *qname) {
5714	int ret = 1;
5715	xmlElementPtr eDecl;
5716	int extsubset = 0;
5717
5718	if (ctxt == NULL)
5719	return(0);
5720	/* printf("PushElem %s\n", qname); */
5721	if ((ctxt->vstateNr > 0) && (ctxt->vstate != NULL)) {
5722	xmlValidStatePtr state = ctxt->vstate;
5723	xmlElementPtr elemDecl;
5724
5725	/*
5726	* Check the new element agaisnt the content model of the new elem.
5727	*/
5728	if (state->elemDecl != NULL) {
5729	elemDecl = state->elemDecl;
5730
5731	switch(elemDecl->etype) {
5732	case XML_ELEMENT_TYPE_UNDEFINED:
5733	ret = 0;
5734	break;
5735	case XML_ELEMENT_TYPE_EMPTY:
5736	xmlErrValidNode(ctxt, state->node,
5737	XML_DTD_NOT_EMPTY,
5738	"Element %s was declared EMPTY this one has content\n",
5739	state->node->name, NULL, NULL);
5740	ret = 0;
5741	break;
5742	case XML_ELEMENT_TYPE_ANY:
5743	/* I don't think anything is required then */
5744	break;
5745	case XML_ELEMENT_TYPE_MIXED:
5746	/* simple case of declared as #PCDATA */
5747	if ((elemDecl->content != NULL) &&
5748	(elemDecl->content->type ==
5749	XML_ELEMENT_CONTENT_PCDATA)) {
5750	xmlErrValidNode(ctxt, state->node,
5751	XML_DTD_NOT_PCDATA,
5752	"Element %s was declared #PCDATA but contains non text nodes\n",
5753	state->node->name, NULL, NULL);
5754	ret = 0;
5755	} else {
5756	ret = xmlValidateCheckMixed(ctxt, elemDecl->content,
5757	qname);
5758	if (ret != 1) {
5759	xmlErrValidNode(ctxt, state->node,
5760	XML_DTD_INVALID_CHILD,
5761	"Element %s is not declared in %s list of possible children\n",
5762	qname, state->node->name, NULL);
5763	}
5764	}
5765	break;
5766	case XML_ELEMENT_TYPE_ELEMENT:
5767	/*
5768	* TODO:
5769	* VC: Standalone Document Declaration
5770	* - element types with element content, if white space
5771	* occurs directly within any instance of those types.
5772	*/
5773	if (state->exec != NULL) {
5774	ret = xmlRegExecPushString(state->exec, qname, NULL);
5775	if (ret < 0) {
5776	xmlErrValidNode(ctxt, state->node,
5777	XML_DTD_CONTENT_MODEL,
5778	"Element %s content does not follow the DTD, Misplaced %s\n",
5779	state->node->name, qname, NULL);
5780	ret = 0;
5781	} else {
5782	ret = 1;
5783	}
5784	}
5785	break;
5786	}
5787	}
5788	}
5789	eDecl = xmlValidGetElemDecl(ctxt, doc, elem, &extsubset);
5790	vstateVPush(ctxt, eDecl, elem);
5791	return(ret);
5792	}
5793
5794	/**
5795	* xmlValidatePushCData:
5796	* @ctxt: the validation context
5797	* @data: some character data read
5798	* @len: the length of the data
5799	*
5800	* check the CData parsed for validation in the current stack
5801	*
5802	* returns 1 if no validation problem was found or 0 otherwise
5803	*/
5804	int
5805	xmlValidatePushCData(xmlValidCtxtPtr ctxt, const xmlChar *data, int len) {
5806	int ret = 1;
5807
5808	/* printf("CDATA %s %d\n", data, len); */
5809	if (ctxt == NULL)
5810	return(0);
5811	if (len <= 0)
5812	return(ret);
5813	if ((ctxt->vstateNr > 0) && (ctxt->vstate != NULL)) {
5814	xmlValidStatePtr state = ctxt->vstate;
5815	xmlElementPtr elemDecl;
5816
5817	/*
5818	* Check the new element agaisnt the content model of the new elem.
5819	*/
5820	if (state->elemDecl != NULL) {
5821	elemDecl = state->elemDecl;
5822
5823	switch(elemDecl->etype) {
5824	case XML_ELEMENT_TYPE_UNDEFINED:
5825	ret = 0;
5826	break;
5827	case XML_ELEMENT_TYPE_EMPTY:
5828	xmlErrValidNode(ctxt, state->node,
5829	XML_DTD_NOT_EMPTY,
5830	"Element %s was declared EMPTY this one has content\n",
5831	state->node->name, NULL, NULL);
5832	ret = 0;
5833	break;
5834	case XML_ELEMENT_TYPE_ANY:
5835	break;
5836	case XML_ELEMENT_TYPE_MIXED:
5837	break;
5838	case XML_ELEMENT_TYPE_ELEMENT:
5839	if (len > 0) {
5840	int i;
5841
5842	for (i = 0;i < len;i++) {
5843	if (!IS_BLANK_CH(data[i])) {
5844	xmlErrValidNode(ctxt, state->node,
5845	XML_DTD_CONTENT_MODEL,
5846	"Element %s content does not follow the DTD, Text not allowed\n",
5847	state->node->name, NULL, NULL);
5848	ret = 0;
5849	goto done;
5850	}
5851	}
5852	/*
5853	* TODO:
5854	* VC: Standalone Document Declaration
5855	* element types with element content, if white space
5856	* occurs directly within any instance of those types.
5857	*/
5858	}
5859	break;
5860	}
5861	}
5862	}
5863	done:
5864	return(ret);
5865	}
5866
5867	/**
5868	* xmlValidatePopElement:
5869	* @ctxt: the validation context
5870	* @doc: a document instance
5871	* @elem: an element instance
5872	* @qname: the qualified name as appearing in the serialization
5873	*
5874	* Pop the element end from the validation stack.
5875	*
5876	* returns 1 if no validation problem was found or 0 otherwise
5877	*/
5878	int
5879	xmlValidatePopElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc ATTRIBUTE_UNUSED,
5880	xmlNodePtr elem ATTRIBUTE_UNUSED,
5881	const xmlChar *qname ATTRIBUTE_UNUSED) {
5882	int ret = 1;
5883
5884	if (ctxt == NULL)
5885	return(0);
5886	/* printf("PopElem %s\n", qname); */
5887	if ((ctxt->vstateNr > 0) && (ctxt->vstate != NULL)) {
5888	xmlValidStatePtr state = ctxt->vstate;
5889	xmlElementPtr elemDecl;
5890
5891	/*
5892	* Check the new element agaisnt the content model of the new elem.
5893	*/
5894	if (state->elemDecl != NULL) {
5895	elemDecl = state->elemDecl;
5896
5897	if (elemDecl->etype == XML_ELEMENT_TYPE_ELEMENT) {
5898	if (state->exec != NULL) {
5899	ret = xmlRegExecPushString(state->exec, NULL, NULL);
5900	if (ret == 0) {
5901	xmlErrValidNode(ctxt, state->node,
5902	XML_DTD_CONTENT_MODEL,
5903	"Element %s content does not follow the DTD, Expecting more child\n",
5904	state->node->name, NULL,NULL);
5905	} else {
5906	/*
5907	* previous validation errors should not generate
5908	* a new one here
5909	*/
5910	ret = 1;
5911	}
5912	}
5913	}
5914	}
5915	vstateVPop(ctxt);
5916	}
5917	return(ret);
5918	}
5919	#endif /* LIBXML_REGEXP_ENABLED */
5920
5921	/**
5922	* xmlValidateOneElement:
5923	* @ctxt: the validation context
5924	* @doc: a document instance
5925	* @elem: an element instance
5926	*
5927	* Try to validate a single element and it's attributes,
5928	* basically it does the following checks as described by the
5929	* XML-1.0 recommendation:
5930	* - [ VC: Element Valid ]
5931	* - [ VC: Required Attribute ]
5932	* Then call xmlValidateOneAttribute() for each attribute present.
5933	*
5934	* The ID/IDREF checkings are done separately
5935	*
5936	* returns 1 if valid or 0 otherwise
5937	*/
5938
5939	int
5940	xmlValidateOneElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5941	xmlNodePtr elem) {
5942	xmlElementPtr elemDecl = NULL;
5943	xmlElementContentPtr cont;
5944	xmlAttributePtr attr;
5945	xmlNodePtr child;
5946	int ret = 1, tmp;
5947	const xmlChar *name;
5948	int extsubset = 0;
5949
5950	CHECK_DTD;
5951
5952	if (elem == NULL) return(0);
5953	switch (elem->type) {
5954	case XML_ATTRIBUTE_NODE:
5955	xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5956	"Attribute element not expected\n", NULL, NULL ,NULL);
5957	return(0);
5958	case XML_TEXT_NODE:
5959	if (elem->children != NULL) {
5960	xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5961	"Text element has children !\n",
5962	NULL,NULL,NULL);
5963	return(0);
5964	}
5965	if (elem->ns != NULL) {
5966	xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5967	"Text element has namespace !\n",
5968	NULL,NULL,NULL);
5969	return(0);
5970	}
5971	if (elem->content == NULL) {
5972	xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5973	"Text element has no content !\n",
5974	NULL,NULL,NULL);
5975	return(0);
5976	}
5977	return(1);
5978	case XML_XINCLUDE_START:
5979	case XML_XINCLUDE_END:
5980	return(1);
5981	case XML_CDATA_SECTION_NODE:
5982	case XML_ENTITY_REF_NODE:
5983	case XML_PI_NODE:
5984	case XML_COMMENT_NODE:
5985	return(1);
5986	case XML_ENTITY_NODE:
5987	xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5988	"Entity element not expected\n", NULL, NULL ,NULL);
5989	return(0);
5990	case XML_NOTATION_NODE:
5991	xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5992	"Notation element not expected\n", NULL, NULL ,NULL);
5993	return(0);
5994	case XML_DOCUMENT_NODE:
5995	case XML_DOCUMENT_TYPE_NODE:
5996	case XML_DOCUMENT_FRAG_NODE:
5997	xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5998	"Document element not expected\n", NULL, NULL ,NULL);
5999	return(0);
6000	case XML_HTML_DOCUMENT_NODE:
6001	xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
6002	"HTML Document not expected\n", NULL, NULL ,NULL);
6003	return(0);
6004	case XML_ELEMENT_NODE:
6005	break;
6006	default:
6007	xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
6008	"unknown element type\n", NULL, NULL ,NULL);
6009	return(0);
6010	}
6011
6012	/*
6013	* Fetch the declaration
6014	*/
6015	elemDecl = xmlValidGetElemDecl(ctxt, doc, elem, &extsubset);
6016	if (elemDecl == NULL)
6017	return(0);
6018
6019	/*
6020	* If vstateNr is not zero that means continuous validation is
6021	* activated, do not try to check the content model at that level.
6022	*/
6023	if (ctxt->vstateNr == 0) {
6024	/* Check that the element content matches the definition */
6025	switch (elemDecl->etype) {
6026	case XML_ELEMENT_TYPE_UNDEFINED:
6027	xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ELEM,
6028	"No declaration for element %s\n",
6029	elem->name, NULL, NULL);
6030	return(0);
6031	case XML_ELEMENT_TYPE_EMPTY:
6032	if (elem->children != NULL) {
6033	xmlErrValidNode(ctxt, elem, XML_DTD_NOT_EMPTY,
6034	"Element %s was declared EMPTY this one has content\n",
6035	elem->name, NULL, NULL);
6036	ret = 0;
6037	}
6038	break;
6039	case XML_ELEMENT_TYPE_ANY:
6040	/* I don't think anything is required then */
6041	break;
6042	case XML_ELEMENT_TYPE_MIXED:
6043
6044	/* simple case of declared as #PCDATA */
6045	if ((elemDecl->content != NULL) &&
6046	(elemDecl->content->type == XML_ELEMENT_CONTENT_PCDATA)) {
6047	ret = xmlValidateOneCdataElement(ctxt, doc, elem);
6048	if (!ret) {
6049	xmlErrValidNode(ctxt, elem, XML_DTD_NOT_PCDATA,
6050	"Element %s was declared #PCDATA but contains non text nodes\n",
6051	elem->name, NULL, NULL);
6052	}
6053	break;
6054	}
6055	child = elem->children;
6056	/* Hum, this start to get messy */
6057	while (child != NULL) {
6058	if (child->type == XML_ELEMENT_NODE) {
6059	name = child->name;
6060	if ((child->ns != NULL) && (child->ns->prefix != NULL)) {
6061	xmlChar fn[50];
6062	xmlChar *fullname;
6063
6064	fullname = xmlBuildQName(child->name, child->ns->prefix,
6065	fn, 50);
6066	if (fullname == NULL)
6067	return(0);
6068	cont = elemDecl->content;
6069	while (cont != NULL) {
6070	if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
6071	if (xmlStrEqual(cont->name, fullname))
6072	break;
6073	} else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
6074	(cont->c1 != NULL) &&
6075	(cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
6076	if (xmlStrEqual(cont->c1->name, fullname))
6077	break;
6078	} else if ((cont->type != XML_ELEMENT_CONTENT_OR) \|\|
6079	(cont->c1 == NULL) \|\|
6080	(cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
6081	xmlErrValid(NULL, XML_DTD_MIXED_CORRUPT,
6082	"Internal: MIXED struct corrupted\n",
6083	NULL);
6084	break;
6085	}
6086	cont = cont->c2;
6087	}
6088	if ((fullname != fn) && (fullname != child->name))
6089	xmlFree(fullname);
6090	if (cont != NULL)
6091	goto child_ok;
6092	}
6093	cont = elemDecl->content;
6094	while (cont != NULL) {
6095	if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
6096	if (xmlStrEqual(cont->name, name)) break;
6097	} else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
6098	(cont->c1 != NULL) &&
6099	(cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)) {
6100	if (xmlStrEqual(cont->c1->name, name)) break;
6101	} else if ((cont->type != XML_ELEMENT_CONTENT_OR) \|\|
6102	(cont->c1 == NULL) \|\|
6103	(cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)) {
6104	xmlErrValid(ctxt, XML_DTD_MIXED_CORRUPT,
6105	"Internal: MIXED struct corrupted\n",
6106	NULL);
6107	break;
6108	}
6109	cont = cont->c2;
6110	}
6111	if (cont == NULL) {
6112	xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_CHILD,
6113	"Element %s is not declared in %s list of possible children\n",
6114	name, elem->name, NULL);
6115	ret = 0;
6116	}
6117	}
6118	child_ok:
6119	child = child->next;
6120	}
6121	break;
6122	case XML_ELEMENT_TYPE_ELEMENT:
6123	if ((doc->standalone == 1) && (extsubset == 1)) {
6124	/*
6125	* VC: Standalone Document Declaration
6126	* - element types with element content, if white space
6127	* occurs directly within any instance of those types.
6128	*/
6129	child = elem->children;
6130	while (child != NULL) {
6131	if (child->type == XML_TEXT_NODE) {
6132	const xmlChar *content = child->content;
6133
6134	while (IS_BLANK_CH(*content))
6135	content++;
6136	if (*content == 0) {
6137	xmlErrValidNode(ctxt, elem,
6138	XML_DTD_STANDALONE_WHITE_SPACE,
6139	"standalone: %s declared in the external subset contains white spaces nodes\n",
6140	elem->name, NULL, NULL);
6141	ret = 0;
6142	break;
6143	}
6144	}
6145	child =child->next;
6146	}
6147	}
6148	child = elem->children;
6149	cont = elemDecl->content;
6150	tmp = xmlValidateElementContent(ctxt, child, elemDecl, 1, elem);
6151	if (tmp <= 0)
6152	ret = tmp;
6153	break;
6154	}
6155	} /* not continuous */
6156
6157	/* [ VC: Required Attribute ] */
6158	attr = elemDecl->attributes;
6159	while (attr != NULL) {
6160	if (attr->def == XML_ATTRIBUTE_REQUIRED) {
6161	int qualified = -1;
6162
6163	if ((attr->prefix == NULL) &&
6164	(xmlStrEqual(attr->name, BAD_CAST "xmlns"))) {
6165	xmlNsPtr ns;
6166
6167	ns = elem->nsDef;
6168	while (ns != NULL) {
6169	if (ns->prefix == NULL)
6170	goto found;
6171	ns = ns->next;
6172	}
6173	} else if (xmlStrEqual(attr->prefix, BAD_CAST "xmlns")) {
6174	xmlNsPtr ns;
6175
6176	ns = elem->nsDef;
6177	while (ns != NULL) {
6178	if (xmlStrEqual(attr->name, ns->prefix))
6179	goto found;
6180	ns = ns->next;
6181	}
6182	} else {
6183	xmlAttrPtr attrib;
6184
6185	attrib = elem->properties;
6186	while (attrib != NULL) {
6187	if (xmlStrEqual(attrib->name, attr->name)) {
6188	if (attr->prefix != NULL) {
6189	xmlNsPtr nameSpace = attrib->ns;
6190
6191	if (nameSpace == NULL)
6192	nameSpace = elem->ns;
6193	/*
6194	* qualified names handling is problematic, having a
6195	* different prefix should be possible but DTDs don't
6196	* allow to define the URI instead of the prefix :-(
6197	*/
6198	if (nameSpace == NULL) {
6199	if (qualified < 0)
6200	qualified = 0;
6201	} else if (!xmlStrEqual(nameSpace->prefix,
6202	attr->prefix)) {
6203	if (qualified < 1)
6204	qualified = 1;
6205	} else
6206	goto found;
6207	} else {
6208	/*
6209	* We should allow applications to define namespaces
6210	* for their application even if the DTD doesn't
6211	* carry one, otherwise, basically we would always
6212	* break.
6213	*/
6214	goto found;
6215	}
6216	}
6217	attrib = attrib->next;
6218	}
6219	}
6220	if (qualified == -1) {
6221	if (attr->prefix == NULL) {
6222	xmlErrValidNode(ctxt, elem, XML_DTD_MISSING_ATTRIBUTE,
6223	"Element %s does not carry attribute %s\n",
6224	elem->name, attr->name, NULL);
6225	ret = 0;
6226	} else {
6227	xmlErrValidNode(ctxt, elem, XML_DTD_MISSING_ATTRIBUTE,
6228	"Element %s does not carry attribute %s:%s\n",
6229	elem->name, attr->prefix,attr->name);
6230	ret = 0;
6231	}
6232	} else if (qualified == 0) {
6233	xmlErrValidWarning(ctxt, elem, XML_DTD_NO_PREFIX,
6234	"Element %s required attribute %s:%s has no prefix\n",
6235	elem->name, attr->prefix, attr->name);
6236	} else if (qualified == 1) {
6237	xmlErrValidWarning(ctxt, elem, XML_DTD_DIFFERENT_PREFIX,
6238	"Element %s required attribute %s:%s has different prefix\n",
6239	elem->name, attr->prefix, attr->name);
6240	}
6241	} else if (attr->def == XML_ATTRIBUTE_FIXED) {
6242	/*
6243	* Special tests checking #FIXED namespace declarations
6244	* have the right value since this is not done as an
6245	* attribute checking
6246	*/
6247	if ((attr->prefix == NULL) &&
6248	(xmlStrEqual(attr->name, BAD_CAST "xmlns"))) {
6249	xmlNsPtr ns;
6250
6251	ns = elem->nsDef;
6252	while (ns != NULL) {
6253	if (ns->prefix == NULL) {
6254	if (!xmlStrEqual(attr->defaultValue, ns->href)) {
6255	xmlErrValidNode(ctxt, elem,
6256	XML_DTD_ELEM_DEFAULT_NAMESPACE,
6257	"Element %s namespace name for default namespace does not match the DTD\n",
6258	elem->name, NULL, NULL);
6259	ret = 0;
6260	}
6261	goto found;
6262	}
6263	ns = ns->next;
6264	}
6265	} else if (xmlStrEqual(attr->prefix, BAD_CAST "xmlns")) {
6266	xmlNsPtr ns;
6267
6268	ns = elem->nsDef;
6269	while (ns != NULL) {
6270	if (xmlStrEqual(attr->name, ns->prefix)) {
6271	if (!xmlStrEqual(attr->defaultValue, ns->href)) {
6272	xmlErrValidNode(ctxt, elem, XML_DTD_ELEM_NAMESPACE,
6273	"Element %s namespace name for %s does not match the DTD\n",
6274	elem->name, ns->prefix, NULL);
6275	ret = 0;
6276	}
6277	goto found;
6278	}
6279	ns = ns->next;
6280	}
6281	}
6282	}
6283	found:
6284	attr = attr->nexth;
6285	}
6286	return(ret);
6287	}
6288
6289	/**
6290	* xmlValidateRoot:
6291	* @ctxt: the validation context
6292	* @doc: a document instance
6293	*
6294	* Try to validate a the root element
6295	* basically it does the following check as described by the
6296	* XML-1.0 recommendation:
6297	* - [ VC: Root Element Type ]
6298	* it doesn't try to recurse or apply other check to the element
6299	*
6300	* returns 1 if valid or 0 otherwise
6301	*/
6302
6303	int
6304	xmlValidateRoot(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6305	xmlNodePtr root;
6306	int ret;
6307
6308	if (doc == NULL) return(0);
6309
6310	root = xmlDocGetRootElement(doc);
6311	if ((root == NULL) \|\| (root->name == NULL)) {
6312	xmlErrValid(ctxt, XML_DTD_NO_ROOT,
6313	"no root element\n", NULL);
6314	return(0);
6315	}
6316
6317	/*
6318	* When doing post validation against a separate DTD, those may
6319	* no internal subset has been generated
6320	*/
6321	if ((doc->intSubset != NULL) &&
6322	(doc->intSubset->name != NULL)) {
6323	/*
6324	* Check first the document root against the NQName
6325	*/
6326	if (!xmlStrEqual(doc->intSubset->name, root->name)) {
6327	if ((root->ns != NULL) && (root->ns->prefix != NULL)) {
6328	xmlChar fn[50];
6329	xmlChar *fullname;
6330
6331	fullname = xmlBuildQName(root->name, root->ns->prefix, fn, 50);
6332	if (fullname == NULL) {
6333	xmlVErrMemory(ctxt, NULL);
6334	return(0);
6335	}
6336	ret = xmlStrEqual(doc->intSubset->name, fullname);
6337	if ((fullname != fn) && (fullname != root->name))
6338	xmlFree(fullname);
6339	if (ret == 1)
6340	goto name_ok;
6341	}
6342	if ((xmlStrEqual(doc->intSubset->name, BAD_CAST "HTML")) &&
6343	(xmlStrEqual(root->name, BAD_CAST "html")))
6344	goto name_ok;
6345	xmlErrValidNode(ctxt, root, XML_DTD_ROOT_NAME,
6346	"root and DTD name do not match '%s' and '%s'\n",
6347	root->name, doc->intSubset->name, NULL);
6348	return(0);
6349	}
6350	}
6351	name_ok:
6352	return(1);
6353	}
6354
6355
6356	/**
6357	* xmlValidateElement:
6358	* @ctxt: the validation context
6359	* @doc: a document instance
6360	* @elem: an element instance
6361	*
6362	* Try to validate the subtree under an element
6363	*
6364	* returns 1 if valid or 0 otherwise
6365	*/
6366
6367	int
6368	xmlValidateElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr elem) {
6369	xmlNodePtr child;
6370	xmlAttrPtr attr;
6371	xmlNsPtr ns;
6372	const xmlChar *value;
6373	int ret = 1;
6374
6375	if (elem == NULL) return(0);
6376
6377	/*
6378	* XInclude elements were added after parsing in the infoset,
6379	* they don't really mean anything validation wise.
6380	*/
6381	if ((elem->type == XML_XINCLUDE_START) \|\|
6382	(elem->type == XML_XINCLUDE_END) \|\|
6383	(elem->type == XML_NAMESPACE_DECL))
6384	return(1);
6385
6386	CHECK_DTD;
6387
6388	/*
6389	* Entities references have to be handled separately
6390	*/
6391	if (elem->type == XML_ENTITY_REF_NODE) {
6392	return(1);
6393	}
6394
6395	ret &= xmlValidateOneElement(ctxt, doc, elem);
6396	if (elem->type == XML_ELEMENT_NODE) {
6397	attr = elem->properties;
6398	while (attr != NULL) {
6399	value = xmlNodeListGetString(doc, attr->children, 0);
6400	ret &= xmlValidateOneAttribute(ctxt, doc, elem, attr, value);
6401	if (value != NULL)
6402	xmlFree((char *)value);
6403	attr= attr->next;
6404	}
6405	ns = elem->nsDef;
6406	while (ns != NULL) {
6407	if (elem->ns == NULL)
6408	ret &= xmlValidateOneNamespace(ctxt, doc, elem, NULL,
6409	ns, ns->href);
6410	else
6411	ret &= xmlValidateOneNamespace(ctxt, doc, elem,
6412	elem->ns->prefix, ns, ns->href);
6413	ns = ns->next;
6414	}
6415	}
6416	child = elem->children;
6417	while (child != NULL) {
6418	ret &= xmlValidateElement(ctxt, doc, child);
6419	child = child->next;
6420	}
6421
6422	return(ret);
6423	}
6424
6425	/**
6426	* xmlValidateRef:
6427	* @ref: A reference to be validated
6428	* @ctxt: Validation context
6429	* @name: Name of ID we are searching for
6430	*
6431	*/
6432	static void
6433	xmlValidateRef(xmlRefPtr ref, xmlValidCtxtPtr ctxt,
6434	const xmlChar *name) {
6435	xmlAttrPtr id;
6436	xmlAttrPtr attr;
6437
6438	if (ref == NULL)
6439	return;
6440	if ((ref->attr == NULL) && (ref->name == NULL))
6441	return;
6442	attr = ref->attr;
6443	if (attr == NULL) {
6444	xmlChar dup, str = NULL, *cur, save;
6445
6446	dup = xmlStrdup(name);
6447	if (dup == NULL) {
6448	ctxt->valid = 0;
6449	return;
6450	}
6451	cur = dup;
6452	while (*cur != 0) {
6453	str = cur;
6454	while ((cur != 0) && (!IS_BLANK_CH(cur))) cur++;
6455	save = *cur;
6456	*cur = 0;
6457	id = xmlGetID(ctxt->doc, str);
6458	if (id == NULL) {
6459	xmlErrValidNodeNr(ctxt, NULL, XML_DTD_UNKNOWN_ID,
6460	"attribute %s line %d references an unknown ID \"%s\"\n",
6461	ref->name, ref->lineno, str);
6462	ctxt->valid = 0;
6463	}
6464	if (save == 0)
6465	break;
6466	*cur = save;
6467	while (IS_BLANK_CH(*cur)) cur++;
6468	}
6469	xmlFree(dup);
6470	} else if (attr->atype == XML_ATTRIBUTE_IDREF) {
6471	id = xmlGetID(ctxt->doc, name);
6472	if (id == NULL) {
6473	xmlErrValidNode(ctxt, attr->parent, XML_DTD_UNKNOWN_ID,
6474	"IDREF attribute %s references an unknown ID \"%s\"\n",
6475	attr->name, name, NULL);
6476	ctxt->valid = 0;
6477	}
6478	} else if (attr->atype == XML_ATTRIBUTE_IDREFS) {
6479	xmlChar dup, str = NULL, *cur, save;
6480
6481	dup = xmlStrdup(name);
6482	if (dup == NULL) {
6483	xmlVErrMemory(ctxt, "IDREFS split");
6484	ctxt->valid = 0;
6485	return;
6486	}
6487	cur = dup;
6488	while (*cur != 0) {
6489	str = cur;
6490	while ((cur != 0) && (!IS_BLANK_CH(cur))) cur++;
6491	save = *cur;
6492	*cur = 0;
6493	id = xmlGetID(ctxt->doc, str);
6494	if (id == NULL) {
6495	xmlErrValidNode(ctxt, attr->parent, XML_DTD_UNKNOWN_ID,
6496	"IDREFS attribute %s references an unknown ID \"%s\"\n",
6497	attr->name, str, NULL);
6498	ctxt->valid = 0;
6499	}
6500	if (save == 0)
6501	break;
6502	*cur = save;
6503	while (IS_BLANK_CH(*cur)) cur++;
6504	}
6505	xmlFree(dup);
6506	}
6507	}
6508
6509	/**
6510	* xmlWalkValidateList:
6511	* @data: Contents of current link
6512	* @user: Value supplied by the user
6513	*
6514	* Returns 0 to abort the walk or 1 to continue
6515	*/
6516	static int
6517	xmlWalkValidateList(const void data, const void user)
6518	{
6519	xmlValidateMemoPtr memo = (xmlValidateMemoPtr)user;
6520	xmlValidateRef((xmlRefPtr)data, memo->ctxt, memo->name);
6521	return 1;
6522	}
6523
6524	/**
6525	* xmlValidateCheckRefCallback:
6526	* @ref_list: List of references
6527	* @ctxt: Validation context
6528	* @name: Name of ID we are searching for
6529	*
6530	*/
6531	static void
6532	xmlValidateCheckRefCallback(xmlListPtr ref_list, xmlValidCtxtPtr ctxt,
6533	const xmlChar *name) {
6534	xmlValidateMemo memo;
6535
6536	if (ref_list == NULL)
6537	return;
6538	memo.ctxt = ctxt;
6539	memo.name = name;
6540
6541	xmlListWalk(ref_list, xmlWalkValidateList, &memo);
6542
6543	}
6544
6545	/**
6546	* xmlValidateDocumentFinal:
6547	* @ctxt: the validation context
6548	* @doc: a document instance
6549	*
6550	* Does the final step for the document validation once all the
6551	* incremental validation steps have been completed
6552	*
6553	* basically it does the following checks described by the XML Rec
6554	*
6555	* Check all the IDREF/IDREFS attributes definition for validity
6556	*
6557	* returns 1 if valid or 0 otherwise
6558	*/
6559
6560	int
6561	xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6562	xmlRefTablePtr table;
6563	unsigned int save;
6564
6565	if (ctxt == NULL)
6566	return(0);
6567	if (doc == NULL) {
6568	xmlErrValid(ctxt, XML_DTD_NO_DOC,
6569	"xmlValidateDocumentFinal: doc == NULL\n", NULL);
6570	return(0);
6571	}
6572
6573	/* trick to get correct line id report */
6574	save = ctxt->finishDtd;
6575	ctxt->finishDtd = 0;
6576
6577	/*
6578	* Check all the NOTATION/NOTATIONS attributes
6579	*/
6580	/*
6581	* Check all the ENTITY/ENTITIES attributes definition for validity
6582	*/
6583	/*
6584	* Check all the IDREF/IDREFS attributes definition for validity
6585	*/
6586	table = (xmlRefTablePtr) doc->refs;
6587	ctxt->doc = doc;
6588	ctxt->valid = 1;
6589	xmlHashScan(table, (xmlHashScanner) xmlValidateCheckRefCallback, ctxt);
6590
6591	ctxt->finishDtd = save;
6592	return(ctxt->valid);
6593	}
6594
6595	/**
6596	* xmlValidateDtd:
6597	* @ctxt: the validation context
6598	* @doc: a document instance
6599	* @dtd: a dtd instance
6600	*
6601	* Try to validate the document against the dtd instance
6602	*
6603	* Basically it does check all the definitions in the DtD.
6604	* Note the the internal subset (if present) is de-coupled
6605	* (i.e. not used), which could give problems if ID or IDREF
6606	* is present.
6607	*
6608	* returns 1 if valid or 0 otherwise
6609	*/
6610
6611	int
6612	xmlValidateDtd(xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlDtdPtr dtd) {
6613	int ret;
6614	xmlDtdPtr oldExt, oldInt;
6615	xmlNodePtr root;
6616
6617	if (dtd == NULL) return(0);
6618	if (doc == NULL) return(0);
6619	oldExt = doc->extSubset;
6620	oldInt = doc->intSubset;
6621	doc->extSubset = dtd;
6622	doc->intSubset = NULL;
6623	ret = xmlValidateRoot(ctxt, doc);
6624	if (ret == 0) {
6625	doc->extSubset = oldExt;
6626	doc->intSubset = oldInt;
6627	return(ret);
6628	}
6629	if (doc->ids != NULL) {
6630	xmlFreeIDTable(doc->ids);
6631	doc->ids = NULL;
6632	}
6633	if (doc->refs != NULL) {
6634	xmlFreeRefTable(doc->refs);
6635	doc->refs = NULL;
6636	}
6637	root = xmlDocGetRootElement(doc);
6638	ret = xmlValidateElement(ctxt, doc, root);
6639	ret &= xmlValidateDocumentFinal(ctxt, doc);
6640	doc->extSubset = oldExt;
6641	doc->intSubset = oldInt;
6642	return(ret);
6643	}
6644
6645	static void
6646	xmlValidateNotationCallback(xmlEntityPtr cur, xmlValidCtxtPtr ctxt,
6647	const xmlChar *name ATTRIBUTE_UNUSED) {
6648	if (cur == NULL)
6649	return;
6650	if (cur->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
6651	xmlChar *notation = cur->content;
6652
6653	if (notation != NULL) {
6654	int ret;
6655
6656	ret = xmlValidateNotationUse(ctxt, cur->doc, notation);
6657	if (ret != 1) {
6658	ctxt->valid = 0;
6659	}
6660	}
6661	}
6662	}
6663
6664	static void
6665	xmlValidateAttributeCallback(xmlAttributePtr cur, xmlValidCtxtPtr ctxt,
6666	const xmlChar *name ATTRIBUTE_UNUSED) {
6667	int ret;
6668	xmlDocPtr doc;
6669	xmlElementPtr elem = NULL;
6670
6671	if (cur == NULL)
6672	return;
6673	switch (cur->atype) {
6674	case XML_ATTRIBUTE_CDATA:
6675	case XML_ATTRIBUTE_ID:
6676	case XML_ATTRIBUTE_IDREF :
6677	case XML_ATTRIBUTE_IDREFS:
6678	case XML_ATTRIBUTE_NMTOKEN:
6679	case XML_ATTRIBUTE_NMTOKENS:
6680	case XML_ATTRIBUTE_ENUMERATION:
6681	break;
6682	case XML_ATTRIBUTE_ENTITY:
6683	case XML_ATTRIBUTE_ENTITIES:
6684	case XML_ATTRIBUTE_NOTATION:
6685	if (cur->defaultValue != NULL) {
6686
6687	ret = xmlValidateAttributeValue2(ctxt, ctxt->doc, cur->name,
6688	cur->atype, cur->defaultValue);
6689	if ((ret == 0) && (ctxt->valid == 1))
6690	ctxt->valid = 0;
6691	}
6692	if (cur->tree != NULL) {
6693	xmlEnumerationPtr tree = cur->tree;
6694	while (tree != NULL) {
6695	ret = xmlValidateAttributeValue2(ctxt, ctxt->doc,
6696	cur->name, cur->atype, tree->name);
6697	if ((ret == 0) && (ctxt->valid == 1))
6698	ctxt->valid = 0;
6699	tree = tree->next;
6700	}
6701	}
6702	}
6703	if (cur->atype == XML_ATTRIBUTE_NOTATION) {
6704	doc = cur->doc;
6705	if (cur->elem == NULL) {
6706	xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
6707	"xmlValidateAttributeCallback(%s): internal error\n",
6708	(const char *) cur->name);
6709	return;
6710	}
6711
6712	if (doc != NULL)
6713	elem = xmlGetDtdElementDesc(doc->intSubset, cur->elem);
6714	if ((elem == NULL) && (doc != NULL))
6715	elem = xmlGetDtdElementDesc(doc->extSubset, cur->elem);
6716	if ((elem == NULL) && (cur->parent != NULL) &&
6717	(cur->parent->type == XML_DTD_NODE))
6718	elem = xmlGetDtdElementDesc((xmlDtdPtr) cur->parent, cur->elem);
6719	if (elem == NULL) {
6720	xmlErrValidNode(ctxt, NULL, XML_DTD_UNKNOWN_ELEM,
6721	"attribute %s: could not find decl for element %s\n",
6722	cur->name, cur->elem, NULL);
6723	return;
6724	}
6725	if (elem->etype == XML_ELEMENT_TYPE_EMPTY) {
6726	xmlErrValidNode(ctxt, NULL, XML_DTD_EMPTY_NOTATION,
6727	"NOTATION attribute %s declared for EMPTY element %s\n",
6728	cur->name, cur->elem, NULL);
6729	ctxt->valid = 0;
6730	}
6731	}
6732	}
6733
6734	/**
6735	* xmlValidateDtdFinal:
6736	* @ctxt: the validation context
6737	* @doc: a document instance
6738	*
6739	* Does the final step for the dtds validation once all the
6740	* subsets have been parsed
6741	*
6742	* basically it does the following checks described by the XML Rec
6743	* - check that ENTITY and ENTITIES type attributes default or
6744	* possible values matches one of the defined entities.
6745	* - check that NOTATION type attributes default or
6746	* possible values matches one of the defined notations.
6747	*
6748	* returns 1 if valid or 0 if invalid and -1 if not well-formed
6749	*/
6750
6751	int
6752	xmlValidateDtdFinal(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6753	xmlDtdPtr dtd;
6754	xmlAttributeTablePtr table;
6755	xmlEntitiesTablePtr entities;
6756
6757	if ((doc == NULL) \|\| (ctxt == NULL)) return(0);
6758	if ((doc->intSubset == NULL) && (doc->extSubset == NULL))
6759	return(0);
6760	ctxt->doc = doc;
6761	ctxt->valid = 1;
6762	dtd = doc->intSubset;
6763	if ((dtd != NULL) && (dtd->attributes != NULL)) {
6764	table = (xmlAttributeTablePtr) dtd->attributes;
6765	xmlHashScan(table, (xmlHashScanner) xmlValidateAttributeCallback, ctxt);
6766	}
6767	if ((dtd != NULL) && (dtd->entities != NULL)) {
6768	entities = (xmlEntitiesTablePtr) dtd->entities;
6769	xmlHashScan(entities, (xmlHashScanner) xmlValidateNotationCallback,
6770	ctxt);
6771	}
6772	dtd = doc->extSubset;
6773	if ((dtd != NULL) && (dtd->attributes != NULL)) {
6774	table = (xmlAttributeTablePtr) dtd->attributes;
6775	xmlHashScan(table, (xmlHashScanner) xmlValidateAttributeCallback, ctxt);
6776	}
6777	if ((dtd != NULL) && (dtd->entities != NULL)) {
6778	entities = (xmlEntitiesTablePtr) dtd->entities;
6779	xmlHashScan(entities, (xmlHashScanner) xmlValidateNotationCallback,
6780	ctxt);
6781	}
6782	return(ctxt->valid);
6783	}
6784
6785	/**
6786	* xmlValidateDocument:
6787	* @ctxt: the validation context
6788	* @doc: a document instance
6789	*
6790	* Try to validate the document instance
6791	*
6792	* basically it does the all the checks described by the XML Rec
6793	* i.e. validates the internal and external subset (if present)
6794	* and validate the document tree.
6795	*
6796	* returns 1 if valid or 0 otherwise
6797	*/
6798
6799	int
6800	xmlValidateDocument(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6801	int ret;
6802	xmlNodePtr root;
6803
6804	if (doc == NULL)
6805	return(0);
6806	if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
6807	xmlErrValid(ctxt, XML_DTD_NO_DTD,
6808	"no DTD found!\n", NULL);
6809	return(0);
6810	}
6811	if ((doc->intSubset != NULL) && ((doc->intSubset->SystemID != NULL) \|\|
6812	(doc->intSubset->ExternalID != NULL)) && (doc->extSubset == NULL)) {
6813	xmlChar *sysID;
6814	if (doc->intSubset->SystemID != NULL) {
6815	sysID = xmlBuildURI(doc->intSubset->SystemID,
6816	doc->URL);
6817	if (sysID == NULL) {
6818	xmlErrValid(ctxt, XML_DTD_LOAD_ERROR,
6819	"Could not build URI for external subset \"%s\"\n",
6820	(const char *) doc->intSubset->SystemID);
6821	return 0;
6822	}
6823	} else
6824	sysID = NULL;
6825	doc->extSubset = xmlParseDTD(doc->intSubset->ExternalID,
6826	(const xmlChar *)sysID);
6827	if (sysID != NULL)
6828	xmlFree(sysID);
6829	if (doc->extSubset == NULL) {
6830	if (doc->intSubset->SystemID != NULL) {
6831	xmlErrValid(ctxt, XML_DTD_LOAD_ERROR,
6832	"Could not load the external subset \"%s\"\n",
6833	(const char *) doc->intSubset->SystemID);
6834	} else {
6835	xmlErrValid(ctxt, XML_DTD_LOAD_ERROR,
6836	"Could not load the external subset \"%s\"\n",
6837	(const char *) doc->intSubset->ExternalID);
6838	}
6839	return(0);
6840	}
6841	}
6842
6843	if (doc->ids != NULL) {
6844	xmlFreeIDTable(doc->ids);
6845	doc->ids = NULL;
6846	}
6847	if (doc->refs != NULL) {
6848	xmlFreeRefTable(doc->refs);
6849	doc->refs = NULL;
6850	}
6851	ret = xmlValidateDtdFinal(ctxt, doc);
6852	if (!xmlValidateRoot(ctxt, doc)) return(0);
6853
6854	root = xmlDocGetRootElement(doc);
6855	ret &= xmlValidateElement(ctxt, doc, root);
6856	ret &= xmlValidateDocumentFinal(ctxt, doc);
6857	return(ret);
6858	}
6859
6860	/************************************************************************
6861	* *
6862	* Routines for dynamic validation editing *
6863	* *
6864	************************************************************************/
6865
6866	/**
6867	* xmlValidGetPotentialChildren:
6868	* @ctree: an element content tree
6869	* @names: an array to store the list of child names
6870	* @len: a pointer to the number of element in the list
6871	* @max: the size of the array
6872	*
6873	* Build/extend a list of potential children allowed by the content tree
6874	*
6875	* returns the number of element in the list, or -1 in case of error.
6876	*/
6877
6878	int
6879	xmlValidGetPotentialChildren(xmlElementContent *ctree,
6880	const xmlChar **names,
6881	int *len, int max) {
6882	int i;
6883
6884	if ((ctree == NULL) \|\| (names == NULL) \|\| (len == NULL))
6885	return(-1);
6886	if (len >= max) return(len);
6887
6888	switch (ctree->type) {
6889	case XML_ELEMENT_CONTENT_PCDATA:
6890	for (i = 0; i < *len;i++)
6891	if (xmlStrEqual(BAD_CAST "#PCDATA", names[i])) return(*len);
6892	names[(*len)++] = BAD_CAST "#PCDATA";
6893	break;
6894	case XML_ELEMENT_CONTENT_ELEMENT:
6895	for (i = 0; i < *len;i++)
6896	if (xmlStrEqual(ctree->name, names[i])) return(*len);
6897	names[(*len)++] = ctree->name;
6898	break;
6899	case XML_ELEMENT_CONTENT_SEQ:
6900	xmlValidGetPotentialChildren(ctree->c1, names, len, max);
6901	xmlValidGetPotentialChildren(ctree->c2, names, len, max);
6902	break;
6903	case XML_ELEMENT_CONTENT_OR:
6904	xmlValidGetPotentialChildren(ctree->c1, names, len, max);
6905	xmlValidGetPotentialChildren(ctree->c2, names, len, max);
6906	break;
6907	}
6908
6909	return(*len);
6910	}
6911
6912	/*
6913	* Dummy function to suppress messages while we try out valid elements
6914	*/
6915	static void XMLCDECL xmlNoValidityErr(void *ctx ATTRIBUTE_UNUSED,
6916	const char *msg ATTRIBUTE_UNUSED, ...) {
6917	return;
6918	}
6919
6920	/**
6921	* xmlValidGetValidElements:
6922	* @prev: an element to insert after
6923	* @next: an element to insert next
6924	* @names: an array to store the list of child names
6925	* @max: the size of the array
6926	*
6927	* This function returns the list of authorized children to insert
6928	* within an existing tree while respecting the validity constraints
6929	* forced by the Dtd. The insertion point is defined using @prev and
6930	* @next in the following ways:
6931	* to insert before 'node': xmlValidGetValidElements(node->prev, node, ...
6932	* to insert next 'node': xmlValidGetValidElements(node, node->next, ...
6933	* to replace 'node': xmlValidGetValidElements(node->prev, node->next, ...
6934	* to prepend a child to 'node': xmlValidGetValidElements(NULL, node->childs,
6935	* to append a child to 'node': xmlValidGetValidElements(node->last, NULL, ...
6936	*
6937	* pointers to the element names are inserted at the beginning of the array
6938	* and do not need to be freed.
6939	*
6940	* returns the number of element in the list, or -1 in case of error. If
6941	* the function returns the value @max the caller is invited to grow the
6942	* receiving array and retry.
6943	*/
6944
6945	int
6946	xmlValidGetValidElements(xmlNode prev, xmlNode next, const xmlChar **names,
6947	int max) {
6948	xmlValidCtxt vctxt;
6949	int nb_valid_elements = 0;
6950	const xmlChar *elements[256]={0};
6951	int nb_elements = 0, i;
6952	const xmlChar *name;
6953
6954	xmlNode *ref_node;
6955	xmlNode *parent;
6956	xmlNode *test_node;
6957
6958	xmlNode *prev_next;
6959	xmlNode *next_prev;
6960	xmlNode *parent_childs;
6961	xmlNode *parent_last;
6962
6963	xmlElement *element_desc;
6964
6965	if (prev == NULL && next == NULL)
6966	return(-1);
6967
6968	if (names == NULL) return(-1);
6969	if (max <= 0) return(-1);
6970
6971	memset(&vctxt, 0, sizeof (xmlValidCtxt));
6972	vctxt.error = xmlNoValidityErr; /* this suppresses err/warn output */
6973
6974	nb_valid_elements = 0;
6975	ref_node = prev ? prev : next;
6976	parent = ref_node->parent;
6977
6978	/*
6979	* Retrieves the parent element declaration
6980	*/
6981	element_desc = xmlGetDtdElementDesc(parent->doc->intSubset,
6982	parent->name);
6983	if ((element_desc == NULL) && (parent->doc->extSubset != NULL))
6984	element_desc = xmlGetDtdElementDesc(parent->doc->extSubset,
6985	parent->name);
6986	if (element_desc == NULL) return(-1);
6987
6988	/*
6989	* Do a backup of the current tree structure
6990	*/
6991	prev_next = prev ? prev->next : NULL;
6992	next_prev = next ? next->prev : NULL;
6993	parent_childs = parent->children;
6994	parent_last = parent->last;
6995
6996	/*
6997	* Creates a dummy node and insert it into the tree
6998	*/
6999	test_node = xmlNewDocNode (ref_node->doc, NULL, BAD_CAST "<!dummy?>", NULL);
7000	if (test_node == NULL)
7001	return(-1);
7002
7003	test_node->parent = parent;
7004	test_node->prev = prev;
7005	test_node->next = next;
7006	name = test_node->name;
7007
7008	if (prev) prev->next = test_node;
7009	else parent->children = test_node;
7010
7011	if (next) next->prev = test_node;
7012	else parent->last = test_node;
7013
7014	/*
7015	* Insert each potential child node and check if the parent is
7016	* still valid
7017	*/
7018	nb_elements = xmlValidGetPotentialChildren(element_desc->content,
7019	elements, &nb_elements, 256);
7020
7021	for (i = 0;i < nb_elements;i++) {
7022	test_node->name = elements[i];
7023	if (xmlValidateOneElement(&vctxt, parent->doc, parent)) {
7024	int j;
7025
7026	for (j = 0; j < nb_valid_elements;j++)
7027	if (xmlStrEqual(elements[i], names[j])) break;
7028	names[nb_valid_elements++] = elements[i];
7029	if (nb_valid_elements >= max) break;
7030	}
7031	}
7032
7033	/*
7034	* Restore the tree structure
7035	*/
7036	if (prev) prev->next = prev_next;
7037	if (next) next->prev = next_prev;
7038	parent->children = parent_childs;
7039	parent->last = parent_last;
7040
7041	/*
7042	* Free up the dummy node
7043	*/
7044	test_node->name = name;
7045	xmlFreeNode(test_node);
7046
7047	return(nb_valid_elements);
7048	}
7049	#endif /* LIBXML_VALID_ENABLED */
7050
7051	#define bottom_valid
7052	#include "elfgcchack.h"

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/libs/libxml2-2.9.2/valid.c@ 58072

以其他格式下載: