blob: 6e53a76de3ae5337ab9dad8b6609e2a17785dceb [file] [log] [blame]
Owen Taylor3473f882001-02-23 17:55:21 +00001/*
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 *
Daniel Veillardc5d64342001-06-24 12:13:24 +00007 * daniel@veillard.com
Owen Taylor3473f882001-02-23 17:55:21 +00008 */
9
Daniel Veillard34ce8be2002-03-18 19:37:11 +000010#define IN_LIBXML
Bjorn Reese70a9da52001-04-21 16:57:29 +000011#include "libxml.h"
Owen Taylor3473f882001-02-23 17:55:21 +000012
Owen Taylor3473f882001-02-23 17:55:21 +000013#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>
Daniel Veillard29b17482004-08-16 00:39:03 +000021#include <libxml/uri.h>
Owen Taylor3473f882001-02-23 17:55:21 +000022#include <libxml/valid.h>
23#include <libxml/parser.h>
24#include <libxml/parserInternals.h>
25#include <libxml/xmlerror.h>
26#include <libxml/list.h>
Daniel Veillard3c01b1d2001-10-17 15:58:35 +000027#include <libxml/globals.h>
Owen Taylor3473f882001-02-23 17:55:21 +000028
Daniel Veillard4432df22003-09-28 18:58:27 +000029static xmlElementPtr xmlGetDtdElementDesc2(xmlDtdPtr dtd, const xmlChar *name,
30 int create);
Daniel Veillarde62d36c2001-05-15 08:53:16 +000031/* #define DEBUG_VALID_ALGO */
Daniel Veillard5acfd6b2002-09-18 16:29:02 +000032/* #define DEBUG_REGEXP_ALGO */
Daniel Veillarde62d36c2001-05-15 08:53:16 +000033
Daniel Veillardf8e3db02012-09-11 13:26:36 +080034#define TODO \
Daniel Veillarda646cfd2002-09-17 21:50:03 +000035 xmlGenericError(xmlGenericErrorContext, \
36 "Unimplemented block at %s:%d\n", \
37 __FILE__, __LINE__);
Owen Taylor3473f882001-02-23 17:55:21 +000038
Daniel Veillardae0765b2008-07-31 19:54:59 +000039#ifdef LIBXML_VALID_ENABLED
40static int
41xmlValidateAttributeValueInternal(xmlDocPtr doc, xmlAttributeType type,
42 const xmlChar *value);
43#endif
Daniel Veillard2b8c4a12003-10-02 22:28:19 +000044/************************************************************************
45 * *
46 * Error handling routines *
47 * *
48 ************************************************************************/
49
Daniel Veillard2b8c4a12003-10-02 22:28:19 +000050/**
Daniel Veillardce9457f2003-10-05 21:33:18 +000051 * xmlVErrMemory:
Daniel Veillard2b8c4a12003-10-02 22:28:19 +000052 * @ctxt: an XML validation parser context
53 * @extra: extra informations
54 *
55 * Handle an out of memory error
56 */
57static void
Daniel Veillardce9457f2003-10-05 21:33:18 +000058xmlVErrMemory(xmlValidCtxtPtr ctxt, const char *extra)
Daniel Veillard2b8c4a12003-10-02 22:28:19 +000059{
Daniel Veillardbb5abab2003-10-03 22:21:51 +000060 xmlGenericErrorFunc channel = NULL;
61 xmlParserCtxtPtr pctxt = NULL;
62 void *data = NULL;
63
64 if (ctxt != NULL) {
65 channel = ctxt->error;
66 data = ctxt->userData;
Daniel Veillardeff45a92004-10-29 12:10:55 +000067 /* 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)) {
Daniel Veillardb2dc5672006-08-22 14:45:40 +000071 long delta = (char *) ctxt - (char *) ctxt->userData;
72 if ((delta > 0) && (delta < 250))
73 pctxt = ctxt->userData;
Daniel Veillardeff45a92004-10-29 12:10:55 +000074 }
Daniel Veillardbb5abab2003-10-03 22:21:51 +000075 }
Daniel Veillard2b8c4a12003-10-02 22:28:19 +000076 if (extra)
Daniel Veillard73000572003-10-11 11:26:42 +000077 __xmlRaiseError(NULL, channel, data,
Daniel Veillard72b9e292003-10-28 15:44:17 +000078 pctxt, NULL, XML_FROM_VALID, XML_ERR_NO_MEMORY,
Daniel Veillardbb5abab2003-10-03 22:21:51 +000079 XML_ERR_FATAL, NULL, 0, extra, NULL, NULL, 0, 0,
80 "Memory allocation failed : %s\n", extra);
Daniel Veillard2b8c4a12003-10-02 22:28:19 +000081 else
Daniel Veillard73000572003-10-11 11:26:42 +000082 __xmlRaiseError(NULL, channel, data,
Daniel Veillard72b9e292003-10-28 15:44:17 +000083 pctxt, NULL, XML_FROM_VALID, XML_ERR_NO_MEMORY,
Daniel Veillardbb5abab2003-10-03 22:21:51 +000084 XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0,
85 "Memory allocation failed\n");
Daniel Veillard2b8c4a12003-10-02 22:28:19 +000086}
87
88/**
89 * xmlErrValid:
90 * @ctxt: an XML validation parser context
Daniel Veillardbb5abab2003-10-03 22:21:51 +000091 * @error: the error number
Daniel Veillard2b8c4a12003-10-02 22:28:19 +000092 * @extra: extra informations
93 *
94 * Handle a validation error
95 */
96static void
Daniel Veillardf88d8cf2003-12-08 10:25:02 +000097xmlErrValid(xmlValidCtxtPtr ctxt, xmlParserErrors error,
Daniel Veillardbb5abab2003-10-03 22:21:51 +000098 const char *msg, const char *extra)
Daniel Veillard2b8c4a12003-10-02 22:28:19 +000099{
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000100 xmlGenericErrorFunc channel = NULL;
101 xmlParserCtxtPtr pctxt = NULL;
102 void *data = NULL;
103
104 if (ctxt != NULL) {
105 channel = ctxt->error;
106 data = ctxt->userData;
Daniel Veillardeff45a92004-10-29 12:10:55 +0000107 /* 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)) {
Daniel Veillardb2dc5672006-08-22 14:45:40 +0000111 long delta = (char *) ctxt - (char *) ctxt->userData;
112 if ((delta > 0) && (delta < 250))
113 pctxt = ctxt->userData;
Daniel Veillardeff45a92004-10-29 12:10:55 +0000114 }
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000115 }
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000116 if (extra)
Daniel Veillard73000572003-10-11 11:26:42 +0000117 __xmlRaiseError(NULL, channel, data,
Daniel Veillard72b9e292003-10-28 15:44:17 +0000118 pctxt, NULL, XML_FROM_VALID, error,
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000119 XML_ERR_ERROR, NULL, 0, extra, NULL, NULL, 0, 0,
120 msg, extra);
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000121 else
Daniel Veillard73000572003-10-11 11:26:42 +0000122 __xmlRaiseError(NULL, channel, data,
Daniel Veillard72b9e292003-10-28 15:44:17 +0000123 pctxt, NULL, XML_FROM_VALID, error,
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000124 XML_ERR_ERROR, NULL, 0, NULL, NULL, NULL, 0, 0,
Daniel Veillardbccae2d2009-06-04 11:22:45 +0200125 "%s", msg);
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000126}
127
Daniel Veillardf54cd532004-02-25 11:52:31 +0000128#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 */
140static void
141xmlErrValidNode(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;
Daniel Veillardeff45a92004-10-29 12:10:55 +0000154 /* 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)) {
Daniel Veillardb2dc5672006-08-22 14:45:40 +0000158 long delta = (char *) ctxt - (char *) ctxt->userData;
159 if ((delta > 0) && (delta < 250))
160 pctxt = ctxt->userData;
Daniel Veillardeff45a92004-10-29 12:10:55 +0000161 }
Daniel Veillardf54cd532004-02-25 11:52:31 +0000162 }
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
Daniel Veillardd61e8fb2003-10-19 21:59:17 +0000171#ifdef LIBXML_VALID_ENABLED
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000172/**
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 */
183static void
Daniel Veillard72b9e292003-10-28 15:44:17 +0000184xmlErrValidNodeNr(xmlValidCtxtPtr ctxt,
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000185 xmlNodePtr node, xmlParserErrors error,
186 const char *msg, const xmlChar * str1,
187 int int2, const xmlChar * str3)
188{
Daniel Veillard659e71e2003-10-10 14:10:40 +0000189 xmlStructuredErrorFunc schannel = NULL;
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000190 xmlGenericErrorFunc channel = NULL;
191 xmlParserCtxtPtr pctxt = NULL;
192 void *data = NULL;
193
194 if (ctxt != NULL) {
195 channel = ctxt->error;
196 data = ctxt->userData;
Daniel Veillardeff45a92004-10-29 12:10:55 +0000197 /* 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)) {
Daniel Veillardb2dc5672006-08-22 14:45:40 +0000201 long delta = (char *) ctxt - (char *) ctxt->userData;
202 if ((delta > 0) && (delta < 250))
203 pctxt = ctxt->userData;
Daniel Veillardeff45a92004-10-29 12:10:55 +0000204 }
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000205 }
Daniel Veillard72b9e292003-10-28 15:44:17 +0000206 __xmlRaiseError(schannel, channel, data, pctxt, node, XML_FROM_VALID, error,
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000207 XML_ERR_ERROR, NULL, 0,
208 (const char *) str1,
209 (const char *) str3,
210 NULL, int2, 0, msg, str1, int2, str3);
211}
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000212
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000213/**
214 * xmlErrValidWarning:
215 * @ctxt: an XML validation parser context
216 * @node: the node raising the error
217 * @error: the error number
William M. Brackedb65a72004-02-06 07:36:04 +0000218 * @str1: extra information
219 * @str2: extra information
220 * @str3: extra information
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000221 *
William M. Brackedb65a72004-02-06 07:36:04 +0000222 * Handle a validation error, provide contextual information
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000223 */
224static void
William M. Brackedb65a72004-02-06 07:36:04 +0000225xmlErrValidWarning(xmlValidCtxtPtr ctxt,
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000226 xmlNodePtr node, xmlParserErrors error,
227 const char *msg, const xmlChar * str1,
228 const xmlChar * str2, const xmlChar * str3)
229{
Daniel Veillard659e71e2003-10-10 14:10:40 +0000230 xmlStructuredErrorFunc schannel = NULL;
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000231 xmlGenericErrorFunc channel = NULL;
232 xmlParserCtxtPtr pctxt = NULL;
233 void *data = NULL;
234
235 if (ctxt != NULL) {
William M. Bracke4d526f2004-12-18 00:01:21 +0000236 channel = ctxt->warning;
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000237 data = ctxt->userData;
Daniel Veillardeff45a92004-10-29 12:10:55 +0000238 /* 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)) {
Daniel Veillardb2dc5672006-08-22 14:45:40 +0000242 long delta = (char *) ctxt - (char *) ctxt->userData;
243 if ((delta > 0) && (delta < 250))
244 pctxt = ctxt->userData;
Daniel Veillardeff45a92004-10-29 12:10:55 +0000245 }
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000246 }
Daniel Veillard72b9e292003-10-28 15:44:17 +0000247 __xmlRaiseError(schannel, channel, data, pctxt, node, XML_FROM_VALID, error,
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000248 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
Daniel Veillardea7751d2002-12-20 00:16:24 +0000255
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
266typedef 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
273static int
274vstateVPush(xmlValidCtxtPtr ctxt, xmlElementPtr elemDecl, xmlNodePtr node) {
Daniel Veillarda76fe5c2003-04-24 16:06:47 +0000275 if ((ctxt->vstateMax == 0) || (ctxt->vstateTab == NULL)) {
Daniel Veillardea7751d2002-12-20 00:16:24 +0000276 ctxt->vstateMax = 10;
277 ctxt->vstateTab = (xmlValidState *) xmlMalloc(ctxt->vstateMax *
278 sizeof(ctxt->vstateTab[0]));
279 if (ctxt->vstateTab == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +0000280 xmlVErrMemory(ctxt, "malloc failed");
Daniel Veillardea7751d2002-12-20 00:16:24 +0000281 return(-1);
282 }
283 }
284
285 if (ctxt->vstateNr >= ctxt->vstateMax) {
Daniel Veillarda76fe5c2003-04-24 16:06:47 +0000286 xmlValidState *tmp;
287
288 tmp = (xmlValidState *) xmlRealloc(ctxt->vstateTab,
289 2 * ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
290 if (tmp == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +0000291 xmlVErrMemory(ctxt, "realloc failed");
Daniel Veillardea7751d2002-12-20 00:16:24 +0000292 return(-1);
293 }
Daniel Veillarda76fe5c2003-04-24 16:06:47 +0000294 ctxt->vstateMax *= 2;
295 ctxt->vstateTab = tmp;
Daniel Veillardea7751d2002-12-20 00:16:24 +0000296 }
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) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800304 ctxt->vstateTab[ctxt->vstateNr].exec =
Daniel Veillardea7751d2002-12-20 00:16:24 +0000305 xmlRegNewExecCtxt(elemDecl->contModel, NULL, NULL);
306 } else {
307 ctxt->vstateTab[ctxt->vstateNr].exec = NULL;
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000308 xmlErrValidNode(ctxt, (xmlNodePtr) elemDecl,
309 XML_ERR_INTERNAL_ERROR,
310 "Failed to build content model regexp for %s\n",
311 node->name, NULL, NULL);
Daniel Veillardea7751d2002-12-20 00:16:24 +0000312 }
313 }
314 return(ctxt->vstateNr++);
315}
316
317static int
318vstateVPop(xmlValidCtxtPtr ctxt) {
319 xmlElementPtr elemDecl;
320
Daniel Veillard336fc7d2002-12-27 19:37:04 +0000321 if (ctxt->vstateNr < 1) return(-1);
Daniel Veillardea7751d2002-12-20 00:16:24 +0000322 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 */
Daniel Veillarddab4cb32001-04-20 13:03:48 +0000338/*
Daniel Veillard1c732d22002-11-30 11:22:59 +0000339 * If regexp are not enabled, it uses a home made algorithm less
340 * complex and easier to
Daniel Veillardcbaf3992001-12-31 16:16:02 +0000341 * debug/maintain than a generic NFA -> DFA state based algo. The
Daniel Veillarddab4cb32001-04-20 13:03:48 +0000342 * 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
Daniel Veillardb44025c2001-10-11 22:55:55 +0000351typedef struct _xmlValidState {
Daniel Veillarddab4cb32001-04-20 13:03:48 +0000352 xmlElementContentPtr cont; /* pointer to the content model subtree */
353 xmlNodePtr node; /* pointer to the current node in the list */
Daniel Veillardcbaf3992001-12-31 16:16:02 +0000354 long occurs;/* bitfield for multiple occurrences */
Daniel Veillarddab4cb32001-04-20 13:03:48 +0000355 unsigned char depth; /* current depth in the overall tree */
356 unsigned char state; /* ROLLBACK_XXX */
357} _xmlValidState;
358
Daniel Veillardfc57b412002-04-29 15:50:14 +0000359#define MAX_RECURSE 25000
Daniel Veillarddab4cb32001-04-20 13:03:48 +0000360#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
Daniel Veillard5344c602001-12-31 16:37:34 +0000367#define OCCURRENCE (ctxt->vstate->occurs & (1 << DEPTH))
368#define PARENT_OCCURRENCE (ctxt->vstate->occurs & ((1 << DEPTH) - 1))
Daniel Veillarddab4cb32001-04-20 13:03:48 +0000369
Daniel Veillard5344c602001-12-31 16:37:34 +0000370#define SET_OCCURRENCE ctxt->vstate->occurs |= (1 << DEPTH)
371#define RESET_OCCURRENCE ctxt->vstate->occurs &= ((1 << DEPTH) - 1)
Daniel Veillarddab4cb32001-04-20 13:03:48 +0000372
373static int
374vstateVPush(xmlValidCtxtPtr ctxt, xmlElementContentPtr cont,
375 xmlNodePtr node, unsigned char depth, long occurs,
376 unsigned char state) {
Daniel Veillardbed7b052001-05-19 14:59:49 +0000377 int i = ctxt->vstateNr - 1;
378
Daniel Veillard940492d2002-04-15 10:15:25 +0000379 if (ctxt->vstateNr > MAX_RECURSE) {
380 return(-1);
381 }
Daniel Veillarda76fe5c2003-04-24 16:06:47 +0000382 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) {
Daniel Veillardce9457f2003-10-05 21:33:18 +0000387 xmlVErrMemory(ctxt, "malloc failed");
Daniel Veillarda76fe5c2003-04-24 16:06:47 +0000388 return(-1);
389 }
390 }
Daniel Veillarddab4cb32001-04-20 13:03:48 +0000391 if (ctxt->vstateNr >= ctxt->vstateMax) {
Daniel Veillarda76fe5c2003-04-24 16:06:47 +0000392 xmlValidState *tmp;
393
394 tmp = (xmlValidState *) xmlRealloc(ctxt->vstateTab,
395 2 * ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
396 if (tmp == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +0000397 xmlVErrMemory(ctxt, "malloc failed");
Daniel Veillard940492d2002-04-15 10:15:25 +0000398 return(-1);
Daniel Veillarddab4cb32001-04-20 13:03:48 +0000399 }
Daniel Veillarda76fe5c2003-04-24 16:06:47 +0000400 ctxt->vstateMax *= 2;
401 ctxt->vstateTab = tmp;
Daniel Veillard06803992001-04-22 10:35:56 +0000402 ctxt->vstate = &ctxt->vstateTab[0];
Daniel Veillarddab4cb32001-04-20 13:03:48 +0000403 }
Daniel Veillardbed7b052001-05-19 14:59:49 +0000404 /*
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);
Daniel Veillarddab4cb32001-04-20 13:03:48 +0000413 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
421static int
422vstateVPop(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
Daniel Veillard118aed72002-09-24 14:13:13 +0000434#endif /* LIBXML_REGEXP_ENABLED */
435
Daniel Veillard1c732d22002-11-30 11:22:59 +0000436static int
437nodeVPush(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) {
Daniel Veillardce9457f2003-10-05 21:33:18 +0000445 xmlVErrMemory(ctxt, "malloc failed");
Daniel Veillard1c732d22002-11-30 11:22:59 +0000446 ctxt->nodeMax = 0;
447 return (0);
448 }
449 }
450 if (ctxt->nodeNr >= ctxt->nodeMax) {
Daniel Veillarda76fe5c2003-04-24 16:06:47 +0000451 xmlNodePtr *tmp;
452 tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
453 ctxt->nodeMax * 2 * sizeof(ctxt->nodeTab[0]));
454 if (tmp == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +0000455 xmlVErrMemory(ctxt, "realloc failed");
Daniel Veillard1c732d22002-11-30 11:22:59 +0000456 return (0);
457 }
Daniel Veillarda76fe5c2003-04-24 16:06:47 +0000458 ctxt->nodeMax *= 2;
459 ctxt->nodeTab = tmp;
Daniel Veillard1c732d22002-11-30 11:22:59 +0000460 }
461 ctxt->nodeTab[ctxt->nodeNr] = value;
462 ctxt->node = value;
463 return (ctxt->nodeNr++);
464}
465static xmlNodePtr
466nodeVPop(xmlValidCtxtPtr ctxt)
467{
468 xmlNodePtr ret;
469
470 if (ctxt->nodeNr <= 0)
Daniel Veillard24505b02005-07-28 23:49:35 +0000471 return (NULL);
Daniel Veillard1c732d22002-11-30 11:22:59 +0000472 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];
Daniel Veillard24505b02005-07-28 23:49:35 +0000478 ctxt->nodeTab[ctxt->nodeNr] = NULL;
Daniel Veillard1c732d22002-11-30 11:22:59 +0000479 return (ret);
480}
Owen Taylor3473f882001-02-23 17:55:21 +0000481
Owen Taylor3473f882001-02-23 17:55:21 +0000482#ifdef DEBUG_VALID_ALGO
Daniel Veillarddab4cb32001-04-20 13:03:48 +0000483static void
484xmlValidPrintNode(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;
Daniel Veillardce2c2f02001-10-18 14:57:24 +0000529#ifdef LIBXML_DOCB_ENABLED
530 case XML_DOCB_DOCUMENT_NODE:
531 xmlGenericError(xmlGenericErrorContext, "?docb? ");
532 break;
533#endif
Daniel Veillarddab4cb32001-04-20 13:03:48 +0000534 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
558static void
559xmlValidPrintNodeList(xmlNodePtr cur) {
Owen Taylor3473f882001-02-23 17:55:21 +0000560 if (cur == NULL)
561 xmlGenericError(xmlGenericErrorContext, "null ");
562 while (cur != NULL) {
Daniel Veillarddab4cb32001-04-20 13:03:48 +0000563 xmlValidPrintNode(cur);
Owen Taylor3473f882001-02-23 17:55:21 +0000564 cur = cur->next;
565 }
566}
567
Daniel Veillarddab4cb32001-04-20 13:03:48 +0000568static void
569xmlValidDebug(xmlNodePtr cur, xmlElementContentPtr cont) {
Daniel Veillard83391282003-03-06 21:37:30 +0000570 char expr[5000];
Owen Taylor3473f882001-02-23 17:55:21 +0000571
572 expr[0] = 0;
573 xmlGenericError(xmlGenericErrorContext, "valid: ");
574 xmlValidPrintNodeList(cur);
575 xmlGenericError(xmlGenericErrorContext, "against ");
Daniel Veillardd3d06722001-08-15 12:06:36 +0000576 xmlSnprintfElementContent(expr, 5000, cont, 1);
Owen Taylor3473f882001-02-23 17:55:21 +0000577 xmlGenericError(xmlGenericErrorContext, "%s\n", expr);
578}
579
Daniel Veillarddab4cb32001-04-20 13:03:48 +0000580static void
581xmlValidDebugState(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
606static void
607xmlValidStateDebug(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/*****
Owen Taylor3473f882001-02-23 17:55:21 +0000620#define DEBUG_VALID_STATE(n,c) xmlValidDebug(n,c);
Daniel Veillarddab4cb32001-04-20 13:03:48 +0000621 *****/
622
623#define DEBUG_VALID_STATE(n,c) xmlValidStateDebug(ctxt);
Daniel Veillarde356c282001-03-10 12:32:04 +0000624#define DEBUG_VALID_MSG(m) \
625 xmlGenericError(xmlGenericErrorContext, "%s\n", m);
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800626
Owen Taylor3473f882001-02-23 17:55:21 +0000627#else
628#define DEBUG_VALID_STATE(n,c)
Daniel Veillarde356c282001-03-10 12:32:04 +0000629#define DEBUG_VALID_MSG(m)
Owen Taylor3473f882001-02-23 17:55:21 +0000630#endif
631
Daniel Veillardcbaf3992001-12-31 16:16:02 +0000632/* TODO: use hash table for accesses to elem and attribute definitions */
Owen Taylor3473f882001-02-23 17:55:21 +0000633
Daniel Veillardb9cd8b42002-09-05 10:58:49 +0000634
Owen Taylor3473f882001-02-23 17:55:21 +0000635#define CHECK_DTD \
636 if (doc == NULL) return(0); \
637 else if ((doc->intSubset == NULL) && \
638 (doc->extSubset == NULL)) return(0)
639
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000640#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 *
Daniel Veillard84d70a42002-09-16 10:51:38 +0000656 * Returns 1 if successful or 0 in case of error.
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000657 */
658static int
659xmlValidBuildAContentModel(xmlElementContentPtr content,
660 xmlValidCtxtPtr ctxt,
661 const xmlChar *name) {
662 if (content == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000663 xmlErrValidNode(ctxt, NULL, XML_ERR_INTERNAL_ERROR,
664 "Found NULL content in content model of %s\n",
665 name, NULL, NULL);
Daniel Veillard84d70a42002-09-16 10:51:38 +0000666 return(0);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000667 }
668 switch (content->type) {
669 case XML_ELEMENT_CONTENT_PCDATA:
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000670 xmlErrValidNode(ctxt, NULL, XML_ERR_INTERNAL_ERROR,
671 "Found PCDATA in content model of %s\n",
672 name, NULL, NULL);
Daniel Veillard84d70a42002-09-16 10:51:38 +0000673 return(0);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000674 break;
675 case XML_ELEMENT_CONTENT_ELEMENT: {
676 xmlAutomataStatePtr oldstate = ctxt->state;
Daniel Veillardc00cda82003-04-07 10:22:39 +0000677 xmlChar fn[50];
678 xmlChar *fullname;
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800679
Daniel Veillardc00cda82003-04-07 10:22:39 +0000680 fullname = xmlBuildQName(content->name, content->prefix, fn, 50);
681 if (fullname == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +0000682 xmlVErrMemory(ctxt, "Building content model");
Daniel Veillardc00cda82003-04-07 10:22:39 +0000683 return(0);
Daniel Veillarda646cfd2002-09-17 21:50:03 +0000684 }
685
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000686 switch (content->ocur) {
687 case XML_ELEMENT_CONTENT_ONCE:
688 ctxt->state = xmlAutomataNewTransition(ctxt->am,
Daniel Veillardc00cda82003-04-07 10:22:39 +0000689 ctxt->state, NULL, fullname, NULL);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000690 break;
691 case XML_ELEMENT_CONTENT_OPT:
692 ctxt->state = xmlAutomataNewTransition(ctxt->am,
Daniel Veillardc00cda82003-04-07 10:22:39 +0000693 ctxt->state, NULL, fullname, NULL);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000694 xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
695 break;
696 case XML_ELEMENT_CONTENT_PLUS:
697 ctxt->state = xmlAutomataNewTransition(ctxt->am,
Daniel Veillardc00cda82003-04-07 10:22:39 +0000698 ctxt->state, NULL, fullname, NULL);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000699 xmlAutomataNewTransition(ctxt->am, ctxt->state,
Daniel Veillardc00cda82003-04-07 10:22:39 +0000700 ctxt->state, fullname, NULL);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000701 break;
702 case XML_ELEMENT_CONTENT_MULT:
William M. Brack8b0cbb02004-04-17 13:31:06 +0000703 ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800704 ctxt->state, NULL);
William M. Brack8b0cbb02004-04-17 13:31:06 +0000705 xmlAutomataNewTransition(ctxt->am,
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800706 ctxt->state, ctxt->state, fullname, NULL);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000707 break;
708 }
Daniel Veillardc00cda82003-04-07 10:22:39 +0000709 if ((fullname != fn) && (fullname != content->name))
710 xmlFree(fullname);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000711 break;
712 }
713 case XML_ELEMENT_CONTENT_SEQ: {
Daniel Veillard5acfd6b2002-09-18 16:29:02 +0000714 xmlAutomataStatePtr oldstate, oldend;
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000715 xmlElementContentOccur ocur;
716
717 /*
718 * Simply iterate over the content
719 */
720 oldstate = ctxt->state;
721 ocur = content->ocur;
Daniel Veillardf4be0182003-02-24 19:54:33 +0000722 if (ocur != XML_ELEMENT_CONTENT_ONCE) {
723 ctxt->state = xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
724 oldstate = ctxt->state;
725 }
Daniel Veillarda646cfd2002-09-17 21:50:03 +0000726 do {
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000727 xmlValidBuildAContentModel(content->c1, ctxt, name);
728 content = content->c2;
Daniel Veillarda646cfd2002-09-17 21:50:03 +0000729 } while ((content->type == XML_ELEMENT_CONTENT_SEQ) &&
730 (content->ocur == XML_ELEMENT_CONTENT_ONCE));
731 xmlValidBuildAContentModel(content, ctxt, name);
Daniel Veillard5acfd6b2002-09-18 16:29:02 +0000732 oldend = ctxt->state;
733 ctxt->state = xmlAutomataNewEpsilon(ctxt->am, oldend, NULL);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000734 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);
Daniel Veillard5acfd6b2002-09-18 16:29:02 +0000742 xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000743 break;
744 case XML_ELEMENT_CONTENT_PLUS:
Daniel Veillard5acfd6b2002-09-18 16:29:02 +0000745 xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000746 break;
747 }
748 break;
749 }
750 case XML_ELEMENT_CONTENT_OR: {
Daniel Veillard5acfd6b2002-09-18 16:29:02 +0000751 xmlAutomataStatePtr oldstate, oldend;
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000752 xmlElementContentOccur ocur;
753
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000754 ocur = content->ocur;
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800755 if ((ocur == XML_ELEMENT_CONTENT_PLUS) ||
Daniel Veillard5acfd6b2002-09-18 16:29:02 +0000756 (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);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000762
763 /*
764 * iterate over the subtypes and remerge the end with an
765 * epsilon transition
766 */
Daniel Veillarda646cfd2002-09-17 21:50:03 +0000767 do {
Daniel Veillard5acfd6b2002-09-18 16:29:02 +0000768 ctxt->state = oldstate;
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000769 xmlValidBuildAContentModel(content->c1, ctxt, name);
Daniel Veillard5acfd6b2002-09-18 16:29:02 +0000770 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldend);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000771 content = content->c2;
Daniel Veillarda646cfd2002-09-17 21:50:03 +0000772 } while ((content->type == XML_ELEMENT_CONTENT_OR) &&
773 (content->ocur == XML_ELEMENT_CONTENT_ONCE));
Daniel Veillard5acfd6b2002-09-18 16:29:02 +0000774 ctxt->state = oldstate;
Daniel Veillarda646cfd2002-09-17 21:50:03 +0000775 xmlValidBuildAContentModel(content, ctxt, name);
Daniel Veillard5acfd6b2002-09-18 16:29:02 +0000776 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldend);
777 ctxt->state = xmlAutomataNewEpsilon(ctxt->am, oldend, NULL);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000778 switch (ocur) {
779 case XML_ELEMENT_CONTENT_ONCE:
780 break;
781 case XML_ELEMENT_CONTENT_OPT:
Daniel Veillard5acfd6b2002-09-18 16:29:02 +0000782 xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000783 break;
784 case XML_ELEMENT_CONTENT_MULT:
Daniel Veillard5acfd6b2002-09-18 16:29:02 +0000785 xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
786 xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000787 break;
788 case XML_ELEMENT_CONTENT_PLUS:
Daniel Veillard5acfd6b2002-09-18 16:29:02 +0000789 xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000790 break;
791 }
792 break;
793 }
794 default:
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000795 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
796 "ContentModel broken for element %s\n",
797 (const char *) name);
Daniel Veillard84d70a42002-09-16 10:51:38 +0000798 return(0);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000799 }
Daniel Veillard84d70a42002-09-16 10:51:38 +0000800 return(1);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000801}
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 *
Daniel Veillard84d70a42002-09-16 10:51:38 +0000810 * Returns 1 in case of success, 0 in case of error
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000811 */
812int
813xmlValidBuildContentModel(xmlValidCtxtPtr ctxt, xmlElementPtr elem) {
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000814
815 if ((ctxt == NULL) || (elem == NULL))
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000816 return(0);
Daniel Veillard84d70a42002-09-16 10:51:38 +0000817 if (elem->type != XML_ELEMENT_DECL)
818 return(0);
819 if (elem->etype != XML_ELEMENT_TYPE_ELEMENT)
820 return(1);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000821 /* TODO: should we rebuild in this case ? */
Daniel Veillardec498e12003-02-05 11:01:50 +0000822 if (elem->contModel != NULL) {
823 if (!xmlRegexpIsDeterminist(elem->contModel)) {
824 ctxt->valid = 0;
825 return(0);
826 }
Daniel Veillard84d70a42002-09-16 10:51:38 +0000827 return(1);
Daniel Veillardec498e12003-02-05 11:01:50 +0000828 }
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000829
830 ctxt->am = xmlNewAutomata();
831 if (ctxt->am == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000832 xmlErrValidNode(ctxt, (xmlNodePtr) elem,
833 XML_ERR_INTERNAL_ERROR,
834 "Cannot create automata for element %s\n",
835 elem->name, NULL, NULL);
Daniel Veillard84d70a42002-09-16 10:51:38 +0000836 return(0);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000837 }
William M. Brack78637da2003-07-31 14:47:38 +0000838 ctxt->state = xmlAutomataGetInitState(ctxt->am);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000839 xmlValidBuildAContentModel(elem->content, ctxt, elem->name);
840 xmlAutomataSetFinalState(ctxt->am, ctxt->state);
Daniel Veillard84d70a42002-09-16 10:51:38 +0000841 elem->contModel = xmlAutomataCompile(ctxt->am);
Daniel Veillarda76fe5c2003-04-24 16:06:47 +0000842 if (xmlRegexpIsDeterminist(elem->contModel) != 1) {
Daniel Veillard5acfd6b2002-09-18 16:29:02 +0000843 char expr[5000];
844 expr[0] = 0;
845 xmlSnprintfElementContent(expr, 5000, elem->content, 1);
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000846 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);
Daniel Veillard5acfd6b2002-09-18 16:29:02 +0000850#ifdef DEBUG_REGEXP_ALGO
851 xmlRegexpPrint(stderr, elem->contModel);
852#endif
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000853 ctxt->valid = 0;
Daniel Veillardec498e12003-02-05 11:01:50 +0000854 ctxt->state = NULL;
855 xmlFreeAutomata(ctxt->am);
856 ctxt->am = NULL;
857 return(0);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000858 }
859 ctxt->state = NULL;
860 xmlFreeAutomata(ctxt->am);
861 ctxt->am = NULL;
Daniel Veillard84d70a42002-09-16 10:51:38 +0000862 return(1);
Daniel Veillardaeb258a2002-09-13 14:48:12 +0000863}
864
865#endif /* LIBXML_REGEXP_ENABLED */
866
Owen Taylor3473f882001-02-23 17:55:21 +0000867/****************************************************************
868 * *
869 * Util functions for data allocation/deallocation *
870 * *
871 ****************************************************************/
872
873/**
Daniel Veillarda37aab82003-06-09 09:10:36 +0000874 * xmlNewValidCtxt:
875 *
876 * Allocate a validation context structure.
877 *
878 * Returns NULL if not, otherwise the new validation context structure
879 */
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000880xmlValidCtxtPtr xmlNewValidCtxt(void) {
Daniel Veillarda37aab82003-06-09 09:10:36 +0000881 xmlValidCtxtPtr ret;
882
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000883 if ((ret = xmlMalloc(sizeof (xmlValidCtxt))) == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +0000884 xmlVErrMemory(NULL, "malloc failed");
Daniel Veillarda37aab82003-06-09 09:10:36 +0000885 return (NULL);
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000886 }
Daniel Veillarda37aab82003-06-09 09:10:36 +0000887
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 */
899void
900xmlFreeValidCtxt(xmlValidCtxtPtr cur) {
Daniel Veillardc0be74b2004-11-03 19:16:55 +0000901 if (cur->vstateTab != NULL)
902 xmlFree(cur->vstateTab);
903 if (cur->nodeTab != NULL)
904 xmlFree(cur->nodeTab);
Daniel Veillarda37aab82003-06-09 09:10:36 +0000905 xmlFree(cur);
906}
907
Daniel Veillard4432df22003-09-28 18:58:27 +0000908#endif /* LIBXML_VALID_ENABLED */
909
Daniel Veillarda37aab82003-06-09 09:10:36 +0000910/**
Daniel Veillardcee2b3a2005-01-25 00:22:52 +0000911 * xmlNewDocElementContent:
912 * @doc: the document
Owen Taylor3473f882001-02-23 17:55:21 +0000913 * @name: the subelement name or NULL
914 * @type: the type of element content decl
915 *
Daniel Veillardcee2b3a2005-01-25 00:22:52 +0000916 * Allocate an element content structure for the document.
Owen Taylor3473f882001-02-23 17:55:21 +0000917 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +0000918 * Returns NULL if not, otherwise the new element content structure
Owen Taylor3473f882001-02-23 17:55:21 +0000919 */
920xmlElementContentPtr
Daniel Veillardcee2b3a2005-01-25 00:22:52 +0000921xmlNewDocElementContent(xmlDocPtr doc, const xmlChar *name,
922 xmlElementContentType type) {
Owen Taylor3473f882001-02-23 17:55:21 +0000923 xmlElementContentPtr ret;
Daniel Veillardcee2b3a2005-01-25 00:22:52 +0000924 xmlDictPtr dict = NULL;
925
926 if (doc != NULL)
927 dict = doc->dict;
Owen Taylor3473f882001-02-23 17:55:21 +0000928
929 switch(type) {
930 case XML_ELEMENT_CONTENT_ELEMENT:
931 if (name == NULL) {
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000932 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
933 "xmlNewElementContent : name == NULL !\n",
934 NULL);
Owen Taylor3473f882001-02-23 17:55:21 +0000935 }
936 break;
937 case XML_ELEMENT_CONTENT_PCDATA:
938 case XML_ELEMENT_CONTENT_SEQ:
939 case XML_ELEMENT_CONTENT_OR:
940 if (name != NULL) {
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000941 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
942 "xmlNewElementContent : name != NULL !\n",
943 NULL);
Owen Taylor3473f882001-02-23 17:55:21 +0000944 }
945 break;
946 default:
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800947 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000948 "Internal: ELEMENT content corrupted invalid type\n",
949 NULL);
Owen Taylor3473f882001-02-23 17:55:21 +0000950 return(NULL);
951 }
952 ret = (xmlElementContentPtr) xmlMalloc(sizeof(xmlElementContent));
953 if (ret == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +0000954 xmlVErrMemory(NULL, "malloc failed");
Owen Taylor3473f882001-02-23 17:55:21 +0000955 return(NULL);
956 }
Daniel Veillardd54fa3e2002-02-20 16:48:52 +0000957 memset(ret, 0, sizeof(xmlElementContent));
Owen Taylor3473f882001-02-23 17:55:21 +0000958 ret->type = type;
959 ret->ocur = XML_ELEMENT_CONTENT_ONCE;
Daniel Veillardbe480fb2001-11-08 23:36:42 +0000960 if (name != NULL) {
Daniel Veillardcee2b3a2005-01-25 00:22:52 +0000961 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 }
Daniel Veillardbe480fb2001-11-08 23:36:42 +0000979 }
Daniel Veillardcee2b3a2005-01-25 00:22:52 +0000980 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 */
993xmlElementContentPtr
994xmlNewElementContent(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.
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001004 *
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00001005 * Returns the new xmlElementContentPtr or NULL in case of error.
1006 */
1007xmlElementContentPtr
1008xmlCopyDocElementContent(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 }
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001031
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00001032 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 }
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001061
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00001062 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 }
Owen Taylor3473f882001-02-23 17:55:21 +00001076 return(ret);
1077}
1078
1079/**
1080 * xmlCopyElementContent:
Daniel Veillard01c13b52002-12-10 15:19:08 +00001081 * @cur: An element content pointer.
Owen Taylor3473f882001-02-23 17:55:21 +00001082 *
1083 * Build a copy of an element content description.
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00001084 * Deprecated, use xmlCopyDocElementContent instead
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001085 *
Owen Taylor3473f882001-02-23 17:55:21 +00001086 * Returns the new xmlElementContentPtr or NULL in case of error.
1087 */
1088xmlElementContentPtr
1089xmlCopyElementContent(xmlElementContentPtr cur) {
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00001090 return(xmlCopyDocElementContent(NULL, cur));
1091}
Owen Taylor3473f882001-02-23 17:55:21 +00001092
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00001093/**
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 */
1100void
1101xmlFreeDocElementContent(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:
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001117 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00001118 "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;
Owen Taylor3473f882001-02-23 17:55:21 +00001134 }
Owen Taylor3473f882001-02-23 17:55:21 +00001135}
1136
1137/**
1138 * xmlFreeElementContent:
1139 * @cur: the element content tree to free
1140 *
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00001141 * Free an element content structure. The whole subtree is removed.
1142 * Deprecated, use xmlFreeDocElementContent instead
Owen Taylor3473f882001-02-23 17:55:21 +00001143 */
1144void
1145xmlFreeElementContent(xmlElementContentPtr cur) {
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00001146 xmlFreeDocElementContent(NULL, cur);
Owen Taylor3473f882001-02-23 17:55:21 +00001147}
1148
Daniel Veillarda9cce9c2003-09-29 13:20:24 +00001149#ifdef LIBXML_OUTPUT_ENABLED
Owen Taylor3473f882001-02-23 17:55:21 +00001150/**
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 */
Daniel Veillard56a4cb82001-03-24 17:00:36 +00001158static void
Owen Taylor3473f882001-02-23 17:55:21 +00001159xmlDumpElementContent(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:
Daniel Veillardbe480fb2001-11-08 23:36:42 +00001168 if (content->prefix != NULL) {
1169 xmlBufferWriteCHAR(buf, content->prefix);
1170 xmlBufferWriteChar(buf, ":");
1171 }
Owen Taylor3473f882001-02-23 17:55:21 +00001172 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, " , ");
William M. Brack4119d1c2004-06-24 02:24:44 +00001181 if ((content->c2->type == XML_ELEMENT_CONTENT_OR) ||
1182 ((content->c2->type == XML_ELEMENT_CONTENT_SEQ) &&
1183 (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)))
Owen Taylor3473f882001-02-23 17:55:21 +00001184 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, " | ");
William M. Brack4119d1c2004-06-24 02:24:44 +00001195 if ((content->c2->type == XML_ELEMENT_CONTENT_SEQ) ||
1196 ((content->c2->type == XML_ELEMENT_CONTENT_OR) &&
1197 (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)))
Owen Taylor3473f882001-02-23 17:55:21 +00001198 xmlDumpElementContent(buf, content->c2, 1);
1199 else
1200 xmlDumpElementContent(buf, content->c2, 0);
1201 break;
1202 default:
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001203 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00001204 "Internal: ELEMENT content corrupted invalid type\n",
1205 NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00001206 }
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
Daniel Veillard1b75c3b2005-06-26 21:49:08 +00001228 * @englob: 1 if one must print the englobing parenthesis, 0 otherwise
Owen Taylor3473f882001-02-23 17:55:21 +00001229 *
Daniel Veillardd3d06722001-08-15 12:06:36 +00001230 * Deprecated, unsafe, use xmlSnprintfElementContent
1231 */
1232void
1233xmlSprintfElementContent(char *buf ATTRIBUTE_UNUSED,
1234 xmlElementContentPtr content ATTRIBUTE_UNUSED,
Daniel Veillard1b75c3b2005-06-26 21:49:08 +00001235 int englob ATTRIBUTE_UNUSED) {
Daniel Veillardd3d06722001-08-15 12:06:36 +00001236}
Daniel Veillarda9cce9c2003-09-29 13:20:24 +00001237#endif /* LIBXML_OUTPUT_ENABLED */
Daniel Veillardd3d06722001-08-15 12:06:36 +00001238
1239/**
1240 * xmlSnprintfElementContent:
1241 * @buf: an output buffer
1242 * @size: the buffer size
1243 * @content: An element table
Daniel Veillard1b75c3b2005-06-26 21:49:08 +00001244 * @englob: 1 if one must print the englobing parenthesis, 0 otherwise
Daniel Veillardd3d06722001-08-15 12:06:36 +00001245 *
Owen Taylor3473f882001-02-23 17:55:21 +00001246 * This will dump the content of the element content definition
1247 * Intended just for the debug routine
1248 */
1249void
Daniel Veillard1b75c3b2005-06-26 21:49:08 +00001250xmlSnprintfElementContent(char *buf, int size, xmlElementContentPtr content, int englob) {
Daniel Veillardd3d06722001-08-15 12:06:36 +00001251 int len;
1252
Owen Taylor3473f882001-02-23 17:55:21 +00001253 if (content == NULL) return;
Daniel Veillardd3d06722001-08-15 12:06:36 +00001254 len = strlen(buf);
1255 if (size - len < 50) {
1256 if ((size - len > 4) && (buf[len - 1] != '.'))
1257 strcat(buf, " ...");
1258 return;
1259 }
Daniel Veillard1b75c3b2005-06-26 21:49:08 +00001260 if (englob) strcat(buf, "(");
Owen Taylor3473f882001-02-23 17:55:21 +00001261 switch (content->type) {
1262 case XML_ELEMENT_CONTENT_PCDATA:
1263 strcat(buf, "#PCDATA");
1264 break;
1265 case XML_ELEMENT_CONTENT_ELEMENT:
Daniel Veillardbe480fb2001-11-08 23:36:42 +00001266 if (content->prefix != NULL) {
Daniel Veillard4b3a84f2002-03-19 14:36:46 +00001267 if (size - len < xmlStrlen(content->prefix) + 10) {
Daniel Veillardbe480fb2001-11-08 23:36:42 +00001268 strcat(buf, " ...");
1269 return;
1270 }
1271 strcat(buf, (char *) content->prefix);
1272 strcat(buf, ":");
1273 }
Daniel Veillard4b3a84f2002-03-19 14:36:46 +00001274 if (size - len < xmlStrlen(content->name) + 10) {
Daniel Veillardd3d06722001-08-15 12:06:36 +00001275 strcat(buf, " ...");
1276 return;
1277 }
Daniel Veillarda76fe5c2003-04-24 16:06:47 +00001278 if (content->name != NULL)
1279 strcat(buf, (char *) content->name);
Owen Taylor3473f882001-02-23 17:55:21 +00001280 break;
1281 case XML_ELEMENT_CONTENT_SEQ:
1282 if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1283 (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
Daniel Veillardd3d06722001-08-15 12:06:36 +00001284 xmlSnprintfElementContent(buf, size, content->c1, 1);
Owen Taylor3473f882001-02-23 17:55:21 +00001285 else
Daniel Veillardd3d06722001-08-15 12:06:36 +00001286 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 }
Owen Taylor3473f882001-02-23 17:55:21 +00001293 strcat(buf, " , ");
Daniel Veillard5acfd6b2002-09-18 16:29:02 +00001294 if (((content->c2->type == XML_ELEMENT_CONTENT_OR) ||
1295 (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)) &&
1296 (content->c2->type != XML_ELEMENT_CONTENT_ELEMENT))
Daniel Veillardd3d06722001-08-15 12:06:36 +00001297 xmlSnprintfElementContent(buf, size, content->c2, 1);
Owen Taylor3473f882001-02-23 17:55:21 +00001298 else
Daniel Veillardd3d06722001-08-15 12:06:36 +00001299 xmlSnprintfElementContent(buf, size, content->c2, 0);
Owen Taylor3473f882001-02-23 17:55:21 +00001300 break;
1301 case XML_ELEMENT_CONTENT_OR:
1302 if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1303 (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
Daniel Veillardd3d06722001-08-15 12:06:36 +00001304 xmlSnprintfElementContent(buf, size, content->c1, 1);
Owen Taylor3473f882001-02-23 17:55:21 +00001305 else
Daniel Veillardd3d06722001-08-15 12:06:36 +00001306 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 }
Owen Taylor3473f882001-02-23 17:55:21 +00001313 strcat(buf, " | ");
Daniel Veillard5acfd6b2002-09-18 16:29:02 +00001314 if (((content->c2->type == XML_ELEMENT_CONTENT_SEQ) ||
1315 (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)) &&
1316 (content->c2->type != XML_ELEMENT_CONTENT_ELEMENT))
Daniel Veillardd3d06722001-08-15 12:06:36 +00001317 xmlSnprintfElementContent(buf, size, content->c2, 1);
Owen Taylor3473f882001-02-23 17:55:21 +00001318 else
Daniel Veillardd3d06722001-08-15 12:06:36 +00001319 xmlSnprintfElementContent(buf, size, content->c2, 0);
Owen Taylor3473f882001-02-23 17:55:21 +00001320 break;
1321 }
Daniel Veillard1b75c3b2005-06-26 21:49:08 +00001322 if (englob)
Owen Taylor3473f882001-02-23 17:55:21 +00001323 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/**
Owen Taylor3473f882001-02-23 17:55:21 +00001346 * xmlFreeElement:
1347 * @elem: An element
1348 *
1349 * Deallocate the memory used by an element definition
1350 */
Daniel Veillard56a4cb82001-03-24 17:00:36 +00001351static void
Owen Taylor3473f882001-02-23 17:55:21 +00001352xmlFreeElement(xmlElementPtr elem) {
1353 if (elem == NULL) return;
1354 xmlUnlinkNode((xmlNodePtr) elem);
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00001355 xmlFreeDocElementContent(elem->doc, elem->content);
Owen Taylor3473f882001-02-23 17:55:21 +00001356 if (elem->name != NULL)
1357 xmlFree((xmlChar *) elem->name);
1358 if (elem->prefix != NULL)
1359 xmlFree((xmlChar *) elem->prefix);
Daniel Veillard84d70a42002-09-16 10:51:38 +00001360#ifdef LIBXML_REGEXP_ENABLED
1361 if (elem->contModel != NULL)
1362 xmlRegFreeRegexp(elem->contModel);
1363#endif
Owen Taylor3473f882001-02-23 17:55:21 +00001364 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 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00001378 * Returns NULL if not, otherwise the entity
Owen Taylor3473f882001-02-23 17:55:21 +00001379 */
1380xmlElementPtr
William M. Brackedb65a72004-02-06 07:36:04 +00001381xmlAddElementDecl(xmlValidCtxtPtr ctxt,
Daniel Veillarda9cce9c2003-09-29 13:20:24 +00001382 xmlDtdPtr dtd, const xmlChar *name,
Owen Taylor3473f882001-02-23 17:55:21 +00001383 xmlElementTypeVal type,
1384 xmlElementContentPtr content) {
1385 xmlElementPtr ret;
1386 xmlElementTablePtr table;
Daniel Veillarda10efa82001-04-18 13:09:01 +00001387 xmlAttributePtr oldAttributes = NULL;
Owen Taylor3473f882001-02-23 17:55:21 +00001388 xmlChar *ns, *uqname;
1389
1390 if (dtd == NULL) {
Owen Taylor3473f882001-02-23 17:55:21 +00001391 return(NULL);
1392 }
1393 if (name == NULL) {
Owen Taylor3473f882001-02-23 17:55:21 +00001394 return(NULL);
1395 }
Daniel Veillard316a5c32005-01-23 22:56:39 +00001396
Owen Taylor3473f882001-02-23 17:55:21 +00001397 switch (type) {
1398 case XML_ELEMENT_TYPE_EMPTY:
1399 if (content != NULL) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001400 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00001401 "xmlAddElementDecl: content != NULL for EMPTY\n",
1402 NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00001403 return(NULL);
1404 }
1405 break;
1406 case XML_ELEMENT_TYPE_ANY:
1407 if (content != NULL) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001408 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00001409 "xmlAddElementDecl: content != NULL for ANY\n",
1410 NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00001411 return(NULL);
1412 }
1413 break;
1414 case XML_ELEMENT_TYPE_MIXED:
1415 if (content == NULL) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001416 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00001417 "xmlAddElementDecl: content == NULL for MIXED\n",
1418 NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00001419 return(NULL);
1420 }
1421 break;
1422 case XML_ELEMENT_TYPE_ELEMENT:
1423 if (content == NULL) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001424 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00001425 "xmlAddElementDecl: content == NULL for ELEMENT\n",
1426 NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00001427 return(NULL);
1428 }
1429 break;
1430 default:
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001431 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00001432 "Internal: ELEMENT decl corrupted invalid type\n",
1433 NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00001434 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) {
Daniel Veillard316a5c32005-01-23 22:56:39 +00001449 xmlDictPtr dict = NULL;
1450
1451 if (dtd->doc != NULL)
1452 dict = dtd->doc->dict;
1453 table = xmlHashCreateDict(0, dict);
Owen Taylor3473f882001-02-23 17:55:21 +00001454 dtd->elements = (void *) table;
1455 }
1456 if (table == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00001457 xmlVErrMemory(ctxt,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00001458 "xmlAddElementDecl: Table creation failed!\n");
Daniel Veillarda76fe5c2003-04-24 16:06:47 +00001459 if (uqname != NULL)
1460 xmlFree(uqname);
1461 if (ns != NULL)
1462 xmlFree(ns);
Owen Taylor3473f882001-02-23 17:55:21 +00001463 return(NULL);
1464 }
1465
Daniel Veillarda10efa82001-04-18 13:09:01 +00001466 /*
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 }
Owen Taylor3473f882001-02-23 17:55:21 +00001478 }
Owen Taylor3473f882001-02-23 17:55:21 +00001479
1480 /*
Daniel Veillarda10efa82001-04-18 13:09:01 +00001481 * 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) {
Daniel Veillard4432df22003-09-28 18:58:27 +00001487#ifdef LIBXML_VALID_ENABLED
Daniel Veillarda10efa82001-04-18 13:09:01 +00001488 /*
Daniel Veillardcbaf3992001-12-31 16:16:02 +00001489 * The element is already defined in this DTD.
Daniel Veillarda10efa82001-04-18 13:09:01 +00001490 */
Daniel Veillardbb5abab2003-10-03 22:21:51 +00001491 xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ELEM_REDEFINED,
1492 "Redefinition of element %s\n",
1493 name, NULL, NULL);
Daniel Veillard4432df22003-09-28 18:58:27 +00001494#endif /* LIBXML_VALID_ENABLED */
Daniel Veillarda10efa82001-04-18 13:09:01 +00001495 if (uqname != NULL)
1496 xmlFree(uqname);
Daniel Veillarda76fe5c2003-04-24 16:06:47 +00001497 if (ns != NULL)
1498 xmlFree(ns);
Daniel Veillarda10efa82001-04-18 13:09:01 +00001499 return(NULL);
1500 }
William M. Brackd6e347e2005-04-15 01:34:41 +00001501 if (ns != NULL) {
1502 xmlFree(ns);
1503 ns = NULL;
1504 }
Daniel Veillarda10efa82001-04-18 13:09:01 +00001505 } else {
1506 ret = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
1507 if (ret == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00001508 xmlVErrMemory(ctxt, "malloc failed");
Daniel Veillarda76fe5c2003-04-24 16:06:47 +00001509 if (uqname != NULL)
1510 xmlFree(uqname);
1511 if (ns != NULL)
1512 xmlFree(ns);
Daniel Veillarda10efa82001-04-18 13:09:01 +00001513 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);
Daniel Veillarda76fe5c2003-04-24 16:06:47 +00001522 if (ret->name == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00001523 xmlVErrMemory(ctxt, "malloc failed");
Daniel Veillarda76fe5c2003-04-24 16:06:47 +00001524 if (uqname != NULL)
1525 xmlFree(uqname);
1526 if (ns != NULL)
1527 xmlFree(ns);
1528 xmlFree(ret);
1529 return(NULL);
1530 }
Daniel Veillarda10efa82001-04-18 13:09:01 +00001531 ret->prefix = ns;
1532
1533 /*
1534 * Validity Check:
1535 * Insertion must not fail
1536 */
1537 if (xmlHashAddEntry2(table, name, ns, ret)) {
Daniel Veillard4432df22003-09-28 18:58:27 +00001538#ifdef LIBXML_VALID_ENABLED
Daniel Veillarda10efa82001-04-18 13:09:01 +00001539 /*
Daniel Veillardcbaf3992001-12-31 16:16:02 +00001540 * The element is already defined in this DTD.
Daniel Veillarda10efa82001-04-18 13:09:01 +00001541 */
Daniel Veillardbb5abab2003-10-03 22:21:51 +00001542 xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ELEM_REDEFINED,
1543 "Redefinition of element %s\n",
1544 name, NULL, NULL);
Daniel Veillard4432df22003-09-28 18:58:27 +00001545#endif /* LIBXML_VALID_ENABLED */
Daniel Veillarda10efa82001-04-18 13:09:01 +00001546 xmlFreeElement(ret);
1547 if (uqname != NULL)
1548 xmlFree(uqname);
1549 return(NULL);
1550 }
William M. Brack4e52f2f2003-09-14 18:07:39 +00001551 /*
1552 * For new element, may have attributes from earlier
1553 * definition in internal subset
1554 */
1555 ret->attributes = oldAttributes;
Daniel Veillarda10efa82001-04-18 13:09:01 +00001556 }
1557
1558 /*
1559 * Finish to fill the structure.
Owen Taylor3473f882001-02-23 17:55:21 +00001560 */
1561 ret->etype = type;
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00001562 /*
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 */
Daniel Veillardc394f732005-01-26 00:04:52 +00001567 if ((ctxt != NULL) &&
1568 ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
1569 (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1))) {
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00001570 ret->content = content;
1571 if (content != NULL)
1572 content->parent = (xmlElementContentPtr) 1;
1573 } else {
1574 ret->content = xmlCopyDocElementContent(dtd->doc, content);
1575 }
Owen Taylor3473f882001-02-23 17:55:21 +00001576
1577 /*
Daniel Veillardcbaf3992001-12-31 16:16:02 +00001578 * Link it to the DTD
Owen Taylor3473f882001-02-23 17:55:21 +00001579 */
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 */
1600void
1601xmlFreeElementTable(xmlElementTablePtr table) {
1602 xmlHashFree(table, (xmlHashDeallocator) xmlFreeElement);
1603}
1604
Daniel Veillard652327a2003-09-29 18:02:38 +00001605#ifdef LIBXML_TREE_ENABLED
Owen Taylor3473f882001-02-23 17:55:21 +00001606/**
1607 * xmlCopyElement:
1608 * @elem: An element
1609 *
1610 * Build a copy of an element.
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001611 *
Owen Taylor3473f882001-02-23 17:55:21 +00001612 * Returns the new xmlElementPtr or NULL in case of error.
1613 */
Daniel Veillard56a4cb82001-03-24 17:00:36 +00001614static xmlElementPtr
Owen Taylor3473f882001-02-23 17:55:21 +00001615xmlCopyElement(xmlElementPtr elem) {
1616 xmlElementPtr cur;
1617
1618 cur = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
1619 if (cur == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00001620 xmlVErrMemory(NULL, "malloc failed");
Owen Taylor3473f882001-02-23 17:55:21 +00001621 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.
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001645 *
Owen Taylor3473f882001-02-23 17:55:21 +00001646 * Returns the new xmlElementTablePtr or NULL in case of error.
1647 */
1648xmlElementTablePtr
1649xmlCopyElementTable(xmlElementTablePtr table) {
1650 return((xmlElementTablePtr) xmlHashCopy(table,
1651 (xmlHashCopier) xmlCopyElement));
1652}
Daniel Veillard652327a2003-09-29 18:02:38 +00001653#endif /* LIBXML_TREE_ENABLED */
Owen Taylor3473f882001-02-23 17:55:21 +00001654
Daniel Veillarda9cce9c2003-09-29 13:20:24 +00001655#ifdef LIBXML_OUTPUT_ENABLED
Owen Taylor3473f882001-02-23 17:55:21 +00001656/**
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 */
1664void
1665xmlDumpElementDecl(xmlBufferPtr buf, xmlElementPtr elem) {
Daniel Veillardce682bc2004-11-05 17:22:25 +00001666 if ((buf == NULL) || (elem == NULL))
1667 return;
Owen Taylor3473f882001-02-23 17:55:21 +00001668 switch (elem->etype) {
1669 case XML_ELEMENT_TYPE_EMPTY:
1670 xmlBufferWriteChar(buf, "<!ELEMENT ");
Daniel Veillardbe480fb2001-11-08 23:36:42 +00001671 if (elem->prefix != NULL) {
1672 xmlBufferWriteCHAR(buf, elem->prefix);
1673 xmlBufferWriteChar(buf, ":");
1674 }
Owen Taylor3473f882001-02-23 17:55:21 +00001675 xmlBufferWriteCHAR(buf, elem->name);
1676 xmlBufferWriteChar(buf, " EMPTY>\n");
1677 break;
1678 case XML_ELEMENT_TYPE_ANY:
1679 xmlBufferWriteChar(buf, "<!ELEMENT ");
Daniel Veillardbe480fb2001-11-08 23:36:42 +00001680 if (elem->prefix != NULL) {
1681 xmlBufferWriteCHAR(buf, elem->prefix);
1682 xmlBufferWriteChar(buf, ":");
1683 }
Owen Taylor3473f882001-02-23 17:55:21 +00001684 xmlBufferWriteCHAR(buf, elem->name);
1685 xmlBufferWriteChar(buf, " ANY>\n");
1686 break;
1687 case XML_ELEMENT_TYPE_MIXED:
1688 xmlBufferWriteChar(buf, "<!ELEMENT ");
Daniel Veillardbe480fb2001-11-08 23:36:42 +00001689 if (elem->prefix != NULL) {
1690 xmlBufferWriteCHAR(buf, elem->prefix);
1691 xmlBufferWriteChar(buf, ":");
1692 }
Owen Taylor3473f882001-02-23 17:55:21 +00001693 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 ");
Daniel Veillardbe480fb2001-11-08 23:36:42 +00001700 if (elem->prefix != NULL) {
1701 xmlBufferWriteCHAR(buf, elem->prefix);
1702 xmlBufferWriteChar(buf, ":");
1703 }
Owen Taylor3473f882001-02-23 17:55:21 +00001704 xmlBufferWriteCHAR(buf, elem->name);
1705 xmlBufferWriteChar(buf, " ");
1706 xmlDumpElementContent(buf, elem->content, 1);
1707 xmlBufferWriteChar(buf, ">\n");
1708 break;
1709 default:
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001710 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00001711 "Internal: ELEMENT struct corrupted invalid type\n",
1712 NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00001713 }
1714}
1715
1716/**
William M. Brack9e660592003-10-20 14:56:06 +00001717 * 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 */
1724static void
1725xmlDumpElementDeclScan(xmlElementPtr elem, xmlBufferPtr buf) {
1726 xmlDumpElementDecl(buf, elem);
1727}
1728
1729/**
Owen Taylor3473f882001-02-23 17:55:21 +00001730 * 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 */
1736void
1737xmlDumpElementTable(xmlBufferPtr buf, xmlElementTablePtr table) {
Daniel Veillardce682bc2004-11-05 17:22:25 +00001738 if ((buf == NULL) || (table == NULL))
1739 return;
William M. Brack9e660592003-10-20 14:56:06 +00001740 xmlHashScan(table, (xmlHashScanner) xmlDumpElementDeclScan, buf);
Owen Taylor3473f882001-02-23 17:55:21 +00001741}
Daniel Veillarda9cce9c2003-09-29 13:20:24 +00001742#endif /* LIBXML_OUTPUT_ENABLED */
Owen Taylor3473f882001-02-23 17:55:21 +00001743
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 */
1753xmlEnumerationPtr
Daniel Veillard2fdbd322003-08-18 12:15:38 +00001754xmlCreateEnumeration(const xmlChar *name) {
Owen Taylor3473f882001-02-23 17:55:21 +00001755 xmlEnumerationPtr ret;
1756
1757 ret = (xmlEnumerationPtr) xmlMalloc(sizeof(xmlEnumeration));
1758 if (ret == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00001759 xmlVErrMemory(NULL, "malloc failed");
Owen Taylor3473f882001-02-23 17:55:21 +00001760 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 */
1775void
1776xmlFreeEnumeration(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);
Owen Taylor3473f882001-02-23 17:55:21 +00001782 xmlFree(cur);
1783}
1784
Daniel Veillard652327a2003-09-29 18:02:38 +00001785#ifdef LIBXML_TREE_ENABLED
Owen Taylor3473f882001-02-23 17:55:21 +00001786/**
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 */
1795xmlEnumerationPtr
1796xmlCopyEnumeration(xmlEnumerationPtr cur) {
1797 xmlEnumerationPtr ret;
1798
1799 if (cur == NULL) return(NULL);
1800 ret = xmlCreateEnumeration((xmlChar *) cur->name);
1801
1802 if (cur->next != NULL) ret->next = xmlCopyEnumeration(cur->next);
1803 else ret->next = NULL;
1804
1805 return(ret);
1806}
Daniel Veillard652327a2003-09-29 18:02:38 +00001807#endif /* LIBXML_TREE_ENABLED */
Owen Taylor3473f882001-02-23 17:55:21 +00001808
Daniel Veillarda9cce9c2003-09-29 13:20:24 +00001809#ifdef LIBXML_OUTPUT_ENABLED
Owen Taylor3473f882001-02-23 17:55:21 +00001810/**
1811 * xmlDumpEnumeration:
1812 * @buf: the XML buffer output
1813 * @enum: An enumeration
1814 *
1815 * This will dump the content of the enumeration
1816 */
Daniel Veillard56a4cb82001-03-24 17:00:36 +00001817static void
Owen Taylor3473f882001-02-23 17:55:21 +00001818xmlDumpEnumeration(xmlBufferPtr buf, xmlEnumerationPtr cur) {
Daniel Veillardce682bc2004-11-05 17:22:25 +00001819 if ((buf == NULL) || (cur == NULL))
1820 return;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001821
Owen Taylor3473f882001-02-23 17:55:21 +00001822 xmlBufferWriteCHAR(buf, cur->name);
1823 if (cur->next == NULL)
1824 xmlBufferWriteChar(buf, ")");
1825 else {
1826 xmlBufferWriteChar(buf, " | ");
1827 xmlDumpEnumeration(buf, cur->next);
1828 }
1829}
Daniel Veillarda9cce9c2003-09-29 13:20:24 +00001830#endif /* LIBXML_OUTPUT_ENABLED */
Owen Taylor3473f882001-02-23 17:55:21 +00001831
Daniel Veillard4432df22003-09-28 18:58:27 +00001832#ifdef LIBXML_VALID_ENABLED
Owen Taylor3473f882001-02-23 17:55:21 +00001833/**
Owen Taylor3473f882001-02-23 17:55:21 +00001834 * xmlScanIDAttributeDecl:
1835 * @ctxt: the validation context
1836 * @elem: the element name
Daniel Veillarddbee0f12005-06-27 13:42:57 +00001837 * @err: whether to raise errors here
Owen Taylor3473f882001-02-23 17:55:21 +00001838 *
1839 * Verify that the element don't have too many ID attributes
1840 * declared.
1841 *
1842 * Returns the number of ID attributes found.
1843 */
Daniel Veillard56a4cb82001-03-24 17:00:36 +00001844static int
Daniel Veillarddbee0f12005-06-27 13:42:57 +00001845xmlScanIDAttributeDecl(xmlValidCtxtPtr ctxt, xmlElementPtr elem, int err) {
Owen Taylor3473f882001-02-23 17:55:21 +00001846 xmlAttributePtr cur;
1847 int ret = 0;
1848
1849 if (elem == NULL) return(0);
1850 cur = elem->attributes;
1851 while (cur != NULL) {
1852 if (cur->atype == XML_ATTRIBUTE_ID) {
1853 ret ++;
Daniel Veillarddbee0f12005-06-27 13:42:57 +00001854 if ((ret > 1) && (err))
Daniel Veillardbb5abab2003-10-03 22:21:51 +00001855 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_MULTIPLE_ID,
Daniel Veillarda10efa82001-04-18 13:09:01 +00001856 "Element %s has too many ID attributes defined : %s\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00001857 elem->name, cur->name, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00001858 }
1859 cur = cur->nexth;
1860 }
1861 return(ret);
1862}
Daniel Veillard4432df22003-09-28 18:58:27 +00001863#endif /* LIBXML_VALID_ENABLED */
Owen Taylor3473f882001-02-23 17:55:21 +00001864
1865/**
1866 * xmlFreeAttribute:
1867 * @elem: An attribute
1868 *
1869 * Deallocate the memory used by an attribute definition
1870 */
Daniel Veillard56a4cb82001-03-24 17:00:36 +00001871static void
Owen Taylor3473f882001-02-23 17:55:21 +00001872xmlFreeAttribute(xmlAttributePtr attr) {
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00001873 xmlDictPtr dict;
1874
Owen Taylor3473f882001-02-23 17:55:21 +00001875 if (attr == NULL) return;
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00001876 if (attr->doc != NULL)
1877 dict = attr->doc->dict;
1878 else
1879 dict = NULL;
Owen Taylor3473f882001-02-23 17:55:21 +00001880 xmlUnlinkNode((xmlNodePtr) attr);
1881 if (attr->tree != NULL)
1882 xmlFreeEnumeration(attr->tree);
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00001883 if (dict) {
1884 if ((attr->elem != NULL) && (!xmlDictOwns(dict, attr->elem)))
1885 xmlFree((xmlChar *) attr->elem);
1886 if ((attr->name != NULL) && (!xmlDictOwns(dict, attr->name)))
1887 xmlFree((xmlChar *) attr->name);
1888 if ((attr->prefix != NULL) && (!xmlDictOwns(dict, attr->prefix)))
1889 xmlFree((xmlChar *) attr->prefix);
1890 if ((attr->defaultValue != NULL) &&
1891 (!xmlDictOwns(dict, attr->defaultValue)))
1892 xmlFree((xmlChar *) attr->defaultValue);
1893 } else {
1894 if (attr->elem != NULL)
1895 xmlFree((xmlChar *) attr->elem);
1896 if (attr->name != NULL)
1897 xmlFree((xmlChar *) attr->name);
1898 if (attr->defaultValue != NULL)
1899 xmlFree((xmlChar *) attr->defaultValue);
1900 if (attr->prefix != NULL)
1901 xmlFree((xmlChar *) attr->prefix);
1902 }
Owen Taylor3473f882001-02-23 17:55:21 +00001903 xmlFree(attr);
1904}
1905
1906
1907/**
1908 * xmlAddAttributeDecl:
1909 * @ctxt: the validation context
1910 * @dtd: pointer to the DTD
1911 * @elem: the element name
1912 * @name: the attribute name
1913 * @ns: the attribute namespace prefix
1914 * @type: the attribute type
1915 * @def: the attribute default type
1916 * @defaultValue: the attribute default value
1917 * @tree: if it's an enumeration, the associated list
1918 *
1919 * Register a new attribute declaration
1920 * Note that @tree becomes the ownership of the DTD
1921 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00001922 * Returns NULL if not new, otherwise the attribute decl
Owen Taylor3473f882001-02-23 17:55:21 +00001923 */
1924xmlAttributePtr
William M. Brackedb65a72004-02-06 07:36:04 +00001925xmlAddAttributeDecl(xmlValidCtxtPtr ctxt,
Daniel Veillarda9cce9c2003-09-29 13:20:24 +00001926 xmlDtdPtr dtd, const xmlChar *elem,
Owen Taylor3473f882001-02-23 17:55:21 +00001927 const xmlChar *name, const xmlChar *ns,
1928 xmlAttributeType type, xmlAttributeDefault def,
1929 const xmlChar *defaultValue, xmlEnumerationPtr tree) {
1930 xmlAttributePtr ret;
1931 xmlAttributeTablePtr table;
1932 xmlElementPtr elemDef;
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00001933 xmlDictPtr dict = NULL;
Owen Taylor3473f882001-02-23 17:55:21 +00001934
1935 if (dtd == NULL) {
Owen Taylor3473f882001-02-23 17:55:21 +00001936 xmlFreeEnumeration(tree);
1937 return(NULL);
1938 }
1939 if (name == NULL) {
Owen Taylor3473f882001-02-23 17:55:21 +00001940 xmlFreeEnumeration(tree);
1941 return(NULL);
1942 }
1943 if (elem == NULL) {
Owen Taylor3473f882001-02-23 17:55:21 +00001944 xmlFreeEnumeration(tree);
1945 return(NULL);
1946 }
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00001947 if (dtd->doc != NULL)
1948 dict = dtd->doc->dict;
Daniel Veillardd85f4f42002-03-25 10:48:46 +00001949
Daniel Veillard4432df22003-09-28 18:58:27 +00001950#ifdef LIBXML_VALID_ENABLED
Owen Taylor3473f882001-02-23 17:55:21 +00001951 /*
1952 * Check the type and possibly the default value.
1953 */
1954 switch (type) {
1955 case XML_ATTRIBUTE_CDATA:
1956 break;
1957 case XML_ATTRIBUTE_ID:
1958 break;
1959 case XML_ATTRIBUTE_IDREF:
1960 break;
1961 case XML_ATTRIBUTE_IDREFS:
1962 break;
1963 case XML_ATTRIBUTE_ENTITY:
1964 break;
1965 case XML_ATTRIBUTE_ENTITIES:
1966 break;
1967 case XML_ATTRIBUTE_NMTOKEN:
1968 break;
1969 case XML_ATTRIBUTE_NMTOKENS:
1970 break;
1971 case XML_ATTRIBUTE_ENUMERATION:
1972 break;
1973 case XML_ATTRIBUTE_NOTATION:
1974 break;
1975 default:
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001976 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00001977 "Internal: ATTRIBUTE struct corrupted invalid type\n",
1978 NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00001979 xmlFreeEnumeration(tree);
1980 return(NULL);
1981 }
Daniel Veillardf8e3db02012-09-11 13:26:36 +08001982 if ((defaultValue != NULL) &&
Daniel Veillardae0765b2008-07-31 19:54:59 +00001983 (!xmlValidateAttributeValueInternal(dtd->doc, type, defaultValue))) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00001984 xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ATTRIBUTE_DEFAULT,
1985 "Attribute %s of %s: invalid default value\n",
1986 elem, name, defaultValue);
Owen Taylor3473f882001-02-23 17:55:21 +00001987 defaultValue = NULL;
Daniel Veillard42595322004-11-08 10:52:06 +00001988 if (ctxt != NULL)
1989 ctxt->valid = 0;
Owen Taylor3473f882001-02-23 17:55:21 +00001990 }
Daniel Veillard4432df22003-09-28 18:58:27 +00001991#endif /* LIBXML_VALID_ENABLED */
Owen Taylor3473f882001-02-23 17:55:21 +00001992
1993 /*
Daniel Veillardd85f4f42002-03-25 10:48:46 +00001994 * Check first that an attribute defined in the external subset wasn't
1995 * already defined in the internal subset
1996 */
1997 if ((dtd->doc != NULL) && (dtd->doc->extSubset == dtd) &&
1998 (dtd->doc->intSubset != NULL) &&
1999 (dtd->doc->intSubset->attributes != NULL)) {
2000 ret = xmlHashLookup3(dtd->doc->intSubset->attributes, name, ns, elem);
Daniel Veillardae0765b2008-07-31 19:54:59 +00002001 if (ret != NULL) {
2002 xmlFreeEnumeration(tree);
Daniel Veillardd85f4f42002-03-25 10:48:46 +00002003 return(NULL);
Daniel Veillardae0765b2008-07-31 19:54:59 +00002004 }
Daniel Veillardd85f4f42002-03-25 10:48:46 +00002005 }
2006
2007 /*
Owen Taylor3473f882001-02-23 17:55:21 +00002008 * Create the Attribute table if needed.
2009 */
2010 table = (xmlAttributeTablePtr) dtd->attributes;
2011 if (table == NULL) {
Daniel Veillard316a5c32005-01-23 22:56:39 +00002012 table = xmlHashCreateDict(0, dict);
Owen Taylor3473f882001-02-23 17:55:21 +00002013 dtd->attributes = (void *) table;
2014 }
2015 if (table == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00002016 xmlVErrMemory(ctxt,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00002017 "xmlAddAttributeDecl: Table creation failed!\n");
Daniel Veillardae0765b2008-07-31 19:54:59 +00002018 xmlFreeEnumeration(tree);
Owen Taylor3473f882001-02-23 17:55:21 +00002019 return(NULL);
2020 }
2021
2022
2023 ret = (xmlAttributePtr) xmlMalloc(sizeof(xmlAttribute));
2024 if (ret == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00002025 xmlVErrMemory(ctxt, "malloc failed");
Daniel Veillardae0765b2008-07-31 19:54:59 +00002026 xmlFreeEnumeration(tree);
Owen Taylor3473f882001-02-23 17:55:21 +00002027 return(NULL);
2028 }
2029 memset(ret, 0, sizeof(xmlAttribute));
2030 ret->type = XML_ATTRIBUTE_DECL;
2031
2032 /*
2033 * fill the structure.
2034 */
2035 ret->atype = type;
William M. Brackf810de02005-07-06 22:48:41 +00002036 /*
2037 * doc must be set before possible error causes call
2038 * to xmlFreeAttribute (because it's used to check on
2039 * dict use)
2040 */
2041 ret->doc = dtd->doc;
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00002042 if (dict) {
2043 ret->name = xmlDictLookup(dict, name, -1);
2044 ret->prefix = xmlDictLookup(dict, ns, -1);
2045 ret->elem = xmlDictLookup(dict, elem, -1);
2046 } else {
2047 ret->name = xmlStrdup(name);
2048 ret->prefix = xmlStrdup(ns);
2049 ret->elem = xmlStrdup(elem);
2050 }
Owen Taylor3473f882001-02-23 17:55:21 +00002051 ret->def = def;
2052 ret->tree = tree;
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00002053 if (defaultValue != NULL) {
2054 if (dict)
2055 ret->defaultValue = xmlDictLookup(dict, defaultValue, -1);
2056 else
2057 ret->defaultValue = xmlStrdup(defaultValue);
2058 }
Owen Taylor3473f882001-02-23 17:55:21 +00002059
2060 /*
2061 * Validity Check:
2062 * Search the DTD for previous declarations of the ATTLIST
2063 */
Daniel Veillardcee2b3a2005-01-25 00:22:52 +00002064 if (xmlHashAddEntry3(table, ret->name, ret->prefix, ret->elem, ret) < 0) {
Daniel Veillard4432df22003-09-28 18:58:27 +00002065#ifdef LIBXML_VALID_ENABLED
Owen Taylor3473f882001-02-23 17:55:21 +00002066 /*
Daniel Veillardcbaf3992001-12-31 16:16:02 +00002067 * The attribute is already defined in this DTD.
Owen Taylor3473f882001-02-23 17:55:21 +00002068 */
Daniel Veillardbb5abab2003-10-03 22:21:51 +00002069 xmlErrValidWarning(ctxt, (xmlNodePtr) dtd, XML_DTD_ATTRIBUTE_REDEFINED,
Daniel Veillard58e44c92002-08-02 22:19:49 +00002070 "Attribute %s of element %s: already defined\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00002071 name, elem, NULL);
Daniel Veillard4432df22003-09-28 18:58:27 +00002072#endif /* LIBXML_VALID_ENABLED */
Owen Taylor3473f882001-02-23 17:55:21 +00002073 xmlFreeAttribute(ret);
2074 return(NULL);
2075 }
2076
2077 /*
2078 * Validity Check:
2079 * Multiple ID per element
2080 */
Daniel Veillarda10efa82001-04-18 13:09:01 +00002081 elemDef = xmlGetDtdElementDesc2(dtd, elem, 1);
Owen Taylor3473f882001-02-23 17:55:21 +00002082 if (elemDef != NULL) {
Daniel Veillard48da9102001-08-07 01:10:10 +00002083
Daniel Veillard4432df22003-09-28 18:58:27 +00002084#ifdef LIBXML_VALID_ENABLED
Owen Taylor3473f882001-02-23 17:55:21 +00002085 if ((type == XML_ATTRIBUTE_ID) &&
Daniel Veillarddbee0f12005-06-27 13:42:57 +00002086 (xmlScanIDAttributeDecl(NULL, elemDef, 1) != 0)) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00002087 xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_MULTIPLE_ID,
Owen Taylor3473f882001-02-23 17:55:21 +00002088 "Element %s has too may ID attributes defined : %s\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00002089 elem, name, NULL);
Daniel Veillard42595322004-11-08 10:52:06 +00002090 if (ctxt != NULL)
2091 ctxt->valid = 0;
Daniel Veillardc7612992002-02-17 22:47:37 +00002092 }
Daniel Veillard4432df22003-09-28 18:58:27 +00002093#endif /* LIBXML_VALID_ENABLED */
Daniel Veillardc7612992002-02-17 22:47:37 +00002094
Daniel Veillard48da9102001-08-07 01:10:10 +00002095 /*
2096 * Insert namespace default def first they need to be
Daniel Veillardcbaf3992001-12-31 16:16:02 +00002097 * processed first.
Daniel Veillard48da9102001-08-07 01:10:10 +00002098 */
2099 if ((xmlStrEqual(ret->name, BAD_CAST "xmlns")) ||
2100 ((ret->prefix != NULL &&
2101 (xmlStrEqual(ret->prefix, BAD_CAST "xmlns"))))) {
2102 ret->nexth = elemDef->attributes;
2103 elemDef->attributes = ret;
2104 } else {
2105 xmlAttributePtr tmp = elemDef->attributes;
2106
2107 while ((tmp != NULL) &&
2108 ((xmlStrEqual(tmp->name, BAD_CAST "xmlns")) ||
2109 ((ret->prefix != NULL &&
2110 (xmlStrEqual(ret->prefix, BAD_CAST "xmlns")))))) {
2111 if (tmp->nexth == NULL)
2112 break;
2113 tmp = tmp->nexth;
2114 }
2115 if (tmp != NULL) {
2116 ret->nexth = tmp->nexth;
2117 tmp->nexth = ret;
2118 } else {
2119 ret->nexth = elemDef->attributes;
2120 elemDef->attributes = ret;
2121 }
2122 }
Owen Taylor3473f882001-02-23 17:55:21 +00002123 }
2124
2125 /*
Daniel Veillardcbaf3992001-12-31 16:16:02 +00002126 * Link it to the DTD
Owen Taylor3473f882001-02-23 17:55:21 +00002127 */
2128 ret->parent = dtd;
Owen Taylor3473f882001-02-23 17:55:21 +00002129 if (dtd->last == NULL) {
2130 dtd->children = dtd->last = (xmlNodePtr) ret;
2131 } else {
2132 dtd->last->next = (xmlNodePtr) ret;
2133 ret->prev = dtd->last;
2134 dtd->last = (xmlNodePtr) ret;
2135 }
2136 return(ret);
2137}
2138
2139/**
2140 * xmlFreeAttributeTable:
2141 * @table: An attribute table
2142 *
2143 * Deallocate the memory used by an entities hash table.
2144 */
2145void
2146xmlFreeAttributeTable(xmlAttributeTablePtr table) {
2147 xmlHashFree(table, (xmlHashDeallocator) xmlFreeAttribute);
2148}
2149
Daniel Veillard652327a2003-09-29 18:02:38 +00002150#ifdef LIBXML_TREE_ENABLED
Owen Taylor3473f882001-02-23 17:55:21 +00002151/**
2152 * xmlCopyAttribute:
2153 * @attr: An attribute
2154 *
2155 * Build a copy of an attribute.
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002156 *
Owen Taylor3473f882001-02-23 17:55:21 +00002157 * Returns the new xmlAttributePtr or NULL in case of error.
2158 */
Daniel Veillard56a4cb82001-03-24 17:00:36 +00002159static xmlAttributePtr
Owen Taylor3473f882001-02-23 17:55:21 +00002160xmlCopyAttribute(xmlAttributePtr attr) {
2161 xmlAttributePtr cur;
2162
2163 cur = (xmlAttributePtr) xmlMalloc(sizeof(xmlAttribute));
2164 if (cur == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00002165 xmlVErrMemory(NULL, "malloc failed");
Owen Taylor3473f882001-02-23 17:55:21 +00002166 return(NULL);
2167 }
2168 memset(cur, 0, sizeof(xmlAttribute));
Daniel Veillard36065812002-01-24 15:02:46 +00002169 cur->type = XML_ATTRIBUTE_DECL;
Owen Taylor3473f882001-02-23 17:55:21 +00002170 cur->atype = attr->atype;
2171 cur->def = attr->def;
2172 cur->tree = xmlCopyEnumeration(attr->tree);
2173 if (attr->elem != NULL)
2174 cur->elem = xmlStrdup(attr->elem);
2175 if (attr->name != NULL)
2176 cur->name = xmlStrdup(attr->name);
Daniel Veillard36065812002-01-24 15:02:46 +00002177 if (attr->prefix != NULL)
2178 cur->prefix = xmlStrdup(attr->prefix);
Owen Taylor3473f882001-02-23 17:55:21 +00002179 if (attr->defaultValue != NULL)
2180 cur->defaultValue = xmlStrdup(attr->defaultValue);
2181 return(cur);
2182}
2183
2184/**
2185 * xmlCopyAttributeTable:
2186 * @table: An attribute table
2187 *
2188 * Build a copy of an attribute table.
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002189 *
Owen Taylor3473f882001-02-23 17:55:21 +00002190 * Returns the new xmlAttributeTablePtr or NULL in case of error.
2191 */
2192xmlAttributeTablePtr
2193xmlCopyAttributeTable(xmlAttributeTablePtr table) {
2194 return((xmlAttributeTablePtr) xmlHashCopy(table,
2195 (xmlHashCopier) xmlCopyAttribute));
2196}
Daniel Veillard652327a2003-09-29 18:02:38 +00002197#endif /* LIBXML_TREE_ENABLED */
Owen Taylor3473f882001-02-23 17:55:21 +00002198
Daniel Veillarda9cce9c2003-09-29 13:20:24 +00002199#ifdef LIBXML_OUTPUT_ENABLED
Owen Taylor3473f882001-02-23 17:55:21 +00002200/**
2201 * xmlDumpAttributeDecl:
2202 * @buf: the XML buffer output
2203 * @attr: An attribute declaration
2204 *
2205 * This will dump the content of the attribute declaration as an XML
2206 * DTD definition
2207 */
2208void
2209xmlDumpAttributeDecl(xmlBufferPtr buf, xmlAttributePtr attr) {
Daniel Veillardce682bc2004-11-05 17:22:25 +00002210 if ((buf == NULL) || (attr == NULL))
2211 return;
Owen Taylor3473f882001-02-23 17:55:21 +00002212 xmlBufferWriteChar(buf, "<!ATTLIST ");
2213 xmlBufferWriteCHAR(buf, attr->elem);
2214 xmlBufferWriteChar(buf, " ");
2215 if (attr->prefix != NULL) {
2216 xmlBufferWriteCHAR(buf, attr->prefix);
2217 xmlBufferWriteChar(buf, ":");
2218 }
2219 xmlBufferWriteCHAR(buf, attr->name);
2220 switch (attr->atype) {
2221 case XML_ATTRIBUTE_CDATA:
2222 xmlBufferWriteChar(buf, " CDATA");
2223 break;
2224 case XML_ATTRIBUTE_ID:
2225 xmlBufferWriteChar(buf, " ID");
2226 break;
2227 case XML_ATTRIBUTE_IDREF:
2228 xmlBufferWriteChar(buf, " IDREF");
2229 break;
2230 case XML_ATTRIBUTE_IDREFS:
2231 xmlBufferWriteChar(buf, " IDREFS");
2232 break;
2233 case XML_ATTRIBUTE_ENTITY:
2234 xmlBufferWriteChar(buf, " ENTITY");
2235 break;
2236 case XML_ATTRIBUTE_ENTITIES:
2237 xmlBufferWriteChar(buf, " ENTITIES");
2238 break;
2239 case XML_ATTRIBUTE_NMTOKEN:
2240 xmlBufferWriteChar(buf, " NMTOKEN");
2241 break;
2242 case XML_ATTRIBUTE_NMTOKENS:
2243 xmlBufferWriteChar(buf, " NMTOKENS");
2244 break;
2245 case XML_ATTRIBUTE_ENUMERATION:
2246 xmlBufferWriteChar(buf, " (");
2247 xmlDumpEnumeration(buf, attr->tree);
2248 break;
2249 case XML_ATTRIBUTE_NOTATION:
2250 xmlBufferWriteChar(buf, " NOTATION (");
2251 xmlDumpEnumeration(buf, attr->tree);
2252 break;
2253 default:
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002254 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00002255 "Internal: ATTRIBUTE struct corrupted invalid type\n",
2256 NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00002257 }
2258 switch (attr->def) {
2259 case XML_ATTRIBUTE_NONE:
2260 break;
2261 case XML_ATTRIBUTE_REQUIRED:
2262 xmlBufferWriteChar(buf, " #REQUIRED");
2263 break;
2264 case XML_ATTRIBUTE_IMPLIED:
2265 xmlBufferWriteChar(buf, " #IMPLIED");
2266 break;
2267 case XML_ATTRIBUTE_FIXED:
2268 xmlBufferWriteChar(buf, " #FIXED");
2269 break;
2270 default:
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002271 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00002272 "Internal: ATTRIBUTE struct corrupted invalid def\n",
2273 NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00002274 }
2275 if (attr->defaultValue != NULL) {
2276 xmlBufferWriteChar(buf, " ");
2277 xmlBufferWriteQuotedString(buf, attr->defaultValue);
2278 }
2279 xmlBufferWriteChar(buf, ">\n");
2280}
2281
2282/**
William M. Brack9e660592003-10-20 14:56:06 +00002283 * xmlDumpAttributeDeclScan:
2284 * @attr: An attribute declaration
2285 * @buf: the XML buffer output
2286 *
2287 * This is used with the hash scan function - just reverses arguments
2288 */
2289static void
2290xmlDumpAttributeDeclScan(xmlAttributePtr attr, xmlBufferPtr buf) {
2291 xmlDumpAttributeDecl(buf, attr);
2292}
2293
2294/**
Owen Taylor3473f882001-02-23 17:55:21 +00002295 * xmlDumpAttributeTable:
2296 * @buf: the XML buffer output
2297 * @table: An attribute table
2298 *
2299 * This will dump the content of the attribute table as an XML DTD definition
2300 */
2301void
2302xmlDumpAttributeTable(xmlBufferPtr buf, xmlAttributeTablePtr table) {
Daniel Veillardce682bc2004-11-05 17:22:25 +00002303 if ((buf == NULL) || (table == NULL))
2304 return;
William M. Brack9e660592003-10-20 14:56:06 +00002305 xmlHashScan(table, (xmlHashScanner) xmlDumpAttributeDeclScan, buf);
Owen Taylor3473f882001-02-23 17:55:21 +00002306}
Daniel Veillarda9cce9c2003-09-29 13:20:24 +00002307#endif /* LIBXML_OUTPUT_ENABLED */
Owen Taylor3473f882001-02-23 17:55:21 +00002308
2309/************************************************************************
2310 * *
2311 * NOTATIONs *
2312 * *
2313 ************************************************************************/
2314/**
Owen Taylor3473f882001-02-23 17:55:21 +00002315 * xmlFreeNotation:
2316 * @not: A notation
2317 *
2318 * Deallocate the memory used by an notation definition
2319 */
Daniel Veillard56a4cb82001-03-24 17:00:36 +00002320static void
Owen Taylor3473f882001-02-23 17:55:21 +00002321xmlFreeNotation(xmlNotationPtr nota) {
2322 if (nota == NULL) return;
2323 if (nota->name != NULL)
2324 xmlFree((xmlChar *) nota->name);
2325 if (nota->PublicID != NULL)
2326 xmlFree((xmlChar *) nota->PublicID);
2327 if (nota->SystemID != NULL)
2328 xmlFree((xmlChar *) nota->SystemID);
Owen Taylor3473f882001-02-23 17:55:21 +00002329 xmlFree(nota);
2330}
2331
2332
2333/**
2334 * xmlAddNotationDecl:
2335 * @dtd: pointer to the DTD
2336 * @ctxt: the validation context
2337 * @name: the entity name
2338 * @PublicID: the public identifier or NULL
2339 * @SystemID: the system identifier or NULL
2340 *
2341 * Register a new notation declaration
2342 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00002343 * Returns NULL if not, otherwise the entity
Owen Taylor3473f882001-02-23 17:55:21 +00002344 */
2345xmlNotationPtr
William M. Brackedb65a72004-02-06 07:36:04 +00002346xmlAddNotationDecl(xmlValidCtxtPtr ctxt, xmlDtdPtr dtd,
Daniel Veillard56a4cb82001-03-24 17:00:36 +00002347 const xmlChar *name,
Owen Taylor3473f882001-02-23 17:55:21 +00002348 const xmlChar *PublicID, const xmlChar *SystemID) {
2349 xmlNotationPtr ret;
2350 xmlNotationTablePtr table;
2351
2352 if (dtd == NULL) {
Owen Taylor3473f882001-02-23 17:55:21 +00002353 return(NULL);
2354 }
2355 if (name == NULL) {
Owen Taylor3473f882001-02-23 17:55:21 +00002356 return(NULL);
2357 }
2358 if ((PublicID == NULL) && (SystemID == NULL)) {
Daniel Veillard7aea52d2002-02-17 23:07:47 +00002359 return(NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00002360 }
2361
2362 /*
2363 * Create the Notation table if needed.
2364 */
2365 table = (xmlNotationTablePtr) dtd->notations;
Daniel Veillard316a5c32005-01-23 22:56:39 +00002366 if (table == NULL) {
2367 xmlDictPtr dict = NULL;
2368 if (dtd->doc != NULL)
2369 dict = dtd->doc->dict;
2370
2371 dtd->notations = table = xmlHashCreateDict(0, dict);
2372 }
Owen Taylor3473f882001-02-23 17:55:21 +00002373 if (table == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00002374 xmlVErrMemory(ctxt,
Owen Taylor3473f882001-02-23 17:55:21 +00002375 "xmlAddNotationDecl: Table creation failed!\n");
2376 return(NULL);
2377 }
2378
2379 ret = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation));
2380 if (ret == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00002381 xmlVErrMemory(ctxt, "malloc failed");
Owen Taylor3473f882001-02-23 17:55:21 +00002382 return(NULL);
2383 }
2384 memset(ret, 0, sizeof(xmlNotation));
2385
2386 /*
2387 * fill the structure.
2388 */
2389 ret->name = xmlStrdup(name);
2390 if (SystemID != NULL)
2391 ret->SystemID = xmlStrdup(SystemID);
2392 if (PublicID != NULL)
2393 ret->PublicID = xmlStrdup(PublicID);
2394
2395 /*
2396 * Validity Check:
2397 * Check the DTD for previous declarations of the ATTLIST
2398 */
2399 if (xmlHashAddEntry(table, name, ret)) {
Daniel Veillard4432df22003-09-28 18:58:27 +00002400#ifdef LIBXML_VALID_ENABLED
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002401 xmlErrValid(NULL, XML_DTD_NOTATION_REDEFINED,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00002402 "xmlAddNotationDecl: %s already defined\n",
2403 (const char *) name);
Daniel Veillard4432df22003-09-28 18:58:27 +00002404#endif /* LIBXML_VALID_ENABLED */
Owen Taylor3473f882001-02-23 17:55:21 +00002405 xmlFreeNotation(ret);
2406 return(NULL);
2407 }
2408 return(ret);
2409}
2410
2411/**
2412 * xmlFreeNotationTable:
2413 * @table: An notation table
2414 *
2415 * Deallocate the memory used by an entities hash table.
2416 */
2417void
2418xmlFreeNotationTable(xmlNotationTablePtr table) {
2419 xmlHashFree(table, (xmlHashDeallocator) xmlFreeNotation);
2420}
2421
Daniel Veillard652327a2003-09-29 18:02:38 +00002422#ifdef LIBXML_TREE_ENABLED
Owen Taylor3473f882001-02-23 17:55:21 +00002423/**
2424 * xmlCopyNotation:
2425 * @nota: A notation
2426 *
2427 * Build a copy of a notation.
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002428 *
Owen Taylor3473f882001-02-23 17:55:21 +00002429 * Returns the new xmlNotationPtr or NULL in case of error.
2430 */
Daniel Veillard56a4cb82001-03-24 17:00:36 +00002431static xmlNotationPtr
Owen Taylor3473f882001-02-23 17:55:21 +00002432xmlCopyNotation(xmlNotationPtr nota) {
2433 xmlNotationPtr cur;
2434
2435 cur = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation));
2436 if (cur == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00002437 xmlVErrMemory(NULL, "malloc failed");
Owen Taylor3473f882001-02-23 17:55:21 +00002438 return(NULL);
2439 }
2440 if (nota->name != NULL)
2441 cur->name = xmlStrdup(nota->name);
2442 else
2443 cur->name = NULL;
2444 if (nota->PublicID != NULL)
2445 cur->PublicID = xmlStrdup(nota->PublicID);
2446 else
2447 cur->PublicID = NULL;
2448 if (nota->SystemID != NULL)
2449 cur->SystemID = xmlStrdup(nota->SystemID);
2450 else
2451 cur->SystemID = NULL;
2452 return(cur);
2453}
2454
2455/**
2456 * xmlCopyNotationTable:
2457 * @table: A notation table
2458 *
2459 * Build a copy of a notation table.
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002460 *
Owen Taylor3473f882001-02-23 17:55:21 +00002461 * Returns the new xmlNotationTablePtr or NULL in case of error.
2462 */
2463xmlNotationTablePtr
2464xmlCopyNotationTable(xmlNotationTablePtr table) {
2465 return((xmlNotationTablePtr) xmlHashCopy(table,
2466 (xmlHashCopier) xmlCopyNotation));
2467}
Daniel Veillard652327a2003-09-29 18:02:38 +00002468#endif /* LIBXML_TREE_ENABLED */
Owen Taylor3473f882001-02-23 17:55:21 +00002469
Daniel Veillarda9cce9c2003-09-29 13:20:24 +00002470#ifdef LIBXML_OUTPUT_ENABLED
Owen Taylor3473f882001-02-23 17:55:21 +00002471/**
2472 * xmlDumpNotationDecl:
2473 * @buf: the XML buffer output
2474 * @nota: A notation declaration
2475 *
2476 * This will dump the content the notation declaration as an XML DTD definition
2477 */
2478void
2479xmlDumpNotationDecl(xmlBufferPtr buf, xmlNotationPtr nota) {
Daniel Veillardce682bc2004-11-05 17:22:25 +00002480 if ((buf == NULL) || (nota == NULL))
2481 return;
Owen Taylor3473f882001-02-23 17:55:21 +00002482 xmlBufferWriteChar(buf, "<!NOTATION ");
2483 xmlBufferWriteCHAR(buf, nota->name);
2484 if (nota->PublicID != NULL) {
2485 xmlBufferWriteChar(buf, " PUBLIC ");
2486 xmlBufferWriteQuotedString(buf, nota->PublicID);
2487 if (nota->SystemID != NULL) {
2488 xmlBufferWriteChar(buf, " ");
Daniel Veillard41c4a752004-09-08 20:55:38 +00002489 xmlBufferWriteQuotedString(buf, nota->SystemID);
Owen Taylor3473f882001-02-23 17:55:21 +00002490 }
2491 } else {
2492 xmlBufferWriteChar(buf, " SYSTEM ");
Daniel Veillard41c4a752004-09-08 20:55:38 +00002493 xmlBufferWriteQuotedString(buf, nota->SystemID);
Owen Taylor3473f882001-02-23 17:55:21 +00002494 }
2495 xmlBufferWriteChar(buf, " >\n");
2496}
2497
2498/**
William M. Brack9e660592003-10-20 14:56:06 +00002499 * xmlDumpNotationDeclScan:
2500 * @nota: A notation declaration
2501 * @buf: the XML buffer output
2502 *
2503 * This is called with the hash scan function, and just reverses args
2504 */
2505static void
2506xmlDumpNotationDeclScan(xmlNotationPtr nota, xmlBufferPtr buf) {
2507 xmlDumpNotationDecl(buf, nota);
2508}
2509
2510/**
Owen Taylor3473f882001-02-23 17:55:21 +00002511 * xmlDumpNotationTable:
2512 * @buf: the XML buffer output
2513 * @table: A notation table
2514 *
2515 * This will dump the content of the notation table as an XML DTD definition
2516 */
2517void
2518xmlDumpNotationTable(xmlBufferPtr buf, xmlNotationTablePtr table) {
Daniel Veillardce682bc2004-11-05 17:22:25 +00002519 if ((buf == NULL) || (table == NULL))
2520 return;
William M. Brack9e660592003-10-20 14:56:06 +00002521 xmlHashScan(table, (xmlHashScanner) xmlDumpNotationDeclScan, buf);
Owen Taylor3473f882001-02-23 17:55:21 +00002522}
Daniel Veillarda9cce9c2003-09-29 13:20:24 +00002523#endif /* LIBXML_OUTPUT_ENABLED */
Owen Taylor3473f882001-02-23 17:55:21 +00002524
2525/************************************************************************
2526 * *
2527 * IDs *
2528 * *
2529 ************************************************************************/
2530/**
Daniel Veillard8d7b5c72003-11-15 18:24:36 +00002531 * DICT_FREE:
2532 * @str: a string
2533 *
2534 * Free a string if it is not owned by the "dict" dictionnary in the
2535 * current scope
2536 */
2537#define DICT_FREE(str) \
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002538 if ((str) && ((!dict) || \
Daniel Veillard8d7b5c72003-11-15 18:24:36 +00002539 (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \
2540 xmlFree((char *)(str));
2541
2542/**
Owen Taylor3473f882001-02-23 17:55:21 +00002543 * xmlFreeID:
2544 * @not: A id
2545 *
2546 * Deallocate the memory used by an id definition
2547 */
Daniel Veillard56a4cb82001-03-24 17:00:36 +00002548static void
Owen Taylor3473f882001-02-23 17:55:21 +00002549xmlFreeID(xmlIDPtr id) {
Daniel Veillard8d7b5c72003-11-15 18:24:36 +00002550 xmlDictPtr dict = NULL;
2551
Owen Taylor3473f882001-02-23 17:55:21 +00002552 if (id == NULL) return;
Daniel Veillard8d7b5c72003-11-15 18:24:36 +00002553
2554 if (id->doc != NULL)
2555 dict = id->doc->dict;
2556
Owen Taylor3473f882001-02-23 17:55:21 +00002557 if (id->value != NULL)
Daniel Veillard8d7b5c72003-11-15 18:24:36 +00002558 DICT_FREE(id->value)
Daniel Veillardea7751d2002-12-20 00:16:24 +00002559 if (id->name != NULL)
Daniel Veillard8d7b5c72003-11-15 18:24:36 +00002560 DICT_FREE(id->name)
Owen Taylor3473f882001-02-23 17:55:21 +00002561 xmlFree(id);
2562}
2563
Daniel Veillard8d7b5c72003-11-15 18:24:36 +00002564
Owen Taylor3473f882001-02-23 17:55:21 +00002565/**
2566 * xmlAddID:
2567 * @ctxt: the validation context
2568 * @doc: pointer to the document
2569 * @value: the value name
2570 * @attr: the attribute holding the ID
2571 *
2572 * Register a new id declaration
2573 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00002574 * Returns NULL if not, otherwise the new xmlIDPtr
Owen Taylor3473f882001-02-23 17:55:21 +00002575 */
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002576xmlIDPtr
Owen Taylor3473f882001-02-23 17:55:21 +00002577xmlAddID(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value,
2578 xmlAttrPtr attr) {
2579 xmlIDPtr ret;
2580 xmlIDTablePtr table;
2581
2582 if (doc == NULL) {
Owen Taylor3473f882001-02-23 17:55:21 +00002583 return(NULL);
2584 }
2585 if (value == NULL) {
Owen Taylor3473f882001-02-23 17:55:21 +00002586 return(NULL);
2587 }
2588 if (attr == NULL) {
Owen Taylor3473f882001-02-23 17:55:21 +00002589 return(NULL);
2590 }
2591
2592 /*
2593 * Create the ID table if needed.
2594 */
2595 table = (xmlIDTablePtr) doc->ids;
Daniel Veillard316a5c32005-01-23 22:56:39 +00002596 if (table == NULL) {
2597 doc->ids = table = xmlHashCreateDict(0, doc->dict);
2598 }
Owen Taylor3473f882001-02-23 17:55:21 +00002599 if (table == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00002600 xmlVErrMemory(ctxt,
Owen Taylor3473f882001-02-23 17:55:21 +00002601 "xmlAddID: Table creation failed!\n");
2602 return(NULL);
2603 }
2604
2605 ret = (xmlIDPtr) xmlMalloc(sizeof(xmlID));
2606 if (ret == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00002607 xmlVErrMemory(ctxt, "malloc failed");
Owen Taylor3473f882001-02-23 17:55:21 +00002608 return(NULL);
2609 }
2610
2611 /*
2612 * fill the structure.
2613 */
2614 ret->value = xmlStrdup(value);
Daniel Veillard8d7b5c72003-11-15 18:24:36 +00002615 ret->doc = doc;
Daniel Veillardea7751d2002-12-20 00:16:24 +00002616 if ((ctxt != NULL) && (ctxt->vstateNr != 0)) {
2617 /*
2618 * Operating in streaming mode, attr is gonna disapear
2619 */
Daniel Veillard8d7b5c72003-11-15 18:24:36 +00002620 if (doc->dict != NULL)
2621 ret->name = xmlDictLookup(doc->dict, attr->name, -1);
2622 else
2623 ret->name = xmlStrdup(attr->name);
Daniel Veillardea7751d2002-12-20 00:16:24 +00002624 ret->attr = NULL;
2625 } else {
2626 ret->attr = attr;
2627 ret->name = NULL;
2628 }
2629 ret->lineno = xmlGetLineNo(attr->parent);
Owen Taylor3473f882001-02-23 17:55:21 +00002630
2631 if (xmlHashAddEntry(table, value, ret) < 0) {
Daniel Veillard4432df22003-09-28 18:58:27 +00002632#ifdef LIBXML_VALID_ENABLED
Owen Taylor3473f882001-02-23 17:55:21 +00002633 /*
Daniel Veillardcbaf3992001-12-31 16:16:02 +00002634 * The id is already defined in this DTD.
Owen Taylor3473f882001-02-23 17:55:21 +00002635 */
Daniel Veillardd3669b22004-02-25 12:34:55 +00002636 if ((ctxt != NULL) && (ctxt->error != NULL)) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00002637 xmlErrValidNode(ctxt, attr->parent, XML_DTD_ID_REDEFINED,
2638 "ID %s already defined\n",
2639 value, NULL, NULL);
Daniel Veillard76575762002-09-05 14:21:15 +00002640 }
Daniel Veillard4432df22003-09-28 18:58:27 +00002641#endif /* LIBXML_VALID_ENABLED */
Owen Taylor3473f882001-02-23 17:55:21 +00002642 xmlFreeID(ret);
2643 return(NULL);
2644 }
Daniel Veillard249d7bb2003-03-19 21:02:29 +00002645 if (attr != NULL)
2646 attr->atype = XML_ATTRIBUTE_ID;
Owen Taylor3473f882001-02-23 17:55:21 +00002647 return(ret);
2648}
2649
2650/**
2651 * xmlFreeIDTable:
2652 * @table: An id table
2653 *
2654 * Deallocate the memory used by an ID hash table.
2655 */
2656void
2657xmlFreeIDTable(xmlIDTablePtr table) {
2658 xmlHashFree(table, (xmlHashDeallocator) xmlFreeID);
2659}
2660
2661/**
2662 * xmlIsID:
2663 * @doc: the document
2664 * @elem: the element carrying the attribute
2665 * @attr: the attribute
2666 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00002667 * Determine whether an attribute is of type ID. In case we have DTD(s)
Daniel Veillard9dc1cf12002-10-08 08:26:11 +00002668 * then this is done if DTD loading has been requested. In the case
2669 * of HTML documents parsed with the HTML parser, then ID detection is
2670 * done systematically.
Owen Taylor3473f882001-02-23 17:55:21 +00002671 *
2672 * Returns 0 or 1 depending on the lookup result
2673 */
2674int
2675xmlIsID(xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr) {
Daniel Veillard54f9a4f2005-09-03 13:28:24 +00002676 if ((attr == NULL) || (attr->name == NULL)) return(0);
2677 if ((attr->ns != NULL) && (attr->ns->prefix != NULL) &&
2678 (!strcmp((char *) attr->name, "id")) &&
2679 (!strcmp((char *) attr->ns->prefix, "xml")))
2680 return(1);
Owen Taylor3473f882001-02-23 17:55:21 +00002681 if (doc == NULL) return(0);
Daniel Veillardf3c06692009-10-16 16:47:58 +02002682 if ((doc->intSubset == NULL) && (doc->extSubset == NULL) &&
2683 (doc->type != XML_HTML_DOCUMENT_NODE)) {
Owen Taylor3473f882001-02-23 17:55:21 +00002684 return(0);
2685 } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
Rob Richards04bffc02006-03-03 16:44:37 +00002686 if ((xmlStrEqual(BAD_CAST "id", attr->name)) ||
2687 ((xmlStrEqual(BAD_CAST "name", attr->name)) &&
Daniel Veillard38431c32007-06-12 16:20:09 +00002688 ((elem == NULL) || (xmlStrEqual(elem->name, BAD_CAST "a")))))
Owen Taylor3473f882001-02-23 17:55:21 +00002689 return(1);
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002690 return(0);
Daniel Veillard379a3b72005-08-12 10:18:14 +00002691 } else if (elem == NULL) {
2692 return(0);
Owen Taylor3473f882001-02-23 17:55:21 +00002693 } else {
Daniel Veillard465a0002005-08-22 12:07:04 +00002694 xmlAttributePtr attrDecl = NULL;
Owen Taylor3473f882001-02-23 17:55:21 +00002695
Daniel Veillard379a3b72005-08-12 10:18:14 +00002696 xmlChar felem[50], fattr[50];
2697 xmlChar *fullelemname, *fullattrname;
2698
2699 fullelemname = (elem->ns != NULL && elem->ns->prefix != NULL) ?
2700 xmlBuildQName(elem->name, elem->ns->prefix, felem, 50) :
2701 (xmlChar *)elem->name;
2702
2703 fullattrname = (attr->ns != NULL && attr->ns->prefix != NULL) ?
2704 xmlBuildQName(attr->name, attr->ns->prefix, fattr, 50) :
2705 (xmlChar *)attr->name;
2706
2707 if (fullelemname != NULL && fullattrname != NULL) {
2708 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullelemname,
2709 fullattrname);
Daniel Veillard37f961d2002-07-06 17:53:56 +00002710 if ((attrDecl == NULL) && (doc->extSubset != NULL))
Daniel Veillard379a3b72005-08-12 10:18:14 +00002711 attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullelemname,
2712 fullattrname);
Daniel Veillard37f961d2002-07-06 17:53:56 +00002713 }
Owen Taylor3473f882001-02-23 17:55:21 +00002714
Daniel Veillard379a3b72005-08-12 10:18:14 +00002715 if ((fullattrname != fattr) && (fullattrname != attr->name))
2716 xmlFree(fullattrname);
2717 if ((fullelemname != felem) && (fullelemname != elem->name))
2718 xmlFree(fullelemname);
2719
Owen Taylor3473f882001-02-23 17:55:21 +00002720 if ((attrDecl != NULL) && (attrDecl->atype == XML_ATTRIBUTE_ID))
2721 return(1);
2722 }
2723 return(0);
2724}
2725
2726/**
Daniel Veillard01c13b52002-12-10 15:19:08 +00002727 * xmlRemoveID:
Owen Taylor3473f882001-02-23 17:55:21 +00002728 * @doc: the document
2729 * @attr: the attribute
2730 *
2731 * Remove the given attribute from the ID table maintained internally.
2732 *
2733 * Returns -1 if the lookup failed and 0 otherwise
2734 */
2735int
2736xmlRemoveID(xmlDocPtr doc, xmlAttrPtr attr) {
Owen Taylor3473f882001-02-23 17:55:21 +00002737 xmlIDTablePtr table;
Daniel Veillard8d7b5c72003-11-15 18:24:36 +00002738 xmlIDPtr id;
Owen Taylor3473f882001-02-23 17:55:21 +00002739 xmlChar *ID;
2740
2741 if (doc == NULL) return(-1);
2742 if (attr == NULL) return(-1);
2743 table = (xmlIDTablePtr) doc->ids;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002744 if (table == NULL)
Owen Taylor3473f882001-02-23 17:55:21 +00002745 return(-1);
2746
2747 if (attr == NULL)
2748 return(-1);
2749 ID = xmlNodeListGetString(doc, attr->children, 1);
2750 if (ID == NULL)
2751 return(-1);
Daniel Veillard8d7b5c72003-11-15 18:24:36 +00002752 id = xmlHashLookup(table, ID);
2753 if (id == NULL || id->attr != attr) {
Owen Taylor3473f882001-02-23 17:55:21 +00002754 xmlFree(ID);
2755 return(-1);
2756 }
Daniel Veillard91b955c2004-12-10 10:26:42 +00002757 xmlHashRemoveEntry(table, ID, (xmlHashDeallocator) xmlFreeID);
Owen Taylor3473f882001-02-23 17:55:21 +00002758 xmlFree(ID);
Daniel Veillardda6f4af2005-06-20 17:17:54 +00002759 attr->atype = 0;
Owen Taylor3473f882001-02-23 17:55:21 +00002760 return(0);
2761}
2762
2763/**
2764 * xmlGetID:
2765 * @doc: pointer to the document
2766 * @ID: the ID value
2767 *
2768 * Search the attribute declaring the given ID
2769 *
2770 * Returns NULL if not found, otherwise the xmlAttrPtr defining the ID
2771 */
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002772xmlAttrPtr
Owen Taylor3473f882001-02-23 17:55:21 +00002773xmlGetID(xmlDocPtr doc, const xmlChar *ID) {
2774 xmlIDTablePtr table;
2775 xmlIDPtr id;
2776
2777 if (doc == NULL) {
Owen Taylor3473f882001-02-23 17:55:21 +00002778 return(NULL);
2779 }
2780
2781 if (ID == NULL) {
Owen Taylor3473f882001-02-23 17:55:21 +00002782 return(NULL);
2783 }
2784
2785 table = (xmlIDTablePtr) doc->ids;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002786 if (table == NULL)
Owen Taylor3473f882001-02-23 17:55:21 +00002787 return(NULL);
2788
2789 id = xmlHashLookup(table, ID);
2790 if (id == NULL)
2791 return(NULL);
Daniel Veillardea7751d2002-12-20 00:16:24 +00002792 if (id->attr == NULL) {
2793 /*
2794 * We are operating on a stream, return a well known reference
2795 * since the attribute node doesn't exist anymore
2796 */
2797 return((xmlAttrPtr) doc);
2798 }
Owen Taylor3473f882001-02-23 17:55:21 +00002799 return(id->attr);
2800}
2801
2802/************************************************************************
2803 * *
2804 * Refs *
2805 * *
2806 ************************************************************************/
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002807typedef struct xmlRemoveMemo_t
Owen Taylor3473f882001-02-23 17:55:21 +00002808{
2809 xmlListPtr l;
2810 xmlAttrPtr ap;
Daniel Veillard8730c562001-02-26 10:49:57 +00002811} xmlRemoveMemo;
2812
2813typedef xmlRemoveMemo *xmlRemoveMemoPtr;
2814
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002815typedef struct xmlValidateMemo_t
Daniel Veillard8730c562001-02-26 10:49:57 +00002816{
2817 xmlValidCtxtPtr ctxt;
2818 const xmlChar *name;
2819} xmlValidateMemo;
2820
2821typedef xmlValidateMemo *xmlValidateMemoPtr;
Owen Taylor3473f882001-02-23 17:55:21 +00002822
2823/**
Owen Taylor3473f882001-02-23 17:55:21 +00002824 * xmlFreeRef:
2825 * @lk: A list link
2826 *
2827 * Deallocate the memory used by a ref definition
2828 */
2829static void
2830xmlFreeRef(xmlLinkPtr lk) {
Daniel Veillard37721922001-05-04 15:21:12 +00002831 xmlRefPtr ref = (xmlRefPtr)xmlLinkGetData(lk);
2832 if (ref == NULL) return;
2833 if (ref->value != NULL)
2834 xmlFree((xmlChar *)ref->value);
Daniel Veillardea7751d2002-12-20 00:16:24 +00002835 if (ref->name != NULL)
2836 xmlFree((xmlChar *)ref->name);
Daniel Veillard37721922001-05-04 15:21:12 +00002837 xmlFree(ref);
Owen Taylor3473f882001-02-23 17:55:21 +00002838}
2839
2840/**
2841 * xmlFreeRefList:
2842 * @list_ref: A list of references.
2843 *
2844 * Deallocate the memory used by a list of references
2845 */
2846static void
2847xmlFreeRefList(xmlListPtr list_ref) {
Daniel Veillard37721922001-05-04 15:21:12 +00002848 if (list_ref == NULL) return;
2849 xmlListDelete(list_ref);
Owen Taylor3473f882001-02-23 17:55:21 +00002850}
2851
2852/**
2853 * xmlWalkRemoveRef:
2854 * @data: Contents of current link
2855 * @user: Value supplied by the user
2856 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00002857 * Returns 0 to abort the walk or 1 to continue
Owen Taylor3473f882001-02-23 17:55:21 +00002858 */
2859static int
2860xmlWalkRemoveRef(const void *data, const void *user)
2861{
Daniel Veillard37721922001-05-04 15:21:12 +00002862 xmlAttrPtr attr0 = ((xmlRefPtr)data)->attr;
2863 xmlAttrPtr attr1 = ((xmlRemoveMemoPtr)user)->ap;
2864 xmlListPtr ref_list = ((xmlRemoveMemoPtr)user)->l;
Owen Taylor3473f882001-02-23 17:55:21 +00002865
Daniel Veillard37721922001-05-04 15:21:12 +00002866 if (attr0 == attr1) { /* Matched: remove and terminate walk */
2867 xmlListRemoveFirst(ref_list, (void *)data);
2868 return 0;
2869 }
2870 return 1;
Owen Taylor3473f882001-02-23 17:55:21 +00002871}
2872
2873/**
Daniel Veillard770075b2004-02-25 10:44:30 +00002874 * xmlDummyCompare
2875 * @data0: Value supplied by the user
2876 * @data1: Value supplied by the user
2877 *
2878 * Do nothing, return 0. Used to create unordered lists.
2879 */
2880static int
Daniel Veillardf54cd532004-02-25 11:52:31 +00002881xmlDummyCompare(const void *data0 ATTRIBUTE_UNUSED,
2882 const void *data1 ATTRIBUTE_UNUSED)
Daniel Veillard770075b2004-02-25 10:44:30 +00002883{
2884 return (0);
2885}
2886
2887/**
Owen Taylor3473f882001-02-23 17:55:21 +00002888 * xmlAddRef:
2889 * @ctxt: the validation context
2890 * @doc: pointer to the document
2891 * @value: the value name
2892 * @attr: the attribute holding the Ref
2893 *
2894 * Register a new ref declaration
2895 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00002896 * Returns NULL if not, otherwise the new xmlRefPtr
Owen Taylor3473f882001-02-23 17:55:21 +00002897 */
Daniel Veillardf8e3db02012-09-11 13:26:36 +08002898xmlRefPtr
William M. Brackedb65a72004-02-06 07:36:04 +00002899xmlAddRef(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value,
Owen Taylor3473f882001-02-23 17:55:21 +00002900 xmlAttrPtr attr) {
Daniel Veillard37721922001-05-04 15:21:12 +00002901 xmlRefPtr ret;
2902 xmlRefTablePtr table;
2903 xmlListPtr ref_list;
Owen Taylor3473f882001-02-23 17:55:21 +00002904
Daniel Veillard37721922001-05-04 15:21:12 +00002905 if (doc == NULL) {
Daniel Veillard37721922001-05-04 15:21:12 +00002906 return(NULL);
2907 }
2908 if (value == NULL) {
Daniel Veillard37721922001-05-04 15:21:12 +00002909 return(NULL);
2910 }
2911 if (attr == NULL) {
Daniel Veillard37721922001-05-04 15:21:12 +00002912 return(NULL);
2913 }
Owen Taylor3473f882001-02-23 17:55:21 +00002914
Daniel Veillard37721922001-05-04 15:21:12 +00002915 /*
Owen Taylor3473f882001-02-23 17:55:21 +00002916 * Create the Ref table if needed.
2917 */
Daniel Veillard37721922001-05-04 15:21:12 +00002918 table = (xmlRefTablePtr) doc->refs;
Daniel Veillard316a5c32005-01-23 22:56:39 +00002919 if (table == NULL) {
2920 doc->refs = table = xmlHashCreateDict(0, doc->dict);
2921 }
Daniel Veillard37721922001-05-04 15:21:12 +00002922 if (table == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00002923 xmlVErrMemory(ctxt,
Daniel Veillard37721922001-05-04 15:21:12 +00002924 "xmlAddRef: Table creation failed!\n");
2925 return(NULL);
2926 }
Owen Taylor3473f882001-02-23 17:55:21 +00002927
Daniel Veillard37721922001-05-04 15:21:12 +00002928 ret = (xmlRefPtr) xmlMalloc(sizeof(xmlRef));
2929 if (ret == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00002930 xmlVErrMemory(ctxt, "malloc failed");
Daniel Veillard37721922001-05-04 15:21:12 +00002931 return(NULL);
2932 }
Owen Taylor3473f882001-02-23 17:55:21 +00002933
Daniel Veillard37721922001-05-04 15:21:12 +00002934 /*
Owen Taylor3473f882001-02-23 17:55:21 +00002935 * fill the structure.
2936 */
Daniel Veillard37721922001-05-04 15:21:12 +00002937 ret->value = xmlStrdup(value);
Daniel Veillardea7751d2002-12-20 00:16:24 +00002938 if ((ctxt != NULL) && (ctxt->vstateNr != 0)) {
2939 /*
2940 * Operating in streaming mode, attr is gonna disapear
2941 */
2942 ret->name = xmlStrdup(attr->name);
2943 ret->attr = NULL;
2944 } else {
2945 ret->name = NULL;
2946 ret->attr = attr;
2947 }
2948 ret->lineno = xmlGetLineNo(attr->parent);
Owen Taylor3473f882001-02-23 17:55:21 +00002949
Daniel Veillard37721922001-05-04 15:21:12 +00002950 /* To add a reference :-
2951 * References are maintained as a list of references,
2952 * Lookup the entry, if no entry create new nodelist
2953 * Add the owning node to the NodeList
2954 * Return the ref
2955 */
Owen Taylor3473f882001-02-23 17:55:21 +00002956
Daniel Veillard37721922001-05-04 15:21:12 +00002957 if (NULL == (ref_list = xmlHashLookup(table, value))) {
Daniel Veillard770075b2004-02-25 10:44:30 +00002958 if (NULL == (ref_list = xmlListCreate(xmlFreeRef, xmlDummyCompare))) {
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00002959 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2960 "xmlAddRef: Reference list creation failed!\n",
2961 NULL);
Daniel Veillardf6cf57a2007-05-09 23:53:30 +00002962 goto failed;
Daniel Veillard37721922001-05-04 15:21:12 +00002963 }
2964 if (xmlHashAddEntry(table, value, ref_list) < 0) {
2965 xmlListDelete(ref_list);
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00002966 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2967 "xmlAddRef: Reference list insertion failed!\n",
2968 NULL);
Daniel Veillardf6cf57a2007-05-09 23:53:30 +00002969 goto failed;
Daniel Veillard37721922001-05-04 15:21:12 +00002970 }
2971 }
Daniel Veillardf6cf57a2007-05-09 23:53:30 +00002972 if (xmlListAppend(ref_list, ret) != 0) {
2973 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2974 "xmlAddRef: Reference list insertion failed!\n",
2975 NULL);
2976 goto failed;
2977 }
Daniel Veillard37721922001-05-04 15:21:12 +00002978 return(ret);
Daniel Veillardf6cf57a2007-05-09 23:53:30 +00002979failed:
2980 if (ret != NULL) {
2981 if (ret->value != NULL)
2982 xmlFree((char *)ret->value);
2983 if (ret->name != NULL)
2984 xmlFree((char *)ret->name);
2985 xmlFree(ret);
2986 }
2987 return(NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00002988}
2989
2990/**
2991 * xmlFreeRefTable:
2992 * @table: An ref table
2993 *
2994 * Deallocate the memory used by an Ref hash table.
2995 */
2996void
2997xmlFreeRefTable(xmlRefTablePtr table) {
Daniel Veillard37721922001-05-04 15:21:12 +00002998 xmlHashFree(table, (xmlHashDeallocator) xmlFreeRefList);
Owen Taylor3473f882001-02-23 17:55:21 +00002999}
3000
3001/**
3002 * xmlIsRef:
3003 * @doc: the document
3004 * @elem: the element carrying the attribute
3005 * @attr: the attribute
3006 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00003007 * Determine whether an attribute is of type Ref. In case we have DTD(s)
Owen Taylor3473f882001-02-23 17:55:21 +00003008 * then this is simple, otherwise we use an heuristic: name Ref (upper
3009 * or lowercase).
3010 *
3011 * Returns 0 or 1 depending on the lookup result
3012 */
3013int
3014xmlIsRef(xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr) {
Daniel Veillardce244ad2004-11-05 10:03:46 +00003015 if (attr == NULL)
3016 return(0);
3017 if (doc == NULL) {
3018 doc = attr->doc;
3019 if (doc == NULL) return(0);
3020 }
3021
Daniel Veillard37721922001-05-04 15:21:12 +00003022 if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
3023 return(0);
3024 } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
3025 /* TODO @@@ */
Daniel Veillardf8e3db02012-09-11 13:26:36 +08003026 return(0);
Daniel Veillard37721922001-05-04 15:21:12 +00003027 } else {
3028 xmlAttributePtr attrDecl;
Owen Taylor3473f882001-02-23 17:55:21 +00003029
Daniel Veillardce244ad2004-11-05 10:03:46 +00003030 if (elem == NULL) return(0);
Daniel Veillard37721922001-05-04 15:21:12 +00003031 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, attr->name);
3032 if ((attrDecl == NULL) && (doc->extSubset != NULL))
3033 attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
3034 elem->name, attr->name);
Owen Taylor3473f882001-02-23 17:55:21 +00003035
Daniel Veillard37721922001-05-04 15:21:12 +00003036 if ((attrDecl != NULL) &&
3037 (attrDecl->atype == XML_ATTRIBUTE_IDREF ||
3038 attrDecl->atype == XML_ATTRIBUTE_IDREFS))
3039 return(1);
3040 }
3041 return(0);
Owen Taylor3473f882001-02-23 17:55:21 +00003042}
3043
3044/**
Daniel Veillard01c13b52002-12-10 15:19:08 +00003045 * xmlRemoveRef:
Owen Taylor3473f882001-02-23 17:55:21 +00003046 * @doc: the document
3047 * @attr: the attribute
3048 *
3049 * Remove the given attribute from the Ref table maintained internally.
3050 *
3051 * Returns -1 if the lookup failed and 0 otherwise
3052 */
3053int
3054xmlRemoveRef(xmlDocPtr doc, xmlAttrPtr attr) {
Daniel Veillard37721922001-05-04 15:21:12 +00003055 xmlListPtr ref_list;
3056 xmlRefTablePtr table;
3057 xmlChar *ID;
3058 xmlRemoveMemo target;
Owen Taylor3473f882001-02-23 17:55:21 +00003059
Daniel Veillard37721922001-05-04 15:21:12 +00003060 if (doc == NULL) return(-1);
3061 if (attr == NULL) return(-1);
3062 table = (xmlRefTablePtr) doc->refs;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08003063 if (table == NULL)
Daniel Veillard37721922001-05-04 15:21:12 +00003064 return(-1);
Owen Taylor3473f882001-02-23 17:55:21 +00003065
Daniel Veillard37721922001-05-04 15:21:12 +00003066 if (attr == NULL)
3067 return(-1);
3068 ID = xmlNodeListGetString(doc, attr->children, 1);
3069 if (ID == NULL)
3070 return(-1);
3071 ref_list = xmlHashLookup(table, ID);
Owen Taylor3473f882001-02-23 17:55:21 +00003072
Daniel Veillard37721922001-05-04 15:21:12 +00003073 if(ref_list == NULL) {
3074 xmlFree(ID);
3075 return (-1);
3076 }
3077 /* At this point, ref_list refers to a list of references which
3078 * have the same key as the supplied attr. Our list of references
3079 * is ordered by reference address and we don't have that information
3080 * here to use when removing. We'll have to walk the list and
3081 * check for a matching attribute, when we find one stop the walk
3082 * and remove the entry.
3083 * The list is ordered by reference, so that means we don't have the
3084 * key. Passing the list and the reference to the walker means we
3085 * will have enough data to be able to remove the entry.
3086 */
3087 target.l = ref_list;
3088 target.ap = attr;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08003089
Daniel Veillard37721922001-05-04 15:21:12 +00003090 /* Remove the supplied attr from our list */
3091 xmlListWalk(ref_list, xmlWalkRemoveRef, &target);
Owen Taylor3473f882001-02-23 17:55:21 +00003092
Daniel Veillard37721922001-05-04 15:21:12 +00003093 /*If the list is empty then remove the list entry in the hash */
3094 if (xmlListEmpty(ref_list))
3095 xmlHashUpdateEntry(table, ID, NULL, (xmlHashDeallocator)
3096 xmlFreeRefList);
3097 xmlFree(ID);
3098 return(0);
Owen Taylor3473f882001-02-23 17:55:21 +00003099}
3100
3101/**
3102 * xmlGetRefs:
3103 * @doc: pointer to the document
3104 * @ID: the ID value
3105 *
Daniel Veillardf8e3db02012-09-11 13:26:36 +08003106 * Find the set of references for the supplied ID.
Owen Taylor3473f882001-02-23 17:55:21 +00003107 *
3108 * Returns NULL if not found, otherwise node set for the ID.
3109 */
Daniel Veillardf8e3db02012-09-11 13:26:36 +08003110xmlListPtr
Owen Taylor3473f882001-02-23 17:55:21 +00003111xmlGetRefs(xmlDocPtr doc, const xmlChar *ID) {
Daniel Veillard37721922001-05-04 15:21:12 +00003112 xmlRefTablePtr table;
Owen Taylor3473f882001-02-23 17:55:21 +00003113
Daniel Veillard37721922001-05-04 15:21:12 +00003114 if (doc == NULL) {
Daniel Veillard37721922001-05-04 15:21:12 +00003115 return(NULL);
3116 }
Owen Taylor3473f882001-02-23 17:55:21 +00003117
Daniel Veillard37721922001-05-04 15:21:12 +00003118 if (ID == NULL) {
Daniel Veillard37721922001-05-04 15:21:12 +00003119 return(NULL);
3120 }
Owen Taylor3473f882001-02-23 17:55:21 +00003121
Daniel Veillard37721922001-05-04 15:21:12 +00003122 table = (xmlRefTablePtr) doc->refs;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08003123 if (table == NULL)
Daniel Veillard37721922001-05-04 15:21:12 +00003124 return(NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00003125
Daniel Veillard37721922001-05-04 15:21:12 +00003126 return (xmlHashLookup(table, ID));
Owen Taylor3473f882001-02-23 17:55:21 +00003127}
3128
3129/************************************************************************
3130 * *
3131 * Routines for validity checking *
3132 * *
3133 ************************************************************************/
3134
3135/**
3136 * xmlGetDtdElementDesc:
3137 * @dtd: a pointer to the DtD to search
3138 * @name: the element name
3139 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00003140 * Search the DTD for the description of this element
Owen Taylor3473f882001-02-23 17:55:21 +00003141 *
3142 * returns the xmlElementPtr if found or NULL
3143 */
3144
3145xmlElementPtr
3146xmlGetDtdElementDesc(xmlDtdPtr dtd, const xmlChar *name) {
3147 xmlElementTablePtr table;
3148 xmlElementPtr cur;
3149 xmlChar *uqname = NULL, *prefix = NULL;
3150
Daniel Veillarda76fe5c2003-04-24 16:06:47 +00003151 if ((dtd == NULL) || (name == NULL)) return(NULL);
Daniel Veillarda10efa82001-04-18 13:09:01 +00003152 if (dtd->elements == NULL)
3153 return(NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00003154 table = (xmlElementTablePtr) dtd->elements;
3155
3156 uqname = xmlSplitQName2(name, &prefix);
Daniel Veillarda10efa82001-04-18 13:09:01 +00003157 if (uqname != NULL)
3158 name = uqname;
3159 cur = xmlHashLookup2(table, name, prefix);
3160 if (prefix != NULL) xmlFree(prefix);
3161 if (uqname != NULL) xmlFree(uqname);
3162 return(cur);
3163}
3164/**
3165 * xmlGetDtdElementDesc2:
3166 * @dtd: a pointer to the DtD to search
3167 * @name: the element name
3168 * @create: create an empty description if not found
3169 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00003170 * Search the DTD for the description of this element
Daniel Veillarda10efa82001-04-18 13:09:01 +00003171 *
3172 * returns the xmlElementPtr if found or NULL
3173 */
3174
Daniel Veillard86fd5a72001-12-13 14:55:21 +00003175static xmlElementPtr
Daniel Veillarda10efa82001-04-18 13:09:01 +00003176xmlGetDtdElementDesc2(xmlDtdPtr dtd, const xmlChar *name, int create) {
3177 xmlElementTablePtr table;
3178 xmlElementPtr cur;
3179 xmlChar *uqname = NULL, *prefix = NULL;
3180
3181 if (dtd == NULL) return(NULL);
3182 if (dtd->elements == NULL) {
Daniel Veillard316a5c32005-01-23 22:56:39 +00003183 xmlDictPtr dict = NULL;
3184
3185 if (dtd->doc != NULL)
3186 dict = dtd->doc->dict;
3187
Daniel Veillardf8e3db02012-09-11 13:26:36 +08003188 if (!create)
Daniel Veillarda10efa82001-04-18 13:09:01 +00003189 return(NULL);
3190 /*
3191 * Create the Element table if needed.
3192 */
3193 table = (xmlElementTablePtr) dtd->elements;
3194 if (table == NULL) {
Daniel Veillard316a5c32005-01-23 22:56:39 +00003195 table = xmlHashCreateDict(0, dict);
Daniel Veillarda10efa82001-04-18 13:09:01 +00003196 dtd->elements = (void *) table;
3197 }
3198 if (table == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00003199 xmlVErrMemory(NULL, "element table allocation failed");
Daniel Veillarda10efa82001-04-18 13:09:01 +00003200 return(NULL);
3201 }
3202 }
3203 table = (xmlElementTablePtr) dtd->elements;
3204
3205 uqname = xmlSplitQName2(name, &prefix);
3206 if (uqname != NULL)
3207 name = uqname;
3208 cur = xmlHashLookup2(table, name, prefix);
3209 if ((cur == NULL) && (create)) {
3210 cur = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
3211 if (cur == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00003212 xmlVErrMemory(NULL, "malloc failed");
Daniel Veillarda10efa82001-04-18 13:09:01 +00003213 return(NULL);
3214 }
3215 memset(cur, 0, sizeof(xmlElement));
3216 cur->type = XML_ELEMENT_DECL;
3217
3218 /*
3219 * fill the structure.
3220 */
3221 cur->name = xmlStrdup(name);
3222 cur->prefix = xmlStrdup(prefix);
3223 cur->etype = XML_ELEMENT_TYPE_UNDEFINED;
3224
3225 xmlHashAddEntry2(table, name, prefix, cur);
3226 }
3227 if (prefix != NULL) xmlFree(prefix);
3228 if (uqname != NULL) xmlFree(uqname);
Owen Taylor3473f882001-02-23 17:55:21 +00003229 return(cur);
3230}
3231
3232/**
3233 * xmlGetDtdQElementDesc:
3234 * @dtd: a pointer to the DtD to search
3235 * @name: the element name
3236 * @prefix: the element namespace prefix
3237 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00003238 * Search the DTD for the description of this element
Owen Taylor3473f882001-02-23 17:55:21 +00003239 *
3240 * returns the xmlElementPtr if found or NULL
3241 */
3242
Daniel Veillard48da9102001-08-07 01:10:10 +00003243xmlElementPtr
Owen Taylor3473f882001-02-23 17:55:21 +00003244xmlGetDtdQElementDesc(xmlDtdPtr dtd, const xmlChar *name,
3245 const xmlChar *prefix) {
3246 xmlElementTablePtr table;
3247
3248 if (dtd == NULL) return(NULL);
3249 if (dtd->elements == NULL) return(NULL);
3250 table = (xmlElementTablePtr) dtd->elements;
3251
3252 return(xmlHashLookup2(table, name, prefix));
3253}
3254
3255/**
3256 * xmlGetDtdAttrDesc:
3257 * @dtd: a pointer to the DtD to search
3258 * @elem: the element name
3259 * @name: the attribute name
3260 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00003261 * Search the DTD for the description of this attribute on
Owen Taylor3473f882001-02-23 17:55:21 +00003262 * this element.
3263 *
3264 * returns the xmlAttributePtr if found or NULL
3265 */
3266
3267xmlAttributePtr
3268xmlGetDtdAttrDesc(xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name) {
3269 xmlAttributeTablePtr table;
3270 xmlAttributePtr cur;
3271 xmlChar *uqname = NULL, *prefix = NULL;
3272
3273 if (dtd == NULL) return(NULL);
3274 if (dtd->attributes == NULL) return(NULL);
3275
3276 table = (xmlAttributeTablePtr) dtd->attributes;
3277 if (table == NULL)
3278 return(NULL);
3279
3280 uqname = xmlSplitQName2(name, &prefix);
3281
3282 if (uqname != NULL) {
3283 cur = xmlHashLookup3(table, uqname, prefix, elem);
3284 if (prefix != NULL) xmlFree(prefix);
3285 if (uqname != NULL) xmlFree(uqname);
3286 } else
3287 cur = xmlHashLookup3(table, name, NULL, elem);
3288 return(cur);
3289}
3290
3291/**
3292 * xmlGetDtdQAttrDesc:
3293 * @dtd: a pointer to the DtD to search
3294 * @elem: the element name
3295 * @name: the attribute name
3296 * @prefix: the attribute namespace prefix
3297 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00003298 * Search the DTD for the description of this qualified attribute on
Owen Taylor3473f882001-02-23 17:55:21 +00003299 * this element.
3300 *
3301 * returns the xmlAttributePtr if found or NULL
3302 */
3303
Daniel Veillard48da9102001-08-07 01:10:10 +00003304xmlAttributePtr
Owen Taylor3473f882001-02-23 17:55:21 +00003305xmlGetDtdQAttrDesc(xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name,
3306 const xmlChar *prefix) {
3307 xmlAttributeTablePtr table;
3308
3309 if (dtd == NULL) return(NULL);
3310 if (dtd->attributes == NULL) return(NULL);
3311 table = (xmlAttributeTablePtr) dtd->attributes;
3312
3313 return(xmlHashLookup3(table, name, prefix, elem));
3314}
3315
3316/**
3317 * xmlGetDtdNotationDesc:
3318 * @dtd: a pointer to the DtD to search
3319 * @name: the notation name
3320 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00003321 * Search the DTD for the description of this notation
Owen Taylor3473f882001-02-23 17:55:21 +00003322 *
3323 * returns the xmlNotationPtr if found or NULL
3324 */
3325
3326xmlNotationPtr
3327xmlGetDtdNotationDesc(xmlDtdPtr dtd, const xmlChar *name) {
3328 xmlNotationTablePtr table;
3329
3330 if (dtd == NULL) return(NULL);
3331 if (dtd->notations == NULL) return(NULL);
3332 table = (xmlNotationTablePtr) dtd->notations;
3333
3334 return(xmlHashLookup(table, name));
3335}
3336
Daniel Veillardf54cd532004-02-25 11:52:31 +00003337#if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
Owen Taylor3473f882001-02-23 17:55:21 +00003338/**
3339 * xmlValidateNotationUse:
3340 * @ctxt: the validation context
3341 * @doc: the document
3342 * @notationName: the notation name to check
3343 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00003344 * Validate that the given name match a notation declaration.
Owen Taylor3473f882001-02-23 17:55:21 +00003345 * - [ VC: Notation Declared ]
3346 *
3347 * returns 1 if valid or 0 otherwise
3348 */
3349
3350int
3351xmlValidateNotationUse(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
3352 const xmlChar *notationName) {
3353 xmlNotationPtr notaDecl;
Daniel Veillardeab3ac92009-08-12 10:39:29 +02003354 if ((doc == NULL) || (doc->intSubset == NULL) ||
3355 (notationName == NULL)) return(-1);
Owen Taylor3473f882001-02-23 17:55:21 +00003356
3357 notaDecl = xmlGetDtdNotationDesc(doc->intSubset, notationName);
3358 if ((notaDecl == NULL) && (doc->extSubset != NULL))
3359 notaDecl = xmlGetDtdNotationDesc(doc->extSubset, notationName);
3360
Daniel Veillarde637c4a2003-03-30 21:10:09 +00003361 if ((notaDecl == NULL) && (ctxt != NULL)) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00003362 xmlErrValidNode(ctxt, (xmlNodePtr) doc, XML_DTD_UNKNOWN_NOTATION,
3363 "NOTATION %s is not declared\n",
3364 notationName, NULL, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00003365 return(0);
3366 }
3367 return(1);
3368}
Daniel Veillardf54cd532004-02-25 11:52:31 +00003369#endif /* LIBXML_VALID_ENABLED or LIBXML_SCHEMAS_ENABLED */
Owen Taylor3473f882001-02-23 17:55:21 +00003370
3371/**
Daniel Veillard01c13b52002-12-10 15:19:08 +00003372 * xmlIsMixedElement:
Owen Taylor3473f882001-02-23 17:55:21 +00003373 * @doc: the document
3374 * @name: the element name
3375 *
3376 * Search in the DtDs whether an element accept Mixed content (or ANY)
3377 * basically if it is supposed to accept text childs
3378 *
3379 * returns 0 if no, 1 if yes, and -1 if no element description is available
3380 */
3381
3382int
3383xmlIsMixedElement(xmlDocPtr doc, const xmlChar *name) {
3384 xmlElementPtr elemDecl;
3385
3386 if ((doc == NULL) || (doc->intSubset == NULL)) return(-1);
3387
3388 elemDecl = xmlGetDtdElementDesc(doc->intSubset, name);
3389 if ((elemDecl == NULL) && (doc->extSubset != NULL))
3390 elemDecl = xmlGetDtdElementDesc(doc->extSubset, name);
3391 if (elemDecl == NULL) return(-1);
3392 switch (elemDecl->etype) {
Daniel Veillarda10efa82001-04-18 13:09:01 +00003393 case XML_ELEMENT_TYPE_UNDEFINED:
3394 return(-1);
Owen Taylor3473f882001-02-23 17:55:21 +00003395 case XML_ELEMENT_TYPE_ELEMENT:
3396 return(0);
3397 case XML_ELEMENT_TYPE_EMPTY:
3398 /*
3399 * return 1 for EMPTY since we want VC error to pop up
3400 * on <empty> </empty> for example
3401 */
3402 case XML_ELEMENT_TYPE_ANY:
3403 case XML_ELEMENT_TYPE_MIXED:
3404 return(1);
3405 }
3406 return(1);
3407}
3408
Daniel Veillard4432df22003-09-28 18:58:27 +00003409#ifdef LIBXML_VALID_ENABLED
Daniel Veillardae0765b2008-07-31 19:54:59 +00003410
3411static int
3412xmlIsDocNameStartChar(xmlDocPtr doc, int c) {
3413 if ((doc == NULL) || (doc->properties & XML_DOC_OLD10) == 0) {
3414 /*
3415 * Use the new checks of production [4] [4a] amd [5] of the
3416 * Update 5 of XML-1.0
3417 */
3418 if (((c >= 'a') && (c <= 'z')) ||
3419 ((c >= 'A') && (c <= 'Z')) ||
3420 (c == '_') || (c == ':') ||
3421 ((c >= 0xC0) && (c <= 0xD6)) ||
3422 ((c >= 0xD8) && (c <= 0xF6)) ||
3423 ((c >= 0xF8) && (c <= 0x2FF)) ||
3424 ((c >= 0x370) && (c <= 0x37D)) ||
3425 ((c >= 0x37F) && (c <= 0x1FFF)) ||
3426 ((c >= 0x200C) && (c <= 0x200D)) ||
3427 ((c >= 0x2070) && (c <= 0x218F)) ||
3428 ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3429 ((c >= 0x3001) && (c <= 0xD7FF)) ||
3430 ((c >= 0xF900) && (c <= 0xFDCF)) ||
3431 ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3432 ((c >= 0x10000) && (c <= 0xEFFFF)))
3433 return(1);
3434 } else {
3435 if (IS_LETTER(c) || (c == '_') || (c == ':'))
3436 return(1);
3437 }
3438 return(0);
3439}
3440
3441static int
3442xmlIsDocNameChar(xmlDocPtr doc, int c) {
3443 if ((doc == NULL) || (doc->properties & XML_DOC_OLD10) == 0) {
3444 /*
3445 * Use the new checks of production [4] [4a] amd [5] of the
3446 * Update 5 of XML-1.0
3447 */
3448 if (((c >= 'a') && (c <= 'z')) ||
3449 ((c >= 'A') && (c <= 'Z')) ||
3450 ((c >= '0') && (c <= '9')) || /* !start */
3451 (c == '_') || (c == ':') ||
3452 (c == '-') || (c == '.') || (c == 0xB7) || /* !start */
3453 ((c >= 0xC0) && (c <= 0xD6)) ||
3454 ((c >= 0xD8) && (c <= 0xF6)) ||
3455 ((c >= 0xF8) && (c <= 0x2FF)) ||
3456 ((c >= 0x300) && (c <= 0x36F)) || /* !start */
3457 ((c >= 0x370) && (c <= 0x37D)) ||
3458 ((c >= 0x37F) && (c <= 0x1FFF)) ||
3459 ((c >= 0x200C) && (c <= 0x200D)) ||
3460 ((c >= 0x203F) && (c <= 0x2040)) || /* !start */
3461 ((c >= 0x2070) && (c <= 0x218F)) ||
3462 ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3463 ((c >= 0x3001) && (c <= 0xD7FF)) ||
3464 ((c >= 0xF900) && (c <= 0xFDCF)) ||
3465 ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3466 ((c >= 0x10000) && (c <= 0xEFFFF)))
3467 return(1);
3468 } else {
3469 if ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
3470 (c == '.') || (c == '-') ||
3471 (c == '_') || (c == ':') ||
3472 (IS_COMBINING(c)) ||
3473 (IS_EXTENDER(c)))
3474 return(1);
3475 }
3476 return(0);
3477}
3478
3479/**
3480 * xmlValidateNameValue:
3481 * @doc: pointer to the document or NULL
3482 * @value: an Name value
3483 *
3484 * Validate that the given value match Name production
3485 *
3486 * returns 1 if valid or 0 otherwise
3487 */
3488
3489static int
3490xmlValidateNameValueInternal(xmlDocPtr doc, const xmlChar *value) {
3491 const xmlChar *cur;
3492 int val, len;
3493
3494 if (value == NULL) return(0);
3495 cur = value;
3496 val = xmlStringCurrentChar(NULL, cur, &len);
3497 cur += len;
3498 if (!xmlIsDocNameStartChar(doc, val))
3499 return(0);
3500
3501 val = xmlStringCurrentChar(NULL, cur, &len);
3502 cur += len;
3503 while (xmlIsDocNameChar(doc, val)) {
3504 val = xmlStringCurrentChar(NULL, cur, &len);
3505 cur += len;
3506 }
3507
3508 if (val != 0) return(0);
3509
3510 return(1);
3511}
3512
Owen Taylor3473f882001-02-23 17:55:21 +00003513/**
3514 * xmlValidateNameValue:
3515 * @value: an Name value
3516 *
3517 * Validate that the given value match Name production
3518 *
3519 * returns 1 if valid or 0 otherwise
3520 */
3521
Daniel Veillard9b731d72002-04-14 12:56:08 +00003522int
Owen Taylor3473f882001-02-23 17:55:21 +00003523xmlValidateNameValue(const xmlChar *value) {
Daniel Veillardae0765b2008-07-31 19:54:59 +00003524 return(xmlValidateNameValueInternal(NULL, value));
3525}
3526
3527/**
3528 * xmlValidateNamesValueInternal:
3529 * @doc: pointer to the document or NULL
3530 * @value: an Names value
3531 *
3532 * Validate that the given value match Names production
3533 *
3534 * returns 1 if valid or 0 otherwise
3535 */
3536
3537static int
3538xmlValidateNamesValueInternal(xmlDocPtr doc, const xmlChar *value) {
Owen Taylor3473f882001-02-23 17:55:21 +00003539 const xmlChar *cur;
Daniel Veillardd8224e02002-01-13 15:43:22 +00003540 int val, len;
Owen Taylor3473f882001-02-23 17:55:21 +00003541
3542 if (value == NULL) return(0);
3543 cur = value;
Daniel Veillardd8224e02002-01-13 15:43:22 +00003544 val = xmlStringCurrentChar(NULL, cur, &len);
3545 cur += len;
Daniel Veillardae0765b2008-07-31 19:54:59 +00003546
3547 if (!xmlIsDocNameStartChar(doc, val))
Owen Taylor3473f882001-02-23 17:55:21 +00003548 return(0);
Owen Taylor3473f882001-02-23 17:55:21 +00003549
Daniel Veillardd8224e02002-01-13 15:43:22 +00003550 val = xmlStringCurrentChar(NULL, cur, &len);
3551 cur += len;
Daniel Veillardae0765b2008-07-31 19:54:59 +00003552 while (xmlIsDocNameChar(doc, val)) {
Daniel Veillardd8224e02002-01-13 15:43:22 +00003553 val = xmlStringCurrentChar(NULL, cur, &len);
3554 cur += len;
3555 }
Owen Taylor3473f882001-02-23 17:55:21 +00003556
Daniel Veillardae0765b2008-07-31 19:54:59 +00003557 /* Should not test IS_BLANK(val) here -- see erratum E20*/
3558 while (val == 0x20) {
3559 while (val == 0x20) {
3560 val = xmlStringCurrentChar(NULL, cur, &len);
3561 cur += len;
3562 }
3563
3564 if (!xmlIsDocNameStartChar(doc, val))
3565 return(0);
3566
3567 val = xmlStringCurrentChar(NULL, cur, &len);
3568 cur += len;
3569
3570 while (xmlIsDocNameChar(doc, val)) {
3571 val = xmlStringCurrentChar(NULL, cur, &len);
3572 cur += len;
3573 }
3574 }
3575
Daniel Veillardd8224e02002-01-13 15:43:22 +00003576 if (val != 0) return(0);
Owen Taylor3473f882001-02-23 17:55:21 +00003577
3578 return(1);
3579}
3580
3581/**
3582 * xmlValidateNamesValue:
3583 * @value: an Names value
3584 *
3585 * Validate that the given value match Names production
3586 *
3587 * returns 1 if valid or 0 otherwise
3588 */
3589
Daniel Veillard9b731d72002-04-14 12:56:08 +00003590int
Owen Taylor3473f882001-02-23 17:55:21 +00003591xmlValidateNamesValue(const xmlChar *value) {
Daniel Veillardae0765b2008-07-31 19:54:59 +00003592 return(xmlValidateNamesValueInternal(NULL, value));
3593}
3594
3595/**
3596 * xmlValidateNmtokenValueInternal:
3597 * @doc: pointer to the document or NULL
3598 * @value: an Nmtoken value
3599 *
3600 * Validate that the given value match Nmtoken production
3601 *
3602 * [ VC: Name Token ]
3603 *
3604 * returns 1 if valid or 0 otherwise
3605 */
3606
3607static int
3608xmlValidateNmtokenValueInternal(xmlDocPtr doc, const xmlChar *value) {
Owen Taylor3473f882001-02-23 17:55:21 +00003609 const xmlChar *cur;
Daniel Veillardd8224e02002-01-13 15:43:22 +00003610 int val, len;
Owen Taylor3473f882001-02-23 17:55:21 +00003611
3612 if (value == NULL) return(0);
3613 cur = value;
Daniel Veillardd8224e02002-01-13 15:43:22 +00003614 val = xmlStringCurrentChar(NULL, cur, &len);
3615 cur += len;
Daniel Veillardae0765b2008-07-31 19:54:59 +00003616
3617 if (!xmlIsDocNameChar(doc, val))
Owen Taylor3473f882001-02-23 17:55:21 +00003618 return(0);
Owen Taylor3473f882001-02-23 17:55:21 +00003619
Daniel Veillardd8224e02002-01-13 15:43:22 +00003620 val = xmlStringCurrentChar(NULL, cur, &len);
3621 cur += len;
Daniel Veillardae0765b2008-07-31 19:54:59 +00003622 while (xmlIsDocNameChar(doc, val)) {
Daniel Veillardd8224e02002-01-13 15:43:22 +00003623 val = xmlStringCurrentChar(NULL, cur, &len);
3624 cur += len;
Owen Taylor3473f882001-02-23 17:55:21 +00003625 }
3626
Daniel Veillardd8224e02002-01-13 15:43:22 +00003627 if (val != 0) return(0);
Owen Taylor3473f882001-02-23 17:55:21 +00003628
3629 return(1);
3630}
3631
3632/**
3633 * xmlValidateNmtokenValue:
Daniel Veillardcbaf3992001-12-31 16:16:02 +00003634 * @value: an Nmtoken value
Owen Taylor3473f882001-02-23 17:55:21 +00003635 *
3636 * Validate that the given value match Nmtoken production
3637 *
3638 * [ VC: Name Token ]
Daniel Veillardae0765b2008-07-31 19:54:59 +00003639 *
Owen Taylor3473f882001-02-23 17:55:21 +00003640 * returns 1 if valid or 0 otherwise
3641 */
3642
Daniel Veillard9b731d72002-04-14 12:56:08 +00003643int
Owen Taylor3473f882001-02-23 17:55:21 +00003644xmlValidateNmtokenValue(const xmlChar *value) {
Daniel Veillardae0765b2008-07-31 19:54:59 +00003645 return(xmlValidateNmtokenValueInternal(NULL, value));
3646}
3647
3648/**
3649 * xmlValidateNmtokensValueInternal:
3650 * @doc: pointer to the document or NULL
3651 * @value: an Nmtokens value
3652 *
3653 * Validate that the given value match Nmtokens production
3654 *
3655 * [ VC: Name Token ]
3656 *
3657 * returns 1 if valid or 0 otherwise
3658 */
3659
3660static int
3661xmlValidateNmtokensValueInternal(xmlDocPtr doc, const xmlChar *value) {
Owen Taylor3473f882001-02-23 17:55:21 +00003662 const xmlChar *cur;
Daniel Veillardd8224e02002-01-13 15:43:22 +00003663 int val, len;
Owen Taylor3473f882001-02-23 17:55:21 +00003664
3665 if (value == NULL) return(0);
3666 cur = value;
Daniel Veillardd8224e02002-01-13 15:43:22 +00003667 val = xmlStringCurrentChar(NULL, cur, &len);
3668 cur += len;
Owen Taylor3473f882001-02-23 17:55:21 +00003669
Daniel Veillardae0765b2008-07-31 19:54:59 +00003670 while (IS_BLANK(val)) {
Daniel Veillardd8224e02002-01-13 15:43:22 +00003671 val = xmlStringCurrentChar(NULL, cur, &len);
3672 cur += len;
3673 }
Owen Taylor3473f882001-02-23 17:55:21 +00003674
Daniel Veillardae0765b2008-07-31 19:54:59 +00003675 if (!xmlIsDocNameChar(doc, val))
3676 return(0);
3677
3678 while (xmlIsDocNameChar(doc, val)) {
3679 val = xmlStringCurrentChar(NULL, cur, &len);
3680 cur += len;
3681 }
3682
3683 /* Should not test IS_BLANK(val) here -- see erratum E20*/
3684 while (val == 0x20) {
3685 while (val == 0x20) {
3686 val = xmlStringCurrentChar(NULL, cur, &len);
3687 cur += len;
3688 }
3689 if (val == 0) return(1);
3690
3691 if (!xmlIsDocNameChar(doc, val))
3692 return(0);
3693
3694 val = xmlStringCurrentChar(NULL, cur, &len);
3695 cur += len;
3696
3697 while (xmlIsDocNameChar(doc, val)) {
3698 val = xmlStringCurrentChar(NULL, cur, &len);
3699 cur += len;
3700 }
3701 }
3702
Daniel Veillardd8224e02002-01-13 15:43:22 +00003703 if (val != 0) return(0);
Owen Taylor3473f882001-02-23 17:55:21 +00003704
3705 return(1);
3706}
3707
3708/**
3709 * xmlValidateNmtokensValue:
Daniel Veillardcbaf3992001-12-31 16:16:02 +00003710 * @value: an Nmtokens value
Owen Taylor3473f882001-02-23 17:55:21 +00003711 *
3712 * Validate that the given value match Nmtokens production
3713 *
3714 * [ VC: Name Token ]
Daniel Veillardae0765b2008-07-31 19:54:59 +00003715 *
Owen Taylor3473f882001-02-23 17:55:21 +00003716 * returns 1 if valid or 0 otherwise
3717 */
3718
Daniel Veillard9b731d72002-04-14 12:56:08 +00003719int
Owen Taylor3473f882001-02-23 17:55:21 +00003720xmlValidateNmtokensValue(const xmlChar *value) {
Daniel Veillardae0765b2008-07-31 19:54:59 +00003721 return(xmlValidateNmtokensValueInternal(NULL, value));
Owen Taylor3473f882001-02-23 17:55:21 +00003722}
3723
3724/**
3725 * xmlValidateNotationDecl:
3726 * @ctxt: the validation context
3727 * @doc: a document instance
3728 * @nota: a notation definition
3729 *
3730 * Try to validate a single notation definition
3731 * basically it does the following checks as described by the
3732 * XML-1.0 recommendation:
Daniel Veillardcbaf3992001-12-31 16:16:02 +00003733 * - it seems that no validity constraint exists on notation declarations
Owen Taylor3473f882001-02-23 17:55:21 +00003734 * But this function get called anyway ...
3735 *
3736 * returns 1 if valid or 0 otherwise
3737 */
3738
3739int
Daniel Veillardc86a4fa2001-03-26 16:28:29 +00003740xmlValidateNotationDecl(xmlValidCtxtPtr ctxt ATTRIBUTE_UNUSED, xmlDocPtr doc ATTRIBUTE_UNUSED,
3741 xmlNotationPtr nota ATTRIBUTE_UNUSED) {
Owen Taylor3473f882001-02-23 17:55:21 +00003742 int ret = 1;
3743
3744 return(ret);
3745}
3746
3747/**
Daniel Veillardbe2bd6a2008-11-27 15:26:28 +00003748 * xmlValidateAttributeValueInternal:
3749 * @doc: the document
Owen Taylor3473f882001-02-23 17:55:21 +00003750 * @type: an attribute type
3751 * @value: an attribute value
3752 *
3753 * Validate that the given attribute value match the proper production
3754 *
Owen Taylor3473f882001-02-23 17:55:21 +00003755 * returns 1 if valid or 0 otherwise
3756 */
3757
Daniel Veillardae0765b2008-07-31 19:54:59 +00003758static int
3759xmlValidateAttributeValueInternal(xmlDocPtr doc, xmlAttributeType type,
3760 const xmlChar *value) {
Owen Taylor3473f882001-02-23 17:55:21 +00003761 switch (type) {
3762 case XML_ATTRIBUTE_ENTITIES:
3763 case XML_ATTRIBUTE_IDREFS:
Daniel Veillardae0765b2008-07-31 19:54:59 +00003764 return(xmlValidateNamesValueInternal(doc, value));
Owen Taylor3473f882001-02-23 17:55:21 +00003765 case XML_ATTRIBUTE_ENTITY:
3766 case XML_ATTRIBUTE_IDREF:
3767 case XML_ATTRIBUTE_ID:
3768 case XML_ATTRIBUTE_NOTATION:
Daniel Veillardae0765b2008-07-31 19:54:59 +00003769 return(xmlValidateNameValueInternal(doc, value));
Owen Taylor3473f882001-02-23 17:55:21 +00003770 case XML_ATTRIBUTE_NMTOKENS:
3771 case XML_ATTRIBUTE_ENUMERATION:
Daniel Veillardae0765b2008-07-31 19:54:59 +00003772 return(xmlValidateNmtokensValueInternal(doc, value));
Owen Taylor3473f882001-02-23 17:55:21 +00003773 case XML_ATTRIBUTE_NMTOKEN:
Daniel Veillardae0765b2008-07-31 19:54:59 +00003774 return(xmlValidateNmtokenValueInternal(doc, value));
Owen Taylor3473f882001-02-23 17:55:21 +00003775 case XML_ATTRIBUTE_CDATA:
3776 break;
3777 }
3778 return(1);
3779}
3780
Daniel Veillardbe2bd6a2008-11-27 15:26:28 +00003781/**
3782 * xmlValidateAttributeValue:
3783 * @type: an attribute type
3784 * @value: an attribute value
3785 *
3786 * Validate that the given attribute value match the proper production
3787 *
3788 * [ VC: ID ]
3789 * Values of type ID must match the Name production....
3790 *
3791 * [ VC: IDREF ]
3792 * Values of type IDREF must match the Name production, and values
3793 * of type IDREFS must match Names ...
3794 *
3795 * [ VC: Entity Name ]
3796 * Values of type ENTITY must match the Name production, values
3797 * of type ENTITIES must match Names ...
3798 *
3799 * [ VC: Name Token ]
3800 * Values of type NMTOKEN must match the Nmtoken production; values
Daniel Veillardf8e3db02012-09-11 13:26:36 +08003801 * of type NMTOKENS must match Nmtokens.
Daniel Veillardbe2bd6a2008-11-27 15:26:28 +00003802 *
3803 * returns 1 if valid or 0 otherwise
3804 */
Daniel Veillardae0765b2008-07-31 19:54:59 +00003805int
3806xmlValidateAttributeValue(xmlAttributeType type, const xmlChar *value) {
3807 return(xmlValidateAttributeValueInternal(NULL, type, value));
3808}
3809
Owen Taylor3473f882001-02-23 17:55:21 +00003810/**
3811 * xmlValidateAttributeValue2:
3812 * @ctxt: the validation context
3813 * @doc: the document
3814 * @name: the attribute name (used for error reporting only)
3815 * @type: the attribute type
3816 * @value: the attribute value
3817 *
3818 * Validate that the given attribute value match a given type.
3819 * This typically cannot be done before having finished parsing
3820 * the subsets.
3821 *
3822 * [ VC: IDREF ]
3823 * Values of type IDREF must match one of the declared IDs
3824 * Values of type IDREFS must match a sequence of the declared IDs
3825 * each Name must match the value of an ID attribute on some element
3826 * in the XML document; i.e. IDREF values must match the value of
3827 * some ID attribute
3828 *
3829 * [ VC: Entity Name ]
3830 * Values of type ENTITY must match one declared entity
3831 * Values of type ENTITIES must match a sequence of declared entities
3832 *
3833 * [ VC: Notation Attributes ]
3834 * all notation names in the declaration must be declared.
3835 *
3836 * returns 1 if valid or 0 otherwise
3837 */
3838
Daniel Veillard56a4cb82001-03-24 17:00:36 +00003839static int
Owen Taylor3473f882001-02-23 17:55:21 +00003840xmlValidateAttributeValue2(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
3841 const xmlChar *name, xmlAttributeType type, const xmlChar *value) {
3842 int ret = 1;
3843 switch (type) {
3844 case XML_ATTRIBUTE_IDREFS:
3845 case XML_ATTRIBUTE_IDREF:
3846 case XML_ATTRIBUTE_ID:
3847 case XML_ATTRIBUTE_NMTOKENS:
3848 case XML_ATTRIBUTE_ENUMERATION:
3849 case XML_ATTRIBUTE_NMTOKEN:
3850 case XML_ATTRIBUTE_CDATA:
3851 break;
3852 case XML_ATTRIBUTE_ENTITY: {
3853 xmlEntityPtr ent;
3854
3855 ent = xmlGetDocEntity(doc, value);
Daniel Veillard62998c02003-09-15 12:56:36 +00003856 /* yeah it's a bit messy... */
Daniel Veillard878eab02002-02-19 13:46:09 +00003857 if ((ent == NULL) && (doc->standalone == 1)) {
3858 doc->standalone = 0;
3859 ent = xmlGetDocEntity(doc, value);
Daniel Veillardf8e3db02012-09-11 13:26:36 +08003860 }
Owen Taylor3473f882001-02-23 17:55:21 +00003861 if (ent == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00003862 xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3863 XML_DTD_UNKNOWN_ENTITY,
Owen Taylor3473f882001-02-23 17:55:21 +00003864 "ENTITY attribute %s reference an unknown entity \"%s\"\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00003865 name, value, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00003866 ret = 0;
3867 } else if (ent->etype != XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00003868 xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3869 XML_DTD_ENTITY_TYPE,
Owen Taylor3473f882001-02-23 17:55:21 +00003870 "ENTITY attribute %s reference an entity \"%s\" of wrong type\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00003871 name, value, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00003872 ret = 0;
3873 }
3874 break;
3875 }
3876 case XML_ATTRIBUTE_ENTITIES: {
3877 xmlChar *dup, *nam = NULL, *cur, save;
3878 xmlEntityPtr ent;
3879
3880 dup = xmlStrdup(value);
3881 if (dup == NULL)
3882 return(0);
3883 cur = dup;
3884 while (*cur != 0) {
3885 nam = cur;
William M. Brack76e95df2003-10-18 16:20:14 +00003886 while ((*cur != 0) && (!IS_BLANK_CH(*cur))) cur++;
Owen Taylor3473f882001-02-23 17:55:21 +00003887 save = *cur;
3888 *cur = 0;
3889 ent = xmlGetDocEntity(doc, nam);
3890 if (ent == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00003891 xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3892 XML_DTD_UNKNOWN_ENTITY,
Owen Taylor3473f882001-02-23 17:55:21 +00003893 "ENTITIES attribute %s reference an unknown entity \"%s\"\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00003894 name, nam, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00003895 ret = 0;
3896 } else if (ent->etype != XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00003897 xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3898 XML_DTD_ENTITY_TYPE,
Owen Taylor3473f882001-02-23 17:55:21 +00003899 "ENTITIES attribute %s reference an entity \"%s\" of wrong type\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00003900 name, nam, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00003901 ret = 0;
3902 }
3903 if (save == 0)
3904 break;
3905 *cur = save;
William M. Brack76e95df2003-10-18 16:20:14 +00003906 while (IS_BLANK_CH(*cur)) cur++;
Owen Taylor3473f882001-02-23 17:55:21 +00003907 }
3908 xmlFree(dup);
3909 break;
3910 }
3911 case XML_ATTRIBUTE_NOTATION: {
3912 xmlNotationPtr nota;
3913
3914 nota = xmlGetDtdNotationDesc(doc->intSubset, value);
3915 if ((nota == NULL) && (doc->extSubset != NULL))
3916 nota = xmlGetDtdNotationDesc(doc->extSubset, value);
3917
3918 if (nota == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00003919 xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3920 XML_DTD_UNKNOWN_NOTATION,
Owen Taylor3473f882001-02-23 17:55:21 +00003921 "NOTATION attribute %s reference an unknown notation \"%s\"\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00003922 name, value, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00003923 ret = 0;
3924 }
3925 break;
3926 }
3927 }
3928 return(ret);
3929}
3930
3931/**
Daniel Veillard8dc16a62002-02-19 21:08:48 +00003932 * xmlValidCtxtNormalizeAttributeValue:
3933 * @ctxt: the validation context
3934 * @doc: the document
3935 * @elem: the parent
3936 * @name: the attribute name
3937 * @value: the attribute value
3938 * @ctxt: the validation context or NULL
3939 *
3940 * Does the validation related extra step of the normalization of attribute
3941 * values:
3942 *
3943 * If the declared value is not CDATA, then the XML processor must further
3944 * process the normalized attribute value by discarding any leading and
3945 * trailing space (#x20) characters, and by replacing sequences of space
3946 * (#x20) characters by single space (#x20) character.
3947 *
3948 * Also check VC: Standalone Document Declaration in P32, and update
3949 * ctxt->valid accordingly
3950 *
3951 * returns a new normalized string if normalization is needed, NULL otherwise
3952 * the caller must free the returned value.
3953 */
3954
3955xmlChar *
3956xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
3957 xmlNodePtr elem, const xmlChar *name, const xmlChar *value) {
3958 xmlChar *ret, *dst;
3959 const xmlChar *src;
3960 xmlAttributePtr attrDecl = NULL;
3961 int extsubset = 0;
3962
3963 if (doc == NULL) return(NULL);
3964 if (elem == NULL) return(NULL);
3965 if (name == NULL) return(NULL);
3966 if (value == NULL) return(NULL);
3967
3968 if ((elem->ns != NULL) && (elem->ns->prefix != NULL)) {
Daniel Veillardc00cda82003-04-07 10:22:39 +00003969 xmlChar fn[50];
3970 xmlChar *fullname;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08003971
Daniel Veillardc00cda82003-04-07 10:22:39 +00003972 fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
3973 if (fullname == NULL)
Daniel Veillard24505b02005-07-28 23:49:35 +00003974 return(NULL);
Daniel Veillardc00cda82003-04-07 10:22:39 +00003975 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname, name);
Daniel Veillard8dc16a62002-02-19 21:08:48 +00003976 if ((attrDecl == NULL) && (doc->extSubset != NULL)) {
Daniel Veillardc00cda82003-04-07 10:22:39 +00003977 attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullname, name);
Daniel Veillard8dc16a62002-02-19 21:08:48 +00003978 if (attrDecl != NULL)
3979 extsubset = 1;
3980 }
Daniel Veillardc00cda82003-04-07 10:22:39 +00003981 if ((fullname != fn) && (fullname != elem->name))
3982 xmlFree(fullname);
Daniel Veillard8dc16a62002-02-19 21:08:48 +00003983 }
3984 if ((attrDecl == NULL) && (doc->intSubset != NULL))
3985 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, name);
3986 if ((attrDecl == NULL) && (doc->extSubset != NULL)) {
3987 attrDecl = xmlGetDtdAttrDesc(doc->extSubset, elem->name, name);
3988 if (attrDecl != NULL)
3989 extsubset = 1;
3990 }
3991
3992 if (attrDecl == NULL)
3993 return(NULL);
3994 if (attrDecl->atype == XML_ATTRIBUTE_CDATA)
3995 return(NULL);
3996
3997 ret = xmlStrdup(value);
3998 if (ret == NULL)
3999 return(NULL);
4000 src = value;
4001 dst = ret;
4002 while (*src == 0x20) src++;
4003 while (*src != 0) {
4004 if (*src == 0x20) {
4005 while (*src == 0x20) src++;
4006 if (*src != 0)
4007 *dst++ = 0x20;
4008 } else {
4009 *dst++ = *src++;
4010 }
4011 }
4012 *dst = 0;
4013 if ((doc->standalone) && (extsubset == 1) && (!xmlStrEqual(value, ret))) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004014 xmlErrValidNode(ctxt, elem, XML_DTD_NOT_STANDALONE,
Daniel Veillard8dc16a62002-02-19 21:08:48 +00004015"standalone: %s on %s value had to be normalized based on external subset declaration\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004016 name, elem->name, NULL);
Daniel Veillard8dc16a62002-02-19 21:08:48 +00004017 ctxt->valid = 0;
4018 }
4019 return(ret);
4020}
4021
4022/**
Owen Taylor3473f882001-02-23 17:55:21 +00004023 * xmlValidNormalizeAttributeValue:
4024 * @doc: the document
4025 * @elem: the parent
4026 * @name: the attribute name
4027 * @value: the attribute value
4028 *
4029 * Does the validation related extra step of the normalization of attribute
4030 * values:
4031 *
4032 * If the declared value is not CDATA, then the XML processor must further
4033 * process the normalized attribute value by discarding any leading and
4034 * trailing space (#x20) characters, and by replacing sequences of space
4035 * (#x20) characters by single space (#x20) character.
4036 *
Daniel Veillard652327a2003-09-29 18:02:38 +00004037 * Returns a new normalized string if normalization is needed, NULL otherwise
Owen Taylor3473f882001-02-23 17:55:21 +00004038 * the caller must free the returned value.
4039 */
4040
4041xmlChar *
4042xmlValidNormalizeAttributeValue(xmlDocPtr doc, xmlNodePtr elem,
4043 const xmlChar *name, const xmlChar *value) {
4044 xmlChar *ret, *dst;
4045 const xmlChar *src;
4046 xmlAttributePtr attrDecl = NULL;
4047
4048 if (doc == NULL) return(NULL);
4049 if (elem == NULL) return(NULL);
4050 if (name == NULL) return(NULL);
4051 if (value == NULL) return(NULL);
4052
4053 if ((elem->ns != NULL) && (elem->ns->prefix != NULL)) {
Daniel Veillardc00cda82003-04-07 10:22:39 +00004054 xmlChar fn[50];
4055 xmlChar *fullname;
Daniel Veillard594e5df2009-09-07 14:58:47 +02004056
Daniel Veillardc00cda82003-04-07 10:22:39 +00004057 fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
4058 if (fullname == NULL)
Daniel Veillard24505b02005-07-28 23:49:35 +00004059 return(NULL);
Daniel Veillardc00cda82003-04-07 10:22:39 +00004060 if ((fullname != fn) && (fullname != elem->name))
4061 xmlFree(fullname);
Owen Taylor3473f882001-02-23 17:55:21 +00004062 }
4063 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, name);
4064 if ((attrDecl == NULL) && (doc->extSubset != NULL))
4065 attrDecl = xmlGetDtdAttrDesc(doc->extSubset, elem->name, name);
4066
4067 if (attrDecl == NULL)
4068 return(NULL);
4069 if (attrDecl->atype == XML_ATTRIBUTE_CDATA)
4070 return(NULL);
4071
4072 ret = xmlStrdup(value);
4073 if (ret == NULL)
4074 return(NULL);
4075 src = value;
4076 dst = ret;
4077 while (*src == 0x20) src++;
4078 while (*src != 0) {
4079 if (*src == 0x20) {
4080 while (*src == 0x20) src++;
4081 if (*src != 0)
4082 *dst++ = 0x20;
4083 } else {
4084 *dst++ = *src++;
4085 }
4086 }
4087 *dst = 0;
4088 return(ret);
4089}
4090
Daniel Veillard56a4cb82001-03-24 17:00:36 +00004091static void
Owen Taylor3473f882001-02-23 17:55:21 +00004092xmlValidateAttributeIdCallback(xmlAttributePtr attr, int *count,
Daniel Veillardc86a4fa2001-03-26 16:28:29 +00004093 const xmlChar* name ATTRIBUTE_UNUSED) {
Owen Taylor3473f882001-02-23 17:55:21 +00004094 if (attr->atype == XML_ATTRIBUTE_ID) (*count)++;
4095}
4096
4097/**
4098 * xmlValidateAttributeDecl:
4099 * @ctxt: the validation context
4100 * @doc: a document instance
4101 * @attr: an attribute definition
4102 *
4103 * Try to validate a single attribute definition
4104 * basically it does the following checks as described by the
4105 * XML-1.0 recommendation:
4106 * - [ VC: Attribute Default Legal ]
4107 * - [ VC: Enumeration ]
4108 * - [ VC: ID Attribute Default ]
4109 *
4110 * The ID/IDREF uniqueness and matching are done separately
4111 *
4112 * returns 1 if valid or 0 otherwise
4113 */
4114
4115int
4116xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4117 xmlAttributePtr attr) {
4118 int ret = 1;
4119 int val;
4120 CHECK_DTD;
4121 if(attr == NULL) return(1);
Daniel Veillardae0765b2008-07-31 19:54:59 +00004122
Owen Taylor3473f882001-02-23 17:55:21 +00004123 /* Attribute Default Legal */
4124 /* Enumeration */
4125 if (attr->defaultValue != NULL) {
Daniel Veillardae0765b2008-07-31 19:54:59 +00004126 val = xmlValidateAttributeValueInternal(doc, attr->atype,
4127 attr->defaultValue);
Owen Taylor3473f882001-02-23 17:55:21 +00004128 if (val == 0) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004129 xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ATTRIBUTE_DEFAULT,
Daniel Veillard58e44c92002-08-02 22:19:49 +00004130 "Syntax of default value for attribute %s of %s is not valid\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004131 attr->name, attr->elem, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00004132 }
4133 ret &= val;
4134 }
4135
4136 /* ID Attribute Default */
4137 if ((attr->atype == XML_ATTRIBUTE_ID)&&
4138 (attr->def != XML_ATTRIBUTE_IMPLIED) &&
4139 (attr->def != XML_ATTRIBUTE_REQUIRED)) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004140 xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ID_FIXED,
Daniel Veillard58e44c92002-08-02 22:19:49 +00004141 "ID attribute %s of %s is not valid must be #IMPLIED or #REQUIRED\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004142 attr->name, attr->elem, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00004143 ret = 0;
4144 }
4145
4146 /* One ID per Element Type */
4147 if (attr->atype == XML_ATTRIBUTE_ID) {
4148 int nbId;
4149
Daniel Veillardcbaf3992001-12-31 16:16:02 +00004150 /* the trick is that we parse DtD as their own internal subset */
Owen Taylor3473f882001-02-23 17:55:21 +00004151 xmlElementPtr elem = xmlGetDtdElementDesc(doc->intSubset,
4152 attr->elem);
4153 if (elem != NULL) {
Daniel Veillarddbee0f12005-06-27 13:42:57 +00004154 nbId = xmlScanIDAttributeDecl(NULL, elem, 0);
Owen Taylor3473f882001-02-23 17:55:21 +00004155 } else {
4156 xmlAttributeTablePtr table;
4157
4158 /*
4159 * The attribute may be declared in the internal subset and the
4160 * element in the external subset.
4161 */
4162 nbId = 0;
Daniel Veillard11ce4002006-03-10 00:36:23 +00004163 if (doc->intSubset != NULL) {
4164 table = (xmlAttributeTablePtr) doc->intSubset->attributes;
4165 xmlHashScan3(table, NULL, NULL, attr->elem, (xmlHashScanner)
4166 xmlValidateAttributeIdCallback, &nbId);
4167 }
Owen Taylor3473f882001-02-23 17:55:21 +00004168 }
4169 if (nbId > 1) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +08004170
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004171 xmlErrValidNodeNr(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
Owen Taylor3473f882001-02-23 17:55:21 +00004172 "Element %s has %d ID attribute defined in the internal subset : %s\n",
4173 attr->elem, nbId, attr->name);
4174 } else if (doc->extSubset != NULL) {
4175 int extId = 0;
4176 elem = xmlGetDtdElementDesc(doc->extSubset, attr->elem);
4177 if (elem != NULL) {
Daniel Veillarddbee0f12005-06-27 13:42:57 +00004178 extId = xmlScanIDAttributeDecl(NULL, elem, 0);
Owen Taylor3473f882001-02-23 17:55:21 +00004179 }
4180 if (extId > 1) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004181 xmlErrValidNodeNr(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
Owen Taylor3473f882001-02-23 17:55:21 +00004182 "Element %s has %d ID attribute defined in the external subset : %s\n",
4183 attr->elem, extId, attr->name);
4184 } else if (extId + nbId > 1) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004185 xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
Owen Taylor3473f882001-02-23 17:55:21 +00004186"Element %s has ID attributes defined in the internal and external subset : %s\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004187 attr->elem, attr->name, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00004188 }
4189 }
4190 }
4191
4192 /* Validity Constraint: Enumeration */
4193 if ((attr->defaultValue != NULL) && (attr->tree != NULL)) {
4194 xmlEnumerationPtr tree = attr->tree;
4195 while (tree != NULL) {
4196 if (xmlStrEqual(tree->name, attr->defaultValue)) break;
4197 tree = tree->next;
4198 }
4199 if (tree == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004200 xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ATTRIBUTE_VALUE,
Daniel Veillard58e44c92002-08-02 22:19:49 +00004201"Default value \"%s\" for attribute %s of %s is not among the enumerated set\n",
Owen Taylor3473f882001-02-23 17:55:21 +00004202 attr->defaultValue, attr->name, attr->elem);
4203 ret = 0;
4204 }
4205 }
4206
4207 return(ret);
4208}
4209
4210/**
4211 * xmlValidateElementDecl:
4212 * @ctxt: the validation context
4213 * @doc: a document instance
4214 * @elem: an element definition
4215 *
4216 * Try to validate a single element definition
4217 * basically it does the following checks as described by the
4218 * XML-1.0 recommendation:
4219 * - [ VC: One ID per Element Type ]
4220 * - [ VC: No Duplicate Types ]
4221 * - [ VC: Unique Element Type Declaration ]
4222 *
4223 * returns 1 if valid or 0 otherwise
4224 */
4225
4226int
4227xmlValidateElementDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4228 xmlElementPtr elem) {
4229 int ret = 1;
4230 xmlElementPtr tst;
4231
4232 CHECK_DTD;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08004233
Owen Taylor3473f882001-02-23 17:55:21 +00004234 if (elem == NULL) return(1);
4235
Daniel Veillard5acfd6b2002-09-18 16:29:02 +00004236#if 0
Daniel Veillard84d70a42002-09-16 10:51:38 +00004237#ifdef LIBXML_REGEXP_ENABLED
4238 /* Build the regexp associated to the content model */
4239 ret = xmlValidBuildContentModel(ctxt, elem);
4240#endif
Daniel Veillard5acfd6b2002-09-18 16:29:02 +00004241#endif
Daniel Veillard84d70a42002-09-16 10:51:38 +00004242
Owen Taylor3473f882001-02-23 17:55:21 +00004243 /* No Duplicate Types */
4244 if (elem->etype == XML_ELEMENT_TYPE_MIXED) {
4245 xmlElementContentPtr cur, next;
4246 const xmlChar *name;
4247
4248 cur = elem->content;
4249 while (cur != NULL) {
4250 if (cur->type != XML_ELEMENT_CONTENT_OR) break;
4251 if (cur->c1 == NULL) break;
4252 if (cur->c1->type == XML_ELEMENT_CONTENT_ELEMENT) {
4253 name = cur->c1->name;
4254 next = cur->c2;
4255 while (next != NULL) {
4256 if (next->type == XML_ELEMENT_CONTENT_ELEMENT) {
Daniel Veillard7b68df92003-08-03 22:58:54 +00004257 if ((xmlStrEqual(next->name, name)) &&
Daniel Veillarda7216122009-08-21 18:22:58 +02004258 (xmlStrEqual(next->prefix, cur->c1->prefix))) {
4259 if (cur->c1->prefix == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004260 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
Owen Taylor3473f882001-02-23 17:55:21 +00004261 "Definition of %s has duplicate references of %s\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004262 elem->name, name, NULL);
Daniel Veillard7b68df92003-08-03 22:58:54 +00004263 } else {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004264 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
Daniel Veillard7b68df92003-08-03 22:58:54 +00004265 "Definition of %s has duplicate references of %s:%s\n",
Daniel Veillarda7216122009-08-21 18:22:58 +02004266 elem->name, cur->c1->prefix, name);
Daniel Veillard7b68df92003-08-03 22:58:54 +00004267 }
Owen Taylor3473f882001-02-23 17:55:21 +00004268 ret = 0;
4269 }
4270 break;
4271 }
4272 if (next->c1 == NULL) break;
4273 if (next->c1->type != XML_ELEMENT_CONTENT_ELEMENT) break;
Daniel Veillard7b68df92003-08-03 22:58:54 +00004274 if ((xmlStrEqual(next->c1->name, name)) &&
Daniel Veillarda7216122009-08-21 18:22:58 +02004275 (xmlStrEqual(next->c1->prefix, cur->c1->prefix))) {
4276 if (cur->c1->prefix == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004277 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
Daniel Veillard7b68df92003-08-03 22:58:54 +00004278 "Definition of %s has duplicate references to %s\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004279 elem->name, name, NULL);
Daniel Veillard7b68df92003-08-03 22:58:54 +00004280 } else {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004281 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
Daniel Veillard7b68df92003-08-03 22:58:54 +00004282 "Definition of %s has duplicate references to %s:%s\n",
Daniel Veillarda7216122009-08-21 18:22:58 +02004283 elem->name, cur->c1->prefix, name);
Daniel Veillard7b68df92003-08-03 22:58:54 +00004284 }
Owen Taylor3473f882001-02-23 17:55:21 +00004285 ret = 0;
4286 }
4287 next = next->c2;
4288 }
4289 }
4290 cur = cur->c2;
4291 }
4292 }
4293
4294 /* VC: Unique Element Type Declaration */
4295 tst = xmlGetDtdElementDesc(doc->intSubset, elem->name);
Daniel Veillarda10efa82001-04-18 13:09:01 +00004296 if ((tst != NULL ) && (tst != elem) &&
Daniel Veillardbe480fb2001-11-08 23:36:42 +00004297 ((tst->prefix == elem->prefix) ||
4298 (xmlStrEqual(tst->prefix, elem->prefix))) &&
Daniel Veillarda10efa82001-04-18 13:09:01 +00004299 (tst->etype != XML_ELEMENT_TYPE_UNDEFINED)) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004300 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_ELEM_REDEFINED,
4301 "Redefinition of element %s\n",
4302 elem->name, NULL, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00004303 ret = 0;
4304 }
4305 tst = xmlGetDtdElementDesc(doc->extSubset, elem->name);
Daniel Veillarda10efa82001-04-18 13:09:01 +00004306 if ((tst != NULL ) && (tst != elem) &&
Daniel Veillardbe480fb2001-11-08 23:36:42 +00004307 ((tst->prefix == elem->prefix) ||
4308 (xmlStrEqual(tst->prefix, elem->prefix))) &&
Daniel Veillarda10efa82001-04-18 13:09:01 +00004309 (tst->etype != XML_ELEMENT_TYPE_UNDEFINED)) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004310 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_ELEM_REDEFINED,
4311 "Redefinition of element %s\n",
4312 elem->name, NULL, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00004313 ret = 0;
4314 }
Daniel Veillarda10efa82001-04-18 13:09:01 +00004315 /* One ID per Element Type
4316 * already done when registering the attribute
Owen Taylor3473f882001-02-23 17:55:21 +00004317 if (xmlScanIDAttributeDecl(ctxt, elem) > 1) {
4318 ret = 0;
Daniel Veillarda10efa82001-04-18 13:09:01 +00004319 } */
Owen Taylor3473f882001-02-23 17:55:21 +00004320 return(ret);
4321}
4322
4323/**
4324 * xmlValidateOneAttribute:
4325 * @ctxt: the validation context
4326 * @doc: a document instance
4327 * @elem: an element instance
4328 * @attr: an attribute instance
4329 * @value: the attribute value (without entities processing)
4330 *
4331 * Try to validate a single attribute for an element
4332 * basically it does the following checks as described by the
4333 * XML-1.0 recommendation:
4334 * - [ VC: Attribute Value Type ]
4335 * - [ VC: Fixed Attribute Default ]
4336 * - [ VC: Entity Name ]
4337 * - [ VC: Name Token ]
4338 * - [ VC: ID ]
4339 * - [ VC: IDREF ]
4340 * - [ VC: Entity Name ]
4341 * - [ VC: Notation Attributes ]
4342 *
4343 * The ID/IDREF uniqueness and matching are done separately
4344 *
4345 * returns 1 if valid or 0 otherwise
4346 */
4347
4348int
4349xmlValidateOneAttribute(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
Daniel Veillardf8e3db02012-09-11 13:26:36 +08004350 xmlNodePtr elem, xmlAttrPtr attr, const xmlChar *value)
Daniel Veillard07cb8222003-09-10 10:51:05 +00004351{
Owen Taylor3473f882001-02-23 17:55:21 +00004352 xmlAttributePtr attrDecl = NULL;
4353 int val;
4354 int ret = 1;
4355
4356 CHECK_DTD;
4357 if ((elem == NULL) || (elem->name == NULL)) return(0);
4358 if ((attr == NULL) || (attr->name == NULL)) return(0);
4359
4360 if ((elem->ns != NULL) && (elem->ns->prefix != NULL)) {
Daniel Veillardc00cda82003-04-07 10:22:39 +00004361 xmlChar fn[50];
4362 xmlChar *fullname;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08004363
Daniel Veillardc00cda82003-04-07 10:22:39 +00004364 fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
4365 if (fullname == NULL)
4366 return(0);
Owen Taylor3473f882001-02-23 17:55:21 +00004367 if (attr->ns != NULL) {
Daniel Veillardc00cda82003-04-07 10:22:39 +00004368 attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, fullname,
Owen Taylor3473f882001-02-23 17:55:21 +00004369 attr->name, attr->ns->prefix);
4370 if ((attrDecl == NULL) && (doc->extSubset != NULL))
Daniel Veillardc00cda82003-04-07 10:22:39 +00004371 attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, fullname,
Owen Taylor3473f882001-02-23 17:55:21 +00004372 attr->name, attr->ns->prefix);
4373 } else {
Daniel Veillardc00cda82003-04-07 10:22:39 +00004374 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname, attr->name);
Owen Taylor3473f882001-02-23 17:55:21 +00004375 if ((attrDecl == NULL) && (doc->extSubset != NULL))
4376 attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
Daniel Veillardc00cda82003-04-07 10:22:39 +00004377 fullname, attr->name);
Owen Taylor3473f882001-02-23 17:55:21 +00004378 }
Daniel Veillardc00cda82003-04-07 10:22:39 +00004379 if ((fullname != fn) && (fullname != elem->name))
4380 xmlFree(fullname);
Owen Taylor3473f882001-02-23 17:55:21 +00004381 }
4382 if (attrDecl == NULL) {
4383 if (attr->ns != NULL) {
4384 attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, elem->name,
4385 attr->name, attr->ns->prefix);
4386 if ((attrDecl == NULL) && (doc->extSubset != NULL))
4387 attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, elem->name,
4388 attr->name, attr->ns->prefix);
4389 } else {
4390 attrDecl = xmlGetDtdAttrDesc(doc->intSubset,
4391 elem->name, attr->name);
4392 if ((attrDecl == NULL) && (doc->extSubset != NULL))
4393 attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
4394 elem->name, attr->name);
4395 }
4396 }
4397
4398
4399 /* Validity Constraint: Attribute Value Type */
4400 if (attrDecl == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004401 xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
Daniel Veillard58e44c92002-08-02 22:19:49 +00004402 "No declaration for attribute %s of element %s\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004403 attr->name, elem->name, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00004404 return(0);
4405 }
4406 attr->atype = attrDecl->atype;
4407
Daniel Veillardae0765b2008-07-31 19:54:59 +00004408 val = xmlValidateAttributeValueInternal(doc, attrDecl->atype, value);
Owen Taylor3473f882001-02-23 17:55:21 +00004409 if (val == 0) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004410 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
Daniel Veillard58e44c92002-08-02 22:19:49 +00004411 "Syntax of value for attribute %s of %s is not valid\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004412 attr->name, elem->name, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00004413 ret = 0;
4414 }
4415
4416 /* Validity constraint: Fixed Attribute Default */
4417 if (attrDecl->def == XML_ATTRIBUTE_FIXED) {
4418 if (!xmlStrEqual(value, attrDecl->defaultValue)) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004419 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_DEFAULT,
Daniel Veillard58e44c92002-08-02 22:19:49 +00004420 "Value for attribute %s of %s is different from default \"%s\"\n",
Owen Taylor3473f882001-02-23 17:55:21 +00004421 attr->name, elem->name, attrDecl->defaultValue);
4422 ret = 0;
4423 }
4424 }
4425
4426 /* Validity Constraint: ID uniqueness */
4427 if (attrDecl->atype == XML_ATTRIBUTE_ID) {
4428 if (xmlAddID(ctxt, doc, value, attr) == NULL)
4429 ret = 0;
4430 }
4431
4432 if ((attrDecl->atype == XML_ATTRIBUTE_IDREF) ||
4433 (attrDecl->atype == XML_ATTRIBUTE_IDREFS)) {
4434 if (xmlAddRef(ctxt, doc, value, attr) == NULL)
4435 ret = 0;
4436 }
4437
4438 /* Validity Constraint: Notation Attributes */
4439 if (attrDecl->atype == XML_ATTRIBUTE_NOTATION) {
4440 xmlEnumerationPtr tree = attrDecl->tree;
4441 xmlNotationPtr nota;
4442
4443 /* First check that the given NOTATION was declared */
4444 nota = xmlGetDtdNotationDesc(doc->intSubset, value);
4445 if (nota == NULL)
4446 nota = xmlGetDtdNotationDesc(doc->extSubset, value);
Daniel Veillardf8e3db02012-09-11 13:26:36 +08004447
Owen Taylor3473f882001-02-23 17:55:21 +00004448 if (nota == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004449 xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
Daniel Veillard58e44c92002-08-02 22:19:49 +00004450 "Value \"%s\" for attribute %s of %s is not a declared Notation\n",
Owen Taylor3473f882001-02-23 17:55:21 +00004451 value, attr->name, elem->name);
4452 ret = 0;
4453 }
4454
4455 /* Second, verify that it's among the list */
4456 while (tree != NULL) {
4457 if (xmlStrEqual(tree->name, value)) break;
4458 tree = tree->next;
4459 }
4460 if (tree == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004461 xmlErrValidNode(ctxt, elem, XML_DTD_NOTATION_VALUE,
Daniel Veillard58e44c92002-08-02 22:19:49 +00004462"Value \"%s\" for attribute %s of %s is not among the enumerated notations\n",
Owen Taylor3473f882001-02-23 17:55:21 +00004463 value, attr->name, elem->name);
4464 ret = 0;
4465 }
4466 }
4467
4468 /* Validity Constraint: Enumeration */
4469 if (attrDecl->atype == XML_ATTRIBUTE_ENUMERATION) {
4470 xmlEnumerationPtr tree = attrDecl->tree;
4471 while (tree != NULL) {
4472 if (xmlStrEqual(tree->name, value)) break;
4473 tree = tree->next;
4474 }
4475 if (tree == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004476 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
Daniel Veillard58e44c92002-08-02 22:19:49 +00004477 "Value \"%s\" for attribute %s of %s is not among the enumerated set\n",
Owen Taylor3473f882001-02-23 17:55:21 +00004478 value, attr->name, elem->name);
4479 ret = 0;
4480 }
4481 }
4482
4483 /* Fixed Attribute Default */
4484 if ((attrDecl->def == XML_ATTRIBUTE_FIXED) &&
4485 (!xmlStrEqual(attrDecl->defaultValue, value))) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004486 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
Daniel Veillard58e44c92002-08-02 22:19:49 +00004487 "Value for attribute %s of %s must be \"%s\"\n",
Owen Taylor3473f882001-02-23 17:55:21 +00004488 attr->name, elem->name, attrDecl->defaultValue);
4489 ret = 0;
4490 }
4491
4492 /* Extra check for the attribute value */
4493 ret &= xmlValidateAttributeValue2(ctxt, doc, attr->name,
4494 attrDecl->atype, value);
4495
4496 return(ret);
4497}
4498
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004499/**
4500 * xmlValidateOneNamespace:
4501 * @ctxt: the validation context
4502 * @doc: a document instance
4503 * @elem: an element instance
Daniel Veillarda9b66d02002-12-11 14:23:49 +00004504 * @prefix: the namespace prefix
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004505 * @ns: an namespace declaration instance
4506 * @value: the attribute value (without entities processing)
4507 *
4508 * Try to validate a single namespace declaration for an element
4509 * basically it does the following checks as described by the
4510 * XML-1.0 recommendation:
4511 * - [ VC: Attribute Value Type ]
4512 * - [ VC: Fixed Attribute Default ]
4513 * - [ VC: Entity Name ]
4514 * - [ VC: Name Token ]
4515 * - [ VC: ID ]
4516 * - [ VC: IDREF ]
4517 * - [ VC: Entity Name ]
4518 * - [ VC: Notation Attributes ]
4519 *
4520 * The ID/IDREF uniqueness and matching are done separately
4521 *
4522 * returns 1 if valid or 0 otherwise
4523 */
4524
4525int
4526xmlValidateOneNamespace(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4527xmlNodePtr elem, const xmlChar *prefix, xmlNsPtr ns, const xmlChar *value) {
4528 /* xmlElementPtr elemDecl; */
4529 xmlAttributePtr attrDecl = NULL;
4530 int val;
4531 int ret = 1;
4532
4533 CHECK_DTD;
4534 if ((elem == NULL) || (elem->name == NULL)) return(0);
4535 if ((ns == NULL) || (ns->href == NULL)) return(0);
4536
4537 if (prefix != NULL) {
Daniel Veillardc00cda82003-04-07 10:22:39 +00004538 xmlChar fn[50];
4539 xmlChar *fullname;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08004540
Daniel Veillardc00cda82003-04-07 10:22:39 +00004541 fullname = xmlBuildQName(elem->name, prefix, fn, 50);
4542 if (fullname == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00004543 xmlVErrMemory(ctxt, "Validating namespace");
Daniel Veillardc00cda82003-04-07 10:22:39 +00004544 return(0);
4545 }
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004546 if (ns->prefix != NULL) {
Daniel Veillardc00cda82003-04-07 10:22:39 +00004547 attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, fullname,
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004548 ns->prefix, BAD_CAST "xmlns");
4549 if ((attrDecl == NULL) && (doc->extSubset != NULL))
Daniel Veillardc00cda82003-04-07 10:22:39 +00004550 attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, fullname,
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004551 ns->prefix, BAD_CAST "xmlns");
4552 } else {
Daniel Veillardc00cda82003-04-07 10:22:39 +00004553 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname,
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004554 BAD_CAST "xmlns");
4555 if ((attrDecl == NULL) && (doc->extSubset != NULL))
Daniel Veillardc00cda82003-04-07 10:22:39 +00004556 attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullname,
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004557 BAD_CAST "xmlns");
4558 }
Daniel Veillardc00cda82003-04-07 10:22:39 +00004559 if ((fullname != fn) && (fullname != elem->name))
4560 xmlFree(fullname);
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004561 }
4562 if (attrDecl == NULL) {
4563 if (ns->prefix != NULL) {
4564 attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, elem->name,
4565 ns->prefix, BAD_CAST "xmlns");
4566 if ((attrDecl == NULL) && (doc->extSubset != NULL))
4567 attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, elem->name,
4568 ns->prefix, BAD_CAST "xmlns");
4569 } else {
4570 attrDecl = xmlGetDtdAttrDesc(doc->intSubset,
4571 elem->name, BAD_CAST "xmlns");
4572 if ((attrDecl == NULL) && (doc->extSubset != NULL))
4573 attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
4574 elem->name, BAD_CAST "xmlns");
4575 }
4576 }
4577
4578
4579 /* Validity Constraint: Attribute Value Type */
4580 if (attrDecl == NULL) {
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004581 if (ns->prefix != NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004582 xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004583 "No declaration for attribute xmlns:%s of element %s\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004584 ns->prefix, elem->name, NULL);
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004585 } else {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004586 xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004587 "No declaration for attribute xmlns of element %s\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004588 elem->name, NULL, NULL);
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004589 }
4590 return(0);
4591 }
4592
Daniel Veillardae0765b2008-07-31 19:54:59 +00004593 val = xmlValidateAttributeValueInternal(doc, attrDecl->atype, value);
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004594 if (val == 0) {
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004595 if (ns->prefix != NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004596 xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_DEFAULT,
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004597 "Syntax of value for attribute xmlns:%s of %s is not valid\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004598 ns->prefix, elem->name, NULL);
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004599 } else {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004600 xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_DEFAULT,
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004601 "Syntax of value for attribute xmlns of %s is not valid\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004602 elem->name, NULL, NULL);
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004603 }
4604 ret = 0;
4605 }
4606
4607 /* Validity constraint: Fixed Attribute Default */
4608 if (attrDecl->def == XML_ATTRIBUTE_FIXED) {
4609 if (!xmlStrEqual(value, attrDecl->defaultValue)) {
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004610 if (ns->prefix != NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004611 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_DEFAULT,
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004612 "Value for attribute xmlns:%s of %s is different from default \"%s\"\n",
4613 ns->prefix, elem->name, attrDecl->defaultValue);
4614 } else {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004615 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_DEFAULT,
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004616 "Value for attribute xmlns of %s is different from default \"%s\"\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004617 elem->name, attrDecl->defaultValue, NULL);
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004618 }
4619 ret = 0;
4620 }
4621 }
4622
4623 /* Validity Constraint: ID uniqueness */
4624 if (attrDecl->atype == XML_ATTRIBUTE_ID) {
4625 if (xmlAddID(ctxt, doc, value, (xmlAttrPtr) ns) == NULL)
4626 ret = 0;
4627 }
4628
4629 if ((attrDecl->atype == XML_ATTRIBUTE_IDREF) ||
4630 (attrDecl->atype == XML_ATTRIBUTE_IDREFS)) {
4631 if (xmlAddRef(ctxt, doc, value, (xmlAttrPtr) ns) == NULL)
4632 ret = 0;
4633 }
4634
4635 /* Validity Constraint: Notation Attributes */
4636 if (attrDecl->atype == XML_ATTRIBUTE_NOTATION) {
4637 xmlEnumerationPtr tree = attrDecl->tree;
4638 xmlNotationPtr nota;
4639
4640 /* First check that the given NOTATION was declared */
4641 nota = xmlGetDtdNotationDesc(doc->intSubset, value);
4642 if (nota == NULL)
4643 nota = xmlGetDtdNotationDesc(doc->extSubset, value);
Daniel Veillardf8e3db02012-09-11 13:26:36 +08004644
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004645 if (nota == NULL) {
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004646 if (ns->prefix != NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004647 xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004648 "Value \"%s\" for attribute xmlns:%s of %s is not a declared Notation\n",
4649 value, ns->prefix, elem->name);
4650 } else {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004651 xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004652 "Value \"%s\" for attribute xmlns of %s is not a declared Notation\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004653 value, elem->name, NULL);
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004654 }
4655 ret = 0;
4656 }
4657
4658 /* Second, verify that it's among the list */
4659 while (tree != NULL) {
4660 if (xmlStrEqual(tree->name, value)) break;
4661 tree = tree->next;
4662 }
4663 if (tree == NULL) {
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004664 if (ns->prefix != NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004665 xmlErrValidNode(ctxt, elem, XML_DTD_NOTATION_VALUE,
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004666"Value \"%s\" for attribute xmlns:%s of %s is not among the enumerated notations\n",
4667 value, ns->prefix, elem->name);
4668 } else {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004669 xmlErrValidNode(ctxt, elem, XML_DTD_NOTATION_VALUE,
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004670"Value \"%s\" for attribute xmlns of %s is not among the enumerated notations\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004671 value, elem->name, NULL);
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004672 }
4673 ret = 0;
4674 }
4675 }
4676
4677 /* Validity Constraint: Enumeration */
4678 if (attrDecl->atype == XML_ATTRIBUTE_ENUMERATION) {
4679 xmlEnumerationPtr tree = attrDecl->tree;
4680 while (tree != NULL) {
4681 if (xmlStrEqual(tree->name, value)) break;
4682 tree = tree->next;
4683 }
4684 if (tree == NULL) {
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004685 if (ns->prefix != NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004686 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004687"Value \"%s\" for attribute xmlns:%s of %s is not among the enumerated set\n",
4688 value, ns->prefix, elem->name);
4689 } else {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004690 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004691"Value \"%s\" for attribute xmlns of %s is not among the enumerated set\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004692 value, elem->name, NULL);
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004693 }
4694 ret = 0;
4695 }
4696 }
4697
4698 /* Fixed Attribute Default */
4699 if ((attrDecl->def == XML_ATTRIBUTE_FIXED) &&
4700 (!xmlStrEqual(attrDecl->defaultValue, value))) {
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004701 if (ns->prefix != NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004702 xmlErrValidNode(ctxt, elem, XML_DTD_ELEM_NAMESPACE,
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004703 "Value for attribute xmlns:%s of %s must be \"%s\"\n",
4704 ns->prefix, elem->name, attrDecl->defaultValue);
4705 } else {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004706 xmlErrValidNode(ctxt, elem, XML_DTD_ELEM_NAMESPACE,
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004707 "Value for attribute xmlns of %s must be \"%s\"\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00004708 elem->name, attrDecl->defaultValue, NULL);
Daniel Veillard90d68fb2002-09-26 16:10:21 +00004709 }
4710 ret = 0;
4711 }
4712
4713 /* Extra check for the attribute value */
4714 if (ns->prefix != NULL) {
4715 ret &= xmlValidateAttributeValue2(ctxt, doc, ns->prefix,
4716 attrDecl->atype, value);
4717 } else {
4718 ret &= xmlValidateAttributeValue2(ctxt, doc, BAD_CAST "xmlns",
4719 attrDecl->atype, value);
4720 }
4721
4722 return(ret);
4723}
4724
Daniel Veillard118aed72002-09-24 14:13:13 +00004725#ifndef LIBXML_REGEXP_ENABLED
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004726/**
4727 * xmlValidateSkipIgnorable:
4728 * @ctxt: the validation context
4729 * @child: the child list
4730 *
4731 * Skip ignorable elements w.r.t. the validation process
4732 *
4733 * returns the first element to consider for validation of the content model
4734 */
4735
4736static xmlNodePtr
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00004737xmlValidateSkipIgnorable(xmlNodePtr child) {
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004738 while (child != NULL) {
4739 switch (child->type) {
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004740 /* These things are ignored (skipped) during validation. */
4741 case XML_PI_NODE:
4742 case XML_COMMENT_NODE:
4743 case XML_XINCLUDE_START:
4744 case XML_XINCLUDE_END:
4745 child = child->next;
4746 break;
4747 case XML_TEXT_NODE:
4748 if (xmlIsBlankNode(child))
4749 child = child->next;
4750 else
4751 return(child);
4752 break;
4753 /* keep current node */
4754 default:
4755 return(child);
4756 }
4757 }
4758 return(child);
4759}
4760
4761/**
4762 * xmlValidateElementType:
4763 * @ctxt: the validation context
4764 *
4765 * Try to validate the content model of an element internal function
4766 *
Daniel Veillard4de4d3b2001-05-07 20:50:47 +00004767 * returns 1 if valid or 0 ,-1 in case of error, -2 if an entity
4768 * reference is found and -3 if the validation succeeded but
4769 * the content model is not determinist.
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004770 */
4771
4772static int
4773xmlValidateElementType(xmlValidCtxtPtr ctxt) {
Daniel Veillardb4545fd2001-11-20 09:37:09 +00004774 int ret = -1;
Daniel Veillard4de4d3b2001-05-07 20:50:47 +00004775 int determinist = 1;
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004776
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00004777 NODE = xmlValidateSkipIgnorable(NODE);
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004778 if ((NODE == NULL) && (CONT == NULL))
4779 return(1);
Daniel Veillardf8e3db02012-09-11 13:26:36 +08004780 if ((NODE == NULL) &&
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004781 ((CONT->ocur == XML_ELEMENT_CONTENT_MULT) ||
4782 (CONT->ocur == XML_ELEMENT_CONTENT_OPT))) {
4783 return(1);
4784 }
4785 if (CONT == NULL) return(-1);
Daniel Veillard7533cc82001-04-24 15:52:00 +00004786 if ((NODE != NULL) && (NODE->type == XML_ENTITY_REF_NODE))
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00004787 return(-2);
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004788
4789 /*
4790 * We arrive here when more states need to be examined
4791 */
4792cont:
4793
4794 /*
4795 * We just recovered from a rollback generated by a possible
4796 * epsilon transition, go directly to the analysis phase
4797 */
4798 if (STATE == ROLLBACK_PARENT) {
Daniel Veillardcbaf3992001-12-31 16:16:02 +00004799 DEBUG_VALID_MSG("restored parent branch");
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004800 DEBUG_VALID_STATE(NODE, CONT)
4801 ret = 1;
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004802 goto analyze;
4803 }
4804
4805 DEBUG_VALID_STATE(NODE, CONT)
4806 /*
4807 * we may have to save a backup state here. This is the equivalent
4808 * of handling epsilon transition in NFAs.
4809 */
Daniel Veillarde62d36c2001-05-15 08:53:16 +00004810 if ((CONT != NULL) &&
Daniel Veillardce2c2f02001-10-18 14:57:24 +00004811 ((CONT->parent == NULL) ||
4812 (CONT->parent->type != XML_ELEMENT_CONTENT_OR)) &&
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004813 ((CONT->ocur == XML_ELEMENT_CONTENT_MULT) ||
Daniel Veillardca1f1722001-04-20 15:47:35 +00004814 (CONT->ocur == XML_ELEMENT_CONTENT_OPT) ||
Daniel Veillard5344c602001-12-31 16:37:34 +00004815 ((CONT->ocur == XML_ELEMENT_CONTENT_PLUS) && (OCCURRENCE)))) {
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004816 DEBUG_VALID_MSG("saving parent branch");
Daniel Veillard940492d2002-04-15 10:15:25 +00004817 if (vstateVPush(ctxt, CONT, NODE, DEPTH, OCCURS, ROLLBACK_PARENT) < 0)
4818 return(0);
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004819 }
4820
4821
4822 /*
4823 * Check first if the content matches
4824 */
4825 switch (CONT->type) {
4826 case XML_ELEMENT_CONTENT_PCDATA:
4827 if (NODE == NULL) {
4828 DEBUG_VALID_MSG("pcdata failed no node");
4829 ret = 0;
4830 break;
4831 }
4832 if (NODE->type == XML_TEXT_NODE) {
4833 DEBUG_VALID_MSG("pcdata found, skip to next");
4834 /*
4835 * go to next element in the content model
4836 * skipping ignorable elems
4837 */
4838 do {
4839 NODE = NODE->next;
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00004840 NODE = xmlValidateSkipIgnorable(NODE);
4841 if ((NODE != NULL) &&
4842 (NODE->type == XML_ENTITY_REF_NODE))
4843 return(-2);
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004844 } while ((NODE != NULL) &&
4845 ((NODE->type != XML_ELEMENT_NODE) &&
Daniel Veillardd6dc4cb2002-02-19 14:18:08 +00004846 (NODE->type != XML_TEXT_NODE) &&
4847 (NODE->type != XML_CDATA_SECTION_NODE)));
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004848 ret = 1;
4849 break;
4850 } else {
4851 DEBUG_VALID_MSG("pcdata failed");
4852 ret = 0;
4853 break;
4854 }
4855 break;
4856 case XML_ELEMENT_CONTENT_ELEMENT:
4857 if (NODE == NULL) {
4858 DEBUG_VALID_MSG("element failed no node");
4859 ret = 0;
4860 break;
4861 }
Daniel Veillard8bdd2202001-06-11 12:47:59 +00004862 ret = ((NODE->type == XML_ELEMENT_NODE) &&
4863 (xmlStrEqual(NODE->name, CONT->name)));
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004864 if (ret == 1) {
Daniel Veillardbe480fb2001-11-08 23:36:42 +00004865 if ((NODE->ns == NULL) || (NODE->ns->prefix == NULL)) {
4866 ret = (CONT->prefix == NULL);
4867 } else if (CONT->prefix == NULL) {
4868 ret = 0;
4869 } else {
4870 ret = xmlStrEqual(NODE->ns->prefix, CONT->prefix);
4871 }
4872 }
4873 if (ret == 1) {
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004874 DEBUG_VALID_MSG("element found, skip to next");
4875 /*
4876 * go to next element in the content model
4877 * skipping ignorable elems
4878 */
4879 do {
4880 NODE = NODE->next;
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00004881 NODE = xmlValidateSkipIgnorable(NODE);
4882 if ((NODE != NULL) &&
4883 (NODE->type == XML_ENTITY_REF_NODE))
4884 return(-2);
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004885 } while ((NODE != NULL) &&
4886 ((NODE->type != XML_ELEMENT_NODE) &&
Daniel Veillardd6dc4cb2002-02-19 14:18:08 +00004887 (NODE->type != XML_TEXT_NODE) &&
4888 (NODE->type != XML_CDATA_SECTION_NODE)));
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004889 } else {
4890 DEBUG_VALID_MSG("element failed");
4891 ret = 0;
4892 break;
4893 }
4894 break;
4895 case XML_ELEMENT_CONTENT_OR:
4896 /*
Daniel Veillard85349052001-04-20 13:48:21 +00004897 * Small optimization.
4898 */
4899 if (CONT->c1->type == XML_ELEMENT_CONTENT_ELEMENT) {
4900 if ((NODE == NULL) ||
4901 (!xmlStrEqual(NODE->name, CONT->c1->name))) {
4902 DEPTH++;
4903 CONT = CONT->c2;
4904 goto cont;
4905 }
Daniel Veillardbe480fb2001-11-08 23:36:42 +00004906 if ((NODE->ns == NULL) || (NODE->ns->prefix == NULL)) {
4907 ret = (CONT->c1->prefix == NULL);
4908 } else if (CONT->c1->prefix == NULL) {
4909 ret = 0;
4910 } else {
4911 ret = xmlStrEqual(NODE->ns->prefix, CONT->c1->prefix);
4912 }
4913 if (ret == 0) {
4914 DEPTH++;
4915 CONT = CONT->c2;
4916 goto cont;
4917 }
Daniel Veillard85349052001-04-20 13:48:21 +00004918 }
4919
4920 /*
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004921 * save the second branch 'or' branch
4922 */
4923 DEBUG_VALID_MSG("saving 'or' branch");
Daniel Veillard940492d2002-04-15 10:15:25 +00004924 if (vstateVPush(ctxt, CONT->c2, NODE, (unsigned char)(DEPTH + 1),
4925 OCCURS, ROLLBACK_OR) < 0)
4926 return(-1);
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004927 DEPTH++;
4928 CONT = CONT->c1;
4929 goto cont;
4930 case XML_ELEMENT_CONTENT_SEQ:
Daniel Veillard1d047672001-06-09 16:41:01 +00004931 /*
4932 * Small optimization.
4933 */
4934 if ((CONT->c1->type == XML_ELEMENT_CONTENT_ELEMENT) &&
4935 ((CONT->c1->ocur == XML_ELEMENT_CONTENT_OPT) ||
4936 (CONT->c1->ocur == XML_ELEMENT_CONTENT_MULT))) {
4937 if ((NODE == NULL) ||
4938 (!xmlStrEqual(NODE->name, CONT->c1->name))) {
4939 DEPTH++;
4940 CONT = CONT->c2;
4941 goto cont;
4942 }
Daniel Veillardbe480fb2001-11-08 23:36:42 +00004943 if ((NODE->ns == NULL) || (NODE->ns->prefix == NULL)) {
4944 ret = (CONT->c1->prefix == NULL);
4945 } else if (CONT->c1->prefix == NULL) {
4946 ret = 0;
4947 } else {
4948 ret = xmlStrEqual(NODE->ns->prefix, CONT->c1->prefix);
4949 }
4950 if (ret == 0) {
4951 DEPTH++;
4952 CONT = CONT->c2;
4953 goto cont;
4954 }
Daniel Veillard1d047672001-06-09 16:41:01 +00004955 }
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004956 DEPTH++;
4957 CONT = CONT->c1;
4958 goto cont;
4959 }
4960
4961 /*
4962 * At this point handle going up in the tree
4963 */
4964 if (ret == -1) {
4965 DEBUG_VALID_MSG("error found returning");
4966 return(ret);
4967 }
4968analyze:
4969 while (CONT != NULL) {
4970 /*
Daniel Veillardcbaf3992001-12-31 16:16:02 +00004971 * First do the analysis depending on the occurrence model at
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004972 * this level.
4973 */
4974 if (ret == 0) {
4975 switch (CONT->ocur) {
Daniel Veillard4de4d3b2001-05-07 20:50:47 +00004976 xmlNodePtr cur;
4977
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004978 case XML_ELEMENT_CONTENT_ONCE:
Daniel Veillard4de4d3b2001-05-07 20:50:47 +00004979 cur = ctxt->vstate->node;
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004980 DEBUG_VALID_MSG("Once branch failed, rollback");
4981 if (vstateVPop(ctxt) < 0 ) {
4982 DEBUG_VALID_MSG("exhaustion, failed");
4983 return(0);
4984 }
Daniel Veillard4de4d3b2001-05-07 20:50:47 +00004985 if (cur != ctxt->vstate->node)
4986 determinist = -3;
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004987 goto cont;
4988 case XML_ELEMENT_CONTENT_PLUS:
Daniel Veillard5344c602001-12-31 16:37:34 +00004989 if (OCCURRENCE == 0) {
Daniel Veillard4de4d3b2001-05-07 20:50:47 +00004990 cur = ctxt->vstate->node;
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004991 DEBUG_VALID_MSG("Plus branch failed, rollback");
4992 if (vstateVPop(ctxt) < 0 ) {
4993 DEBUG_VALID_MSG("exhaustion, failed");
4994 return(0);
4995 }
Daniel Veillard4de4d3b2001-05-07 20:50:47 +00004996 if (cur != ctxt->vstate->node)
4997 determinist = -3;
Daniel Veillarddab4cb32001-04-20 13:03:48 +00004998 goto cont;
4999 }
5000 DEBUG_VALID_MSG("Plus branch found");
5001 ret = 1;
5002 break;
5003 case XML_ELEMENT_CONTENT_MULT:
5004#ifdef DEBUG_VALID_ALGO
Daniel Veillard5344c602001-12-31 16:37:34 +00005005 if (OCCURRENCE == 0) {
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005006 DEBUG_VALID_MSG("Mult branch failed");
5007 } else {
5008 DEBUG_VALID_MSG("Mult branch found");
5009 }
5010#endif
5011 ret = 1;
5012 break;
5013 case XML_ELEMENT_CONTENT_OPT:
5014 DEBUG_VALID_MSG("Option branch failed");
5015 ret = 1;
5016 break;
5017 }
5018 } else {
5019 switch (CONT->ocur) {
5020 case XML_ELEMENT_CONTENT_OPT:
5021 DEBUG_VALID_MSG("Option branch succeeded");
5022 ret = 1;
5023 break;
5024 case XML_ELEMENT_CONTENT_ONCE:
5025 DEBUG_VALID_MSG("Once branch succeeded");
5026 ret = 1;
5027 break;
5028 case XML_ELEMENT_CONTENT_PLUS:
5029 if (STATE == ROLLBACK_PARENT) {
5030 DEBUG_VALID_MSG("Plus branch rollback");
5031 ret = 1;
5032 break;
5033 }
5034 if (NODE == NULL) {
5035 DEBUG_VALID_MSG("Plus branch exhausted");
5036 ret = 1;
5037 break;
5038 }
5039 DEBUG_VALID_MSG("Plus branch succeeded, continuing");
Daniel Veillard5344c602001-12-31 16:37:34 +00005040 SET_OCCURRENCE;
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005041 goto cont;
5042 case XML_ELEMENT_CONTENT_MULT:
5043 if (STATE == ROLLBACK_PARENT) {
5044 DEBUG_VALID_MSG("Mult branch rollback");
5045 ret = 1;
5046 break;
5047 }
5048 if (NODE == NULL) {
5049 DEBUG_VALID_MSG("Mult branch exhausted");
5050 ret = 1;
5051 break;
5052 }
5053 DEBUG_VALID_MSG("Mult branch succeeded, continuing");
Daniel Veillard5344c602001-12-31 16:37:34 +00005054 /* SET_OCCURRENCE; */
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005055 goto cont;
5056 }
5057 }
5058 STATE = 0;
5059
5060 /*
5061 * Then act accordingly at the parent level
5062 */
Daniel Veillard5344c602001-12-31 16:37:34 +00005063 RESET_OCCURRENCE;
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005064 if (CONT->parent == NULL)
5065 break;
5066
5067 switch (CONT->parent->type) {
5068 case XML_ELEMENT_CONTENT_PCDATA:
5069 DEBUG_VALID_MSG("Error: parent pcdata");
5070 return(-1);
5071 case XML_ELEMENT_CONTENT_ELEMENT:
5072 DEBUG_VALID_MSG("Error: parent element");
5073 return(-1);
5074 case XML_ELEMENT_CONTENT_OR:
5075 if (ret == 1) {
5076 DEBUG_VALID_MSG("Or succeeded");
5077 CONT = CONT->parent;
5078 DEPTH--;
5079 } else {
5080 DEBUG_VALID_MSG("Or failed");
5081 CONT = CONT->parent;
5082 DEPTH--;
5083 }
5084 break;
5085 case XML_ELEMENT_CONTENT_SEQ:
5086 if (ret == 0) {
5087 DEBUG_VALID_MSG("Sequence failed");
5088 CONT = CONT->parent;
5089 DEPTH--;
5090 } else if (CONT == CONT->parent->c1) {
5091 DEBUG_VALID_MSG("Sequence testing 2nd branch");
5092 CONT = CONT->parent->c2;
5093 goto cont;
5094 } else {
5095 DEBUG_VALID_MSG("Sequence succeeded");
5096 CONT = CONT->parent;
5097 DEPTH--;
5098 }
5099 }
5100 }
5101 if (NODE != NULL) {
Daniel Veillard4de4d3b2001-05-07 20:50:47 +00005102 xmlNodePtr cur;
5103
5104 cur = ctxt->vstate->node;
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005105 DEBUG_VALID_MSG("Failed, remaining input, rollback");
5106 if (vstateVPop(ctxt) < 0 ) {
5107 DEBUG_VALID_MSG("exhaustion, failed");
5108 return(0);
5109 }
Daniel Veillard4de4d3b2001-05-07 20:50:47 +00005110 if (cur != ctxt->vstate->node)
5111 determinist = -3;
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005112 goto cont;
5113 }
5114 if (ret == 0) {
Daniel Veillard4de4d3b2001-05-07 20:50:47 +00005115 xmlNodePtr cur;
5116
5117 cur = ctxt->vstate->node;
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005118 DEBUG_VALID_MSG("Failure, rollback");
5119 if (vstateVPop(ctxt) < 0 ) {
5120 DEBUG_VALID_MSG("exhaustion, failed");
5121 return(0);
5122 }
Daniel Veillard4de4d3b2001-05-07 20:50:47 +00005123 if (cur != ctxt->vstate->node)
5124 determinist = -3;
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005125 goto cont;
5126 }
Daniel Veillard4de4d3b2001-05-07 20:50:47 +00005127 return(determinist);
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005128}
Daniel Veillard23e73572002-09-19 19:56:43 +00005129#endif
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005130
5131/**
Daniel Veillardd3d06722001-08-15 12:06:36 +00005132 * xmlSnprintfElements:
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005133 * @buf: an output buffer
Daniel Veillardd3d06722001-08-15 12:06:36 +00005134 * @size: the size of the buffer
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005135 * @content: An element
5136 * @glob: 1 if one must print the englobing parenthesis, 0 otherwise
5137 *
5138 * This will dump the list of elements to the buffer
5139 * Intended just for the debug routine
5140 */
5141static void
Daniel Veillardd3d06722001-08-15 12:06:36 +00005142xmlSnprintfElements(char *buf, int size, xmlNodePtr node, int glob) {
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005143 xmlNodePtr cur;
Daniel Veillardd3d06722001-08-15 12:06:36 +00005144 int len;
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005145
5146 if (node == NULL) return;
5147 if (glob) strcat(buf, "(");
5148 cur = node;
5149 while (cur != NULL) {
Daniel Veillardd3d06722001-08-15 12:06:36 +00005150 len = strlen(buf);
5151 if (size - len < 50) {
5152 if ((size - len > 4) && (buf[len - 1] != '.'))
5153 strcat(buf, " ...");
5154 return;
5155 }
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005156 switch (cur->type) {
5157 case XML_ELEMENT_NODE:
Daniel Veillardbe480fb2001-11-08 23:36:42 +00005158 if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
Daniel Veillard4b3a84f2002-03-19 14:36:46 +00005159 if (size - len < xmlStrlen(cur->ns->prefix) + 10) {
Daniel Veillardbe480fb2001-11-08 23:36:42 +00005160 if ((size - len > 4) && (buf[len - 1] != '.'))
5161 strcat(buf, " ...");
5162 return;
5163 }
5164 strcat(buf, (char *) cur->ns->prefix);
5165 strcat(buf, ":");
5166 }
Daniel Veillard4b3a84f2002-03-19 14:36:46 +00005167 if (size - len < xmlStrlen(cur->name) + 10) {
Daniel Veillardd3d06722001-08-15 12:06:36 +00005168 if ((size - len > 4) && (buf[len - 1] != '.'))
5169 strcat(buf, " ...");
5170 return;
5171 }
5172 strcat(buf, (char *) cur->name);
5173 if (cur->next != NULL)
5174 strcat(buf, " ");
5175 break;
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005176 case XML_TEXT_NODE:
Daniel Veillardd3d06722001-08-15 12:06:36 +00005177 if (xmlIsBlankNode(cur))
5178 break;
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005179 case XML_CDATA_SECTION_NODE:
5180 case XML_ENTITY_REF_NODE:
Daniel Veillardd3d06722001-08-15 12:06:36 +00005181 strcat(buf, "CDATA");
5182 if (cur->next != NULL)
5183 strcat(buf, " ");
5184 break;
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005185 case XML_ATTRIBUTE_NODE:
5186 case XML_DOCUMENT_NODE:
Daniel Veillardeae522a2001-04-23 13:41:34 +00005187#ifdef LIBXML_DOCB_ENABLED
5188 case XML_DOCB_DOCUMENT_NODE:
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005189#endif
5190 case XML_HTML_DOCUMENT_NODE:
5191 case XML_DOCUMENT_TYPE_NODE:
5192 case XML_DOCUMENT_FRAG_NODE:
5193 case XML_NOTATION_NODE:
5194 case XML_NAMESPACE_DECL:
Daniel Veillardd3d06722001-08-15 12:06:36 +00005195 strcat(buf, "???");
5196 if (cur->next != NULL)
5197 strcat(buf, " ");
5198 break;
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005199 case XML_ENTITY_NODE:
5200 case XML_PI_NODE:
5201 case XML_DTD_NODE:
5202 case XML_COMMENT_NODE:
5203 case XML_ELEMENT_DECL:
5204 case XML_ATTRIBUTE_DECL:
5205 case XML_ENTITY_DECL:
5206 case XML_XINCLUDE_START:
5207 case XML_XINCLUDE_END:
Daniel Veillardd3d06722001-08-15 12:06:36 +00005208 break;
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005209 }
5210 cur = cur->next;
5211 }
5212 if (glob) strcat(buf, ")");
5213}
5214
5215/**
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005216 * xmlValidateElementContent:
5217 * @ctxt: the validation context
5218 * @child: the child list
Daniel Veillardbe480fb2001-11-08 23:36:42 +00005219 * @elemDecl: pointer to the element declaration
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005220 * @warn: emit the error message
Daniel Veillardb9cd8b42002-09-05 10:58:49 +00005221 * @parent: the parent element (for error reporting)
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005222 *
5223 * Try to validate the content model of an element
5224 *
5225 * returns 1 if valid or 0 if not and -1 in case of error
5226 */
5227
5228static int
5229xmlValidateElementContent(xmlValidCtxtPtr ctxt, xmlNodePtr child,
Daniel Veillardb9cd8b42002-09-05 10:58:49 +00005230 xmlElementPtr elemDecl, int warn, xmlNodePtr parent) {
Daniel Veillard5acfd6b2002-09-18 16:29:02 +00005231 int ret = 1;
Daniel Veillard23e73572002-09-19 19:56:43 +00005232#ifndef LIBXML_REGEXP_ENABLED
Daniel Veillard01992e02002-10-09 10:20:30 +00005233 xmlNodePtr repl = NULL, last = NULL, tmp;
Daniel Veillard23e73572002-09-19 19:56:43 +00005234#endif
Daniel Veillard01992e02002-10-09 10:20:30 +00005235 xmlNodePtr cur;
Daniel Veillardbe480fb2001-11-08 23:36:42 +00005236 xmlElementContentPtr cont;
5237 const xmlChar *name;
5238
Daniel Veillard3e62adb2012-08-09 14:24:02 +08005239 if ((elemDecl == NULL) || (parent == NULL))
Daniel Veillardbe480fb2001-11-08 23:36:42 +00005240 return(-1);
5241 cont = elemDecl->content;
5242 name = elemDecl->name;
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005243
Daniel Veillarda646cfd2002-09-17 21:50:03 +00005244#ifdef LIBXML_REGEXP_ENABLED
5245 /* Build the regexp associated to the content model */
5246 if (elemDecl->contModel == NULL)
5247 ret = xmlValidBuildContentModel(ctxt, elemDecl);
5248 if (elemDecl->contModel == NULL) {
Daniel Veillarda76fe5c2003-04-24 16:06:47 +00005249 return(-1);
Daniel Veillarda646cfd2002-09-17 21:50:03 +00005250 } else {
5251 xmlRegExecCtxtPtr exec;
5252
Daniel Veillardec498e12003-02-05 11:01:50 +00005253 if (!xmlRegexpIsDeterminist(elemDecl->contModel)) {
5254 return(-1);
5255 }
Daniel Veillard01992e02002-10-09 10:20:30 +00005256 ctxt->nodeMax = 0;
5257 ctxt->nodeNr = 0;
5258 ctxt->nodeTab = NULL;
Daniel Veillarda646cfd2002-09-17 21:50:03 +00005259 exec = xmlRegNewExecCtxt(elemDecl->contModel, NULL, NULL);
5260 if (exec != NULL) {
5261 cur = child;
5262 while (cur != NULL) {
5263 switch (cur->type) {
5264 case XML_ENTITY_REF_NODE:
5265 /*
5266 * Push the current node to be able to roll back
5267 * and process within the entity
5268 */
5269 if ((cur->children != NULL) &&
5270 (cur->children->children != NULL)) {
5271 nodeVPush(ctxt, cur);
5272 cur = cur->children->children;
5273 continue;
5274 }
5275 break;
5276 case XML_TEXT_NODE:
5277 if (xmlIsBlankNode(cur))
5278 break;
5279 ret = 0;
5280 goto fail;
5281 case XML_CDATA_SECTION_NODE:
Daniel Veillardea7751d2002-12-20 00:16:24 +00005282 /* TODO */
Daniel Veillarda646cfd2002-09-17 21:50:03 +00005283 ret = 0;
5284 goto fail;
5285 case XML_ELEMENT_NODE:
5286 if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
Daniel Veillardc00cda82003-04-07 10:22:39 +00005287 xmlChar fn[50];
5288 xmlChar *fullname;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08005289
Daniel Veillardc00cda82003-04-07 10:22:39 +00005290 fullname = xmlBuildQName(cur->name,
5291 cur->ns->prefix, fn, 50);
5292 if (fullname == NULL) {
Daniel Veillarda646cfd2002-09-17 21:50:03 +00005293 ret = -1;
5294 goto fail;
5295 }
Daniel Veillardc00cda82003-04-07 10:22:39 +00005296 ret = xmlRegExecPushString(exec, fullname, NULL);
5297 if ((fullname != fn) && (fullname != cur->name))
5298 xmlFree(fullname);
Daniel Veillarda646cfd2002-09-17 21:50:03 +00005299 } else {
5300 ret = xmlRegExecPushString(exec, cur->name, NULL);
5301 }
5302 break;
5303 default:
5304 break;
5305 }
5306 /*
5307 * Switch to next element
5308 */
5309 cur = cur->next;
5310 while (cur == NULL) {
5311 cur = nodeVPop(ctxt);
5312 if (cur == NULL)
5313 break;
5314 cur = cur->next;
5315 }
5316 }
5317 ret = xmlRegExecPushString(exec, NULL, NULL);
5318fail:
5319 xmlRegFreeExecCtxt(exec);
5320 }
5321 }
5322#else /* LIBXML_REGEXP_ENABLED */
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005323 /*
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00005324 * Allocate the stack
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005325 */
5326 ctxt->vstateMax = 8;
5327 ctxt->vstateTab = (xmlValidState *) xmlMalloc(
5328 ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
5329 if (ctxt->vstateTab == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00005330 xmlVErrMemory(ctxt, "malloc failed");
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00005331 return(-1);
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005332 }
5333 /*
5334 * The first entry in the stack is reserved to the current state
5335 */
Daniel Veillarda9142e72001-06-19 11:07:54 +00005336 ctxt->nodeMax = 0;
5337 ctxt->nodeNr = 0;
Daniel Veillard61b33d52001-04-24 13:55:12 +00005338 ctxt->nodeTab = NULL;
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005339 ctxt->vstate = &ctxt->vstateTab[0];
5340 ctxt->vstateNr = 1;
5341 CONT = cont;
5342 NODE = child;
5343 DEPTH = 0;
5344 OCCURS = 0;
5345 STATE = 0;
5346 ret = xmlValidateElementType(ctxt);
Daniel Veillard4de4d3b2001-05-07 20:50:47 +00005347 if ((ret == -3) && (warn)) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005348 xmlErrValidWarning(ctxt, child, XML_DTD_CONTENT_NOT_DETERMINIST,
5349 "Content model for Element %s is ambiguous\n",
Daniel Veillard0cc72772003-10-13 14:00:21 +00005350 name, NULL, NULL);
Daniel Veillard4de4d3b2001-05-07 20:50:47 +00005351 } else if (ret == -2) {
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00005352 /*
5353 * An entities reference appeared at this level.
5354 * Buid a minimal representation of this node content
5355 * sufficient to run the validation process on it
5356 */
5357 DEBUG_VALID_MSG("Found an entity reference, linearizing");
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005358 cur = child;
5359 while (cur != NULL) {
5360 switch (cur->type) {
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00005361 case XML_ENTITY_REF_NODE:
5362 /*
5363 * Push the current node to be able to roll back
5364 * and process within the entity
5365 */
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005366 if ((cur->children != NULL) &&
5367 (cur->children->children != NULL)) {
5368 nodeVPush(ctxt, cur);
5369 cur = cur->children->children;
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00005370 continue;
5371 }
Daniel Veillard64b98c02001-06-17 17:20:21 +00005372 break;
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00005373 case XML_TEXT_NODE:
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005374 if (xmlIsBlankNode(cur))
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00005375 break;
Daniel Veillard04e2dae2001-07-09 20:07:25 +00005376 /* no break on purpose */
Daniel Veillardd6dc4cb2002-02-19 14:18:08 +00005377 case XML_CDATA_SECTION_NODE:
5378 /* no break on purpose */
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00005379 case XML_ELEMENT_NODE:
5380 /*
5381 * Allocate a new node and minimally fills in
5382 * what's required
5383 */
5384 tmp = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
5385 if (tmp == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00005386 xmlVErrMemory(ctxt, "malloc failed");
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00005387 xmlFreeNodeList(repl);
5388 ret = -1;
5389 goto done;
5390 }
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005391 tmp->type = cur->type;
5392 tmp->name = cur->name;
5393 tmp->ns = cur->ns;
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00005394 tmp->next = NULL;
Daniel Veillarded472f32001-12-13 08:48:14 +00005395 tmp->content = NULL;
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00005396 if (repl == NULL)
5397 repl = last = tmp;
5398 else {
5399 last->next = tmp;
5400 last = tmp;
5401 }
Daniel Veillardd6dc4cb2002-02-19 14:18:08 +00005402 if (cur->type == XML_CDATA_SECTION_NODE) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +08005403 /*
Daniel Veillardd6dc4cb2002-02-19 14:18:08 +00005404 * E59 spaces in CDATA does not match the
5405 * nonterminal S
5406 */
5407 tmp->content = xmlStrdup(BAD_CAST "CDATA");
5408 }
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00005409 break;
5410 default:
5411 break;
5412 }
5413 /*
5414 * Switch to next element
5415 */
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005416 cur = cur->next;
5417 while (cur == NULL) {
5418 cur = nodeVPop(ctxt);
5419 if (cur == NULL)
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00005420 break;
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005421 cur = cur->next;
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00005422 }
5423 }
5424
5425 /*
5426 * Relaunch the validation
5427 */
5428 ctxt->vstate = &ctxt->vstateTab[0];
5429 ctxt->vstateNr = 1;
5430 CONT = cont;
5431 NODE = repl;
5432 DEPTH = 0;
5433 OCCURS = 0;
5434 STATE = 0;
5435 ret = xmlValidateElementType(ctxt);
5436 }
Daniel Veillarda646cfd2002-09-17 21:50:03 +00005437#endif /* LIBXML_REGEXP_ENABLED */
Daniel Veillard4de4d3b2001-05-07 20:50:47 +00005438 if ((warn) && ((ret != 1) && (ret != -3))) {
Daniel Veillard6ad5c4a2006-10-11 16:43:06 +00005439 if (ctxt != NULL) {
Daniel Veillardb4545fd2001-11-20 09:37:09 +00005440 char expr[5000];
5441 char list[5000];
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005442
Daniel Veillardb4545fd2001-11-20 09:37:09 +00005443 expr[0] = 0;
Daniel Veillarda76fe5c2003-04-24 16:06:47 +00005444 xmlSnprintfElementContent(&expr[0], 5000, cont, 1);
Daniel Veillardb4545fd2001-11-20 09:37:09 +00005445 list[0] = 0;
Daniel Veillard01992e02002-10-09 10:20:30 +00005446#ifndef LIBXML_REGEXP_ENABLED
Daniel Veillardb4545fd2001-11-20 09:37:09 +00005447 if (repl != NULL)
Daniel Veillarda76fe5c2003-04-24 16:06:47 +00005448 xmlSnprintfElements(&list[0], 5000, repl, 1);
Daniel Veillardb4545fd2001-11-20 09:37:09 +00005449 else
Daniel Veillard01992e02002-10-09 10:20:30 +00005450#endif /* LIBXML_REGEXP_ENABLED */
Daniel Veillarda76fe5c2003-04-24 16:06:47 +00005451 xmlSnprintfElements(&list[0], 5000, child, 1);
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005452
Daniel Veillardb4545fd2001-11-20 09:37:09 +00005453 if (name != NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005454 xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
5455 "Element %s content does not follow the DTD, expecting %s, got %s\n",
5456 name, BAD_CAST expr, BAD_CAST list);
Daniel Veillardb4545fd2001-11-20 09:37:09 +00005457 } else {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005458 xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
5459 "Element content does not follow the DTD, expecting %s, got %s\n",
5460 BAD_CAST expr, BAD_CAST list, NULL);
Daniel Veillardb4545fd2001-11-20 09:37:09 +00005461 }
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005462 } else {
Daniel Veillardb4545fd2001-11-20 09:37:09 +00005463 if (name != NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005464 xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
Daniel Veillard58e44c92002-08-02 22:19:49 +00005465 "Element %s content does not follow the DTD\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005466 name, NULL, NULL);
Daniel Veillardb4545fd2001-11-20 09:37:09 +00005467 } else {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005468 xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
5469 "Element content does not follow the DTD\n",
5470 NULL, NULL, NULL);
Daniel Veillardb4545fd2001-11-20 09:37:09 +00005471 }
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005472 }
5473 ret = 0;
5474 }
Daniel Veillard4de4d3b2001-05-07 20:50:47 +00005475 if (ret == -3)
5476 ret = 1;
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00005477
Daniel Veillard23e73572002-09-19 19:56:43 +00005478#ifndef LIBXML_REGEXP_ENABLED
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00005479done:
5480 /*
5481 * Deallocate the copy if done, and free up the validation stack
5482 */
5483 while (repl != NULL) {
5484 tmp = repl->next;
5485 xmlFree(repl);
5486 repl = tmp;
5487 }
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005488 ctxt->vstateMax = 0;
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005489 if (ctxt->vstateTab != NULL) {
5490 xmlFree(ctxt->vstateTab);
5491 ctxt->vstateTab = NULL;
5492 }
Daniel Veillard01992e02002-10-09 10:20:30 +00005493#endif
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005494 ctxt->nodeMax = 0;
Daniel Veillarda9142e72001-06-19 11:07:54 +00005495 ctxt->nodeNr = 0;
Daniel Veillard34b1b3a2001-04-21 14:16:10 +00005496 if (ctxt->nodeTab != NULL) {
5497 xmlFree(ctxt->nodeTab);
5498 ctxt->nodeTab = NULL;
5499 }
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005500 return(ret);
Daniel Veillard1c14b8d2001-04-21 10:28:59 +00005501
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005502}
Daniel Veillarddab4cb32001-04-20 13:03:48 +00005503
Owen Taylor3473f882001-02-23 17:55:21 +00005504/**
Daniel Veillard04e2dae2001-07-09 20:07:25 +00005505 * xmlValidateCdataElement:
5506 * @ctxt: the validation context
5507 * @doc: a document instance
5508 * @elem: an element instance
5509 *
5510 * Check that an element follows #CDATA
5511 *
5512 * returns 1 if valid or 0 otherwise
5513 */
5514static int
5515xmlValidateOneCdataElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5516 xmlNodePtr elem) {
5517 int ret = 1;
5518 xmlNodePtr cur, child;
5519
Daniel Veillard3e62adb2012-08-09 14:24:02 +08005520 if ((ctxt == NULL) || (doc == NULL) || (elem == NULL) ||
5521 (elem->type != XML_ELEMENT_NODE))
Daniel Veillard04e2dae2001-07-09 20:07:25 +00005522 return(0);
5523
5524 child = elem->children;
5525
5526 cur = child;
5527 while (cur != NULL) {
5528 switch (cur->type) {
5529 case XML_ENTITY_REF_NODE:
5530 /*
5531 * Push the current node to be able to roll back
5532 * and process within the entity
5533 */
5534 if ((cur->children != NULL) &&
5535 (cur->children->children != NULL)) {
5536 nodeVPush(ctxt, cur);
5537 cur = cur->children->children;
5538 continue;
5539 }
5540 break;
5541 case XML_COMMENT_NODE:
5542 case XML_PI_NODE:
5543 case XML_TEXT_NODE:
5544 case XML_CDATA_SECTION_NODE:
5545 break;
5546 default:
5547 ret = 0;
5548 goto done;
5549 }
5550 /*
5551 * Switch to next element
5552 */
5553 cur = cur->next;
5554 while (cur == NULL) {
5555 cur = nodeVPop(ctxt);
5556 if (cur == NULL)
5557 break;
5558 cur = cur->next;
5559 }
5560 }
5561done:
5562 ctxt->nodeMax = 0;
5563 ctxt->nodeNr = 0;
5564 if (ctxt->nodeTab != NULL) {
5565 xmlFree(ctxt->nodeTab);
5566 ctxt->nodeTab = NULL;
5567 }
5568 return(ret);
5569}
5570
5571/**
Daniel Veillardea7751d2002-12-20 00:16:24 +00005572 * xmlValidateCheckMixed:
5573 * @ctxt: the validation context
5574 * @cont: the mixed content model
5575 * @qname: the qualified name as appearing in the serialization
5576 *
5577 * Check if the given node is part of the content model.
5578 *
5579 * Returns 1 if yes, 0 if no, -1 in case of error
5580 */
5581static int
William M. Brackedb65a72004-02-06 07:36:04 +00005582xmlValidateCheckMixed(xmlValidCtxtPtr ctxt,
Daniel Veillardea7751d2002-12-20 00:16:24 +00005583 xmlElementContentPtr cont, const xmlChar *qname) {
Daniel Veillard8d73bcb2003-08-04 01:06:15 +00005584 const xmlChar *name;
5585 int plen;
5586 name = xmlSplitQName3(qname, &plen);
5587
5588 if (name == NULL) {
5589 while (cont != NULL) {
5590 if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
5591 if ((cont->prefix == NULL) && (xmlStrEqual(cont->name, qname)))
5592 return(1);
5593 } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
5594 (cont->c1 != NULL) &&
5595 (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
5596 if ((cont->c1->prefix == NULL) &&
5597 (xmlStrEqual(cont->c1->name, qname)))
5598 return(1);
5599 } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
5600 (cont->c1 == NULL) ||
5601 (cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
Daniel Veillardf8e3db02012-09-11 13:26:36 +08005602 xmlErrValid(NULL, XML_DTD_MIXED_CORRUPT,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00005603 "Internal: MIXED struct corrupted\n",
5604 NULL);
Daniel Veillard8d73bcb2003-08-04 01:06:15 +00005605 break;
5606 }
5607 cont = cont->c2;
Daniel Veillardea7751d2002-12-20 00:16:24 +00005608 }
Daniel Veillard8d73bcb2003-08-04 01:06:15 +00005609 } else {
5610 while (cont != NULL) {
5611 if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
5612 if ((cont->prefix != NULL) &&
5613 (xmlStrncmp(cont->prefix, qname, plen) == 0) &&
5614 (xmlStrEqual(cont->name, name)))
5615 return(1);
5616 } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
5617 (cont->c1 != NULL) &&
5618 (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
5619 if ((cont->c1->prefix != NULL) &&
5620 (xmlStrncmp(cont->c1->prefix, qname, plen) == 0) &&
5621 (xmlStrEqual(cont->c1->name, name)))
5622 return(1);
5623 } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
5624 (cont->c1 == NULL) ||
5625 (cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
Daniel Veillardf8e3db02012-09-11 13:26:36 +08005626 xmlErrValid(ctxt, XML_DTD_MIXED_CORRUPT,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00005627 "Internal: MIXED struct corrupted\n",
5628 NULL);
Daniel Veillard8d73bcb2003-08-04 01:06:15 +00005629 break;
5630 }
5631 cont = cont->c2;
5632 }
Daniel Veillardea7751d2002-12-20 00:16:24 +00005633 }
5634 return(0);
5635}
5636
5637/**
5638 * xmlValidGetElemDecl:
5639 * @ctxt: the validation context
5640 * @doc: a document instance
5641 * @elem: an element instance
5642 * @extsubset: pointer, (out) indicate if the declaration was found
5643 * in the external subset.
5644 *
5645 * Finds a declaration associated to an element in the document.
5646 *
5647 * returns the pointer to the declaration or NULL if not found.
5648 */
5649static xmlElementPtr
5650xmlValidGetElemDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5651 xmlNodePtr elem, int *extsubset) {
5652 xmlElementPtr elemDecl = NULL;
5653 const xmlChar *prefix = NULL;
5654
Daniel Veillardf8e3db02012-09-11 13:26:36 +08005655 if ((ctxt == NULL) || (doc == NULL) ||
Daniel Veillardc0be74b2004-11-03 19:16:55 +00005656 (elem == NULL) || (elem->name == NULL))
5657 return(NULL);
Daniel Veillardea7751d2002-12-20 00:16:24 +00005658 if (extsubset != NULL)
5659 *extsubset = 0;
5660
5661 /*
5662 * Fetch the declaration for the qualified name
5663 */
5664 if ((elem->ns != NULL) && (elem->ns->prefix != NULL))
5665 prefix = elem->ns->prefix;
5666
5667 if (prefix != NULL) {
5668 elemDecl = xmlGetDtdQElementDesc(doc->intSubset,
5669 elem->name, prefix);
5670 if ((elemDecl == NULL) && (doc->extSubset != NULL)) {
5671 elemDecl = xmlGetDtdQElementDesc(doc->extSubset,
5672 elem->name, prefix);
5673 if ((elemDecl != NULL) && (extsubset != NULL))
5674 *extsubset = 1;
5675 }
5676 }
5677
5678 /*
5679 * Fetch the declaration for the non qualified name
5680 * This is "non-strict" validation should be done on the
5681 * full QName but in that case being flexible makes sense.
5682 */
5683 if (elemDecl == NULL) {
5684 elemDecl = xmlGetDtdElementDesc(doc->intSubset, elem->name);
5685 if ((elemDecl == NULL) && (doc->extSubset != NULL)) {
5686 elemDecl = xmlGetDtdElementDesc(doc->extSubset, elem->name);
5687 if ((elemDecl != NULL) && (extsubset != NULL))
5688 *extsubset = 1;
5689 }
5690 }
5691 if (elemDecl == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005692 xmlErrValidNode(ctxt, elem,
5693 XML_DTD_UNKNOWN_ELEM,
5694 "No declaration for element %s\n",
5695 elem->name, NULL, NULL);
Daniel Veillardea7751d2002-12-20 00:16:24 +00005696 }
5697 return(elemDecl);
5698}
5699
Daniel Veillard0e298ad2003-02-04 16:14:33 +00005700#ifdef LIBXML_REGEXP_ENABLED
Daniel Veillardea7751d2002-12-20 00:16:24 +00005701/**
5702 * xmlValidatePushElement:
5703 * @ctxt: the validation context
5704 * @doc: a document instance
5705 * @elem: an element instance
5706 * @qname: the qualified name as appearing in the serialization
5707 *
5708 * Push a new element start on the validation stack.
5709 *
5710 * returns 1 if no validation problem was found or 0 otherwise
5711 */
5712int
5713xmlValidatePushElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5714 xmlNodePtr elem, const xmlChar *qname) {
5715 int ret = 1;
5716 xmlElementPtr eDecl;
5717 int extsubset = 0;
5718
Daniel Veillardc0be74b2004-11-03 19:16:55 +00005719 if (ctxt == NULL)
5720 return(0);
Daniel Veillardef8dd7b2003-03-23 12:02:56 +00005721/* printf("PushElem %s\n", qname); */
Daniel Veillardea7751d2002-12-20 00:16:24 +00005722 if ((ctxt->vstateNr > 0) && (ctxt->vstate != NULL)) {
5723 xmlValidStatePtr state = ctxt->vstate;
5724 xmlElementPtr elemDecl;
5725
5726 /*
5727 * Check the new element agaisnt the content model of the new elem.
5728 */
5729 if (state->elemDecl != NULL) {
5730 elemDecl = state->elemDecl;
5731
5732 switch(elemDecl->etype) {
5733 case XML_ELEMENT_TYPE_UNDEFINED:
5734 ret = 0;
5735 break;
5736 case XML_ELEMENT_TYPE_EMPTY:
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005737 xmlErrValidNode(ctxt, state->node,
5738 XML_DTD_NOT_EMPTY,
Daniel Veillardea7751d2002-12-20 00:16:24 +00005739 "Element %s was declared EMPTY this one has content\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005740 state->node->name, NULL, NULL);
Daniel Veillardea7751d2002-12-20 00:16:24 +00005741 ret = 0;
5742 break;
5743 case XML_ELEMENT_TYPE_ANY:
5744 /* I don't think anything is required then */
5745 break;
5746 case XML_ELEMENT_TYPE_MIXED:
5747 /* simple case of declared as #PCDATA */
5748 if ((elemDecl->content != NULL) &&
5749 (elemDecl->content->type ==
5750 XML_ELEMENT_CONTENT_PCDATA)) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005751 xmlErrValidNode(ctxt, state->node,
5752 XML_DTD_NOT_PCDATA,
Daniel Veillardea7751d2002-12-20 00:16:24 +00005753 "Element %s was declared #PCDATA but contains non text nodes\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005754 state->node->name, NULL, NULL);
Daniel Veillardea7751d2002-12-20 00:16:24 +00005755 ret = 0;
5756 } else {
5757 ret = xmlValidateCheckMixed(ctxt, elemDecl->content,
5758 qname);
5759 if (ret != 1) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005760 xmlErrValidNode(ctxt, state->node,
5761 XML_DTD_INVALID_CHILD,
Daniel Veillardea7751d2002-12-20 00:16:24 +00005762 "Element %s is not declared in %s list of possible children\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005763 qname, state->node->name, NULL);
Daniel Veillardea7751d2002-12-20 00:16:24 +00005764 }
5765 }
5766 break;
5767 case XML_ELEMENT_TYPE_ELEMENT:
5768 /*
5769 * TODO:
5770 * VC: Standalone Document Declaration
5771 * - element types with element content, if white space
5772 * occurs directly within any instance of those types.
5773 */
5774 if (state->exec != NULL) {
5775 ret = xmlRegExecPushString(state->exec, qname, NULL);
5776 if (ret < 0) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005777 xmlErrValidNode(ctxt, state->node,
5778 XML_DTD_CONTENT_MODEL,
5779 "Element %s content does not follow the DTD, Misplaced %s\n",
5780 state->node->name, qname, NULL);
Daniel Veillardea7751d2002-12-20 00:16:24 +00005781 ret = 0;
5782 } else {
5783 ret = 1;
5784 }
5785 }
5786 break;
5787 }
5788 }
5789 }
5790 eDecl = xmlValidGetElemDecl(ctxt, doc, elem, &extsubset);
5791 vstateVPush(ctxt, eDecl, elem);
5792 return(ret);
5793}
5794
5795/**
5796 * xmlValidatePushCData:
5797 * @ctxt: the validation context
5798 * @data: some character data read
Michael Woodfb27e2c2012-09-28 08:59:33 +02005799 * @len: the length of the data
Daniel Veillardea7751d2002-12-20 00:16:24 +00005800 *
5801 * check the CData parsed for validation in the current stack
5802 *
5803 * returns 1 if no validation problem was found or 0 otherwise
5804 */
5805int
5806xmlValidatePushCData(xmlValidCtxtPtr ctxt, const xmlChar *data, int len) {
5807 int ret = 1;
5808
Daniel Veillardef8dd7b2003-03-23 12:02:56 +00005809/* printf("CDATA %s %d\n", data, len); */
Daniel Veillardc0be74b2004-11-03 19:16:55 +00005810 if (ctxt == NULL)
5811 return(0);
Daniel Veillardea7751d2002-12-20 00:16:24 +00005812 if (len <= 0)
5813 return(ret);
5814 if ((ctxt->vstateNr > 0) && (ctxt->vstate != NULL)) {
5815 xmlValidStatePtr state = ctxt->vstate;
5816 xmlElementPtr elemDecl;
5817
5818 /*
5819 * Check the new element agaisnt the content model of the new elem.
5820 */
5821 if (state->elemDecl != NULL) {
5822 elemDecl = state->elemDecl;
5823
5824 switch(elemDecl->etype) {
5825 case XML_ELEMENT_TYPE_UNDEFINED:
5826 ret = 0;
5827 break;
5828 case XML_ELEMENT_TYPE_EMPTY:
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005829 xmlErrValidNode(ctxt, state->node,
5830 XML_DTD_NOT_EMPTY,
Daniel Veillardea7751d2002-12-20 00:16:24 +00005831 "Element %s was declared EMPTY this one has content\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005832 state->node->name, NULL, NULL);
Daniel Veillardea7751d2002-12-20 00:16:24 +00005833 ret = 0;
5834 break;
5835 case XML_ELEMENT_TYPE_ANY:
5836 break;
5837 case XML_ELEMENT_TYPE_MIXED:
5838 break;
5839 case XML_ELEMENT_TYPE_ELEMENT:
5840 if (len > 0) {
5841 int i;
5842
5843 for (i = 0;i < len;i++) {
William M. Brack76e95df2003-10-18 16:20:14 +00005844 if (!IS_BLANK_CH(data[i])) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005845 xmlErrValidNode(ctxt, state->node,
5846 XML_DTD_CONTENT_MODEL,
5847 "Element %s content does not follow the DTD, Text not allowed\n",
5848 state->node->name, NULL, NULL);
Daniel Veillardea7751d2002-12-20 00:16:24 +00005849 ret = 0;
5850 goto done;
5851 }
5852 }
5853 /*
5854 * TODO:
5855 * VC: Standalone Document Declaration
5856 * element types with element content, if white space
5857 * occurs directly within any instance of those types.
5858 */
5859 }
5860 break;
5861 }
5862 }
5863 }
5864done:
5865 return(ret);
5866}
5867
5868/**
5869 * xmlValidatePopElement:
5870 * @ctxt: the validation context
5871 * @doc: a document instance
5872 * @elem: an element instance
5873 * @qname: the qualified name as appearing in the serialization
5874 *
5875 * Pop the element end from the validation stack.
5876 *
5877 * returns 1 if no validation problem was found or 0 otherwise
5878 */
5879int
5880xmlValidatePopElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc ATTRIBUTE_UNUSED,
Daniel Veillard580ced82003-03-21 21:22:48 +00005881 xmlNodePtr elem ATTRIBUTE_UNUSED,
5882 const xmlChar *qname ATTRIBUTE_UNUSED) {
Daniel Veillardea7751d2002-12-20 00:16:24 +00005883 int ret = 1;
5884
Daniel Veillardc0be74b2004-11-03 19:16:55 +00005885 if (ctxt == NULL)
5886 return(0);
Daniel Veillardef8dd7b2003-03-23 12:02:56 +00005887/* printf("PopElem %s\n", qname); */
Daniel Veillardea7751d2002-12-20 00:16:24 +00005888 if ((ctxt->vstateNr > 0) && (ctxt->vstate != NULL)) {
5889 xmlValidStatePtr state = ctxt->vstate;
5890 xmlElementPtr elemDecl;
5891
5892 /*
5893 * Check the new element agaisnt the content model of the new elem.
5894 */
5895 if (state->elemDecl != NULL) {
5896 elemDecl = state->elemDecl;
5897
5898 if (elemDecl->etype == XML_ELEMENT_TYPE_ELEMENT) {
5899 if (state->exec != NULL) {
5900 ret = xmlRegExecPushString(state->exec, NULL, NULL);
5901 if (ret == 0) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005902 xmlErrValidNode(ctxt, state->node,
5903 XML_DTD_CONTENT_MODEL,
5904 "Element %s content does not follow the DTD, Expecting more child\n",
5905 state->node->name, NULL,NULL);
Daniel Veillardea7751d2002-12-20 00:16:24 +00005906 } else {
5907 /*
5908 * previous validation errors should not generate
5909 * a new one here
5910 */
5911 ret = 1;
5912 }
5913 }
5914 }
5915 }
5916 vstateVPop(ctxt);
5917 }
5918 return(ret);
5919}
Daniel Veillard0e298ad2003-02-04 16:14:33 +00005920#endif /* LIBXML_REGEXP_ENABLED */
Daniel Veillardea7751d2002-12-20 00:16:24 +00005921
5922/**
Owen Taylor3473f882001-02-23 17:55:21 +00005923 * xmlValidateOneElement:
5924 * @ctxt: the validation context
5925 * @doc: a document instance
5926 * @elem: an element instance
5927 *
5928 * Try to validate a single element and it's attributes,
5929 * basically it does the following checks as described by the
5930 * XML-1.0 recommendation:
5931 * - [ VC: Element Valid ]
5932 * - [ VC: Required Attribute ]
5933 * Then call xmlValidateOneAttribute() for each attribute present.
5934 *
5935 * The ID/IDREF checkings are done separately
5936 *
5937 * returns 1 if valid or 0 otherwise
5938 */
5939
5940int
5941xmlValidateOneElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5942 xmlNodePtr elem) {
5943 xmlElementPtr elemDecl = NULL;
5944 xmlElementContentPtr cont;
5945 xmlAttributePtr attr;
5946 xmlNodePtr child;
Daniel Veillard8dc16a62002-02-19 21:08:48 +00005947 int ret = 1, tmp;
Owen Taylor3473f882001-02-23 17:55:21 +00005948 const xmlChar *name;
Daniel Veillard8dc16a62002-02-19 21:08:48 +00005949 int extsubset = 0;
Owen Taylor3473f882001-02-23 17:55:21 +00005950
5951 CHECK_DTD;
5952
5953 if (elem == NULL) return(0);
Owen Taylor3473f882001-02-23 17:55:21 +00005954 switch (elem->type) {
5955 case XML_ATTRIBUTE_NODE:
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005956 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5957 "Attribute element not expected\n", NULL, NULL ,NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00005958 return(0);
5959 case XML_TEXT_NODE:
5960 if (elem->children != NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005961 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5962 "Text element has children !\n",
5963 NULL,NULL,NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00005964 return(0);
5965 }
Owen Taylor3473f882001-02-23 17:55:21 +00005966 if (elem->ns != NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005967 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5968 "Text element has namespace !\n",
5969 NULL,NULL,NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00005970 return(0);
5971 }
Owen Taylor3473f882001-02-23 17:55:21 +00005972 if (elem->content == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005973 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5974 "Text element has no content !\n",
5975 NULL,NULL,NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00005976 return(0);
5977 }
5978 return(1);
5979 case XML_XINCLUDE_START:
5980 case XML_XINCLUDE_END:
5981 return(1);
5982 case XML_CDATA_SECTION_NODE:
5983 case XML_ENTITY_REF_NODE:
5984 case XML_PI_NODE:
5985 case XML_COMMENT_NODE:
5986 return(1);
5987 case XML_ENTITY_NODE:
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005988 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5989 "Entity element not expected\n", NULL, NULL ,NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00005990 return(0);
5991 case XML_NOTATION_NODE:
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005992 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5993 "Notation element not expected\n", NULL, NULL ,NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00005994 return(0);
5995 case XML_DOCUMENT_NODE:
5996 case XML_DOCUMENT_TYPE_NODE:
5997 case XML_DOCUMENT_FRAG_NODE:
Daniel Veillardbb5abab2003-10-03 22:21:51 +00005998 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5999 "Document element not expected\n", NULL, NULL ,NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00006000 return(0);
6001 case XML_HTML_DOCUMENT_NODE:
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006002 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
6003 "HTML Document not expected\n", NULL, NULL ,NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00006004 return(0);
6005 case XML_ELEMENT_NODE:
6006 break;
6007 default:
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006008 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
6009 "unknown element type\n", NULL, NULL ,NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00006010 return(0);
6011 }
Owen Taylor3473f882001-02-23 17:55:21 +00006012
6013 /*
Daniel Veillardea7751d2002-12-20 00:16:24 +00006014 * Fetch the declaration
Owen Taylor3473f882001-02-23 17:55:21 +00006015 */
Daniel Veillardea7751d2002-12-20 00:16:24 +00006016 elemDecl = xmlValidGetElemDecl(ctxt, doc, elem, &extsubset);
6017 if (elemDecl == NULL)
Owen Taylor3473f882001-02-23 17:55:21 +00006018 return(0);
Owen Taylor3473f882001-02-23 17:55:21 +00006019
Daniel Veillardea7751d2002-12-20 00:16:24 +00006020 /*
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006021 * If vstateNr is not zero that means continuous validation is
Daniel Veillardea7751d2002-12-20 00:16:24 +00006022 * activated, do not try to check the content model at that level.
6023 */
6024 if (ctxt->vstateNr == 0) {
Daniel Veillardcbaf3992001-12-31 16:16:02 +00006025 /* Check that the element content matches the definition */
Owen Taylor3473f882001-02-23 17:55:21 +00006026 switch (elemDecl->etype) {
Daniel Veillarda10efa82001-04-18 13:09:01 +00006027 case XML_ELEMENT_TYPE_UNDEFINED:
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006028 xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ELEM,
6029 "No declaration for element %s\n",
6030 elem->name, NULL, NULL);
Daniel Veillarda10efa82001-04-18 13:09:01 +00006031 return(0);
Owen Taylor3473f882001-02-23 17:55:21 +00006032 case XML_ELEMENT_TYPE_EMPTY:
6033 if (elem->children != NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006034 xmlErrValidNode(ctxt, elem, XML_DTD_NOT_EMPTY,
Owen Taylor3473f882001-02-23 17:55:21 +00006035 "Element %s was declared EMPTY this one has content\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006036 elem->name, NULL, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00006037 ret = 0;
6038 }
6039 break;
6040 case XML_ELEMENT_TYPE_ANY:
6041 /* I don't think anything is required then */
6042 break;
6043 case XML_ELEMENT_TYPE_MIXED:
Daniel Veillard8dc16a62002-02-19 21:08:48 +00006044
Daniel Veillard04e2dae2001-07-09 20:07:25 +00006045 /* simple case of declared as #PCDATA */
6046 if ((elemDecl->content != NULL) &&
6047 (elemDecl->content->type == XML_ELEMENT_CONTENT_PCDATA)) {
6048 ret = xmlValidateOneCdataElement(ctxt, doc, elem);
6049 if (!ret) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006050 xmlErrValidNode(ctxt, elem, XML_DTD_NOT_PCDATA,
Daniel Veillard04e2dae2001-07-09 20:07:25 +00006051 "Element %s was declared #PCDATA but contains non text nodes\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006052 elem->name, NULL, NULL);
Daniel Veillard04e2dae2001-07-09 20:07:25 +00006053 }
6054 break;
6055 }
Owen Taylor3473f882001-02-23 17:55:21 +00006056 child = elem->children;
Daniel Veillard04e2dae2001-07-09 20:07:25 +00006057 /* Hum, this start to get messy */
Owen Taylor3473f882001-02-23 17:55:21 +00006058 while (child != NULL) {
6059 if (child->type == XML_ELEMENT_NODE) {
6060 name = child->name;
6061 if ((child->ns != NULL) && (child->ns->prefix != NULL)) {
Daniel Veillardc00cda82003-04-07 10:22:39 +00006062 xmlChar fn[50];
6063 xmlChar *fullname;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006064
Daniel Veillardc00cda82003-04-07 10:22:39 +00006065 fullname = xmlBuildQName(child->name, child->ns->prefix,
6066 fn, 50);
6067 if (fullname == NULL)
6068 return(0);
Owen Taylor3473f882001-02-23 17:55:21 +00006069 cont = elemDecl->content;
6070 while (cont != NULL) {
6071 if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
Daniel Veillardc00cda82003-04-07 10:22:39 +00006072 if (xmlStrEqual(cont->name, fullname))
6073 break;
Owen Taylor3473f882001-02-23 17:55:21 +00006074 } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
6075 (cont->c1 != NULL) &&
6076 (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
Daniel Veillardc00cda82003-04-07 10:22:39 +00006077 if (xmlStrEqual(cont->c1->name, fullname))
6078 break;
Owen Taylor3473f882001-02-23 17:55:21 +00006079 } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
6080 (cont->c1 == NULL) ||
6081 (cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006082 xmlErrValid(NULL, XML_DTD_MIXED_CORRUPT,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00006083 "Internal: MIXED struct corrupted\n",
6084 NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00006085 break;
6086 }
6087 cont = cont->c2;
6088 }
Daniel Veillardc00cda82003-04-07 10:22:39 +00006089 if ((fullname != fn) && (fullname != child->name))
6090 xmlFree(fullname);
Owen Taylor3473f882001-02-23 17:55:21 +00006091 if (cont != NULL)
6092 goto child_ok;
6093 }
6094 cont = elemDecl->content;
6095 while (cont != NULL) {
6096 if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
6097 if (xmlStrEqual(cont->name, name)) break;
6098 } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
6099 (cont->c1 != NULL) &&
6100 (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)) {
6101 if (xmlStrEqual(cont->c1->name, name)) break;
6102 } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
6103 (cont->c1 == NULL) ||
6104 (cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006105 xmlErrValid(ctxt, XML_DTD_MIXED_CORRUPT,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00006106 "Internal: MIXED struct corrupted\n",
6107 NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00006108 break;
6109 }
6110 cont = cont->c2;
6111 }
6112 if (cont == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006113 xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_CHILD,
Daniel Veillard5e5c2d02002-02-09 18:03:01 +00006114 "Element %s is not declared in %s list of possible children\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006115 name, elem->name, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00006116 ret = 0;
6117 }
6118 }
6119child_ok:
6120 child = child->next;
6121 }
6122 break;
6123 case XML_ELEMENT_TYPE_ELEMENT:
Daniel Veillard8dc16a62002-02-19 21:08:48 +00006124 if ((doc->standalone == 1) && (extsubset == 1)) {
6125 /*
6126 * VC: Standalone Document Declaration
6127 * - element types with element content, if white space
6128 * occurs directly within any instance of those types.
6129 */
6130 child = elem->children;
6131 while (child != NULL) {
6132 if (child->type == XML_TEXT_NODE) {
6133 const xmlChar *content = child->content;
6134
William M. Brack76e95df2003-10-18 16:20:14 +00006135 while (IS_BLANK_CH(*content))
Daniel Veillard8dc16a62002-02-19 21:08:48 +00006136 content++;
6137 if (*content == 0) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006138 xmlErrValidNode(ctxt, elem,
6139 XML_DTD_STANDALONE_WHITE_SPACE,
Daniel Veillard8dc16a62002-02-19 21:08:48 +00006140"standalone: %s declared in the external subset contains white spaces nodes\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006141 elem->name, NULL, NULL);
Daniel Veillard8dc16a62002-02-19 21:08:48 +00006142 ret = 0;
6143 break;
6144 }
6145 }
6146 child =child->next;
6147 }
6148 }
Owen Taylor3473f882001-02-23 17:55:21 +00006149 child = elem->children;
6150 cont = elemDecl->content;
Daniel Veillardb9cd8b42002-09-05 10:58:49 +00006151 tmp = xmlValidateElementContent(ctxt, child, elemDecl, 1, elem);
Daniel Veillard8dc16a62002-02-19 21:08:48 +00006152 if (tmp <= 0)
6153 ret = tmp;
Owen Taylor3473f882001-02-23 17:55:21 +00006154 break;
6155 }
Daniel Veillardea7751d2002-12-20 00:16:24 +00006156 } /* not continuous */
Owen Taylor3473f882001-02-23 17:55:21 +00006157
6158 /* [ VC: Required Attribute ] */
6159 attr = elemDecl->attributes;
6160 while (attr != NULL) {
6161 if (attr->def == XML_ATTRIBUTE_REQUIRED) {
Owen Taylor3473f882001-02-23 17:55:21 +00006162 int qualified = -1;
Owen Taylor3473f882001-02-23 17:55:21 +00006163
Daniel Veillarde4301c82002-02-13 13:32:35 +00006164 if ((attr->prefix == NULL) &&
6165 (xmlStrEqual(attr->name, BAD_CAST "xmlns"))) {
6166 xmlNsPtr ns;
6167
6168 ns = elem->nsDef;
6169 while (ns != NULL) {
6170 if (ns->prefix == NULL)
Owen Taylor3473f882001-02-23 17:55:21 +00006171 goto found;
Daniel Veillarde4301c82002-02-13 13:32:35 +00006172 ns = ns->next;
Owen Taylor3473f882001-02-23 17:55:21 +00006173 }
Daniel Veillarde4301c82002-02-13 13:32:35 +00006174 } else if (xmlStrEqual(attr->prefix, BAD_CAST "xmlns")) {
6175 xmlNsPtr ns;
6176
6177 ns = elem->nsDef;
6178 while (ns != NULL) {
6179 if (xmlStrEqual(attr->name, ns->prefix))
6180 goto found;
6181 ns = ns->next;
6182 }
6183 } else {
6184 xmlAttrPtr attrib;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006185
Daniel Veillarde4301c82002-02-13 13:32:35 +00006186 attrib = elem->properties;
6187 while (attrib != NULL) {
6188 if (xmlStrEqual(attrib->name, attr->name)) {
6189 if (attr->prefix != NULL) {
6190 xmlNsPtr nameSpace = attrib->ns;
6191
6192 if (nameSpace == NULL)
6193 nameSpace = elem->ns;
6194 /*
6195 * qualified names handling is problematic, having a
6196 * different prefix should be possible but DTDs don't
6197 * allow to define the URI instead of the prefix :-(
6198 */
6199 if (nameSpace == NULL) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006200 if (qualified < 0)
Daniel Veillarde4301c82002-02-13 13:32:35 +00006201 qualified = 0;
6202 } else if (!xmlStrEqual(nameSpace->prefix,
6203 attr->prefix)) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006204 if (qualified < 1)
Daniel Veillarde4301c82002-02-13 13:32:35 +00006205 qualified = 1;
6206 } else
6207 goto found;
6208 } else {
6209 /*
6210 * We should allow applications to define namespaces
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006211 * for their application even if the DTD doesn't
Daniel Veillarde4301c82002-02-13 13:32:35 +00006212 * carry one, otherwise, basically we would always
6213 * break.
6214 */
6215 goto found;
6216 }
6217 }
6218 attrib = attrib->next;
6219 }
Owen Taylor3473f882001-02-23 17:55:21 +00006220 }
6221 if (qualified == -1) {
6222 if (attr->prefix == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006223 xmlErrValidNode(ctxt, elem, XML_DTD_MISSING_ATTRIBUTE,
Daniel Veillard58e44c92002-08-02 22:19:49 +00006224 "Element %s does not carry attribute %s\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006225 elem->name, attr->name, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00006226 ret = 0;
6227 } else {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006228 xmlErrValidNode(ctxt, elem, XML_DTD_MISSING_ATTRIBUTE,
Daniel Veillard58e44c92002-08-02 22:19:49 +00006229 "Element %s does not carry attribute %s:%s\n",
Owen Taylor3473f882001-02-23 17:55:21 +00006230 elem->name, attr->prefix,attr->name);
6231 ret = 0;
6232 }
6233 } else if (qualified == 0) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006234 xmlErrValidWarning(ctxt, elem, XML_DTD_NO_PREFIX,
Owen Taylor3473f882001-02-23 17:55:21 +00006235 "Element %s required attribute %s:%s has no prefix\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006236 elem->name, attr->prefix, attr->name);
Owen Taylor3473f882001-02-23 17:55:21 +00006237 } else if (qualified == 1) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006238 xmlErrValidWarning(ctxt, elem, XML_DTD_DIFFERENT_PREFIX,
Owen Taylor3473f882001-02-23 17:55:21 +00006239 "Element %s required attribute %s:%s has different prefix\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006240 elem->name, attr->prefix, attr->name);
Owen Taylor3473f882001-02-23 17:55:21 +00006241 }
Daniel Veillarde4301c82002-02-13 13:32:35 +00006242 } else if (attr->def == XML_ATTRIBUTE_FIXED) {
6243 /*
6244 * Special tests checking #FIXED namespace declarations
6245 * have the right value since this is not done as an
6246 * attribute checking
6247 */
6248 if ((attr->prefix == NULL) &&
6249 (xmlStrEqual(attr->name, BAD_CAST "xmlns"))) {
6250 xmlNsPtr ns;
6251
6252 ns = elem->nsDef;
6253 while (ns != NULL) {
6254 if (ns->prefix == NULL) {
6255 if (!xmlStrEqual(attr->defaultValue, ns->href)) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006256 xmlErrValidNode(ctxt, elem,
6257 XML_DTD_ELEM_DEFAULT_NAMESPACE,
Daniel Veillarde4301c82002-02-13 13:32:35 +00006258 "Element %s namespace name for default namespace does not match the DTD\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006259 elem->name, NULL, NULL);
Daniel Veillardc7612992002-02-17 22:47:37 +00006260 ret = 0;
Daniel Veillarde4301c82002-02-13 13:32:35 +00006261 }
6262 goto found;
6263 }
6264 ns = ns->next;
6265 }
6266 } else if (xmlStrEqual(attr->prefix, BAD_CAST "xmlns")) {
6267 xmlNsPtr ns;
6268
6269 ns = elem->nsDef;
6270 while (ns != NULL) {
6271 if (xmlStrEqual(attr->name, ns->prefix)) {
6272 if (!xmlStrEqual(attr->defaultValue, ns->href)) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006273 xmlErrValidNode(ctxt, elem, XML_DTD_ELEM_NAMESPACE,
Daniel Veillard58e44c92002-08-02 22:19:49 +00006274 "Element %s namespace name for %s does not match the DTD\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006275 elem->name, ns->prefix, NULL);
Daniel Veillardc7612992002-02-17 22:47:37 +00006276 ret = 0;
Daniel Veillarde4301c82002-02-13 13:32:35 +00006277 }
6278 goto found;
6279 }
6280 ns = ns->next;
6281 }
6282 }
Owen Taylor3473f882001-02-23 17:55:21 +00006283 }
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006284found:
Owen Taylor3473f882001-02-23 17:55:21 +00006285 attr = attr->nexth;
6286 }
6287 return(ret);
6288}
6289
6290/**
6291 * xmlValidateRoot:
6292 * @ctxt: the validation context
6293 * @doc: a document instance
6294 *
6295 * Try to validate a the root element
6296 * basically it does the following check as described by the
6297 * XML-1.0 recommendation:
6298 * - [ VC: Root Element Type ]
6299 * it doesn't try to recurse or apply other check to the element
6300 *
6301 * returns 1 if valid or 0 otherwise
6302 */
6303
6304int
6305xmlValidateRoot(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6306 xmlNodePtr root;
Daniel Veillardc00cda82003-04-07 10:22:39 +00006307 int ret;
6308
Owen Taylor3473f882001-02-23 17:55:21 +00006309 if (doc == NULL) return(0);
6310
6311 root = xmlDocGetRootElement(doc);
6312 if ((root == NULL) || (root->name == NULL)) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006313 xmlErrValid(ctxt, XML_DTD_NO_ROOT,
6314 "no root element\n", NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00006315 return(0);
6316 }
6317
6318 /*
6319 * When doing post validation against a separate DTD, those may
6320 * no internal subset has been generated
6321 */
6322 if ((doc->intSubset != NULL) &&
6323 (doc->intSubset->name != NULL)) {
6324 /*
6325 * Check first the document root against the NQName
6326 */
6327 if (!xmlStrEqual(doc->intSubset->name, root->name)) {
6328 if ((root->ns != NULL) && (root->ns->prefix != NULL)) {
Daniel Veillardc00cda82003-04-07 10:22:39 +00006329 xmlChar fn[50];
6330 xmlChar *fullname;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006331
Daniel Veillardc00cda82003-04-07 10:22:39 +00006332 fullname = xmlBuildQName(root->name, root->ns->prefix, fn, 50);
6333 if (fullname == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00006334 xmlVErrMemory(ctxt, NULL);
Daniel Veillardc00cda82003-04-07 10:22:39 +00006335 return(0);
6336 }
6337 ret = xmlStrEqual(doc->intSubset->name, fullname);
6338 if ((fullname != fn) && (fullname != root->name))
6339 xmlFree(fullname);
6340 if (ret == 1)
Owen Taylor3473f882001-02-23 17:55:21 +00006341 goto name_ok;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006342 }
Owen Taylor3473f882001-02-23 17:55:21 +00006343 if ((xmlStrEqual(doc->intSubset->name, BAD_CAST "HTML")) &&
6344 (xmlStrEqual(root->name, BAD_CAST "html")))
6345 goto name_ok;
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006346 xmlErrValidNode(ctxt, root, XML_DTD_ROOT_NAME,
6347 "root and DTD name do not match '%s' and '%s'\n",
6348 root->name, doc->intSubset->name, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00006349 return(0);
Owen Taylor3473f882001-02-23 17:55:21 +00006350 }
6351 }
6352name_ok:
6353 return(1);
6354}
6355
6356
6357/**
6358 * xmlValidateElement:
6359 * @ctxt: the validation context
6360 * @doc: a document instance
6361 * @elem: an element instance
6362 *
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006363 * Try to validate the subtree under an element
Owen Taylor3473f882001-02-23 17:55:21 +00006364 *
6365 * returns 1 if valid or 0 otherwise
6366 */
6367
6368int
6369xmlValidateElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr elem) {
6370 xmlNodePtr child;
6371 xmlAttrPtr attr;
Daniel Veillarde133dd82003-10-30 10:42:20 +00006372 xmlNsPtr ns;
Daniel Veillarda8ff65d2003-11-03 16:20:10 +00006373 const xmlChar *value;
Owen Taylor3473f882001-02-23 17:55:21 +00006374 int ret = 1;
6375
6376 if (elem == NULL) return(0);
6377
6378 /*
6379 * XInclude elements were added after parsing in the infoset,
6380 * they don't really mean anything validation wise.
6381 */
6382 if ((elem->type == XML_XINCLUDE_START) ||
Daniel Veillard3e62adb2012-08-09 14:24:02 +08006383 (elem->type == XML_XINCLUDE_END) ||
6384 (elem->type == XML_NAMESPACE_DECL))
Owen Taylor3473f882001-02-23 17:55:21 +00006385 return(1);
6386
6387 CHECK_DTD;
6388
Daniel Veillard10ea86c2001-06-20 13:55:33 +00006389 /*
6390 * Entities references have to be handled separately
6391 */
6392 if (elem->type == XML_ENTITY_REF_NODE) {
6393 return(1);
6394 }
6395
Owen Taylor3473f882001-02-23 17:55:21 +00006396 ret &= xmlValidateOneElement(ctxt, doc, elem);
Daniel Veillard8874b942005-08-25 13:19:21 +00006397 if (elem->type == XML_ELEMENT_NODE) {
6398 attr = elem->properties;
6399 while (attr != NULL) {
6400 value = xmlNodeListGetString(doc, attr->children, 0);
6401 ret &= xmlValidateOneAttribute(ctxt, doc, elem, attr, value);
6402 if (value != NULL)
6403 xmlFree((char *)value);
6404 attr= attr->next;
6405 }
6406 ns = elem->nsDef;
6407 while (ns != NULL) {
6408 if (elem->ns == NULL)
6409 ret &= xmlValidateOneNamespace(ctxt, doc, elem, NULL,
6410 ns, ns->href);
6411 else
6412 ret &= xmlValidateOneNamespace(ctxt, doc, elem,
6413 elem->ns->prefix, ns, ns->href);
6414 ns = ns->next;
6415 }
Daniel Veillarde133dd82003-10-30 10:42:20 +00006416 }
Owen Taylor3473f882001-02-23 17:55:21 +00006417 child = elem->children;
6418 while (child != NULL) {
6419 ret &= xmlValidateElement(ctxt, doc, child);
6420 child = child->next;
6421 }
6422
6423 return(ret);
6424}
6425
Daniel Veillard8730c562001-02-26 10:49:57 +00006426/**
6427 * xmlValidateRef:
6428 * @ref: A reference to be validated
6429 * @ctxt: Validation context
6430 * @name: Name of ID we are searching for
6431 *
6432 */
Daniel Veillard56a4cb82001-03-24 17:00:36 +00006433static void
Daniel Veillard8730c562001-02-26 10:49:57 +00006434xmlValidateRef(xmlRefPtr ref, xmlValidCtxtPtr ctxt,
Owen Taylor3473f882001-02-23 17:55:21 +00006435 const xmlChar *name) {
6436 xmlAttrPtr id;
6437 xmlAttrPtr attr;
6438
6439 if (ref == NULL)
6440 return;
Daniel Veillardea7751d2002-12-20 00:16:24 +00006441 if ((ref->attr == NULL) && (ref->name == NULL))
Owen Taylor3473f882001-02-23 17:55:21 +00006442 return;
Daniel Veillardea7751d2002-12-20 00:16:24 +00006443 attr = ref->attr;
6444 if (attr == NULL) {
6445 xmlChar *dup, *str = NULL, *cur, save;
6446
6447 dup = xmlStrdup(name);
6448 if (dup == NULL) {
6449 ctxt->valid = 0;
6450 return;
6451 }
6452 cur = dup;
6453 while (*cur != 0) {
6454 str = cur;
William M. Brack76e95df2003-10-18 16:20:14 +00006455 while ((*cur != 0) && (!IS_BLANK_CH(*cur))) cur++;
Daniel Veillardea7751d2002-12-20 00:16:24 +00006456 save = *cur;
6457 *cur = 0;
6458 id = xmlGetID(ctxt->doc, str);
6459 if (id == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006460 xmlErrValidNodeNr(ctxt, NULL, XML_DTD_UNKNOWN_ID,
Daniel Veillardea7751d2002-12-20 00:16:24 +00006461 "attribute %s line %d references an unknown ID \"%s\"\n",
6462 ref->name, ref->lineno, str);
6463 ctxt->valid = 0;
6464 }
6465 if (save == 0)
6466 break;
6467 *cur = save;
William M. Brack76e95df2003-10-18 16:20:14 +00006468 while (IS_BLANK_CH(*cur)) cur++;
Daniel Veillardea7751d2002-12-20 00:16:24 +00006469 }
6470 xmlFree(dup);
6471 } else if (attr->atype == XML_ATTRIBUTE_IDREF) {
Owen Taylor3473f882001-02-23 17:55:21 +00006472 id = xmlGetID(ctxt->doc, name);
6473 if (id == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006474 xmlErrValidNode(ctxt, attr->parent, XML_DTD_UNKNOWN_ID,
Daniel Veillardea7751d2002-12-20 00:16:24 +00006475 "IDREF attribute %s references an unknown ID \"%s\"\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006476 attr->name, name, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00006477 ctxt->valid = 0;
6478 }
6479 } else if (attr->atype == XML_ATTRIBUTE_IDREFS) {
6480 xmlChar *dup, *str = NULL, *cur, save;
6481
6482 dup = xmlStrdup(name);
6483 if (dup == NULL) {
Daniel Veillardce9457f2003-10-05 21:33:18 +00006484 xmlVErrMemory(ctxt, "IDREFS split");
Owen Taylor3473f882001-02-23 17:55:21 +00006485 ctxt->valid = 0;
6486 return;
6487 }
6488 cur = dup;
6489 while (*cur != 0) {
6490 str = cur;
William M. Brack76e95df2003-10-18 16:20:14 +00006491 while ((*cur != 0) && (!IS_BLANK_CH(*cur))) cur++;
Owen Taylor3473f882001-02-23 17:55:21 +00006492 save = *cur;
6493 *cur = 0;
6494 id = xmlGetID(ctxt->doc, str);
6495 if (id == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006496 xmlErrValidNode(ctxt, attr->parent, XML_DTD_UNKNOWN_ID,
Daniel Veillardea7751d2002-12-20 00:16:24 +00006497 "IDREFS attribute %s references an unknown ID \"%s\"\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006498 attr->name, str, NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00006499 ctxt->valid = 0;
6500 }
6501 if (save == 0)
6502 break;
6503 *cur = save;
William M. Brack76e95df2003-10-18 16:20:14 +00006504 while (IS_BLANK_CH(*cur)) cur++;
Owen Taylor3473f882001-02-23 17:55:21 +00006505 }
6506 xmlFree(dup);
6507 }
6508}
6509
6510/**
Daniel Veillard8730c562001-02-26 10:49:57 +00006511 * xmlWalkValidateList:
6512 * @data: Contents of current link
6513 * @user: Value supplied by the user
6514 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +00006515 * Returns 0 to abort the walk or 1 to continue
Daniel Veillard8730c562001-02-26 10:49:57 +00006516 */
6517static int
6518xmlWalkValidateList(const void *data, const void *user)
6519{
6520 xmlValidateMemoPtr memo = (xmlValidateMemoPtr)user;
6521 xmlValidateRef((xmlRefPtr)data, memo->ctxt, memo->name);
6522 return 1;
6523}
6524
6525/**
6526 * xmlValidateCheckRefCallback:
6527 * @ref_list: List of references
6528 * @ctxt: Validation context
6529 * @name: Name of ID we are searching for
6530 *
6531 */
6532static void
6533xmlValidateCheckRefCallback(xmlListPtr ref_list, xmlValidCtxtPtr ctxt,
6534 const xmlChar *name) {
6535 xmlValidateMemo memo;
6536
6537 if (ref_list == NULL)
6538 return;
6539 memo.ctxt = ctxt;
6540 memo.name = name;
6541
6542 xmlListWalk(ref_list, xmlWalkValidateList, &memo);
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006543
Daniel Veillard8730c562001-02-26 10:49:57 +00006544}
6545
6546/**
Owen Taylor3473f882001-02-23 17:55:21 +00006547 * xmlValidateDocumentFinal:
6548 * @ctxt: the validation context
6549 * @doc: a document instance
6550 *
6551 * Does the final step for the document validation once all the
6552 * incremental validation steps have been completed
6553 *
6554 * basically it does the following checks described by the XML Rec
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006555 *
Daniel Veillardc3da18a2003-03-18 00:31:04 +00006556 * Check all the IDREF/IDREFS attributes definition for validity
Owen Taylor3473f882001-02-23 17:55:21 +00006557 *
6558 * returns 1 if valid or 0 otherwise
6559 */
6560
6561int
6562xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6563 xmlRefTablePtr table;
Daniel Veillardcb3549e2011-11-11 11:25:07 +08006564 unsigned int save;
Owen Taylor3473f882001-02-23 17:55:21 +00006565
Daniel Veillardc0be74b2004-11-03 19:16:55 +00006566 if (ctxt == NULL)
6567 return(0);
Owen Taylor3473f882001-02-23 17:55:21 +00006568 if (doc == NULL) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006569 xmlErrValid(ctxt, XML_DTD_NO_DOC,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +00006570 "xmlValidateDocumentFinal: doc == NULL\n", NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00006571 return(0);
6572 }
6573
Daniel Veillardcb3549e2011-11-11 11:25:07 +08006574 /* trick to get correct line id report */
6575 save = ctxt->finishDtd;
6576 ctxt->finishDtd = 0;
6577
Owen Taylor3473f882001-02-23 17:55:21 +00006578 /*
6579 * Check all the NOTATION/NOTATIONS attributes
6580 */
6581 /*
6582 * Check all the ENTITY/ENTITIES attributes definition for validity
6583 */
6584 /*
6585 * Check all the IDREF/IDREFS attributes definition for validity
6586 */
6587 table = (xmlRefTablePtr) doc->refs;
6588 ctxt->doc = doc;
6589 ctxt->valid = 1;
6590 xmlHashScan(table, (xmlHashScanner) xmlValidateCheckRefCallback, ctxt);
Daniel Veillardcb3549e2011-11-11 11:25:07 +08006591
6592 ctxt->finishDtd = save;
Owen Taylor3473f882001-02-23 17:55:21 +00006593 return(ctxt->valid);
6594}
6595
6596/**
6597 * xmlValidateDtd:
6598 * @ctxt: the validation context
6599 * @doc: a document instance
6600 * @dtd: a dtd instance
6601 *
6602 * Try to validate the document against the dtd instance
6603 *
William M. Brack367df6e2004-10-23 18:14:36 +00006604 * Basically it does check all the definitions in the DtD.
6605 * Note the the internal subset (if present) is de-coupled
6606 * (i.e. not used), which could give problems if ID or IDREF
6607 * is present.
Owen Taylor3473f882001-02-23 17:55:21 +00006608 *
6609 * returns 1 if valid or 0 otherwise
6610 */
6611
6612int
6613xmlValidateDtd(xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlDtdPtr dtd) {
6614 int ret;
William M. Brack367df6e2004-10-23 18:14:36 +00006615 xmlDtdPtr oldExt, oldInt;
Owen Taylor3473f882001-02-23 17:55:21 +00006616 xmlNodePtr root;
6617
6618 if (dtd == NULL) return(0);
6619 if (doc == NULL) return(0);
6620 oldExt = doc->extSubset;
William M. Brack367df6e2004-10-23 18:14:36 +00006621 oldInt = doc->intSubset;
Owen Taylor3473f882001-02-23 17:55:21 +00006622 doc->extSubset = dtd;
William M. Brack367df6e2004-10-23 18:14:36 +00006623 doc->intSubset = NULL;
Owen Taylor3473f882001-02-23 17:55:21 +00006624 ret = xmlValidateRoot(ctxt, doc);
6625 if (ret == 0) {
6626 doc->extSubset = oldExt;
William M. Brack367df6e2004-10-23 18:14:36 +00006627 doc->intSubset = oldInt;
Owen Taylor3473f882001-02-23 17:55:21 +00006628 return(ret);
6629 }
6630 if (doc->ids != NULL) {
6631 xmlFreeIDTable(doc->ids);
6632 doc->ids = NULL;
6633 }
6634 if (doc->refs != NULL) {
6635 xmlFreeRefTable(doc->refs);
6636 doc->refs = NULL;
6637 }
6638 root = xmlDocGetRootElement(doc);
6639 ret = xmlValidateElement(ctxt, doc, root);
6640 ret &= xmlValidateDocumentFinal(ctxt, doc);
6641 doc->extSubset = oldExt;
William M. Brack367df6e2004-10-23 18:14:36 +00006642 doc->intSubset = oldInt;
Owen Taylor3473f882001-02-23 17:55:21 +00006643 return(ret);
6644}
6645
Daniel Veillard56a4cb82001-03-24 17:00:36 +00006646static void
Daniel Veillard8ab0f582002-02-18 18:31:38 +00006647xmlValidateNotationCallback(xmlEntityPtr cur, xmlValidCtxtPtr ctxt,
6648 const xmlChar *name ATTRIBUTE_UNUSED) {
6649 if (cur == NULL)
6650 return;
6651 if (cur->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
6652 xmlChar *notation = cur->content;
6653
Daniel Veillard878eab02002-02-19 13:46:09 +00006654 if (notation != NULL) {
Daniel Veillard8ab0f582002-02-18 18:31:38 +00006655 int ret;
6656
6657 ret = xmlValidateNotationUse(ctxt, cur->doc, notation);
6658 if (ret != 1) {
Daniel Veillard878eab02002-02-19 13:46:09 +00006659 ctxt->valid = 0;
Daniel Veillard8ab0f582002-02-18 18:31:38 +00006660 }
6661 }
6662 }
6663}
6664
6665static void
Owen Taylor3473f882001-02-23 17:55:21 +00006666xmlValidateAttributeCallback(xmlAttributePtr cur, xmlValidCtxtPtr ctxt,
Daniel Veillardc86a4fa2001-03-26 16:28:29 +00006667 const xmlChar *name ATTRIBUTE_UNUSED) {
Daniel Veillard8ab0f582002-02-18 18:31:38 +00006668 int ret;
Daniel Veillard878eab02002-02-19 13:46:09 +00006669 xmlDocPtr doc;
Daniel Veillarda8ff65d2003-11-03 16:20:10 +00006670 xmlElementPtr elem = NULL;
Daniel Veillard8ab0f582002-02-18 18:31:38 +00006671
Owen Taylor3473f882001-02-23 17:55:21 +00006672 if (cur == NULL)
6673 return;
6674 switch (cur->atype) {
6675 case XML_ATTRIBUTE_CDATA:
6676 case XML_ATTRIBUTE_ID:
6677 case XML_ATTRIBUTE_IDREF :
6678 case XML_ATTRIBUTE_IDREFS:
6679 case XML_ATTRIBUTE_NMTOKEN:
6680 case XML_ATTRIBUTE_NMTOKENS:
6681 case XML_ATTRIBUTE_ENUMERATION:
6682 break;
6683 case XML_ATTRIBUTE_ENTITY:
6684 case XML_ATTRIBUTE_ENTITIES:
6685 case XML_ATTRIBUTE_NOTATION:
6686 if (cur->defaultValue != NULL) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006687
Daniel Veillard8ab0f582002-02-18 18:31:38 +00006688 ret = xmlValidateAttributeValue2(ctxt, ctxt->doc, cur->name,
6689 cur->atype, cur->defaultValue);
6690 if ((ret == 0) && (ctxt->valid == 1))
6691 ctxt->valid = 0;
Owen Taylor3473f882001-02-23 17:55:21 +00006692 }
6693 if (cur->tree != NULL) {
6694 xmlEnumerationPtr tree = cur->tree;
6695 while (tree != NULL) {
Daniel Veillard8ab0f582002-02-18 18:31:38 +00006696 ret = xmlValidateAttributeValue2(ctxt, ctxt->doc,
Owen Taylor3473f882001-02-23 17:55:21 +00006697 cur->name, cur->atype, tree->name);
Daniel Veillard8ab0f582002-02-18 18:31:38 +00006698 if ((ret == 0) && (ctxt->valid == 1))
6699 ctxt->valid = 0;
Owen Taylor3473f882001-02-23 17:55:21 +00006700 tree = tree->next;
6701 }
6702 }
6703 }
Daniel Veillard878eab02002-02-19 13:46:09 +00006704 if (cur->atype == XML_ATTRIBUTE_NOTATION) {
6705 doc = cur->doc;
Daniel Veillarda8ff65d2003-11-03 16:20:10 +00006706 if (cur->elem == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006707 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
Daniel Veillard878eab02002-02-19 13:46:09 +00006708 "xmlValidateAttributeCallback(%s): internal error\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006709 (const char *) cur->name);
Daniel Veillard878eab02002-02-19 13:46:09 +00006710 return;
6711 }
Daniel Veillarda8ff65d2003-11-03 16:20:10 +00006712
6713 if (doc != NULL)
6714 elem = xmlGetDtdElementDesc(doc->intSubset, cur->elem);
6715 if ((elem == NULL) && (doc != NULL))
Daniel Veillard878eab02002-02-19 13:46:09 +00006716 elem = xmlGetDtdElementDesc(doc->extSubset, cur->elem);
Daniel Veillarda8ff65d2003-11-03 16:20:10 +00006717 if ((elem == NULL) && (cur->parent != NULL) &&
6718 (cur->parent->type == XML_DTD_NODE))
6719 elem = xmlGetDtdElementDesc((xmlDtdPtr) cur->parent, cur->elem);
Daniel Veillard878eab02002-02-19 13:46:09 +00006720 if (elem == NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006721 xmlErrValidNode(ctxt, NULL, XML_DTD_UNKNOWN_ELEM,
Daniel Veillard878eab02002-02-19 13:46:09 +00006722 "attribute %s: could not find decl for element %s\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006723 cur->name, cur->elem, NULL);
Daniel Veillard878eab02002-02-19 13:46:09 +00006724 return;
6725 }
6726 if (elem->etype == XML_ELEMENT_TYPE_EMPTY) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006727 xmlErrValidNode(ctxt, NULL, XML_DTD_EMPTY_NOTATION,
Daniel Veillard58e44c92002-08-02 22:19:49 +00006728 "NOTATION attribute %s declared for EMPTY element %s\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006729 cur->name, cur->elem, NULL);
Daniel Veillard878eab02002-02-19 13:46:09 +00006730 ctxt->valid = 0;
6731 }
6732 }
Owen Taylor3473f882001-02-23 17:55:21 +00006733}
6734
6735/**
6736 * xmlValidateDtdFinal:
6737 * @ctxt: the validation context
6738 * @doc: a document instance
6739 *
6740 * Does the final step for the dtds validation once all the
6741 * subsets have been parsed
6742 *
6743 * basically it does the following checks described by the XML Rec
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006744 * - check that ENTITY and ENTITIES type attributes default or
Owen Taylor3473f882001-02-23 17:55:21 +00006745 * possible values matches one of the defined entities.
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006746 * - check that NOTATION type attributes default or
Owen Taylor3473f882001-02-23 17:55:21 +00006747 * possible values matches one of the defined notations.
6748 *
Daniel Veillard8ab0f582002-02-18 18:31:38 +00006749 * returns 1 if valid or 0 if invalid and -1 if not well-formed
Owen Taylor3473f882001-02-23 17:55:21 +00006750 */
6751
6752int
6753xmlValidateDtdFinal(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
Owen Taylor3473f882001-02-23 17:55:21 +00006754 xmlDtdPtr dtd;
6755 xmlAttributeTablePtr table;
Daniel Veillard8ab0f582002-02-18 18:31:38 +00006756 xmlEntitiesTablePtr entities;
Owen Taylor3473f882001-02-23 17:55:21 +00006757
Daniel Veillard2cba4152008-08-27 11:45:41 +00006758 if ((doc == NULL) || (ctxt == NULL)) return(0);
Owen Taylor3473f882001-02-23 17:55:21 +00006759 if ((doc->intSubset == NULL) && (doc->extSubset == NULL))
6760 return(0);
6761 ctxt->doc = doc;
Daniel Veillard8ab0f582002-02-18 18:31:38 +00006762 ctxt->valid = 1;
Owen Taylor3473f882001-02-23 17:55:21 +00006763 dtd = doc->intSubset;
6764 if ((dtd != NULL) && (dtd->attributes != NULL)) {
6765 table = (xmlAttributeTablePtr) dtd->attributes;
6766 xmlHashScan(table, (xmlHashScanner) xmlValidateAttributeCallback, ctxt);
Daniel Veillard878eab02002-02-19 13:46:09 +00006767 }
6768 if ((dtd != NULL) && (dtd->entities != NULL)) {
Daniel Veillard8ab0f582002-02-18 18:31:38 +00006769 entities = (xmlEntitiesTablePtr) dtd->entities;
6770 xmlHashScan(entities, (xmlHashScanner) xmlValidateNotationCallback,
6771 ctxt);
Owen Taylor3473f882001-02-23 17:55:21 +00006772 }
6773 dtd = doc->extSubset;
6774 if ((dtd != NULL) && (dtd->attributes != NULL)) {
6775 table = (xmlAttributeTablePtr) dtd->attributes;
6776 xmlHashScan(table, (xmlHashScanner) xmlValidateAttributeCallback, ctxt);
Daniel Veillard878eab02002-02-19 13:46:09 +00006777 }
6778 if ((dtd != NULL) && (dtd->entities != NULL)) {
Daniel Veillard8ab0f582002-02-18 18:31:38 +00006779 entities = (xmlEntitiesTablePtr) dtd->entities;
6780 xmlHashScan(entities, (xmlHashScanner) xmlValidateNotationCallback,
6781 ctxt);
Owen Taylor3473f882001-02-23 17:55:21 +00006782 }
6783 return(ctxt->valid);
6784}
6785
6786/**
6787 * xmlValidateDocument:
6788 * @ctxt: the validation context
6789 * @doc: a document instance
6790 *
6791 * Try to validate the document instance
6792 *
6793 * basically it does the all the checks described by the XML Rec
6794 * i.e. validates the internal and external subset (if present)
6795 * and validate the document tree.
6796 *
6797 * returns 1 if valid or 0 otherwise
6798 */
6799
6800int
6801xmlValidateDocument(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6802 int ret;
6803 xmlNodePtr root;
6804
Daniel Veillardc0be74b2004-11-03 19:16:55 +00006805 if (doc == NULL)
6806 return(0);
Daniel Veillard2fd85422002-10-16 14:32:41 +00006807 if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006808 xmlErrValid(ctxt, XML_DTD_NO_DTD,
6809 "no DTD found!\n", NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00006810 return(0);
Daniel Veillard2fd85422002-10-16 14:32:41 +00006811 }
Owen Taylor3473f882001-02-23 17:55:21 +00006812 if ((doc->intSubset != NULL) && ((doc->intSubset->SystemID != NULL) ||
6813 (doc->intSubset->ExternalID != NULL)) && (doc->extSubset == NULL)) {
William M. Brack8c22f9f2004-08-06 16:23:27 +00006814 xmlChar *sysID;
6815 if (doc->intSubset->SystemID != NULL) {
William M. Brackbebe7302004-08-05 06:46:47 +00006816 sysID = xmlBuildURI(doc->intSubset->SystemID,
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006817 doc->URL);
William M. Brack8c22f9f2004-08-06 16:23:27 +00006818 if (sysID == NULL) {
6819 xmlErrValid(ctxt, XML_DTD_LOAD_ERROR,
6820 "Could not build URI for external subset \"%s\"\n",
6821 (const char *) doc->intSubset->SystemID);
6822 return 0;
6823 }
6824 } else
William M. Brackbebe7302004-08-05 06:46:47 +00006825 sysID = NULL;
William M. Brack8c22f9f2004-08-06 16:23:27 +00006826 doc->extSubset = xmlParseDTD(doc->intSubset->ExternalID,
William M. Brackbebe7302004-08-05 06:46:47 +00006827 (const xmlChar *)sysID);
William M. Brackbebe7302004-08-05 06:46:47 +00006828 if (sysID != NULL)
6829 xmlFree(sysID);
Owen Taylor3473f882001-02-23 17:55:21 +00006830 if (doc->extSubset == NULL) {
6831 if (doc->intSubset->SystemID != NULL) {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006832 xmlErrValid(ctxt, XML_DTD_LOAD_ERROR,
Owen Taylor3473f882001-02-23 17:55:21 +00006833 "Could not load the external subset \"%s\"\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006834 (const char *) doc->intSubset->SystemID);
Owen Taylor3473f882001-02-23 17:55:21 +00006835 } else {
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006836 xmlErrValid(ctxt, XML_DTD_LOAD_ERROR,
Owen Taylor3473f882001-02-23 17:55:21 +00006837 "Could not load the external subset \"%s\"\n",
Daniel Veillardbb5abab2003-10-03 22:21:51 +00006838 (const char *) doc->intSubset->ExternalID);
Owen Taylor3473f882001-02-23 17:55:21 +00006839 }
6840 return(0);
6841 }
6842 }
6843
6844 if (doc->ids != NULL) {
6845 xmlFreeIDTable(doc->ids);
6846 doc->ids = NULL;
6847 }
6848 if (doc->refs != NULL) {
6849 xmlFreeRefTable(doc->refs);
6850 doc->refs = NULL;
6851 }
6852 ret = xmlValidateDtdFinal(ctxt, doc);
6853 if (!xmlValidateRoot(ctxt, doc)) return(0);
6854
6855 root = xmlDocGetRootElement(doc);
6856 ret &= xmlValidateElement(ctxt, doc, root);
6857 ret &= xmlValidateDocumentFinal(ctxt, doc);
6858 return(ret);
6859}
6860
Owen Taylor3473f882001-02-23 17:55:21 +00006861/************************************************************************
6862 * *
6863 * Routines for dynamic validation editing *
6864 * *
6865 ************************************************************************/
6866
6867/**
6868 * xmlValidGetPotentialChildren:
6869 * @ctree: an element content tree
Daniel Veillard7802ba52005-10-27 11:56:20 +00006870 * @names: an array to store the list of child names
Owen Taylor3473f882001-02-23 17:55:21 +00006871 * @len: a pointer to the number of element in the list
6872 * @max: the size of the array
6873 *
6874 * Build/extend a list of potential children allowed by the content tree
6875 *
6876 * returns the number of element in the list, or -1 in case of error.
6877 */
6878
6879int
Daniel Veillard7802ba52005-10-27 11:56:20 +00006880xmlValidGetPotentialChildren(xmlElementContent *ctree,
6881 const xmlChar **names,
Owen Taylor3473f882001-02-23 17:55:21 +00006882 int *len, int max) {
6883 int i;
6884
Daniel Veillard7802ba52005-10-27 11:56:20 +00006885 if ((ctree == NULL) || (names == NULL) || (len == NULL))
Owen Taylor3473f882001-02-23 17:55:21 +00006886 return(-1);
6887 if (*len >= max) return(*len);
6888
6889 switch (ctree->type) {
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006890 case XML_ELEMENT_CONTENT_PCDATA:
Owen Taylor3473f882001-02-23 17:55:21 +00006891 for (i = 0; i < *len;i++)
Daniel Veillard7802ba52005-10-27 11:56:20 +00006892 if (xmlStrEqual(BAD_CAST "#PCDATA", names[i])) return(*len);
6893 names[(*len)++] = BAD_CAST "#PCDATA";
Owen Taylor3473f882001-02-23 17:55:21 +00006894 break;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006895 case XML_ELEMENT_CONTENT_ELEMENT:
Owen Taylor3473f882001-02-23 17:55:21 +00006896 for (i = 0; i < *len;i++)
Daniel Veillard7802ba52005-10-27 11:56:20 +00006897 if (xmlStrEqual(ctree->name, names[i])) return(*len);
6898 names[(*len)++] = ctree->name;
Owen Taylor3473f882001-02-23 17:55:21 +00006899 break;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006900 case XML_ELEMENT_CONTENT_SEQ:
Daniel Veillard7802ba52005-10-27 11:56:20 +00006901 xmlValidGetPotentialChildren(ctree->c1, names, len, max);
6902 xmlValidGetPotentialChildren(ctree->c2, names, len, max);
Owen Taylor3473f882001-02-23 17:55:21 +00006903 break;
6904 case XML_ELEMENT_CONTENT_OR:
Daniel Veillard7802ba52005-10-27 11:56:20 +00006905 xmlValidGetPotentialChildren(ctree->c1, names, len, max);
6906 xmlValidGetPotentialChildren(ctree->c2, names, len, max);
Owen Taylor3473f882001-02-23 17:55:21 +00006907 break;
6908 }
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006909
Owen Taylor3473f882001-02-23 17:55:21 +00006910 return(*len);
6911}
6912
William M. Brack9333cc22004-06-24 08:33:40 +00006913/*
6914 * Dummy function to suppress messages while we try out valid elements
6915 */
Daniel Veillardffa3c742005-07-21 13:24:09 +00006916static void XMLCDECL xmlNoValidityErr(void *ctx ATTRIBUTE_UNUSED,
William M. Brack9333cc22004-06-24 08:33:40 +00006917 const char *msg ATTRIBUTE_UNUSED, ...) {
6918 return;
6919}
6920
Owen Taylor3473f882001-02-23 17:55:21 +00006921/**
6922 * xmlValidGetValidElements:
6923 * @prev: an element to insert after
6924 * @next: an element to insert next
Daniel Veillardaecc0dc2004-05-08 02:32:07 +00006925 * @names: an array to store the list of child names
Owen Taylor3473f882001-02-23 17:55:21 +00006926 * @max: the size of the array
6927 *
6928 * This function returns the list of authorized children to insert
6929 * within an existing tree while respecting the validity constraints
6930 * forced by the Dtd. The insertion point is defined using @prev and
6931 * @next in the following ways:
6932 * to insert before 'node': xmlValidGetValidElements(node->prev, node, ...
6933 * to insert next 'node': xmlValidGetValidElements(node, node->next, ...
6934 * to replace 'node': xmlValidGetValidElements(node->prev, node->next, ...
6935 * to prepend a child to 'node': xmlValidGetValidElements(NULL, node->childs,
6936 * to append a child to 'node': xmlValidGetValidElements(node->last, NULL, ...
6937 *
6938 * pointers to the element names are inserted at the beginning of the array
6939 * and do not need to be freed.
6940 *
6941 * returns the number of element in the list, or -1 in case of error. If
6942 * the function returns the value @max the caller is invited to grow the
6943 * receiving array and retry.
6944 */
6945
6946int
Daniel Veillardaecc0dc2004-05-08 02:32:07 +00006947xmlValidGetValidElements(xmlNode *prev, xmlNode *next, const xmlChar **names,
Owen Taylor3473f882001-02-23 17:55:21 +00006948 int max) {
Daniel Veillardf69bb4b2001-05-19 13:24:56 +00006949 xmlValidCtxt vctxt;
Owen Taylor3473f882001-02-23 17:55:21 +00006950 int nb_valid_elements = 0;
6951 const xmlChar *elements[256];
6952 int nb_elements = 0, i;
Daniel Veillard5e5c2d02002-02-09 18:03:01 +00006953 const xmlChar *name;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006954
Owen Taylor3473f882001-02-23 17:55:21 +00006955 xmlNode *ref_node;
6956 xmlNode *parent;
6957 xmlNode *test_node;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006958
Owen Taylor3473f882001-02-23 17:55:21 +00006959 xmlNode *prev_next;
6960 xmlNode *next_prev;
6961 xmlNode *parent_childs;
6962 xmlNode *parent_last;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006963
Owen Taylor3473f882001-02-23 17:55:21 +00006964 xmlElement *element_desc;
6965
6966 if (prev == NULL && next == NULL)
6967 return(-1);
6968
Daniel Veillardaecc0dc2004-05-08 02:32:07 +00006969 if (names == NULL) return(-1);
Owen Taylor3473f882001-02-23 17:55:21 +00006970 if (max <= 0) return(-1);
6971
William M. Brack9333cc22004-06-24 08:33:40 +00006972 memset(&vctxt, 0, sizeof (xmlValidCtxt));
6973 vctxt.error = xmlNoValidityErr; /* this suppresses err/warn output */
6974
Owen Taylor3473f882001-02-23 17:55:21 +00006975 nb_valid_elements = 0;
6976 ref_node = prev ? prev : next;
6977 parent = ref_node->parent;
6978
6979 /*
6980 * Retrieves the parent element declaration
6981 */
6982 element_desc = xmlGetDtdElementDesc(parent->doc->intSubset,
6983 parent->name);
6984 if ((element_desc == NULL) && (parent->doc->extSubset != NULL))
6985 element_desc = xmlGetDtdElementDesc(parent->doc->extSubset,
6986 parent->name);
6987 if (element_desc == NULL) return(-1);
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006988
Owen Taylor3473f882001-02-23 17:55:21 +00006989 /*
6990 * Do a backup of the current tree structure
6991 */
6992 prev_next = prev ? prev->next : NULL;
6993 next_prev = next ? next->prev : NULL;
6994 parent_childs = parent->children;
6995 parent_last = parent->last;
6996
6997 /*
6998 * Creates a dummy node and insert it into the tree
Daniel Veillardf8e3db02012-09-11 13:26:36 +08006999 */
Daniel Veillard95ddcd32004-10-26 21:53:55 +00007000 test_node = xmlNewDocNode (ref_node->doc, NULL, BAD_CAST "<!dummy?>", NULL);
Owen Taylor3473f882001-02-23 17:55:21 +00007001 test_node->parent = parent;
7002 test_node->prev = prev;
7003 test_node->next = next;
Daniel Veillardd455d792002-02-08 13:37:46 +00007004 name = test_node->name;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08007005
Owen Taylor3473f882001-02-23 17:55:21 +00007006 if (prev) prev->next = test_node;
7007 else parent->children = test_node;
Daniel Veillardf8e3db02012-09-11 13:26:36 +08007008
Owen Taylor3473f882001-02-23 17:55:21 +00007009 if (next) next->prev = test_node;
7010 else parent->last = test_node;
7011
7012 /*
7013 * Insert each potential child node and check if the parent is
7014 * still valid
7015 */
7016 nb_elements = xmlValidGetPotentialChildren(element_desc->content,
7017 elements, &nb_elements, 256);
Daniel Veillardf8e3db02012-09-11 13:26:36 +08007018
Owen Taylor3473f882001-02-23 17:55:21 +00007019 for (i = 0;i < nb_elements;i++) {
7020 test_node->name = elements[i];
Daniel Veillardf69bb4b2001-05-19 13:24:56 +00007021 if (xmlValidateOneElement(&vctxt, parent->doc, parent)) {
Owen Taylor3473f882001-02-23 17:55:21 +00007022 int j;
7023
7024 for (j = 0; j < nb_valid_elements;j++)
Daniel Veillardaecc0dc2004-05-08 02:32:07 +00007025 if (xmlStrEqual(elements[i], names[j])) break;
7026 names[nb_valid_elements++] = elements[i];
Owen Taylor3473f882001-02-23 17:55:21 +00007027 if (nb_valid_elements >= max) break;
7028 }
7029 }
7030
7031 /*
7032 * Restore the tree structure
7033 */
7034 if (prev) prev->next = prev_next;
7035 if (next) next->prev = next_prev;
7036 parent->children = parent_childs;
7037 parent->last = parent_last;
Daniel Veillardd455d792002-02-08 13:37:46 +00007038
7039 /*
7040 * Free up the dummy node
7041 */
7042 test_node->name = name;
7043 xmlFreeNode(test_node);
7044
Owen Taylor3473f882001-02-23 17:55:21 +00007045 return(nb_valid_elements);
7046}
Daniel Veillard4432df22003-09-28 18:58:27 +00007047#endif /* LIBXML_VALID_ENABLED */
7048
Daniel Veillard5d4644e2005-04-01 13:11:58 +00007049#define bottom_valid
7050#include "elfgcchack.h"