1: /*
2: * valid.c : part of the code use to do the DTD handling and the validity
3: * checking
4: *
5: * See Copyright for the status of this software.
6: *
7: * daniel@veillard.com
8: */
9:
10: #define IN_LIBXML
11: #include "libxml.h"
12:
13: #include <string.h>
14:
15: #ifdef HAVE_STDLIB_H
16: #include <stdlib.h>
17: #endif
18:
19: #include <libxml/xmlmemory.h>
20: #include <libxml/hash.h>
21: #include <libxml/uri.h>
22: #include <libxml/valid.h>
23: #include <libxml/parser.h>
24: #include <libxml/parserInternals.h>
25: #include <libxml/xmlerror.h>
26: #include <libxml/list.h>
27: #include <libxml/globals.h>
28:
29: static xmlElementPtr xmlGetDtdElementDesc2(xmlDtdPtr dtd, const xmlChar *name,
30: int create);
31: /* #define DEBUG_VALID_ALGO */
32: /* #define DEBUG_REGEXP_ALGO */
33:
34: #define TODO \
35: xmlGenericError(xmlGenericErrorContext, \
36: "Unimplemented block at %s:%d\n", \
37: __FILE__, __LINE__);
38:
39: #ifdef LIBXML_VALID_ENABLED
40: static int
41: xmlValidateAttributeValueInternal(xmlDocPtr doc, xmlAttributeType type,
42: const xmlChar *value);
43: #endif
44: /************************************************************************
45: * *
46: * Error handling routines *
47: * *
48: ************************************************************************/
49:
50: /**
51: * xmlVErrMemory:
52: * @ctxt: an XML validation parser context
53: * @extra: extra informations
54: *
55: * Handle an out of memory error
56: */
57: static void
58: xmlVErrMemory(xmlValidCtxtPtr ctxt, const char *extra)
59: {
60: xmlGenericErrorFunc channel = NULL;
61: xmlParserCtxtPtr pctxt = NULL;
62: void *data = NULL;
63:
64: if (ctxt != NULL) {
65: channel = ctxt->error;
66: data = ctxt->userData;
67: /* Use the special values to detect if it is part of a parsing
68: context */
69: if ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
70: (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1)) {
71: long delta = (char *) ctxt - (char *) ctxt->userData;
72: if ((delta > 0) && (delta < 250))
73: pctxt = ctxt->userData;
74: }
75: }
76: if (extra)
77: __xmlRaiseError(NULL, channel, data,
78: pctxt, NULL, XML_FROM_VALID, XML_ERR_NO_MEMORY,
79: XML_ERR_FATAL, NULL, 0, extra, NULL, NULL, 0, 0,
80: "Memory allocation failed : %s\n", extra);
81: else
82: __xmlRaiseError(NULL, channel, data,
83: pctxt, NULL, XML_FROM_VALID, XML_ERR_NO_MEMORY,
84: XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0,
85: "Memory allocation failed\n");
86: }
87:
88: /**
89: * xmlErrValid:
90: * @ctxt: an XML validation parser context
91: * @error: the error number
92: * @extra: extra informations
93: *
94: * Handle a validation error
95: */
96: static void
97: xmlErrValid(xmlValidCtxtPtr ctxt, xmlParserErrors error,
98: const char *msg, const char *extra)
99: {
100: xmlGenericErrorFunc channel = NULL;
101: xmlParserCtxtPtr pctxt = NULL;
102: void *data = NULL;
103:
104: if (ctxt != NULL) {
105: channel = ctxt->error;
106: data = ctxt->userData;
107: /* Use the special values to detect if it is part of a parsing
108: context */
109: if ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
110: (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1)) {
111: long delta = (char *) ctxt - (char *) ctxt->userData;
112: if ((delta > 0) && (delta < 250))
113: pctxt = ctxt->userData;
114: }
115: }
116: if (extra)
117: __xmlRaiseError(NULL, channel, data,
118: pctxt, NULL, XML_FROM_VALID, error,
119: XML_ERR_ERROR, NULL, 0, extra, NULL, NULL, 0, 0,
120: msg, extra);
121: else
122: __xmlRaiseError(NULL, channel, data,
123: pctxt, NULL, XML_FROM_VALID, error,
124: XML_ERR_ERROR, NULL, 0, NULL, NULL, NULL, 0, 0,
125: "%s", msg);
126: }
127:
128: #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
129: /**
130: * xmlErrValidNode:
131: * @ctxt: an XML validation parser context
132: * @node: the node raising the error
133: * @error: the error number
134: * @str1: extra informations
135: * @str2: extra informations
136: * @str3: extra informations
137: *
138: * Handle a validation error, provide contextual informations
139: */
140: static void
141: xmlErrValidNode(xmlValidCtxtPtr ctxt,
142: xmlNodePtr node, xmlParserErrors error,
143: const char *msg, const xmlChar * str1,
144: const xmlChar * str2, const xmlChar * str3)
145: {
146: xmlStructuredErrorFunc schannel = NULL;
147: xmlGenericErrorFunc channel = NULL;
148: xmlParserCtxtPtr pctxt = NULL;
149: void *data = NULL;
150:
151: if (ctxt != NULL) {
152: channel = ctxt->error;
153: data = ctxt->userData;
154: /* Use the special values to detect if it is part of a parsing
155: context */
156: if ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
157: (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1)) {
158: long delta = (char *) ctxt - (char *) ctxt->userData;
159: if ((delta > 0) && (delta < 250))
160: pctxt = ctxt->userData;
161: }
162: }
163: __xmlRaiseError(schannel, channel, data, pctxt, node, XML_FROM_VALID, error,
164: XML_ERR_ERROR, NULL, 0,
165: (const char *) str1,
166: (const char *) str1,
167: (const char *) str3, 0, 0, msg, str1, str2, str3);
168: }
169: #endif /* LIBXML_VALID_ENABLED or LIBXML_SCHEMAS_ENABLED */
170:
171: #ifdef LIBXML_VALID_ENABLED
172: /**
173: * xmlErrValidNodeNr:
174: * @ctxt: an XML validation parser context
175: * @node: the node raising the error
176: * @error: the error number
177: * @str1: extra informations
178: * @int2: extra informations
179: * @str3: extra informations
180: *
181: * Handle a validation error, provide contextual informations
182: */
183: static void
184: xmlErrValidNodeNr(xmlValidCtxtPtr ctxt,
185: xmlNodePtr node, xmlParserErrors error,
186: const char *msg, const xmlChar * str1,
187: int int2, const xmlChar * str3)
188: {
189: xmlStructuredErrorFunc schannel = NULL;
190: xmlGenericErrorFunc channel = NULL;
191: xmlParserCtxtPtr pctxt = NULL;
192: void *data = NULL;
193:
194: if (ctxt != NULL) {
195: channel = ctxt->error;
196: data = ctxt->userData;
197: /* Use the special values to detect if it is part of a parsing
198: context */
199: if ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
200: (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1)) {
201: long delta = (char *) ctxt - (char *) ctxt->userData;
202: if ((delta > 0) && (delta < 250))
203: pctxt = ctxt->userData;
204: }
205: }
206: __xmlRaiseError(schannel, channel, data, pctxt, node, XML_FROM_VALID, error,
207: XML_ERR_ERROR, NULL, 0,
208: (const char *) str1,
209: (const char *) str3,
210: NULL, int2, 0, msg, str1, int2, str3);
211: }
212:
213: /**
214: * xmlErrValidWarning:
215: * @ctxt: an XML validation parser context
216: * @node: the node raising the error
217: * @error: the error number
218: * @str1: extra information
219: * @str2: extra information
220: * @str3: extra information
221: *
222: * Handle a validation error, provide contextual information
223: */
224: static void
225: xmlErrValidWarning(xmlValidCtxtPtr ctxt,
226: xmlNodePtr node, xmlParserErrors error,
227: const char *msg, const xmlChar * str1,
228: const xmlChar * str2, const xmlChar * str3)
229: {
230: xmlStructuredErrorFunc schannel = NULL;
231: xmlGenericErrorFunc channel = NULL;
232: xmlParserCtxtPtr pctxt = NULL;
233: void *data = NULL;
234:
235: if (ctxt != NULL) {
236: channel = ctxt->warning;
237: data = ctxt->userData;
238: /* Use the special values to detect if it is part of a parsing
239: context */
240: if ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
241: (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1)) {
242: long delta = (char *) ctxt - (char *) ctxt->userData;
243: if ((delta > 0) && (delta < 250))
244: pctxt = ctxt->userData;
245: }
246: }
247: __xmlRaiseError(schannel, channel, data, pctxt, node, XML_FROM_VALID, error,
248: XML_ERR_WARNING, NULL, 0,
249: (const char *) str1,
250: (const char *) str1,
251: (const char *) str3, 0, 0, msg, str1, str2, str3);
252: }
253:
254:
255:
256: #ifdef LIBXML_REGEXP_ENABLED
257: /*
258: * If regexp are enabled we can do continuous validation without the
259: * need of a tree to validate the content model. this is done in each
260: * callbacks.
261: * Each xmlValidState represent the validation state associated to the
262: * set of nodes currently open from the document root to the current element.
263: */
264:
265:
266: typedef struct _xmlValidState {
267: xmlElementPtr elemDecl; /* pointer to the content model */
268: xmlNodePtr node; /* pointer to the current node */
269: xmlRegExecCtxtPtr exec; /* regexp runtime */
270: } _xmlValidState;
271:
272:
273: static int
274: vstateVPush(xmlValidCtxtPtr ctxt, xmlElementPtr elemDecl, xmlNodePtr node) {
275: if ((ctxt->vstateMax == 0) || (ctxt->vstateTab == NULL)) {
276: ctxt->vstateMax = 10;
277: ctxt->vstateTab = (xmlValidState *) xmlMalloc(ctxt->vstateMax *
278: sizeof(ctxt->vstateTab[0]));
279: if (ctxt->vstateTab == NULL) {
280: xmlVErrMemory(ctxt, "malloc failed");
281: return(-1);
282: }
283: }
284:
285: if (ctxt->vstateNr >= ctxt->vstateMax) {
286: xmlValidState *tmp;
287:
288: tmp = (xmlValidState *) xmlRealloc(ctxt->vstateTab,
289: 2 * ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
290: if (tmp == NULL) {
291: xmlVErrMemory(ctxt, "realloc failed");
292: return(-1);
293: }
294: ctxt->vstateMax *= 2;
295: ctxt->vstateTab = tmp;
296: }
297: ctxt->vstate = &ctxt->vstateTab[ctxt->vstateNr];
298: ctxt->vstateTab[ctxt->vstateNr].elemDecl = elemDecl;
299: ctxt->vstateTab[ctxt->vstateNr].node = node;
300: if ((elemDecl != NULL) && (elemDecl->etype == XML_ELEMENT_TYPE_ELEMENT)) {
301: if (elemDecl->contModel == NULL)
302: xmlValidBuildContentModel(ctxt, elemDecl);
303: if (elemDecl->contModel != NULL) {
304: ctxt->vstateTab[ctxt->vstateNr].exec =
305: xmlRegNewExecCtxt(elemDecl->contModel, NULL, NULL);
306: } else {
307: ctxt->vstateTab[ctxt->vstateNr].exec = NULL;
308: xmlErrValidNode(ctxt, (xmlNodePtr) elemDecl,
309: XML_ERR_INTERNAL_ERROR,
310: "Failed to build content model regexp for %s\n",
311: node->name, NULL, NULL);
312: }
313: }
314: return(ctxt->vstateNr++);
315: }
316:
317: static int
318: vstateVPop(xmlValidCtxtPtr ctxt) {
319: xmlElementPtr elemDecl;
320:
321: if (ctxt->vstateNr < 1) return(-1);
322: ctxt->vstateNr--;
323: elemDecl = ctxt->vstateTab[ctxt->vstateNr].elemDecl;
324: ctxt->vstateTab[ctxt->vstateNr].elemDecl = NULL;
325: ctxt->vstateTab[ctxt->vstateNr].node = NULL;
326: if ((elemDecl != NULL) && (elemDecl->etype == XML_ELEMENT_TYPE_ELEMENT)) {
327: xmlRegFreeExecCtxt(ctxt->vstateTab[ctxt->vstateNr].exec);
328: }
329: ctxt->vstateTab[ctxt->vstateNr].exec = NULL;
330: if (ctxt->vstateNr >= 1)
331: ctxt->vstate = &ctxt->vstateTab[ctxt->vstateNr - 1];
332: else
333: ctxt->vstate = NULL;
334: return(ctxt->vstateNr);
335: }
336:
337: #else /* not LIBXML_REGEXP_ENABLED */
338: /*
339: * If regexp are not enabled, it uses a home made algorithm less
340: * complex and easier to
341: * debug/maintain than a generic NFA -> DFA state based algo. The
342: * only restriction is on the deepness of the tree limited by the
343: * size of the occurs bitfield
344: *
345: * this is the content of a saved state for rollbacks
346: */
347:
348: #define ROLLBACK_OR 0
349: #define ROLLBACK_PARENT 1
350:
351: typedef struct _xmlValidState {
352: xmlElementContentPtr cont; /* pointer to the content model subtree */
353: xmlNodePtr node; /* pointer to the current node in the list */
354: long occurs;/* bitfield for multiple occurrences */
355: unsigned char depth; /* current depth in the overall tree */
356: unsigned char state; /* ROLLBACK_XXX */
357: } _xmlValidState;
358:
359: #define MAX_RECURSE 25000
360: #define MAX_DEPTH ((sizeof(_xmlValidState.occurs)) * 8)
361: #define CONT ctxt->vstate->cont
362: #define NODE ctxt->vstate->node
363: #define DEPTH ctxt->vstate->depth
364: #define OCCURS ctxt->vstate->occurs
365: #define STATE ctxt->vstate->state
366:
367: #define OCCURRENCE (ctxt->vstate->occurs & (1 << DEPTH))
368: #define PARENT_OCCURRENCE (ctxt->vstate->occurs & ((1 << DEPTH) - 1))
369:
370: #define SET_OCCURRENCE ctxt->vstate->occurs |= (1 << DEPTH)
371: #define RESET_OCCURRENCE ctxt->vstate->occurs &= ((1 << DEPTH) - 1)
372:
373: static int
374: vstateVPush(xmlValidCtxtPtr ctxt, xmlElementContentPtr cont,
375: xmlNodePtr node, unsigned char depth, long occurs,
376: unsigned char state) {
377: int i = ctxt->vstateNr - 1;
378:
379: if (ctxt->vstateNr > MAX_RECURSE) {
380: return(-1);
381: }
382: if (ctxt->vstateTab == NULL) {
383: ctxt->vstateMax = 8;
384: ctxt->vstateTab = (xmlValidState *) xmlMalloc(
385: ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
386: if (ctxt->vstateTab == NULL) {
387: xmlVErrMemory(ctxt, "malloc failed");
388: return(-1);
389: }
390: }
391: if (ctxt->vstateNr >= ctxt->vstateMax) {
392: xmlValidState *tmp;
393:
394: tmp = (xmlValidState *) xmlRealloc(ctxt->vstateTab,
395: 2 * ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
396: if (tmp == NULL) {
397: xmlVErrMemory(ctxt, "malloc failed");
398: return(-1);
399: }
400: ctxt->vstateMax *= 2;
401: ctxt->vstateTab = tmp;
402: ctxt->vstate = &ctxt->vstateTab[0];
403: }
404: /*
405: * Don't push on the stack a state already here
406: */
407: if ((i >= 0) && (ctxt->vstateTab[i].cont == cont) &&
408: (ctxt->vstateTab[i].node == node) &&
409: (ctxt->vstateTab[i].depth == depth) &&
410: (ctxt->vstateTab[i].occurs == occurs) &&
411: (ctxt->vstateTab[i].state == state))
412: return(ctxt->vstateNr);
413: ctxt->vstateTab[ctxt->vstateNr].cont = cont;
414: ctxt->vstateTab[ctxt->vstateNr].node = node;
415: ctxt->vstateTab[ctxt->vstateNr].depth = depth;
416: ctxt->vstateTab[ctxt->vstateNr].occurs = occurs;
417: ctxt->vstateTab[ctxt->vstateNr].state = state;
418: return(ctxt->vstateNr++);
419: }
420:
421: static int
422: vstateVPop(xmlValidCtxtPtr ctxt) {
423: if (ctxt->vstateNr <= 1) return(-1);
424: ctxt->vstateNr--;
425: ctxt->vstate = &ctxt->vstateTab[0];
426: ctxt->vstate->cont = ctxt->vstateTab[ctxt->vstateNr].cont;
427: ctxt->vstate->node = ctxt->vstateTab[ctxt->vstateNr].node;
428: ctxt->vstate->depth = ctxt->vstateTab[ctxt->vstateNr].depth;
429: ctxt->vstate->occurs = ctxt->vstateTab[ctxt->vstateNr].occurs;
430: ctxt->vstate->state = ctxt->vstateTab[ctxt->vstateNr].state;
431: return(ctxt->vstateNr);
432: }
433:
434: #endif /* LIBXML_REGEXP_ENABLED */
435:
436: static int
437: nodeVPush(xmlValidCtxtPtr ctxt, xmlNodePtr value)
438: {
439: if (ctxt->nodeMax <= 0) {
440: ctxt->nodeMax = 4;
441: ctxt->nodeTab =
442: (xmlNodePtr *) xmlMalloc(ctxt->nodeMax *
443: sizeof(ctxt->nodeTab[0]));
444: if (ctxt->nodeTab == NULL) {
445: xmlVErrMemory(ctxt, "malloc failed");
446: ctxt->nodeMax = 0;
447: return (0);
448: }
449: }
450: if (ctxt->nodeNr >= ctxt->nodeMax) {
451: xmlNodePtr *tmp;
452: tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
453: ctxt->nodeMax * 2 * sizeof(ctxt->nodeTab[0]));
454: if (tmp == NULL) {
455: xmlVErrMemory(ctxt, "realloc failed");
456: return (0);
457: }
458: ctxt->nodeMax *= 2;
459: ctxt->nodeTab = tmp;
460: }
461: ctxt->nodeTab[ctxt->nodeNr] = value;
462: ctxt->node = value;
463: return (ctxt->nodeNr++);
464: }
465: static xmlNodePtr
466: nodeVPop(xmlValidCtxtPtr ctxt)
467: {
468: xmlNodePtr ret;
469:
470: if (ctxt->nodeNr <= 0)
471: return (NULL);
472: ctxt->nodeNr--;
473: if (ctxt->nodeNr > 0)
474: ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
475: else
476: ctxt->node = NULL;
477: ret = ctxt->nodeTab[ctxt->nodeNr];
478: ctxt->nodeTab[ctxt->nodeNr] = NULL;
479: return (ret);
480: }
481:
482: #ifdef DEBUG_VALID_ALGO
483: static void
484: xmlValidPrintNode(xmlNodePtr cur) {
485: if (cur == NULL) {
486: xmlGenericError(xmlGenericErrorContext, "null");
487: return;
488: }
489: switch (cur->type) {
490: case XML_ELEMENT_NODE:
491: xmlGenericError(xmlGenericErrorContext, "%s ", cur->name);
492: break;
493: case XML_TEXT_NODE:
494: xmlGenericError(xmlGenericErrorContext, "text ");
495: break;
496: case XML_CDATA_SECTION_NODE:
497: xmlGenericError(xmlGenericErrorContext, "cdata ");
498: break;
499: case XML_ENTITY_REF_NODE:
500: xmlGenericError(xmlGenericErrorContext, "&%s; ", cur->name);
501: break;
502: case XML_PI_NODE:
503: xmlGenericError(xmlGenericErrorContext, "pi(%s) ", cur->name);
504: break;
505: case XML_COMMENT_NODE:
506: xmlGenericError(xmlGenericErrorContext, "comment ");
507: break;
508: case XML_ATTRIBUTE_NODE:
509: xmlGenericError(xmlGenericErrorContext, "?attr? ");
510: break;
511: case XML_ENTITY_NODE:
512: xmlGenericError(xmlGenericErrorContext, "?ent? ");
513: break;
514: case XML_DOCUMENT_NODE:
515: xmlGenericError(xmlGenericErrorContext, "?doc? ");
516: break;
517: case XML_DOCUMENT_TYPE_NODE:
518: xmlGenericError(xmlGenericErrorContext, "?doctype? ");
519: break;
520: case XML_DOCUMENT_FRAG_NODE:
521: xmlGenericError(xmlGenericErrorContext, "?frag? ");
522: break;
523: case XML_NOTATION_NODE:
524: xmlGenericError(xmlGenericErrorContext, "?nota? ");
525: break;
526: case XML_HTML_DOCUMENT_NODE:
527: xmlGenericError(xmlGenericErrorContext, "?html? ");
528: break;
529: #ifdef LIBXML_DOCB_ENABLED
530: case XML_DOCB_DOCUMENT_NODE:
531: xmlGenericError(xmlGenericErrorContext, "?docb? ");
532: break;
533: #endif
534: case XML_DTD_NODE:
535: xmlGenericError(xmlGenericErrorContext, "?dtd? ");
536: break;
537: case XML_ELEMENT_DECL:
538: xmlGenericError(xmlGenericErrorContext, "?edecl? ");
539: break;
540: case XML_ATTRIBUTE_DECL:
541: xmlGenericError(xmlGenericErrorContext, "?adecl? ");
542: break;
543: case XML_ENTITY_DECL:
544: xmlGenericError(xmlGenericErrorContext, "?entdecl? ");
545: break;
546: case XML_NAMESPACE_DECL:
547: xmlGenericError(xmlGenericErrorContext, "?nsdecl? ");
548: break;
549: case XML_XINCLUDE_START:
550: xmlGenericError(xmlGenericErrorContext, "incstart ");
551: break;
552: case XML_XINCLUDE_END:
553: xmlGenericError(xmlGenericErrorContext, "incend ");
554: break;
555: }
556: }
557:
558: static void
559: xmlValidPrintNodeList(xmlNodePtr cur) {
560: if (cur == NULL)
561: xmlGenericError(xmlGenericErrorContext, "null ");
562: while (cur != NULL) {
563: xmlValidPrintNode(cur);
564: cur = cur->next;
565: }
566: }
567:
568: static void
569: xmlValidDebug(xmlNodePtr cur, xmlElementContentPtr cont) {
570: char expr[5000];
571:
572: expr[0] = 0;
573: xmlGenericError(xmlGenericErrorContext, "valid: ");
574: xmlValidPrintNodeList(cur);
575: xmlGenericError(xmlGenericErrorContext, "against ");
576: xmlSnprintfElementContent(expr, 5000, cont, 1);
577: xmlGenericError(xmlGenericErrorContext, "%s\n", expr);
578: }
579:
580: static void
581: xmlValidDebugState(xmlValidStatePtr state) {
582: xmlGenericError(xmlGenericErrorContext, "(");
583: if (state->cont == NULL)
584: xmlGenericError(xmlGenericErrorContext, "null,");
585: else
586: switch (state->cont->type) {
587: case XML_ELEMENT_CONTENT_PCDATA:
588: xmlGenericError(xmlGenericErrorContext, "pcdata,");
589: break;
590: case XML_ELEMENT_CONTENT_ELEMENT:
591: xmlGenericError(xmlGenericErrorContext, "%s,",
592: state->cont->name);
593: break;
594: case XML_ELEMENT_CONTENT_SEQ:
595: xmlGenericError(xmlGenericErrorContext, "seq,");
596: break;
597: case XML_ELEMENT_CONTENT_OR:
598: xmlGenericError(xmlGenericErrorContext, "or,");
599: break;
600: }
601: xmlValidPrintNode(state->node);
602: xmlGenericError(xmlGenericErrorContext, ",%d,%X,%d)",
603: state->depth, state->occurs, state->state);
604: }
605:
606: static void
607: xmlValidStateDebug(xmlValidCtxtPtr ctxt) {
608: int i, j;
609:
610: xmlGenericError(xmlGenericErrorContext, "state: ");
611: xmlValidDebugState(ctxt->vstate);
612: xmlGenericError(xmlGenericErrorContext, " stack: %d ",
613: ctxt->vstateNr - 1);
614: for (i = 0, j = ctxt->vstateNr - 1;(i < 3) && (j > 0);i++,j--)
615: xmlValidDebugState(&ctxt->vstateTab[j]);
616: xmlGenericError(xmlGenericErrorContext, "\n");
617: }
618:
619: /*****
620: #define DEBUG_VALID_STATE(n,c) xmlValidDebug(n,c);
621: *****/
622:
623: #define DEBUG_VALID_STATE(n,c) xmlValidStateDebug(ctxt);
624: #define DEBUG_VALID_MSG(m) \
625: xmlGenericError(xmlGenericErrorContext, "%s\n", m);
626:
627: #else
628: #define DEBUG_VALID_STATE(n,c)
629: #define DEBUG_VALID_MSG(m)
630: #endif
631:
632: /* TODO: use hash table for accesses to elem and attribute definitions */
633:
634:
635: #define CHECK_DTD \
636: if (doc == NULL) return(0); \
637: else if ((doc->intSubset == NULL) && \
638: (doc->extSubset == NULL)) return(0)
639:
640: #ifdef LIBXML_REGEXP_ENABLED
641:
642: /************************************************************************
643: * *
644: * Content model validation based on the regexps *
645: * *
646: ************************************************************************/
647:
648: /**
649: * xmlValidBuildAContentModel:
650: * @content: the content model
651: * @ctxt: the schema parser context
652: * @name: the element name whose content is being built
653: *
654: * Generate the automata sequence needed for that type
655: *
656: * Returns 1 if successful or 0 in case of error.
657: */
658: static int
659: xmlValidBuildAContentModel(xmlElementContentPtr content,
660: xmlValidCtxtPtr ctxt,
661: const xmlChar *name) {
662: if (content == NULL) {
663: xmlErrValidNode(ctxt, NULL, XML_ERR_INTERNAL_ERROR,
664: "Found NULL content in content model of %s\n",
665: name, NULL, NULL);
666: return(0);
667: }
668: switch (content->type) {
669: case XML_ELEMENT_CONTENT_PCDATA:
670: xmlErrValidNode(ctxt, NULL, XML_ERR_INTERNAL_ERROR,
671: "Found PCDATA in content model of %s\n",
672: name, NULL, NULL);
673: return(0);
674: break;
675: case XML_ELEMENT_CONTENT_ELEMENT: {
676: xmlAutomataStatePtr oldstate = ctxt->state;
677: xmlChar fn[50];
678: xmlChar *fullname;
679:
680: fullname = xmlBuildQName(content->name, content->prefix, fn, 50);
681: if (fullname == NULL) {
682: xmlVErrMemory(ctxt, "Building content model");
683: return(0);
684: }
685:
686: switch (content->ocur) {
687: case XML_ELEMENT_CONTENT_ONCE:
688: ctxt->state = xmlAutomataNewTransition(ctxt->am,
689: ctxt->state, NULL, fullname, NULL);
690: break;
691: case XML_ELEMENT_CONTENT_OPT:
692: ctxt->state = xmlAutomataNewTransition(ctxt->am,
693: ctxt->state, NULL, fullname, NULL);
694: xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
695: break;
696: case XML_ELEMENT_CONTENT_PLUS:
697: ctxt->state = xmlAutomataNewTransition(ctxt->am,
698: ctxt->state, NULL, fullname, NULL);
699: xmlAutomataNewTransition(ctxt->am, ctxt->state,
700: ctxt->state, fullname, NULL);
701: break;
702: case XML_ELEMENT_CONTENT_MULT:
703: ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
704: ctxt->state, NULL);
705: xmlAutomataNewTransition(ctxt->am,
706: ctxt->state, ctxt->state, fullname, NULL);
707: break;
708: }
709: if ((fullname != fn) && (fullname != content->name))
710: xmlFree(fullname);
711: break;
712: }
713: case XML_ELEMENT_CONTENT_SEQ: {
714: xmlAutomataStatePtr oldstate, oldend;
715: xmlElementContentOccur ocur;
716:
717: /*
718: * Simply iterate over the content
719: */
720: oldstate = ctxt->state;
721: ocur = content->ocur;
722: if (ocur != XML_ELEMENT_CONTENT_ONCE) {
723: ctxt->state = xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
724: oldstate = ctxt->state;
725: }
726: do {
727: xmlValidBuildAContentModel(content->c1, ctxt, name);
728: content = content->c2;
729: } while ((content->type == XML_ELEMENT_CONTENT_SEQ) &&
730: (content->ocur == XML_ELEMENT_CONTENT_ONCE));
731: xmlValidBuildAContentModel(content, ctxt, name);
732: oldend = ctxt->state;
733: ctxt->state = xmlAutomataNewEpsilon(ctxt->am, oldend, NULL);
734: switch (ocur) {
735: case XML_ELEMENT_CONTENT_ONCE:
736: break;
737: case XML_ELEMENT_CONTENT_OPT:
738: xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
739: break;
740: case XML_ELEMENT_CONTENT_MULT:
741: xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
742: xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
743: break;
744: case XML_ELEMENT_CONTENT_PLUS:
745: xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
746: break;
747: }
748: break;
749: }
750: case XML_ELEMENT_CONTENT_OR: {
751: xmlAutomataStatePtr oldstate, oldend;
752: xmlElementContentOccur ocur;
753:
754: ocur = content->ocur;
755: if ((ocur == XML_ELEMENT_CONTENT_PLUS) ||
756: (ocur == XML_ELEMENT_CONTENT_MULT)) {
757: ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
758: ctxt->state, NULL);
759: }
760: oldstate = ctxt->state;
761: oldend = xmlAutomataNewState(ctxt->am);
762:
763: /*
764: * iterate over the subtypes and remerge the end with an
765: * epsilon transition
766: */
767: do {
768: ctxt->state = oldstate;
769: xmlValidBuildAContentModel(content->c1, ctxt, name);
770: xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldend);
771: content = content->c2;
772: } while ((content->type == XML_ELEMENT_CONTENT_OR) &&
773: (content->ocur == XML_ELEMENT_CONTENT_ONCE));
774: ctxt->state = oldstate;
775: xmlValidBuildAContentModel(content, ctxt, name);
776: xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldend);
777: ctxt->state = xmlAutomataNewEpsilon(ctxt->am, oldend, NULL);
778: switch (ocur) {
779: case XML_ELEMENT_CONTENT_ONCE:
780: break;
781: case XML_ELEMENT_CONTENT_OPT:
782: xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
783: break;
784: case XML_ELEMENT_CONTENT_MULT:
785: xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
786: xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
787: break;
788: case XML_ELEMENT_CONTENT_PLUS:
789: xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
790: break;
791: }
792: break;
793: }
794: default:
795: xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
796: "ContentModel broken for element %s\n",
797: (const char *) name);
798: return(0);
799: }
800: return(1);
801: }
802: /**
803: * xmlValidBuildContentModel:
804: * @ctxt: a validation context
805: * @elem: an element declaration node
806: *
807: * (Re)Build the automata associated to the content model of this
808: * element
809: *
810: * Returns 1 in case of success, 0 in case of error
811: */
812: int
813: xmlValidBuildContentModel(xmlValidCtxtPtr ctxt, xmlElementPtr elem) {
814:
815: if ((ctxt == NULL) || (elem == NULL))
816: return(0);
817: if (elem->type != XML_ELEMENT_DECL)
818: return(0);
819: if (elem->etype != XML_ELEMENT_TYPE_ELEMENT)
820: return(1);
821: /* TODO: should we rebuild in this case ? */
822: if (elem->contModel != NULL) {
823: if (!xmlRegexpIsDeterminist(elem->contModel)) {
824: ctxt->valid = 0;
825: return(0);
826: }
827: return(1);
828: }
829:
830: ctxt->am = xmlNewAutomata();
831: if (ctxt->am == NULL) {
832: xmlErrValidNode(ctxt, (xmlNodePtr) elem,
833: XML_ERR_INTERNAL_ERROR,
834: "Cannot create automata for element %s\n",
835: elem->name, NULL, NULL);
836: return(0);
837: }
838: ctxt->state = xmlAutomataGetInitState(ctxt->am);
839: xmlValidBuildAContentModel(elem->content, ctxt, elem->name);
840: xmlAutomataSetFinalState(ctxt->am, ctxt->state);
841: elem->contModel = xmlAutomataCompile(ctxt->am);
842: if (xmlRegexpIsDeterminist(elem->contModel) != 1) {
843: char expr[5000];
844: expr[0] = 0;
845: xmlSnprintfElementContent(expr, 5000, elem->content, 1);
846: xmlErrValidNode(ctxt, (xmlNodePtr) elem,
847: XML_DTD_CONTENT_NOT_DETERMINIST,
848: "Content model of %s is not determinist: %s\n",
849: elem->name, BAD_CAST expr, NULL);
850: #ifdef DEBUG_REGEXP_ALGO
851: xmlRegexpPrint(stderr, elem->contModel);
852: #endif
853: ctxt->valid = 0;
854: ctxt->state = NULL;
855: xmlFreeAutomata(ctxt->am);
856: ctxt->am = NULL;
857: return(0);
858: }
859: ctxt->state = NULL;
860: xmlFreeAutomata(ctxt->am);
861: ctxt->am = NULL;
862: return(1);
863: }
864:
865: #endif /* LIBXML_REGEXP_ENABLED */
866:
867: /****************************************************************
868: * *
869: * Util functions for data allocation/deallocation *
870: * *
871: ****************************************************************/
872:
873: /**
874: * xmlNewValidCtxt:
875: *
876: * Allocate a validation context structure.
877: *
878: * Returns NULL if not, otherwise the new validation context structure
879: */
880: xmlValidCtxtPtr xmlNewValidCtxt(void) {
881: xmlValidCtxtPtr ret;
882:
883: if ((ret = xmlMalloc(sizeof (xmlValidCtxt))) == NULL) {
884: xmlVErrMemory(NULL, "malloc failed");
885: return (NULL);
886: }
887:
888: (void) memset(ret, 0, sizeof (xmlValidCtxt));
889:
890: return (ret);
891: }
892:
893: /**
894: * xmlFreeValidCtxt:
895: * @cur: the validation context to free
896: *
897: * Free a validation context structure.
898: */
899: void
900: xmlFreeValidCtxt(xmlValidCtxtPtr cur) {
901: if (cur->vstateTab != NULL)
902: xmlFree(cur->vstateTab);
903: if (cur->nodeTab != NULL)
904: xmlFree(cur->nodeTab);
905: xmlFree(cur);
906: }
907:
908: #endif /* LIBXML_VALID_ENABLED */
909:
910: /**
911: * xmlNewDocElementContent:
912: * @doc: the document
913: * @name: the subelement name or NULL
914: * @type: the type of element content decl
915: *
916: * Allocate an element content structure for the document.
917: *
918: * Returns NULL if not, otherwise the new element content structure
919: */
920: xmlElementContentPtr
921: xmlNewDocElementContent(xmlDocPtr doc, const xmlChar *name,
922: xmlElementContentType type) {
923: xmlElementContentPtr ret;
924: xmlDictPtr dict = NULL;
925:
926: if (doc != NULL)
927: dict = doc->dict;
928:
929: switch(type) {
930: case XML_ELEMENT_CONTENT_ELEMENT:
931: if (name == NULL) {
932: xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
933: "xmlNewElementContent : name == NULL !\n",
934: NULL);
935: }
936: break;
937: case XML_ELEMENT_CONTENT_PCDATA:
938: case XML_ELEMENT_CONTENT_SEQ:
939: case XML_ELEMENT_CONTENT_OR:
940: if (name != NULL) {
941: xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
942: "xmlNewElementContent : name != NULL !\n",
943: NULL);
944: }
945: break;
946: default:
947: xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
948: "Internal: ELEMENT content corrupted invalid type\n",
949: NULL);
950: return(NULL);
951: }
952: ret = (xmlElementContentPtr) xmlMalloc(sizeof(xmlElementContent));
953: if (ret == NULL) {
954: xmlVErrMemory(NULL, "malloc failed");
955: return(NULL);
956: }
957: memset(ret, 0, sizeof(xmlElementContent));
958: ret->type = type;
959: ret->ocur = XML_ELEMENT_CONTENT_ONCE;
960: if (name != NULL) {
961: int l;
962: const xmlChar *tmp;
963:
964: tmp = xmlSplitQName3(name, &l);
965: if (tmp == NULL) {
966: if (dict == NULL)
967: ret->name = xmlStrdup(name);
968: else
969: ret->name = xmlDictLookup(dict, name, -1);
970: } else {
971: if (dict == NULL) {
972: ret->prefix = xmlStrndup(name, l);
973: ret->name = xmlStrdup(tmp);
974: } else {
975: ret->prefix = xmlDictLookup(dict, name, l);
976: ret->name = xmlDictLookup(dict, tmp, -1);
977: }
978: }
979: }
980: return(ret);
981: }
982:
983: /**
984: * xmlNewElementContent:
985: * @name: the subelement name or NULL
986: * @type: the type of element content decl
987: *
988: * Allocate an element content structure.
989: * Deprecated in favor of xmlNewDocElementContent
990: *
991: * Returns NULL if not, otherwise the new element content structure
992: */
993: xmlElementContentPtr
994: xmlNewElementContent(const xmlChar *name, xmlElementContentType type) {
995: return(xmlNewDocElementContent(NULL, name, type));
996: }
997:
998: /**
999: * xmlCopyDocElementContent:
1000: * @doc: the document owning the element declaration
1001: * @cur: An element content pointer.
1002: *
1003: * Build a copy of an element content description.
1004: *
1005: * Returns the new xmlElementContentPtr or NULL in case of error.
1006: */
1007: xmlElementContentPtr
1008: xmlCopyDocElementContent(xmlDocPtr doc, xmlElementContentPtr cur) {
1009: xmlElementContentPtr ret = NULL, prev = NULL, tmp;
1010: xmlDictPtr dict = NULL;
1011:
1012: if (cur == NULL) return(NULL);
1013:
1014: if (doc != NULL)
1015: dict = doc->dict;
1016:
1017: ret = (xmlElementContentPtr) xmlMalloc(sizeof(xmlElementContent));
1018: if (ret == NULL) {
1019: xmlVErrMemory(NULL, "malloc failed");
1020: return(NULL);
1021: }
1022: memset(ret, 0, sizeof(xmlElementContent));
1023: ret->type = cur->type;
1024: ret->ocur = cur->ocur;
1025: if (cur->name != NULL) {
1026: if (dict)
1027: ret->name = xmlDictLookup(dict, cur->name, -1);
1028: else
1029: ret->name = xmlStrdup(cur->name);
1030: }
1031:
1032: if (cur->prefix != NULL) {
1033: if (dict)
1034: ret->prefix = xmlDictLookup(dict, cur->prefix, -1);
1035: else
1036: ret->prefix = xmlStrdup(cur->prefix);
1037: }
1038: if (cur->c1 != NULL)
1039: ret->c1 = xmlCopyDocElementContent(doc, cur->c1);
1040: if (ret->c1 != NULL)
1041: ret->c1->parent = ret;
1042: if (cur->c2 != NULL) {
1043: prev = ret;
1044: cur = cur->c2;
1045: while (cur != NULL) {
1046: tmp = (xmlElementContentPtr) xmlMalloc(sizeof(xmlElementContent));
1047: if (tmp == NULL) {
1048: xmlVErrMemory(NULL, "malloc failed");
1049: return(ret);
1050: }
1051: memset(tmp, 0, sizeof(xmlElementContent));
1052: tmp->type = cur->type;
1053: tmp->ocur = cur->ocur;
1054: prev->c2 = tmp;
1055: if (cur->name != NULL) {
1056: if (dict)
1057: tmp->name = xmlDictLookup(dict, cur->name, -1);
1058: else
1059: tmp->name = xmlStrdup(cur->name);
1060: }
1061:
1062: if (cur->prefix != NULL) {
1063: if (dict)
1064: tmp->prefix = xmlDictLookup(dict, cur->prefix, -1);
1065: else
1066: tmp->prefix = xmlStrdup(cur->prefix);
1067: }
1068: if (cur->c1 != NULL)
1069: tmp->c1 = xmlCopyDocElementContent(doc,cur->c1);
1070: if (tmp->c1 != NULL)
1071: tmp->c1->parent = ret;
1072: prev = tmp;
1073: cur = cur->c2;
1074: }
1075: }
1076: return(ret);
1077: }
1078:
1079: /**
1080: * xmlCopyElementContent:
1081: * @cur: An element content pointer.
1082: *
1083: * Build a copy of an element content description.
1084: * Deprecated, use xmlCopyDocElementContent instead
1085: *
1086: * Returns the new xmlElementContentPtr or NULL in case of error.
1087: */
1088: xmlElementContentPtr
1089: xmlCopyElementContent(xmlElementContentPtr cur) {
1090: return(xmlCopyDocElementContent(NULL, cur));
1091: }
1092:
1093: /**
1094: * xmlFreeDocElementContent:
1095: * @doc: the document owning the element declaration
1096: * @cur: the element content tree to free
1097: *
1098: * Free an element content structure. The whole subtree is removed.
1099: */
1100: void
1101: xmlFreeDocElementContent(xmlDocPtr doc, xmlElementContentPtr cur) {
1102: xmlElementContentPtr next;
1103: xmlDictPtr dict = NULL;
1104:
1105: if (doc != NULL)
1106: dict = doc->dict;
1107:
1108: while (cur != NULL) {
1109: next = cur->c2;
1110: switch (cur->type) {
1111: case XML_ELEMENT_CONTENT_PCDATA:
1112: case XML_ELEMENT_CONTENT_ELEMENT:
1113: case XML_ELEMENT_CONTENT_SEQ:
1114: case XML_ELEMENT_CONTENT_OR:
1115: break;
1116: default:
1117: xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
1118: "Internal: ELEMENT content corrupted invalid type\n",
1119: NULL);
1120: return;
1121: }
1122: if (cur->c1 != NULL) xmlFreeDocElementContent(doc, cur->c1);
1123: if (dict) {
1124: if ((cur->name != NULL) && (!xmlDictOwns(dict, cur->name)))
1125: xmlFree((xmlChar *) cur->name);
1126: if ((cur->prefix != NULL) && (!xmlDictOwns(dict, cur->prefix)))
1127: xmlFree((xmlChar *) cur->prefix);
1128: } else {
1129: if (cur->name != NULL) xmlFree((xmlChar *) cur->name);
1130: if (cur->prefix != NULL) xmlFree((xmlChar *) cur->prefix);
1131: }
1132: xmlFree(cur);
1133: cur = next;
1134: }
1135: }
1136:
1137: /**
1138: * xmlFreeElementContent:
1139: * @cur: the element content tree to free
1140: *
1141: * Free an element content structure. The whole subtree is removed.
1142: * Deprecated, use xmlFreeDocElementContent instead
1143: */
1144: void
1145: xmlFreeElementContent(xmlElementContentPtr cur) {
1146: xmlFreeDocElementContent(NULL, cur);
1147: }
1148:
1149: #ifdef LIBXML_OUTPUT_ENABLED
1150: /**
1151: * xmlDumpElementContent:
1152: * @buf: An XML buffer
1153: * @content: An element table
1154: * @glob: 1 if one must print the englobing parenthesis, 0 otherwise
1155: *
1156: * This will dump the content of the element table as an XML DTD definition
1157: */
1158: static void
1159: xmlDumpElementContent(xmlBufferPtr buf, xmlElementContentPtr content, int glob) {
1160: if (content == NULL) return;
1161:
1162: if (glob) xmlBufferWriteChar(buf, "(");
1163: switch (content->type) {
1164: case XML_ELEMENT_CONTENT_PCDATA:
1165: xmlBufferWriteChar(buf, "#PCDATA");
1166: break;
1167: case XML_ELEMENT_CONTENT_ELEMENT:
1168: if (content->prefix != NULL) {
1169: xmlBufferWriteCHAR(buf, content->prefix);
1170: xmlBufferWriteChar(buf, ":");
1171: }
1172: xmlBufferWriteCHAR(buf, content->name);
1173: break;
1174: case XML_ELEMENT_CONTENT_SEQ:
1175: if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1176: (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
1177: xmlDumpElementContent(buf, content->c1, 1);
1178: else
1179: xmlDumpElementContent(buf, content->c1, 0);
1180: xmlBufferWriteChar(buf, " , ");
1181: if ((content->c2->type == XML_ELEMENT_CONTENT_OR) ||
1182: ((content->c2->type == XML_ELEMENT_CONTENT_SEQ) &&
1183: (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)))
1184: xmlDumpElementContent(buf, content->c2, 1);
1185: else
1186: xmlDumpElementContent(buf, content->c2, 0);
1187: break;
1188: case XML_ELEMENT_CONTENT_OR:
1189: if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1190: (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
1191: xmlDumpElementContent(buf, content->c1, 1);
1192: else
1193: xmlDumpElementContent(buf, content->c1, 0);
1194: xmlBufferWriteChar(buf, " | ");
1195: if ((content->c2->type == XML_ELEMENT_CONTENT_SEQ) ||
1196: ((content->c2->type == XML_ELEMENT_CONTENT_OR) &&
1197: (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)))
1198: xmlDumpElementContent(buf, content->c2, 1);
1199: else
1200: xmlDumpElementContent(buf, content->c2, 0);
1201: break;
1202: default:
1203: xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
1204: "Internal: ELEMENT content corrupted invalid type\n",
1205: NULL);
1206: }
1207: if (glob)
1208: xmlBufferWriteChar(buf, ")");
1209: switch (content->ocur) {
1210: case XML_ELEMENT_CONTENT_ONCE:
1211: break;
1212: case XML_ELEMENT_CONTENT_OPT:
1213: xmlBufferWriteChar(buf, "?");
1214: break;
1215: case XML_ELEMENT_CONTENT_MULT:
1216: xmlBufferWriteChar(buf, "*");
1217: break;
1218: case XML_ELEMENT_CONTENT_PLUS:
1219: xmlBufferWriteChar(buf, "+");
1220: break;
1221: }
1222: }
1223:
1224: /**
1225: * xmlSprintfElementContent:
1226: * @buf: an output buffer
1227: * @content: An element table
1228: * @englob: 1 if one must print the englobing parenthesis, 0 otherwise
1229: *
1230: * Deprecated, unsafe, use xmlSnprintfElementContent
1231: */
1232: void
1233: xmlSprintfElementContent(char *buf ATTRIBUTE_UNUSED,
1234: xmlElementContentPtr content ATTRIBUTE_UNUSED,
1235: int englob ATTRIBUTE_UNUSED) {
1236: }
1237: #endif /* LIBXML_OUTPUT_ENABLED */
1238:
1239: /**
1240: * xmlSnprintfElementContent:
1241: * @buf: an output buffer
1242: * @size: the buffer size
1243: * @content: An element table
1244: * @englob: 1 if one must print the englobing parenthesis, 0 otherwise
1245: *
1246: * This will dump the content of the element content definition
1247: * Intended just for the debug routine
1248: */
1249: void
1250: xmlSnprintfElementContent(char *buf, int size, xmlElementContentPtr content, int englob) {
1251: int len;
1252:
1253: if (content == NULL) return;
1254: len = strlen(buf);
1255: if (size - len < 50) {
1256: if ((size - len > 4) && (buf[len - 1] != '.'))
1257: strcat(buf, " ...");
1258: return;
1259: }
1260: if (englob) strcat(buf, "(");
1261: switch (content->type) {
1262: case XML_ELEMENT_CONTENT_PCDATA:
1263: strcat(buf, "#PCDATA");
1264: break;
1265: case XML_ELEMENT_CONTENT_ELEMENT:
1266: if (content->prefix != NULL) {
1267: if (size - len < xmlStrlen(content->prefix) + 10) {
1268: strcat(buf, " ...");
1269: return;
1270: }
1271: strcat(buf, (char *) content->prefix);
1272: strcat(buf, ":");
1273: }
1274: if (size - len < xmlStrlen(content->name) + 10) {
1275: strcat(buf, " ...");
1276: return;
1277: }
1278: if (content->name != NULL)
1279: strcat(buf, (char *) content->name);
1280: break;
1281: case XML_ELEMENT_CONTENT_SEQ:
1282: if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1283: (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
1284: xmlSnprintfElementContent(buf, size, content->c1, 1);
1285: else
1286: xmlSnprintfElementContent(buf, size, content->c1, 0);
1287: len = strlen(buf);
1288: if (size - len < 50) {
1289: if ((size - len > 4) && (buf[len - 1] != '.'))
1290: strcat(buf, " ...");
1291: return;
1292: }
1293: strcat(buf, " , ");
1294: if (((content->c2->type == XML_ELEMENT_CONTENT_OR) ||
1295: (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)) &&
1296: (content->c2->type != XML_ELEMENT_CONTENT_ELEMENT))
1297: xmlSnprintfElementContent(buf, size, content->c2, 1);
1298: else
1299: xmlSnprintfElementContent(buf, size, content->c2, 0);
1300: break;
1301: case XML_ELEMENT_CONTENT_OR:
1302: if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1303: (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
1304: xmlSnprintfElementContent(buf, size, content->c1, 1);
1305: else
1306: xmlSnprintfElementContent(buf, size, content->c1, 0);
1307: len = strlen(buf);
1308: if (size - len < 50) {
1309: if ((size - len > 4) && (buf[len - 1] != '.'))
1310: strcat(buf, " ...");
1311: return;
1312: }
1313: strcat(buf, " | ");
1314: if (((content->c2->type == XML_ELEMENT_CONTENT_SEQ) ||
1315: (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)) &&
1316: (content->c2->type != XML_ELEMENT_CONTENT_ELEMENT))
1317: xmlSnprintfElementContent(buf, size, content->c2, 1);
1318: else
1319: xmlSnprintfElementContent(buf, size, content->c2, 0);
1320: break;
1321: }
1322: if (englob)
1323: strcat(buf, ")");
1324: switch (content->ocur) {
1325: case XML_ELEMENT_CONTENT_ONCE:
1326: break;
1327: case XML_ELEMENT_CONTENT_OPT:
1328: strcat(buf, "?");
1329: break;
1330: case XML_ELEMENT_CONTENT_MULT:
1331: strcat(buf, "*");
1332: break;
1333: case XML_ELEMENT_CONTENT_PLUS:
1334: strcat(buf, "+");
1335: break;
1336: }
1337: }
1338:
1339: /****************************************************************
1340: * *
1341: * Registration of DTD declarations *
1342: * *
1343: ****************************************************************/
1344:
1345: /**
1346: * xmlFreeElement:
1347: * @elem: An element
1348: *
1349: * Deallocate the memory used by an element definition
1350: */
1351: static void
1352: xmlFreeElement(xmlElementPtr elem) {
1353: if (elem == NULL) return;
1354: xmlUnlinkNode((xmlNodePtr) elem);
1355: xmlFreeDocElementContent(elem->doc, elem->content);
1356: if (elem->name != NULL)
1357: xmlFree((xmlChar *) elem->name);
1358: if (elem->prefix != NULL)
1359: xmlFree((xmlChar *) elem->prefix);
1360: #ifdef LIBXML_REGEXP_ENABLED
1361: if (elem->contModel != NULL)
1362: xmlRegFreeRegexp(elem->contModel);
1363: #endif
1364: xmlFree(elem);
1365: }
1366:
1367:
1368: /**
1369: * xmlAddElementDecl:
1370: * @ctxt: the validation context
1371: * @dtd: pointer to the DTD
1372: * @name: the entity name
1373: * @type: the element type
1374: * @content: the element content tree or NULL
1375: *
1376: * Register a new element declaration
1377: *
1378: * Returns NULL if not, otherwise the entity
1379: */
1380: xmlElementPtr
1381: xmlAddElementDecl(xmlValidCtxtPtr ctxt,
1382: xmlDtdPtr dtd, const xmlChar *name,
1383: xmlElementTypeVal type,
1384: xmlElementContentPtr content) {
1385: xmlElementPtr ret;
1386: xmlElementTablePtr table;
1387: xmlAttributePtr oldAttributes = NULL;
1388: xmlChar *ns, *uqname;
1389:
1390: if (dtd == NULL) {
1391: return(NULL);
1392: }
1393: if (name == NULL) {
1394: return(NULL);
1395: }
1396:
1397: switch (type) {
1398: case XML_ELEMENT_TYPE_EMPTY:
1399: if (content != NULL) {
1400: xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1401: "xmlAddElementDecl: content != NULL for EMPTY\n",
1402: NULL);
1403: return(NULL);
1404: }
1405: break;
1406: case XML_ELEMENT_TYPE_ANY:
1407: if (content != NULL) {
1408: xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1409: "xmlAddElementDecl: content != NULL for ANY\n",
1410: NULL);
1411: return(NULL);
1412: }
1413: break;
1414: case XML_ELEMENT_TYPE_MIXED:
1415: if (content == NULL) {
1416: xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1417: "xmlAddElementDecl: content == NULL for MIXED\n",
1418: NULL);
1419: return(NULL);
1420: }
1421: break;
1422: case XML_ELEMENT_TYPE_ELEMENT:
1423: if (content == NULL) {
1424: xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1425: "xmlAddElementDecl: content == NULL for ELEMENT\n",
1426: NULL);
1427: return(NULL);
1428: }
1429: break;
1430: default:
1431: xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1432: "Internal: ELEMENT decl corrupted invalid type\n",
1433: NULL);
1434: return(NULL);
1435: }
1436:
1437: /*
1438: * check if name is a QName
1439: */
1440: uqname = xmlSplitQName2(name, &ns);
1441: if (uqname != NULL)
1442: name = uqname;
1443:
1444: /*
1445: * Create the Element table if needed.
1446: */
1447: table = (xmlElementTablePtr) dtd->elements;
1448: if (table == NULL) {
1449: xmlDictPtr dict = NULL;
1450:
1451: if (dtd->doc != NULL)
1452: dict = dtd->doc->dict;
1453: table = xmlHashCreateDict(0, dict);
1454: dtd->elements = (void *) table;
1455: }
1456: if (table == NULL) {
1457: xmlVErrMemory(ctxt,
1458: "xmlAddElementDecl: Table creation failed!\n");
1459: if (uqname != NULL)
1460: xmlFree(uqname);
1461: if (ns != NULL)
1462: xmlFree(ns);
1463: return(NULL);
1464: }
1465:
1466: /*
1467: * lookup old attributes inserted on an undefined element in the
1468: * internal subset.
1469: */
1470: if ((dtd->doc != NULL) && (dtd->doc->intSubset != NULL)) {
1471: ret = xmlHashLookup2(dtd->doc->intSubset->elements, name, ns);
1472: if ((ret != NULL) && (ret->etype == XML_ELEMENT_TYPE_UNDEFINED)) {
1473: oldAttributes = ret->attributes;
1474: ret->attributes = NULL;
1475: xmlHashRemoveEntry2(dtd->doc->intSubset->elements, name, ns, NULL);
1476: xmlFreeElement(ret);
1477: }
1478: }
1479:
1480: /*
1481: * The element may already be present if one of its attribute
1482: * was registered first
1483: */
1484: ret = xmlHashLookup2(table, name, ns);
1485: if (ret != NULL) {
1486: if (ret->etype != XML_ELEMENT_TYPE_UNDEFINED) {
1487: #ifdef LIBXML_VALID_ENABLED
1488: /*
1489: * The element is already defined in this DTD.
1490: */
1491: xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ELEM_REDEFINED,
1492: "Redefinition of element %s\n",
1493: name, NULL, NULL);
1494: #endif /* LIBXML_VALID_ENABLED */
1495: if (uqname != NULL)
1496: xmlFree(uqname);
1497: if (ns != NULL)
1498: xmlFree(ns);
1499: return(NULL);
1500: }
1501: if (ns != NULL) {
1502: xmlFree(ns);
1503: ns = NULL;
1504: }
1505: } else {
1506: ret = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
1507: if (ret == NULL) {
1508: xmlVErrMemory(ctxt, "malloc failed");
1509: if (uqname != NULL)
1510: xmlFree(uqname);
1511: if (ns != NULL)
1512: xmlFree(ns);
1513: return(NULL);
1514: }
1515: memset(ret, 0, sizeof(xmlElement));
1516: ret->type = XML_ELEMENT_DECL;
1517:
1518: /*
1519: * fill the structure.
1520: */
1521: ret->name = xmlStrdup(name);
1522: if (ret->name == NULL) {
1523: xmlVErrMemory(ctxt, "malloc failed");
1524: if (uqname != NULL)
1525: xmlFree(uqname);
1526: if (ns != NULL)
1527: xmlFree(ns);
1528: xmlFree(ret);
1529: return(NULL);
1530: }
1531: ret->prefix = ns;
1532:
1533: /*
1534: * Validity Check:
1535: * Insertion must not fail
1536: */
1537: if (xmlHashAddEntry2(table, name, ns, ret)) {
1538: #ifdef LIBXML_VALID_ENABLED
1539: /*
1540: * The element is already defined in this DTD.
1541: */
1542: xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ELEM_REDEFINED,
1543: "Redefinition of element %s\n",
1544: name, NULL, NULL);
1545: #endif /* LIBXML_VALID_ENABLED */
1546: xmlFreeElement(ret);
1547: if (uqname != NULL)
1548: xmlFree(uqname);
1549: return(NULL);
1550: }
1551: /*
1552: * For new element, may have attributes from earlier
1553: * definition in internal subset
1554: */
1555: ret->attributes = oldAttributes;
1556: }
1557:
1558: /*
1559: * Finish to fill the structure.
1560: */
1561: ret->etype = type;
1562: /*
1563: * Avoid a stupid copy when called by the parser
1564: * and flag it by setting a special parent value
1565: * so the parser doesn't unallocate it.
1566: */
1567: if ((ctxt != NULL) &&
1568: ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
1569: (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1))) {
1570: ret->content = content;
1571: if (content != NULL)
1572: content->parent = (xmlElementContentPtr) 1;
1573: } else {
1574: ret->content = xmlCopyDocElementContent(dtd->doc, content);
1575: }
1576:
1577: /*
1578: * Link it to the DTD
1579: */
1580: ret->parent = dtd;
1581: ret->doc = dtd->doc;
1582: if (dtd->last == NULL) {
1583: dtd->children = dtd->last = (xmlNodePtr) ret;
1584: } else {
1585: dtd->last->next = (xmlNodePtr) ret;
1586: ret->prev = dtd->last;
1587: dtd->last = (xmlNodePtr) ret;
1588: }
1589: if (uqname != NULL)
1590: xmlFree(uqname);
1591: return(ret);
1592: }
1593:
1594: /**
1595: * xmlFreeElementTable:
1596: * @table: An element table
1597: *
1598: * Deallocate the memory used by an element hash table.
1599: */
1600: void
1601: xmlFreeElementTable(xmlElementTablePtr table) {
1602: xmlHashFree(table, (xmlHashDeallocator) xmlFreeElement);
1603: }
1604:
1605: #ifdef LIBXML_TREE_ENABLED
1606: /**
1607: * xmlCopyElement:
1608: * @elem: An element
1609: *
1610: * Build a copy of an element.
1611: *
1612: * Returns the new xmlElementPtr or NULL in case of error.
1613: */
1614: static xmlElementPtr
1615: xmlCopyElement(xmlElementPtr elem) {
1616: xmlElementPtr cur;
1617:
1618: cur = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
1619: if (cur == NULL) {
1620: xmlVErrMemory(NULL, "malloc failed");
1621: return(NULL);
1622: }
1623: memset(cur, 0, sizeof(xmlElement));
1624: cur->type = XML_ELEMENT_DECL;
1625: cur->etype = elem->etype;
1626: if (elem->name != NULL)
1627: cur->name = xmlStrdup(elem->name);
1628: else
1629: cur->name = NULL;
1630: if (elem->prefix != NULL)
1631: cur->prefix = xmlStrdup(elem->prefix);
1632: else
1633: cur->prefix = NULL;
1634: cur->content = xmlCopyElementContent(elem->content);
1635: /* TODO : rebuild the attribute list on the copy */
1636: cur->attributes = NULL;
1637: return(cur);
1638: }
1639:
1640: /**
1641: * xmlCopyElementTable:
1642: * @table: An element table
1643: *
1644: * Build a copy of an element table.
1645: *
1646: * Returns the new xmlElementTablePtr or NULL in case of error.
1647: */
1648: xmlElementTablePtr
1649: xmlCopyElementTable(xmlElementTablePtr table) {
1650: return((xmlElementTablePtr) xmlHashCopy(table,
1651: (xmlHashCopier) xmlCopyElement));
1652: }
1653: #endif /* LIBXML_TREE_ENABLED */
1654:
1655: #ifdef LIBXML_OUTPUT_ENABLED
1656: /**
1657: * xmlDumpElementDecl:
1658: * @buf: the XML buffer output
1659: * @elem: An element table
1660: *
1661: * This will dump the content of the element declaration as an XML
1662: * DTD definition
1663: */
1664: void
1665: xmlDumpElementDecl(xmlBufferPtr buf, xmlElementPtr elem) {
1666: if ((buf == NULL) || (elem == NULL))
1667: return;
1668: switch (elem->etype) {
1669: case XML_ELEMENT_TYPE_EMPTY:
1670: xmlBufferWriteChar(buf, "<!ELEMENT ");
1671: if (elem->prefix != NULL) {
1672: xmlBufferWriteCHAR(buf, elem->prefix);
1673: xmlBufferWriteChar(buf, ":");
1674: }
1675: xmlBufferWriteCHAR(buf, elem->name);
1676: xmlBufferWriteChar(buf, " EMPTY>\n");
1677: break;
1678: case XML_ELEMENT_TYPE_ANY:
1679: xmlBufferWriteChar(buf, "<!ELEMENT ");
1680: if (elem->prefix != NULL) {
1681: xmlBufferWriteCHAR(buf, elem->prefix);
1682: xmlBufferWriteChar(buf, ":");
1683: }
1684: xmlBufferWriteCHAR(buf, elem->name);
1685: xmlBufferWriteChar(buf, " ANY>\n");
1686: break;
1687: case XML_ELEMENT_TYPE_MIXED:
1688: xmlBufferWriteChar(buf, "<!ELEMENT ");
1689: if (elem->prefix != NULL) {
1690: xmlBufferWriteCHAR(buf, elem->prefix);
1691: xmlBufferWriteChar(buf, ":");
1692: }
1693: xmlBufferWriteCHAR(buf, elem->name);
1694: xmlBufferWriteChar(buf, " ");
1695: xmlDumpElementContent(buf, elem->content, 1);
1696: xmlBufferWriteChar(buf, ">\n");
1697: break;
1698: case XML_ELEMENT_TYPE_ELEMENT:
1699: xmlBufferWriteChar(buf, "<!ELEMENT ");
1700: if (elem->prefix != NULL) {
1701: xmlBufferWriteCHAR(buf, elem->prefix);
1702: xmlBufferWriteChar(buf, ":");
1703: }
1704: xmlBufferWriteCHAR(buf, elem->name);
1705: xmlBufferWriteChar(buf, " ");
1706: xmlDumpElementContent(buf, elem->content, 1);
1707: xmlBufferWriteChar(buf, ">\n");
1708: break;
1709: default:
1710: xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
1711: "Internal: ELEMENT struct corrupted invalid type\n",
1712: NULL);
1713: }
1714: }
1715:
1716: /**
1717: * xmlDumpElementDeclScan:
1718: * @elem: An element table
1719: * @buf: the XML buffer output
1720: *
1721: * This routine is used by the hash scan function. It just reverses
1722: * the arguments.
1723: */
1724: static void
1725: xmlDumpElementDeclScan(xmlElementPtr elem, xmlBufferPtr buf) {
1726: xmlDumpElementDecl(buf, elem);
1727: }
1728:
1729: /**
1730: * xmlDumpElementTable:
1731: * @buf: the XML buffer output
1732: * @table: An element table
1733: *
1734: * This will dump the content of the element table as an XML DTD definition
1735: */
1736: void
1737: xmlDumpElementTable(xmlBufferPtr buf, xmlElementTablePtr table) {
1738: if ((buf == NULL) || (table == NULL))
1739: return;
1740: xmlHashScan(table, (xmlHashScanner) xmlDumpElementDeclScan, buf);
1741: }
1742: #endif /* LIBXML_OUTPUT_ENABLED */
1743:
1744: /**
1745: * xmlCreateEnumeration:
1746: * @name: the enumeration name or NULL
1747: *
1748: * create and initialize an enumeration attribute node.
1749: *
1750: * Returns the xmlEnumerationPtr just created or NULL in case
1751: * of error.
1752: */
1753: xmlEnumerationPtr
1754: xmlCreateEnumeration(const xmlChar *name) {
1755: xmlEnumerationPtr ret;
1756:
1757: ret = (xmlEnumerationPtr) xmlMalloc(sizeof(xmlEnumeration));
1758: if (ret == NULL) {
1759: xmlVErrMemory(NULL, "malloc failed");
1760: return(NULL);
1761: }
1762: memset(ret, 0, sizeof(xmlEnumeration));
1763:
1764: if (name != NULL)
1765: ret->name = xmlStrdup(name);
1766: return(ret);
1767: }
1768:
1769: /**
1770: * xmlFreeEnumeration:
1771: * @cur: the tree to free.
1772: *
1773: * free an enumeration attribute node (recursive).
1774: */
1775: void
1776: xmlFreeEnumeration(xmlEnumerationPtr cur) {
1777: if (cur == NULL) return;
1778:
1779: if (cur->next != NULL) xmlFreeEnumeration(cur->next);
1780:
1781: if (cur->name != NULL) xmlFree((xmlChar *) cur->name);
1782: xmlFree(cur);
1783: }
1784:
1785: #ifdef LIBXML_TREE_ENABLED
1786: /**
1787: * xmlCopyEnumeration:
1788: * @cur: the tree to copy.
1789: *
1790: * Copy an enumeration attribute node (recursive).
1791: *
1792: * Returns the xmlEnumerationPtr just created or NULL in case
1793: * of error.
1794: */
1795: xmlEnumerationPtr
1796: xmlCopyEnumeration(xmlEnumerationPtr cur) {
1797: xmlEnumerationPtr ret;
1798:
1799: if (cur == NULL) return(NULL);
1800: ret = xmlCreateEnumeration((xmlChar *) cur->name);
1801:
1802: if (cur->next != NULL) ret->next = xmlCopyEnumeration(cur->next);
1803: else ret->next = NULL;
1804:
1805: return(ret);
1806: }
1807: #endif /* LIBXML_TREE_ENABLED */
1808:
1809: #ifdef LIBXML_OUTPUT_ENABLED
1810: /**
1811: * xmlDumpEnumeration:
1812: * @buf: the XML buffer output
1813: * @enum: An enumeration
1814: *
1815: * This will dump the content of the enumeration
1816: */
1817: static void
1818: xmlDumpEnumeration(xmlBufferPtr buf, xmlEnumerationPtr cur) {
1819: if ((buf == NULL) || (cur == NULL))
1820: return;
1821:
1822: xmlBufferWriteCHAR(buf, cur->name);
1823: if (cur->next == NULL)
1824: xmlBufferWriteChar(buf, ")");
1825: else {
1826: xmlBufferWriteChar(buf, " | ");
1827: xmlDumpEnumeration(buf, cur->next);
1828: }
1829: }
1830: #endif /* LIBXML_OUTPUT_ENABLED */
1831:
1832: #ifdef LIBXML_VALID_ENABLED
1833: /**
1834: * xmlScanIDAttributeDecl:
1835: * @ctxt: the validation context
1836: * @elem: the element name
1837: * @err: whether to raise errors here
1838: *
1839: * Verify that the element don't have too many ID attributes
1840: * declared.
1841: *
1842: * Returns the number of ID attributes found.
1843: */
1844: static int
1845: xmlScanIDAttributeDecl(xmlValidCtxtPtr ctxt, xmlElementPtr elem, int err) {
1846: 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 ++;
1854: if ((ret > 1) && (err))
1855: xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_MULTIPLE_ID,
1856: "Element %s has too many ID attributes defined : %s\n",
1857: elem->name, cur->name, NULL);
1858: }
1859: cur = cur->nexth;
1860: }
1861: return(ret);
1862: }
1863: #endif /* LIBXML_VALID_ENABLED */
1864:
1865: /**
1866: * xmlFreeAttribute:
1867: * @elem: An attribute
1868: *
1869: * Deallocate the memory used by an attribute definition
1870: */
1871: static void
1872: xmlFreeAttribute(xmlAttributePtr attr) {
1873: xmlDictPtr dict;
1874:
1875: if (attr == NULL) return;
1876: if (attr->doc != NULL)
1877: dict = attr->doc->dict;
1878: else
1879: dict = NULL;
1880: xmlUnlinkNode((xmlNodePtr) attr);
1881: if (attr->tree != NULL)
1882: xmlFreeEnumeration(attr->tree);
1883: 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: }
1903: 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: *
1922: * Returns NULL if not new, otherwise the attribute decl
1923: */
1924: xmlAttributePtr
1925: xmlAddAttributeDecl(xmlValidCtxtPtr ctxt,
1926: xmlDtdPtr dtd, const xmlChar *elem,
1927: 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;
1933: xmlDictPtr dict = NULL;
1934:
1935: if (dtd == NULL) {
1936: xmlFreeEnumeration(tree);
1937: return(NULL);
1938: }
1939: if (name == NULL) {
1940: xmlFreeEnumeration(tree);
1941: return(NULL);
1942: }
1943: if (elem == NULL) {
1944: xmlFreeEnumeration(tree);
1945: return(NULL);
1946: }
1947: if (dtd->doc != NULL)
1948: dict = dtd->doc->dict;
1949:
1950: #ifdef LIBXML_VALID_ENABLED
1951: /*
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:
1976: xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1977: "Internal: ATTRIBUTE struct corrupted invalid type\n",
1978: NULL);
1979: xmlFreeEnumeration(tree);
1980: return(NULL);
1981: }
1982: if ((defaultValue != NULL) &&
1983: (!xmlValidateAttributeValueInternal(dtd->doc, type, defaultValue))) {
1984: xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ATTRIBUTE_DEFAULT,
1985: "Attribute %s of %s: invalid default value\n",
1986: elem, name, defaultValue);
1987: defaultValue = NULL;
1988: if (ctxt != NULL)
1989: ctxt->valid = 0;
1990: }
1991: #endif /* LIBXML_VALID_ENABLED */
1992:
1993: /*
1994: * 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);
2001: if (ret != NULL) {
2002: xmlFreeEnumeration(tree);
2003: return(NULL);
2004: }
2005: }
2006:
2007: /*
2008: * Create the Attribute table if needed.
2009: */
2010: table = (xmlAttributeTablePtr) dtd->attributes;
2011: if (table == NULL) {
2012: table = xmlHashCreateDict(0, dict);
2013: dtd->attributes = (void *) table;
2014: }
2015: if (table == NULL) {
2016: xmlVErrMemory(ctxt,
2017: "xmlAddAttributeDecl: Table creation failed!\n");
2018: xmlFreeEnumeration(tree);
2019: return(NULL);
2020: }
2021:
2022:
2023: ret = (xmlAttributePtr) xmlMalloc(sizeof(xmlAttribute));
2024: if (ret == NULL) {
2025: xmlVErrMemory(ctxt, "malloc failed");
2026: xmlFreeEnumeration(tree);
2027: 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;
2036: /*
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;
2042: 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: }
2051: ret->def = def;
2052: ret->tree = tree;
2053: if (defaultValue != NULL) {
2054: if (dict)
2055: ret->defaultValue = xmlDictLookup(dict, defaultValue, -1);
2056: else
2057: ret->defaultValue = xmlStrdup(defaultValue);
2058: }
2059:
2060: /*
2061: * Validity Check:
2062: * Search the DTD for previous declarations of the ATTLIST
2063: */
2064: if (xmlHashAddEntry3(table, ret->name, ret->prefix, ret->elem, ret) < 0) {
2065: #ifdef LIBXML_VALID_ENABLED
2066: /*
2067: * The attribute is already defined in this DTD.
2068: */
2069: xmlErrValidWarning(ctxt, (xmlNodePtr) dtd, XML_DTD_ATTRIBUTE_REDEFINED,
2070: "Attribute %s of element %s: already defined\n",
2071: name, elem, NULL);
2072: #endif /* LIBXML_VALID_ENABLED */
2073: xmlFreeAttribute(ret);
2074: return(NULL);
2075: }
2076:
2077: /*
2078: * Validity Check:
2079: * Multiple ID per element
2080: */
2081: elemDef = xmlGetDtdElementDesc2(dtd, elem, 1);
2082: if (elemDef != NULL) {
2083:
2084: #ifdef LIBXML_VALID_ENABLED
2085: if ((type == XML_ATTRIBUTE_ID) &&
2086: (xmlScanIDAttributeDecl(NULL, elemDef, 1) != 0)) {
2087: xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_MULTIPLE_ID,
2088: "Element %s has too may ID attributes defined : %s\n",
2089: elem, name, NULL);
2090: if (ctxt != NULL)
2091: ctxt->valid = 0;
2092: }
2093: #endif /* LIBXML_VALID_ENABLED */
2094:
2095: /*
2096: * Insert namespace default def first they need to be
2097: * processed first.
2098: */
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: }
2123: }
2124:
2125: /*
2126: * Link it to the DTD
2127: */
2128: ret->parent = dtd;
2129: 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: */
2145: void
2146: xmlFreeAttributeTable(xmlAttributeTablePtr table) {
2147: xmlHashFree(table, (xmlHashDeallocator) xmlFreeAttribute);
2148: }
2149:
2150: #ifdef LIBXML_TREE_ENABLED
2151: /**
2152: * xmlCopyAttribute:
2153: * @attr: An attribute
2154: *
2155: * Build a copy of an attribute.
2156: *
2157: * Returns the new xmlAttributePtr or NULL in case of error.
2158: */
2159: static xmlAttributePtr
2160: xmlCopyAttribute(xmlAttributePtr attr) {
2161: xmlAttributePtr cur;
2162:
2163: cur = (xmlAttributePtr) xmlMalloc(sizeof(xmlAttribute));
2164: if (cur == NULL) {
2165: xmlVErrMemory(NULL, "malloc failed");
2166: return(NULL);
2167: }
2168: memset(cur, 0, sizeof(xmlAttribute));
2169: cur->type = XML_ATTRIBUTE_DECL;
2170: 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);
2177: if (attr->prefix != NULL)
2178: cur->prefix = xmlStrdup(attr->prefix);
2179: 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.
2189: *
2190: * Returns the new xmlAttributeTablePtr or NULL in case of error.
2191: */
2192: xmlAttributeTablePtr
2193: xmlCopyAttributeTable(xmlAttributeTablePtr table) {
2194: return((xmlAttributeTablePtr) xmlHashCopy(table,
2195: (xmlHashCopier) xmlCopyAttribute));
2196: }
2197: #endif /* LIBXML_TREE_ENABLED */
2198:
2199: #ifdef LIBXML_OUTPUT_ENABLED
2200: /**
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: */
2208: void
2209: xmlDumpAttributeDecl(xmlBufferPtr buf, xmlAttributePtr attr) {
2210: if ((buf == NULL) || (attr == NULL))
2211: return;
2212: 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:
2254: xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2255: "Internal: ATTRIBUTE struct corrupted invalid type\n",
2256: NULL);
2257: }
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:
2271: xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2272: "Internal: ATTRIBUTE struct corrupted invalid def\n",
2273: NULL);
2274: }
2275: if (attr->defaultValue != NULL) {
2276: xmlBufferWriteChar(buf, " ");
2277: xmlBufferWriteQuotedString(buf, attr->defaultValue);
2278: }
2279: xmlBufferWriteChar(buf, ">\n");
2280: }
2281:
2282: /**
2283: * 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: */
2289: static void
2290: xmlDumpAttributeDeclScan(xmlAttributePtr attr, xmlBufferPtr buf) {
2291: xmlDumpAttributeDecl(buf, attr);
2292: }
2293:
2294: /**
2295: * 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: */
2301: void
2302: xmlDumpAttributeTable(xmlBufferPtr buf, xmlAttributeTablePtr table) {
2303: if ((buf == NULL) || (table == NULL))
2304: return;
2305: xmlHashScan(table, (xmlHashScanner) xmlDumpAttributeDeclScan, buf);
2306: }
2307: #endif /* LIBXML_OUTPUT_ENABLED */
2308:
2309: /************************************************************************
2310: * *
2311: * NOTATIONs *
2312: * *
2313: ************************************************************************/
2314: /**
2315: * xmlFreeNotation:
2316: * @not: A notation
2317: *
2318: * Deallocate the memory used by an notation definition
2319: */
2320: static void
2321: xmlFreeNotation(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);
2329: 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: *
2343: * Returns NULL if not, otherwise the entity
2344: */
2345: xmlNotationPtr
2346: xmlAddNotationDecl(xmlValidCtxtPtr ctxt, xmlDtdPtr dtd,
2347: const xmlChar *name,
2348: const xmlChar *PublicID, const xmlChar *SystemID) {
2349: xmlNotationPtr ret;
2350: xmlNotationTablePtr table;
2351:
2352: if (dtd == NULL) {
2353: return(NULL);
2354: }
2355: if (name == NULL) {
2356: return(NULL);
2357: }
2358: if ((PublicID == NULL) && (SystemID == NULL)) {
2359: return(NULL);
2360: }
2361:
2362: /*
2363: * Create the Notation table if needed.
2364: */
2365: table = (xmlNotationTablePtr) dtd->notations;
2366: 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: }
2373: if (table == NULL) {
2374: xmlVErrMemory(ctxt,
2375: "xmlAddNotationDecl: Table creation failed!\n");
2376: return(NULL);
2377: }
2378:
2379: ret = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation));
2380: if (ret == NULL) {
2381: xmlVErrMemory(ctxt, "malloc failed");
2382: 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)) {
2400: #ifdef LIBXML_VALID_ENABLED
2401: xmlErrValid(NULL, XML_DTD_NOTATION_REDEFINED,
2402: "xmlAddNotationDecl: %s already defined\n",
2403: (const char *) name);
2404: #endif /* LIBXML_VALID_ENABLED */
2405: 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: */
2417: void
2418: xmlFreeNotationTable(xmlNotationTablePtr table) {
2419: xmlHashFree(table, (xmlHashDeallocator) xmlFreeNotation);
2420: }
2421:
2422: #ifdef LIBXML_TREE_ENABLED
2423: /**
2424: * xmlCopyNotation:
2425: * @nota: A notation
2426: *
2427: * Build a copy of a notation.
2428: *
2429: * Returns the new xmlNotationPtr or NULL in case of error.
2430: */
2431: static xmlNotationPtr
2432: xmlCopyNotation(xmlNotationPtr nota) {
2433: xmlNotationPtr cur;
2434:
2435: cur = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation));
2436: if (cur == NULL) {
2437: xmlVErrMemory(NULL, "malloc failed");
2438: 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.
2460: *
2461: * Returns the new xmlNotationTablePtr or NULL in case of error.
2462: */
2463: xmlNotationTablePtr
2464: xmlCopyNotationTable(xmlNotationTablePtr table) {
2465: return((xmlNotationTablePtr) xmlHashCopy(table,
2466: (xmlHashCopier) xmlCopyNotation));
2467: }
2468: #endif /* LIBXML_TREE_ENABLED */
2469:
2470: #ifdef LIBXML_OUTPUT_ENABLED
2471: /**
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: */
2478: void
2479: xmlDumpNotationDecl(xmlBufferPtr buf, xmlNotationPtr nota) {
2480: if ((buf == NULL) || (nota == NULL))
2481: return;
2482: 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, " ");
2489: xmlBufferWriteQuotedString(buf, nota->SystemID);
2490: }
2491: } else {
2492: xmlBufferWriteChar(buf, " SYSTEM ");
2493: xmlBufferWriteQuotedString(buf, nota->SystemID);
2494: }
2495: xmlBufferWriteChar(buf, " >\n");
2496: }
2497:
2498: /**
2499: * 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: */
2505: static void
2506: xmlDumpNotationDeclScan(xmlNotationPtr nota, xmlBufferPtr buf) {
2507: xmlDumpNotationDecl(buf, nota);
2508: }
2509:
2510: /**
2511: * 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: */
2517: void
2518: xmlDumpNotationTable(xmlBufferPtr buf, xmlNotationTablePtr table) {
2519: if ((buf == NULL) || (table == NULL))
2520: return;
2521: xmlHashScan(table, (xmlHashScanner) xmlDumpNotationDeclScan, buf);
2522: }
2523: #endif /* LIBXML_OUTPUT_ENABLED */
2524:
2525: /************************************************************************
2526: * *
2527: * IDs *
2528: * *
2529: ************************************************************************/
2530: /**
2531: * 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) \
2538: if ((str) && ((!dict) || \
2539: (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \
2540: xmlFree((char *)(str));
2541:
2542: /**
2543: * xmlFreeID:
2544: * @not: A id
2545: *
2546: * Deallocate the memory used by an id definition
2547: */
2548: static void
2549: xmlFreeID(xmlIDPtr id) {
2550: xmlDictPtr dict = NULL;
2551:
2552: if (id == NULL) return;
2553:
2554: if (id->doc != NULL)
2555: dict = id->doc->dict;
2556:
2557: if (id->value != NULL)
2558: DICT_FREE(id->value)
2559: if (id->name != NULL)
2560: DICT_FREE(id->name)
2561: xmlFree(id);
2562: }
2563:
2564:
2565: /**
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: *
2574: * Returns NULL if not, otherwise the new xmlIDPtr
2575: */
2576: xmlIDPtr
2577: xmlAddID(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value,
2578: xmlAttrPtr attr) {
2579: xmlIDPtr ret;
2580: xmlIDTablePtr table;
2581:
2582: if (doc == NULL) {
2583: return(NULL);
2584: }
2585: if (value == NULL) {
2586: return(NULL);
2587: }
2588: if (attr == NULL) {
2589: return(NULL);
2590: }
2591:
2592: /*
2593: * Create the ID table if needed.
2594: */
2595: table = (xmlIDTablePtr) doc->ids;
2596: if (table == NULL) {
2597: doc->ids = table = xmlHashCreateDict(0, doc->dict);
2598: }
2599: if (table == NULL) {
2600: xmlVErrMemory(ctxt,
2601: "xmlAddID: Table creation failed!\n");
2602: return(NULL);
2603: }
2604:
2605: ret = (xmlIDPtr) xmlMalloc(sizeof(xmlID));
2606: if (ret == NULL) {
2607: xmlVErrMemory(ctxt, "malloc failed");
2608: return(NULL);
2609: }
2610:
2611: /*
2612: * fill the structure.
2613: */
2614: ret->value = xmlStrdup(value);
2615: ret->doc = doc;
2616: if ((ctxt != NULL) && (ctxt->vstateNr != 0)) {
2617: /*
2618: * Operating in streaming mode, attr is gonna disapear
2619: */
2620: if (doc->dict != NULL)
2621: ret->name = xmlDictLookup(doc->dict, attr->name, -1);
2622: else
2623: ret->name = xmlStrdup(attr->name);
2624: ret->attr = NULL;
2625: } else {
2626: ret->attr = attr;
2627: ret->name = NULL;
2628: }
2629: ret->lineno = xmlGetLineNo(attr->parent);
2630:
2631: if (xmlHashAddEntry(table, value, ret) < 0) {
2632: #ifdef LIBXML_VALID_ENABLED
2633: /*
2634: * The id is already defined in this DTD.
2635: */
2636: if ((ctxt != NULL) && (ctxt->error != NULL)) {
2637: xmlErrValidNode(ctxt, attr->parent, XML_DTD_ID_REDEFINED,
2638: "ID %s already defined\n",
2639: value, NULL, NULL);
2640: }
2641: #endif /* LIBXML_VALID_ENABLED */
2642: xmlFreeID(ret);
2643: return(NULL);
2644: }
2645: if (attr != NULL)
2646: attr->atype = XML_ATTRIBUTE_ID;
2647: return(ret);
2648: }
2649:
2650: /**
2651: * xmlFreeIDTable:
2652: * @table: An id table
2653: *
2654: * Deallocate the memory used by an ID hash table.
2655: */
2656: void
2657: xmlFreeIDTable(xmlIDTablePtr table) {
2658: xmlHashFree(table, (xmlHashDeallocator) xmlFreeID);
2659: }
2660:
2661: /**
2662: * xmlIsID:
2663: * @doc: the document
2664: * @elem: the element carrying the attribute
2665: * @attr: the attribute
2666: *
2667: * Determine whether an attribute is of type ID. In case we have DTD(s)
2668: * then this is done if DTD loading has been requested. In the case
2669: * of HTML documents parsed with the HTML parser, then ID detection is
2670: * done systematically.
2671: *
2672: * Returns 0 or 1 depending on the lookup result
2673: */
2674: int
2675: xmlIsID(xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr) {
2676: if ((attr == NULL) || (attr->name == NULL)) return(0);
2677: if ((attr->ns != NULL) && (attr->ns->prefix != NULL) &&
2678: (!strcmp((char *) attr->name, "id")) &&
2679: (!strcmp((char *) attr->ns->prefix, "xml")))
2680: return(1);
2681: if (doc == NULL) return(0);
2682: if ((doc->intSubset == NULL) && (doc->extSubset == NULL) &&
2683: (doc->type != XML_HTML_DOCUMENT_NODE)) {
2684: return(0);
2685: } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
2686: if ((xmlStrEqual(BAD_CAST "id", attr->name)) ||
2687: ((xmlStrEqual(BAD_CAST "name", attr->name)) &&
2688: ((elem == NULL) || (xmlStrEqual(elem->name, BAD_CAST "a")))))
2689: return(1);
2690: return(0);
2691: } else if (elem == NULL) {
2692: return(0);
2693: } else {
2694: xmlAttributePtr attrDecl = NULL;
2695:
2696: xmlChar felem[50], fattr[50];
2697: xmlChar *fullelemname, *fullattrname;
2698:
2699: fullelemname = (elem->ns != NULL && elem->ns->prefix != NULL) ?
2700: xmlBuildQName(elem->name, elem->ns->prefix, felem, 50) :
2701: (xmlChar *)elem->name;
2702:
2703: fullattrname = (attr->ns != NULL && attr->ns->prefix != NULL) ?
2704: xmlBuildQName(attr->name, attr->ns->prefix, fattr, 50) :
2705: (xmlChar *)attr->name;
2706:
2707: if (fullelemname != NULL && fullattrname != NULL) {
2708: attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullelemname,
2709: fullattrname);
2710: if ((attrDecl == NULL) && (doc->extSubset != NULL))
2711: attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullelemname,
2712: fullattrname);
2713: }
2714:
2715: if ((fullattrname != fattr) && (fullattrname != attr->name))
2716: xmlFree(fullattrname);
2717: if ((fullelemname != felem) && (fullelemname != elem->name))
2718: xmlFree(fullelemname);
2719:
2720: if ((attrDecl != NULL) && (attrDecl->atype == XML_ATTRIBUTE_ID))
2721: return(1);
2722: }
2723: return(0);
2724: }
2725:
2726: /**
2727: * xmlRemoveID:
2728: * @doc: the document
2729: * @attr: the attribute
2730: *
2731: * Remove the given attribute from the ID table maintained internally.
2732: *
2733: * Returns -1 if the lookup failed and 0 otherwise
2734: */
2735: int
2736: xmlRemoveID(xmlDocPtr doc, xmlAttrPtr attr) {
2737: xmlIDTablePtr table;
2738: xmlIDPtr id;
2739: xmlChar *ID;
2740:
2741: if (doc == NULL) return(-1);
2742: if (attr == NULL) return(-1);
2743: table = (xmlIDTablePtr) doc->ids;
2744: if (table == NULL)
2745: return(-1);
2746:
2747: if (attr == NULL)
2748: return(-1);
2749: ID = xmlNodeListGetString(doc, attr->children, 1);
2750: if (ID == NULL)
2751: return(-1);
2752: id = xmlHashLookup(table, ID);
2753: if (id == NULL || id->attr != attr) {
2754: xmlFree(ID);
2755: return(-1);
2756: }
2757: xmlHashRemoveEntry(table, ID, (xmlHashDeallocator) xmlFreeID);
2758: xmlFree(ID);
2759: attr->atype = 0;
2760: 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: */
2772: xmlAttrPtr
2773: xmlGetID(xmlDocPtr doc, const xmlChar *ID) {
2774: xmlIDTablePtr table;
2775: xmlIDPtr id;
2776:
2777: if (doc == NULL) {
2778: return(NULL);
2779: }
2780:
2781: if (ID == NULL) {
2782: return(NULL);
2783: }
2784:
2785: table = (xmlIDTablePtr) doc->ids;
2786: if (table == NULL)
2787: return(NULL);
2788:
2789: id = xmlHashLookup(table, ID);
2790: if (id == NULL)
2791: return(NULL);
2792: 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: }
2799: return(id->attr);
2800: }
2801:
2802: /************************************************************************
2803: * *
2804: * Refs *
2805: * *
2806: ************************************************************************/
2807: typedef struct xmlRemoveMemo_t
2808: {
2809: xmlListPtr l;
2810: xmlAttrPtr ap;
2811: } xmlRemoveMemo;
2812:
2813: typedef xmlRemoveMemo *xmlRemoveMemoPtr;
2814:
2815: typedef struct xmlValidateMemo_t
2816: {
2817: xmlValidCtxtPtr ctxt;
2818: const xmlChar *name;
2819: } xmlValidateMemo;
2820:
2821: typedef xmlValidateMemo *xmlValidateMemoPtr;
2822:
2823: /**
2824: * xmlFreeRef:
2825: * @lk: A list link
2826: *
2827: * Deallocate the memory used by a ref definition
2828: */
2829: static void
2830: xmlFreeRef(xmlLinkPtr lk) {
2831: xmlRefPtr ref = (xmlRefPtr)xmlLinkGetData(lk);
2832: if (ref == NULL) return;
2833: if (ref->value != NULL)
2834: xmlFree((xmlChar *)ref->value);
2835: if (ref->name != NULL)
2836: xmlFree((xmlChar *)ref->name);
2837: xmlFree(ref);
2838: }
2839:
2840: /**
2841: * xmlFreeRefList:
2842: * @list_ref: A list of references.
2843: *
2844: * Deallocate the memory used by a list of references
2845: */
2846: static void
2847: xmlFreeRefList(xmlListPtr list_ref) {
2848: if (list_ref == NULL) return;
2849: xmlListDelete(list_ref);
2850: }
2851:
2852: /**
2853: * xmlWalkRemoveRef:
2854: * @data: Contents of current link
2855: * @user: Value supplied by the user
2856: *
2857: * Returns 0 to abort the walk or 1 to continue
2858: */
2859: static int
2860: xmlWalkRemoveRef(const void *data, const void *user)
2861: {
2862: xmlAttrPtr attr0 = ((xmlRefPtr)data)->attr;
2863: xmlAttrPtr attr1 = ((xmlRemoveMemoPtr)user)->ap;
2864: xmlListPtr ref_list = ((xmlRemoveMemoPtr)user)->l;
2865:
2866: if (attr0 == attr1) { /* Matched: remove and terminate walk */
2867: xmlListRemoveFirst(ref_list, (void *)data);
2868: return 0;
2869: }
2870: return 1;
2871: }
2872:
2873: /**
2874: * 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: */
2880: static int
2881: xmlDummyCompare(const void *data0 ATTRIBUTE_UNUSED,
2882: const void *data1 ATTRIBUTE_UNUSED)
2883: {
2884: return (0);
2885: }
2886:
2887: /**
2888: * 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: *
2896: * Returns NULL if not, otherwise the new xmlRefPtr
2897: */
2898: xmlRefPtr
2899: xmlAddRef(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value,
2900: xmlAttrPtr attr) {
2901: xmlRefPtr ret;
2902: xmlRefTablePtr table;
2903: xmlListPtr ref_list;
2904:
2905: if (doc == NULL) {
2906: return(NULL);
2907: }
2908: if (value == NULL) {
2909: return(NULL);
2910: }
2911: if (attr == NULL) {
2912: return(NULL);
2913: }
2914:
2915: /*
2916: * Create the Ref table if needed.
2917: */
2918: table = (xmlRefTablePtr) doc->refs;
2919: if (table == NULL) {
2920: doc->refs = table = xmlHashCreateDict(0, doc->dict);
2921: }
2922: if (table == NULL) {
2923: xmlVErrMemory(ctxt,
2924: "xmlAddRef: Table creation failed!\n");
2925: return(NULL);
2926: }
2927:
2928: ret = (xmlRefPtr) xmlMalloc(sizeof(xmlRef));
2929: if (ret == NULL) {
2930: xmlVErrMemory(ctxt, "malloc failed");
2931: return(NULL);
2932: }
2933:
2934: /*
2935: * fill the structure.
2936: */
2937: ret->value = xmlStrdup(value);
2938: 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);
2949:
2950: /* 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: */
2956:
2957: if (NULL == (ref_list = xmlHashLookup(table, value))) {
2958: if (NULL == (ref_list = xmlListCreate(xmlFreeRef, xmlDummyCompare))) {
2959: xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2960: "xmlAddRef: Reference list creation failed!\n",
2961: NULL);
2962: goto failed;
2963: }
2964: if (xmlHashAddEntry(table, value, ref_list) < 0) {
2965: xmlListDelete(ref_list);
2966: xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2967: "xmlAddRef: Reference list insertion failed!\n",
2968: NULL);
2969: goto failed;
2970: }
2971: }
2972: 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: }
2978: return(ret);
2979: failed:
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);
2988: }
2989:
2990: /**
2991: * xmlFreeRefTable:
2992: * @table: An ref table
2993: *
2994: * Deallocate the memory used by an Ref hash table.
2995: */
2996: void
2997: xmlFreeRefTable(xmlRefTablePtr table) {
2998: xmlHashFree(table, (xmlHashDeallocator) xmlFreeRefList);
2999: }
3000:
3001: /**
3002: * xmlIsRef:
3003: * @doc: the document
3004: * @elem: the element carrying the attribute
3005: * @attr: the attribute
3006: *
3007: * Determine whether an attribute is of type Ref. In case we have DTD(s)
3008: * 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: */
3013: int
3014: xmlIsRef(xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr) {
3015: if (attr == NULL)
3016: return(0);
3017: if (doc == NULL) {
3018: doc = attr->doc;
3019: if (doc == NULL) return(0);
3020: }
3021:
3022: if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
3023: return(0);
3024: } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
3025: /* TODO @@@ */
3026: return(0);
3027: } else {
3028: xmlAttributePtr attrDecl;
3029:
3030: if (elem == NULL) return(0);
3031: 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);
3035:
3036: if ((attrDecl != NULL) &&
3037: (attrDecl->atype == XML_ATTRIBUTE_IDREF ||
3038: attrDecl->atype == XML_ATTRIBUTE_IDREFS))
3039: return(1);
3040: }
3041: return(0);
3042: }
3043:
3044: /**
3045: * xmlRemoveRef:
3046: * @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: */
3053: int
3054: xmlRemoveRef(xmlDocPtr doc, xmlAttrPtr attr) {
3055: xmlListPtr ref_list;
3056: xmlRefTablePtr table;
3057: xmlChar *ID;
3058: xmlRemoveMemo target;
3059:
3060: if (doc == NULL) return(-1);
3061: if (attr == NULL) return(-1);
3062: table = (xmlRefTablePtr) doc->refs;
3063: if (table == NULL)
3064: return(-1);
3065:
3066: 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);
3072:
3073: 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;
3089:
3090: /* Remove the supplied attr from our list */
3091: xmlListWalk(ref_list, xmlWalkRemoveRef, &target);
3092:
3093: /*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);
3099: }
3100:
3101: /**
3102: * xmlGetRefs:
3103: * @doc: pointer to the document
3104: * @ID: the ID value
3105: *
3106: * Find the set of references for the supplied ID.
3107: *
3108: * Returns NULL if not found, otherwise node set for the ID.
3109: */
3110: xmlListPtr
3111: xmlGetRefs(xmlDocPtr doc, const xmlChar *ID) {
3112: xmlRefTablePtr table;
3113:
3114: if (doc == NULL) {
3115: return(NULL);
3116: }
3117:
3118: if (ID == NULL) {
3119: return(NULL);
3120: }
3121:
3122: table = (xmlRefTablePtr) doc->refs;
3123: if (table == NULL)
3124: return(NULL);
3125:
3126: return (xmlHashLookup(table, ID));
3127: }
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: *
3140: * Search the DTD for the description of this element
3141: *
3142: * returns the xmlElementPtr if found or NULL
3143: */
3144:
3145: xmlElementPtr
3146: xmlGetDtdElementDesc(xmlDtdPtr dtd, const xmlChar *name) {
3147: xmlElementTablePtr table;
3148: xmlElementPtr cur;
3149: xmlChar *uqname = NULL, *prefix = NULL;
3150:
3151: if ((dtd == NULL) || (name == NULL)) return(NULL);
3152: if (dtd->elements == NULL)
3153: return(NULL);
3154: table = (xmlElementTablePtr) dtd->elements;
3155:
3156: uqname = xmlSplitQName2(name, &prefix);
3157: 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: *
3170: * Search the DTD for the description of this element
3171: *
3172: * returns the xmlElementPtr if found or NULL
3173: */
3174:
3175: static xmlElementPtr
3176: xmlGetDtdElementDesc2(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) {
3183: xmlDictPtr dict = NULL;
3184:
3185: if (dtd->doc != NULL)
3186: dict = dtd->doc->dict;
3187:
3188: if (!create)
3189: return(NULL);
3190: /*
3191: * Create the Element table if needed.
3192: */
3193: table = (xmlElementTablePtr) dtd->elements;
3194: if (table == NULL) {
3195: table = xmlHashCreateDict(0, dict);
3196: dtd->elements = (void *) table;
3197: }
3198: if (table == NULL) {
3199: xmlVErrMemory(NULL, "element table allocation failed");
3200: 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) {
3212: xmlVErrMemory(NULL, "malloc failed");
3213: 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);
3229: 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: *
3238: * Search the DTD for the description of this element
3239: *
3240: * returns the xmlElementPtr if found or NULL
3241: */
3242:
3243: xmlElementPtr
3244: xmlGetDtdQElementDesc(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: *
3261: * Search the DTD for the description of this attribute on
3262: * this element.
3263: *
3264: * returns the xmlAttributePtr if found or NULL
3265: */
3266:
3267: xmlAttributePtr
3268: xmlGetDtdAttrDesc(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: *
3298: * Search the DTD for the description of this qualified attribute on
3299: * this element.
3300: *
3301: * returns the xmlAttributePtr if found or NULL
3302: */
3303:
3304: xmlAttributePtr
3305: xmlGetDtdQAttrDesc(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: *
3321: * Search the DTD for the description of this notation
3322: *
3323: * returns the xmlNotationPtr if found or NULL
3324: */
3325:
3326: xmlNotationPtr
3327: xmlGetDtdNotationDesc(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:
3337: #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
3338: /**
3339: * xmlValidateNotationUse:
3340: * @ctxt: the validation context
3341: * @doc: the document
3342: * @notationName: the notation name to check
3343: *
3344: * Validate that the given name match a notation declaration.
3345: * - [ VC: Notation Declared ]
3346: *
3347: * returns 1 if valid or 0 otherwise
3348: */
3349:
3350: int
3351: xmlValidateNotationUse(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
3352: const xmlChar *notationName) {
3353: xmlNotationPtr notaDecl;
3354: if ((doc == NULL) || (doc->intSubset == NULL) ||
3355: (notationName == NULL)) return(-1);
3356:
3357: notaDecl = xmlGetDtdNotationDesc(doc->intSubset, notationName);
3358: if ((notaDecl == NULL) && (doc->extSubset != NULL))
3359: notaDecl = xmlGetDtdNotationDesc(doc->extSubset, notationName);
3360:
3361: if ((notaDecl == NULL) && (ctxt != NULL)) {
3362: xmlErrValidNode(ctxt, (xmlNodePtr) doc, XML_DTD_UNKNOWN_NOTATION,
3363: "NOTATION %s is not declared\n",
3364: notationName, NULL, NULL);
3365: return(0);
3366: }
3367: return(1);
3368: }
3369: #endif /* LIBXML_VALID_ENABLED or LIBXML_SCHEMAS_ENABLED */
3370:
3371: /**
3372: * xmlIsMixedElement:
3373: * @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:
3382: int
3383: xmlIsMixedElement(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) {
3393: case XML_ELEMENT_TYPE_UNDEFINED:
3394: return(-1);
3395: 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:
3409: #ifdef LIBXML_VALID_ENABLED
3410:
3411: static int
3412: xmlIsDocNameStartChar(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:
3441: static int
3442: xmlIsDocNameChar(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:
3489: static int
3490: xmlValidateNameValueInternal(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:
3513: /**
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:
3522: int
3523: xmlValidateNameValue(const xmlChar *value) {
3524: 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:
3537: static int
3538: xmlValidateNamesValueInternal(xmlDocPtr doc, const xmlChar *value) {
3539: const xmlChar *cur;
3540: int val, len;
3541:
3542: if (value == NULL) return(0);
3543: cur = value;
3544: val = xmlStringCurrentChar(NULL, cur, &len);
3545: cur += len;
3546:
3547: if (!xmlIsDocNameStartChar(doc, val))
3548: return(0);
3549:
3550: val = xmlStringCurrentChar(NULL, cur, &len);
3551: cur += len;
3552: while (xmlIsDocNameChar(doc, val)) {
3553: val = xmlStringCurrentChar(NULL, cur, &len);
3554: cur += len;
3555: }
3556:
3557: /* 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:
3576: if (val != 0) return(0);
3577:
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:
3590: int
3591: xmlValidateNamesValue(const xmlChar *value) {
3592: 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:
3607: static int
3608: xmlValidateNmtokenValueInternal(xmlDocPtr doc, const xmlChar *value) {
3609: const xmlChar *cur;
3610: int val, len;
3611:
3612: if (value == NULL) return(0);
3613: cur = value;
3614: val = xmlStringCurrentChar(NULL, cur, &len);
3615: cur += len;
3616:
3617: if (!xmlIsDocNameChar(doc, val))
3618: return(0);
3619:
3620: val = xmlStringCurrentChar(NULL, cur, &len);
3621: cur += len;
3622: while (xmlIsDocNameChar(doc, val)) {
3623: val = xmlStringCurrentChar(NULL, cur, &len);
3624: cur += len;
3625: }
3626:
3627: if (val != 0) return(0);
3628:
3629: return(1);
3630: }
3631:
3632: /**
3633: * xmlValidateNmtokenValue:
3634: * @value: an Nmtoken value
3635: *
3636: * Validate that the given value match Nmtoken production
3637: *
3638: * [ VC: Name Token ]
3639: *
3640: * returns 1 if valid or 0 otherwise
3641: */
3642:
3643: int
3644: xmlValidateNmtokenValue(const xmlChar *value) {
3645: 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:
3660: static int
3661: xmlValidateNmtokensValueInternal(xmlDocPtr doc, const xmlChar *value) {
3662: const xmlChar *cur;
3663: int val, len;
3664:
3665: if (value == NULL) return(0);
3666: cur = value;
3667: val = xmlStringCurrentChar(NULL, cur, &len);
3668: cur += len;
3669:
3670: while (IS_BLANK(val)) {
3671: val = xmlStringCurrentChar(NULL, cur, &len);
3672: cur += len;
3673: }
3674:
3675: 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:
3703: if (val != 0) return(0);
3704:
3705: return(1);
3706: }
3707:
3708: /**
3709: * xmlValidateNmtokensValue:
3710: * @value: an Nmtokens value
3711: *
3712: * Validate that the given value match Nmtokens production
3713: *
3714: * [ VC: Name Token ]
3715: *
3716: * returns 1 if valid or 0 otherwise
3717: */
3718:
3719: int
3720: xmlValidateNmtokensValue(const xmlChar *value) {
3721: return(xmlValidateNmtokensValueInternal(NULL, value));
3722: }
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:
3733: * - it seems that no validity constraint exists on notation declarations
3734: * But this function get called anyway ...
3735: *
3736: * returns 1 if valid or 0 otherwise
3737: */
3738:
3739: int
3740: xmlValidateNotationDecl(xmlValidCtxtPtr ctxt ATTRIBUTE_UNUSED, xmlDocPtr doc ATTRIBUTE_UNUSED,
3741: xmlNotationPtr nota ATTRIBUTE_UNUSED) {
3742: int ret = 1;
3743:
3744: return(ret);
3745: }
3746:
3747: /**
3748: * xmlValidateAttributeValueInternal:
3749: * @doc: the document
3750: * @type: an attribute type
3751: * @value: an attribute value
3752: *
3753: * Validate that the given attribute value match the proper production
3754: *
3755: * returns 1 if valid or 0 otherwise
3756: */
3757:
3758: static int
3759: xmlValidateAttributeValueInternal(xmlDocPtr doc, xmlAttributeType type,
3760: const xmlChar *value) {
3761: switch (type) {
3762: case XML_ATTRIBUTE_ENTITIES:
3763: case XML_ATTRIBUTE_IDREFS:
3764: return(xmlValidateNamesValueInternal(doc, value));
3765: case XML_ATTRIBUTE_ENTITY:
3766: case XML_ATTRIBUTE_IDREF:
3767: case XML_ATTRIBUTE_ID:
3768: case XML_ATTRIBUTE_NOTATION:
3769: return(xmlValidateNameValueInternal(doc, value));
3770: case XML_ATTRIBUTE_NMTOKENS:
3771: case XML_ATTRIBUTE_ENUMERATION:
3772: return(xmlValidateNmtokensValueInternal(doc, value));
3773: case XML_ATTRIBUTE_NMTOKEN:
3774: return(xmlValidateNmtokenValueInternal(doc, value));
3775: case XML_ATTRIBUTE_CDATA:
3776: break;
3777: }
3778: return(1);
3779: }
3780:
3781: /**
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
3801: * of type NMTOKENS must match Nmtokens.
3802: *
3803: * returns 1 if valid or 0 otherwise
3804: */
3805: int
3806: xmlValidateAttributeValue(xmlAttributeType type, const xmlChar *value) {
3807: return(xmlValidateAttributeValueInternal(NULL, type, value));
3808: }
3809:
3810: /**
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:
3839: static int
3840: xmlValidateAttributeValue2(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);
3856: /* yeah it's a bit messy... */
3857: if ((ent == NULL) && (doc->standalone == 1)) {
3858: doc->standalone = 0;
3859: ent = xmlGetDocEntity(doc, value);
3860: }
3861: if (ent == NULL) {
3862: xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3863: XML_DTD_UNKNOWN_ENTITY,
3864: "ENTITY attribute %s reference an unknown entity \"%s\"\n",
3865: name, value, NULL);
3866: ret = 0;
3867: } else if (ent->etype != XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
3868: xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3869: XML_DTD_ENTITY_TYPE,
3870: "ENTITY attribute %s reference an entity \"%s\" of wrong type\n",
3871: name, value, NULL);
3872: 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;
3886: while ((*cur != 0) && (!IS_BLANK_CH(*cur))) cur++;
3887: save = *cur;
3888: *cur = 0;
3889: ent = xmlGetDocEntity(doc, nam);
3890: if (ent == NULL) {
3891: xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3892: XML_DTD_UNKNOWN_ENTITY,
3893: "ENTITIES attribute %s reference an unknown entity \"%s\"\n",
3894: name, nam, NULL);
3895: ret = 0;
3896: } else if (ent->etype != XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
3897: xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3898: XML_DTD_ENTITY_TYPE,
3899: "ENTITIES attribute %s reference an entity \"%s\" of wrong type\n",
3900: name, nam, NULL);
3901: ret = 0;
3902: }
3903: if (save == 0)
3904: break;
3905: *cur = save;
3906: while (IS_BLANK_CH(*cur)) cur++;
3907: }
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) {
3919: xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3920: XML_DTD_UNKNOWN_NOTATION,
3921: "NOTATION attribute %s reference an unknown notation \"%s\"\n",
3922: name, value, NULL);
3923: ret = 0;
3924: }
3925: break;
3926: }
3927: }
3928: return(ret);
3929: }
3930:
3931: /**
3932: * 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:
3955: xmlChar *
3956: xmlValidCtxtNormalizeAttributeValue(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)) {
3969: xmlChar fn[50];
3970: xmlChar *fullname;
3971:
3972: fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
3973: if (fullname == NULL)
3974: return(NULL);
3975: attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname, name);
3976: if ((attrDecl == NULL) && (doc->extSubset != NULL)) {
3977: attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullname, name);
3978: if (attrDecl != NULL)
3979: extsubset = 1;
3980: }
3981: if ((fullname != fn) && (fullname != elem->name))
3982: xmlFree(fullname);
3983: }
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))) {
4014: xmlErrValidNode(ctxt, elem, XML_DTD_NOT_STANDALONE,
4015: "standalone: %s on %s value had to be normalized based on external subset declaration\n",
4016: name, elem->name, NULL);
4017: ctxt->valid = 0;
4018: }
4019: return(ret);
4020: }
4021:
4022: /**
4023: * 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: *
4037: * Returns a new normalized string if normalization is needed, NULL otherwise
4038: * the caller must free the returned value.
4039: */
4040:
4041: xmlChar *
4042: xmlValidNormalizeAttributeValue(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)) {
4054: xmlChar fn[50];
4055: xmlChar *fullname;
4056:
4057: fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
4058: if (fullname == NULL)
4059: return(NULL);
4060: if ((fullname != fn) && (fullname != elem->name))
4061: xmlFree(fullname);
4062: }
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:
4091: static void
4092: xmlValidateAttributeIdCallback(xmlAttributePtr attr, int *count,
4093: const xmlChar* name ATTRIBUTE_UNUSED) {
4094: 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:
4115: int
4116: xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4117: xmlAttributePtr attr) {
4118: int ret = 1;
4119: int val;
4120: CHECK_DTD;
4121: if(attr == NULL) return(1);
4122:
4123: /* Attribute Default Legal */
4124: /* Enumeration */
4125: if (attr->defaultValue != NULL) {
4126: val = xmlValidateAttributeValueInternal(doc, attr->atype,
4127: attr->defaultValue);
4128: if (val == 0) {
4129: xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ATTRIBUTE_DEFAULT,
4130: "Syntax of default value for attribute %s of %s is not valid\n",
4131: attr->name, attr->elem, NULL);
4132: }
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)) {
4140: xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ID_FIXED,
4141: "ID attribute %s of %s is not valid must be #IMPLIED or #REQUIRED\n",
4142: attr->name, attr->elem, NULL);
4143: ret = 0;
4144: }
4145:
4146: /* One ID per Element Type */
4147: if (attr->atype == XML_ATTRIBUTE_ID) {
4148: int nbId;
4149:
4150: /* the trick is that we parse DtD as their own internal subset */
4151: xmlElementPtr elem = xmlGetDtdElementDesc(doc->intSubset,
4152: attr->elem);
4153: if (elem != NULL) {
4154: nbId = xmlScanIDAttributeDecl(NULL, elem, 0);
4155: } 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;
4163: if (doc->intSubset != NULL) {
4164: table = (xmlAttributeTablePtr) doc->intSubset->attributes;
4165: xmlHashScan3(table, NULL, NULL, attr->elem, (xmlHashScanner)
4166: xmlValidateAttributeIdCallback, &nbId);
4167: }
4168: }
4169: if (nbId > 1) {
4170:
4171: xmlErrValidNodeNr(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
4172: "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) {
4178: extId = xmlScanIDAttributeDecl(NULL, elem, 0);
4179: }
4180: if (extId > 1) {
4181: xmlErrValidNodeNr(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
4182: "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) {
4185: xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
4186: "Element %s has ID attributes defined in the internal and external subset : %s\n",
4187: attr->elem, attr->name, NULL);
4188: }
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) {
4200: xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ATTRIBUTE_VALUE,
4201: "Default value \"%s\" for attribute %s of %s is not among the enumerated set\n",
4202: 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:
4226: int
4227: xmlValidateElementDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4228: xmlElementPtr elem) {
4229: int ret = 1;
4230: xmlElementPtr tst;
4231:
4232: CHECK_DTD;
4233:
4234: if (elem == NULL) return(1);
4235:
4236: #if 0
4237: #ifdef LIBXML_REGEXP_ENABLED
4238: /* Build the regexp associated to the content model */
4239: ret = xmlValidBuildContentModel(ctxt, elem);
4240: #endif
4241: #endif
4242:
4243: /* 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) {
4257: if ((xmlStrEqual(next->name, name)) &&
4258: (xmlStrEqual(next->prefix, cur->c1->prefix))) {
4259: if (cur->c1->prefix == NULL) {
4260: xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
4261: "Definition of %s has duplicate references of %s\n",
4262: elem->name, name, NULL);
4263: } else {
4264: xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
4265: "Definition of %s has duplicate references of %s:%s\n",
4266: elem->name, cur->c1->prefix, name);
4267: }
4268: ret = 0;
4269: }
4270: break;
4271: }
4272: if (next->c1 == NULL) break;
4273: if (next->c1->type != XML_ELEMENT_CONTENT_ELEMENT) break;
4274: if ((xmlStrEqual(next->c1->name, name)) &&
4275: (xmlStrEqual(next->c1->prefix, cur->c1->prefix))) {
4276: if (cur->c1->prefix == NULL) {
4277: xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
4278: "Definition of %s has duplicate references to %s\n",
4279: elem->name, name, NULL);
4280: } else {
4281: xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
4282: "Definition of %s has duplicate references to %s:%s\n",
4283: elem->name, cur->c1->prefix, name);
4284: }
4285: 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);
4296: if ((tst != NULL ) && (tst != elem) &&
4297: ((tst->prefix == elem->prefix) ||
4298: (xmlStrEqual(tst->prefix, elem->prefix))) &&
4299: (tst->etype != XML_ELEMENT_TYPE_UNDEFINED)) {
4300: xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_ELEM_REDEFINED,
4301: "Redefinition of element %s\n",
4302: elem->name, NULL, NULL);
4303: ret = 0;
4304: }
4305: tst = xmlGetDtdElementDesc(doc->extSubset, elem->name);
4306: if ((tst != NULL ) && (tst != elem) &&
4307: ((tst->prefix == elem->prefix) ||
4308: (xmlStrEqual(tst->prefix, elem->prefix))) &&
4309: (tst->etype != XML_ELEMENT_TYPE_UNDEFINED)) {
4310: xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_ELEM_REDEFINED,
4311: "Redefinition of element %s\n",
4312: elem->name, NULL, NULL);
4313: ret = 0;
4314: }
4315: /* One ID per Element Type
4316: * already done when registering the attribute
4317: if (xmlScanIDAttributeDecl(ctxt, elem) > 1) {
4318: ret = 0;
4319: } */
4320: 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:
4348: int
4349: xmlValidateOneAttribute(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4350: xmlNodePtr elem, xmlAttrPtr attr, const xmlChar *value)
4351: {
4352: 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)) {
4361: xmlChar fn[50];
4362: xmlChar *fullname;
4363:
4364: fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
4365: if (fullname == NULL)
4366: return(0);
4367: if (attr->ns != NULL) {
4368: attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, fullname,
4369: attr->name, attr->ns->prefix);
4370: if ((attrDecl == NULL) && (doc->extSubset != NULL))
4371: attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, fullname,
4372: attr->name, attr->ns->prefix);
4373: } else {
4374: attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname, attr->name);
4375: if ((attrDecl == NULL) && (doc->extSubset != NULL))
4376: attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
4377: fullname, attr->name);
4378: }
4379: if ((fullname != fn) && (fullname != elem->name))
4380: xmlFree(fullname);
4381: }
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) {
4401: xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
4402: "No declaration for attribute %s of element %s\n",
4403: attr->name, elem->name, NULL);
4404: return(0);
4405: }
4406: attr->atype = attrDecl->atype;
4407:
4408: val = xmlValidateAttributeValueInternal(doc, attrDecl->atype, value);
4409: if (val == 0) {
4410: xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4411: "Syntax of value for attribute %s of %s is not valid\n",
4412: attr->name, elem->name, NULL);
4413: ret = 0;
4414: }
4415:
4416: /* Validity constraint: Fixed Attribute Default */
4417: if (attrDecl->def == XML_ATTRIBUTE_FIXED) {
4418: if (!xmlStrEqual(value, attrDecl->defaultValue)) {
4419: xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_DEFAULT,
4420: "Value for attribute %s of %s is different from default \"%s\"\n",
4421: 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);
4447:
4448: if (nota == NULL) {
4449: xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
4450: "Value \"%s\" for attribute %s of %s is not a declared Notation\n",
4451: 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) {
4461: xmlErrValidNode(ctxt, elem, XML_DTD_NOTATION_VALUE,
4462: "Value \"%s\" for attribute %s of %s is not among the enumerated notations\n",
4463: 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) {
4476: xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4477: "Value \"%s\" for attribute %s of %s is not among the enumerated set\n",
4478: 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))) {
4486: xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4487: "Value for attribute %s of %s must be \"%s\"\n",
4488: 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:
4499: /**
4500: * xmlValidateOneNamespace:
4501: * @ctxt: the validation context
4502: * @doc: a document instance
4503: * @elem: an element instance
4504: * @prefix: the namespace prefix
4505: * @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:
4525: int
4526: xmlValidateOneNamespace(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4527: xmlNodePtr 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) {
4538: xmlChar fn[50];
4539: xmlChar *fullname;
4540:
4541: fullname = xmlBuildQName(elem->name, prefix, fn, 50);
4542: if (fullname == NULL) {
4543: xmlVErrMemory(ctxt, "Validating namespace");
4544: return(0);
4545: }
4546: if (ns->prefix != NULL) {
4547: attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, fullname,
4548: ns->prefix, BAD_CAST "xmlns");
4549: if ((attrDecl == NULL) && (doc->extSubset != NULL))
4550: attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, fullname,
4551: ns->prefix, BAD_CAST "xmlns");
4552: } else {
4553: attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname,
4554: BAD_CAST "xmlns");
4555: if ((attrDecl == NULL) && (doc->extSubset != NULL))
4556: attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullname,
4557: BAD_CAST "xmlns");
4558: }
4559: if ((fullname != fn) && (fullname != elem->name))
4560: xmlFree(fullname);
4561: }
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) {
4581: if (ns->prefix != NULL) {
4582: xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
4583: "No declaration for attribute xmlns:%s of element %s\n",
4584: ns->prefix, elem->name, NULL);
4585: } else {
4586: xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
4587: "No declaration for attribute xmlns of element %s\n",
4588: elem->name, NULL, NULL);
4589: }
4590: return(0);
4591: }
4592:
4593: val = xmlValidateAttributeValueInternal(doc, attrDecl->atype, value);
4594: if (val == 0) {
4595: if (ns->prefix != NULL) {
4596: xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_DEFAULT,
4597: "Syntax of value for attribute xmlns:%s of %s is not valid\n",
4598: ns->prefix, elem->name, NULL);
4599: } else {
4600: xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_DEFAULT,
4601: "Syntax of value for attribute xmlns of %s is not valid\n",
4602: elem->name, NULL, NULL);
4603: }
4604: ret = 0;
4605: }
4606:
4607: /* Validity constraint: Fixed Attribute Default */
4608: if (attrDecl->def == XML_ATTRIBUTE_FIXED) {
4609: if (!xmlStrEqual(value, attrDecl->defaultValue)) {
4610: if (ns->prefix != NULL) {
4611: xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_DEFAULT,
4612: "Value for attribute xmlns:%s of %s is different from default \"%s\"\n",
4613: ns->prefix, elem->name, attrDecl->defaultValue);
4614: } else {
4615: xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_DEFAULT,
4616: "Value for attribute xmlns of %s is different from default \"%s\"\n",
4617: elem->name, attrDecl->defaultValue, NULL);
4618: }
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);
4644:
4645: if (nota == NULL) {
4646: if (ns->prefix != NULL) {
4647: xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
4648: "Value \"%s\" for attribute xmlns:%s of %s is not a declared Notation\n",
4649: value, ns->prefix, elem->name);
4650: } else {
4651: xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
4652: "Value \"%s\" for attribute xmlns of %s is not a declared Notation\n",
4653: value, elem->name, NULL);
4654: }
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) {
4664: if (ns->prefix != NULL) {
4665: xmlErrValidNode(ctxt, elem, XML_DTD_NOTATION_VALUE,
4666: "Value \"%s\" for attribute xmlns:%s of %s is not among the enumerated notations\n",
4667: value, ns->prefix, elem->name);
4668: } else {
4669: xmlErrValidNode(ctxt, elem, XML_DTD_NOTATION_VALUE,
4670: "Value \"%s\" for attribute xmlns of %s is not among the enumerated notations\n",
4671: value, elem->name, NULL);
4672: }
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) {
4685: if (ns->prefix != NULL) {
4686: xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4687: "Value \"%s\" for attribute xmlns:%s of %s is not among the enumerated set\n",
4688: value, ns->prefix, elem->name);
4689: } else {
4690: xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4691: "Value \"%s\" for attribute xmlns of %s is not among the enumerated set\n",
4692: value, elem->name, NULL);
4693: }
4694: ret = 0;
4695: }
4696: }
4697:
4698: /* Fixed Attribute Default */
4699: if ((attrDecl->def == XML_ATTRIBUTE_FIXED) &&
4700: (!xmlStrEqual(attrDecl->defaultValue, value))) {
4701: if (ns->prefix != NULL) {
4702: xmlErrValidNode(ctxt, elem, XML_DTD_ELEM_NAMESPACE,
4703: "Value for attribute xmlns:%s of %s must be \"%s\"\n",
4704: ns->prefix, elem->name, attrDecl->defaultValue);
4705: } else {
4706: xmlErrValidNode(ctxt, elem, XML_DTD_ELEM_NAMESPACE,
4707: "Value for attribute xmlns of %s must be \"%s\"\n",
4708: elem->name, attrDecl->defaultValue, NULL);
4709: }
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:
4725: #ifndef LIBXML_REGEXP_ENABLED
4726: /**
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:
4736: static xmlNodePtr
4737: xmlValidateSkipIgnorable(xmlNodePtr child) {
4738: while (child != NULL) {
4739: switch (child->type) {
4740: /* 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: *
4767: * 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.
4770: */
4771:
4772: static int
4773: xmlValidateElementType(xmlValidCtxtPtr ctxt) {
4774: int ret = -1;
4775: int determinist = 1;
4776:
4777: NODE = xmlValidateSkipIgnorable(NODE);
4778: if ((NODE == NULL) && (CONT == NULL))
4779: return(1);
4780: if ((NODE == NULL) &&
4781: ((CONT->ocur == XML_ELEMENT_CONTENT_MULT) ||
4782: (CONT->ocur == XML_ELEMENT_CONTENT_OPT))) {
4783: return(1);
4784: }
4785: if (CONT == NULL) return(-1);
4786: if ((NODE != NULL) && (NODE->type == XML_ENTITY_REF_NODE))
4787: return(-2);
4788:
4789: /*
4790: * We arrive here when more states need to be examined
4791: */
4792: cont:
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) {
4799: DEBUG_VALID_MSG("restored parent branch");
4800: DEBUG_VALID_STATE(NODE, CONT)
4801: ret = 1;
4802: 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: */
4810: if ((CONT != NULL) &&
4811: ((CONT->parent == NULL) ||
4812: (CONT->parent->type != XML_ELEMENT_CONTENT_OR)) &&
4813: ((CONT->ocur == XML_ELEMENT_CONTENT_MULT) ||
4814: (CONT->ocur == XML_ELEMENT_CONTENT_OPT) ||
4815: ((CONT->ocur == XML_ELEMENT_CONTENT_PLUS) && (OCCURRENCE)))) {
4816: DEBUG_VALID_MSG("saving parent branch");
4817: if (vstateVPush(ctxt, CONT, NODE, DEPTH, OCCURS, ROLLBACK_PARENT) < 0)
4818: return(0);
4819: }
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;
4840: NODE = xmlValidateSkipIgnorable(NODE);
4841: if ((NODE != NULL) &&
4842: (NODE->type == XML_ENTITY_REF_NODE))
4843: return(-2);
4844: } while ((NODE != NULL) &&
4845: ((NODE->type != XML_ELEMENT_NODE) &&
4846: (NODE->type != XML_TEXT_NODE) &&
4847: (NODE->type != XML_CDATA_SECTION_NODE)));
4848: 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: }
4862: ret = ((NODE->type == XML_ELEMENT_NODE) &&
4863: (xmlStrEqual(NODE->name, CONT->name)));
4864: if (ret == 1) {
4865: 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) {
4874: 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;
4881: NODE = xmlValidateSkipIgnorable(NODE);
4882: if ((NODE != NULL) &&
4883: (NODE->type == XML_ENTITY_REF_NODE))
4884: return(-2);
4885: } while ((NODE != NULL) &&
4886: ((NODE->type != XML_ELEMENT_NODE) &&
4887: (NODE->type != XML_TEXT_NODE) &&
4888: (NODE->type != XML_CDATA_SECTION_NODE)));
4889: } else {
4890: DEBUG_VALID_MSG("element failed");
4891: ret = 0;
4892: break;
4893: }
4894: break;
4895: case XML_ELEMENT_CONTENT_OR:
4896: /*
4897: * 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: }
4906: 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: }
4918: }
4919:
4920: /*
4921: * save the second branch 'or' branch
4922: */
4923: DEBUG_VALID_MSG("saving 'or' branch");
4924: if (vstateVPush(ctxt, CONT->c2, NODE, (unsigned char)(DEPTH + 1),
4925: OCCURS, ROLLBACK_OR) < 0)
4926: return(-1);
4927: DEPTH++;
4928: CONT = CONT->c1;
4929: goto cont;
4930: case XML_ELEMENT_CONTENT_SEQ:
4931: /*
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: }
4943: 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: }
4955: }
4956: 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: }
4968: analyze:
4969: while (CONT != NULL) {
4970: /*
4971: * First do the analysis depending on the occurrence model at
4972: * this level.
4973: */
4974: if (ret == 0) {
4975: switch (CONT->ocur) {
4976: xmlNodePtr cur;
4977:
4978: case XML_ELEMENT_CONTENT_ONCE:
4979: cur = ctxt->vstate->node;
4980: DEBUG_VALID_MSG("Once branch failed, rollback");
4981: if (vstateVPop(ctxt) < 0 ) {
4982: DEBUG_VALID_MSG("exhaustion, failed");
4983: return(0);
4984: }
4985: if (cur != ctxt->vstate->node)
4986: determinist = -3;
4987: goto cont;
4988: case XML_ELEMENT_CONTENT_PLUS:
4989: if (OCCURRENCE == 0) {
4990: cur = ctxt->vstate->node;
4991: DEBUG_VALID_MSG("Plus branch failed, rollback");
4992: if (vstateVPop(ctxt) < 0 ) {
4993: DEBUG_VALID_MSG("exhaustion, failed");
4994: return(0);
4995: }
4996: if (cur != ctxt->vstate->node)
4997: determinist = -3;
4998: 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
5005: if (OCCURRENCE == 0) {
5006: 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");
5040: SET_OCCURRENCE;
5041: 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");
5054: /* SET_OCCURRENCE; */
5055: goto cont;
5056: }
5057: }
5058: STATE = 0;
5059:
5060: /*
5061: * Then act accordingly at the parent level
5062: */
5063: RESET_OCCURRENCE;
5064: 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) {
5102: xmlNodePtr cur;
5103:
5104: cur = ctxt->vstate->node;
5105: DEBUG_VALID_MSG("Failed, remaining input, rollback");
5106: if (vstateVPop(ctxt) < 0 ) {
5107: DEBUG_VALID_MSG("exhaustion, failed");
5108: return(0);
5109: }
5110: if (cur != ctxt->vstate->node)
5111: determinist = -3;
5112: goto cont;
5113: }
5114: if (ret == 0) {
5115: xmlNodePtr cur;
5116:
5117: cur = ctxt->vstate->node;
5118: DEBUG_VALID_MSG("Failure, rollback");
5119: if (vstateVPop(ctxt) < 0 ) {
5120: DEBUG_VALID_MSG("exhaustion, failed");
5121: return(0);
5122: }
5123: if (cur != ctxt->vstate->node)
5124: determinist = -3;
5125: goto cont;
5126: }
5127: return(determinist);
5128: }
5129: #endif
5130:
5131: /**
5132: * xmlSnprintfElements:
5133: * @buf: an output buffer
5134: * @size: the size of the buffer
5135: * @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: */
5141: static void
5142: xmlSnprintfElements(char *buf, int size, xmlNodePtr node, int glob) {
5143: xmlNodePtr cur;
5144: int len;
5145:
5146: if (node == NULL) return;
5147: if (glob) strcat(buf, "(");
5148: cur = node;
5149: while (cur != NULL) {
5150: len = strlen(buf);
5151: if (size - len < 50) {
5152: if ((size - len > 4) && (buf[len - 1] != '.'))
5153: strcat(buf, " ...");
5154: return;
5155: }
5156: switch (cur->type) {
5157: case XML_ELEMENT_NODE:
5158: if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
5159: if (size - len < xmlStrlen(cur->ns->prefix) + 10) {
5160: if ((size - len > 4) && (buf[len - 1] != '.'))
5161: strcat(buf, " ...");
5162: return;
5163: }
5164: strcat(buf, (char *) cur->ns->prefix);
5165: strcat(buf, ":");
5166: }
5167: if (size - len < xmlStrlen(cur->name) + 10) {
5168: 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;
5176: case XML_TEXT_NODE:
5177: if (xmlIsBlankNode(cur))
5178: break;
5179: case XML_CDATA_SECTION_NODE:
5180: case XML_ENTITY_REF_NODE:
5181: strcat(buf, "CDATA");
5182: if (cur->next != NULL)
5183: strcat(buf, " ");
5184: break;
5185: case XML_ATTRIBUTE_NODE:
5186: case XML_DOCUMENT_NODE:
5187: #ifdef LIBXML_DOCB_ENABLED
5188: case XML_DOCB_DOCUMENT_NODE:
5189: #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:
5195: strcat(buf, "???");
5196: if (cur->next != NULL)
5197: strcat(buf, " ");
5198: break;
5199: 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:
5208: break;
5209: }
5210: cur = cur->next;
5211: }
5212: if (glob) strcat(buf, ")");
5213: }
5214:
5215: /**
5216: * xmlValidateElementContent:
5217: * @ctxt: the validation context
5218: * @child: the child list
5219: * @elemDecl: pointer to the element declaration
5220: * @warn: emit the error message
5221: * @parent: the parent element (for error reporting)
5222: *
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:
5228: static int
5229: xmlValidateElementContent(xmlValidCtxtPtr ctxt, xmlNodePtr child,
5230: xmlElementPtr elemDecl, int warn, xmlNodePtr parent) {
5231: int ret = 1;
5232: #ifndef LIBXML_REGEXP_ENABLED
5233: xmlNodePtr repl = NULL, last = NULL, tmp;
5234: #endif
5235: xmlNodePtr cur;
5236: xmlElementContentPtr cont;
5237: const xmlChar *name;
5238:
5239: if ((elemDecl == NULL) || (parent == NULL))
5240: return(-1);
5241: cont = elemDecl->content;
5242: name = elemDecl->name;
5243:
5244: #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) {
5249: return(-1);
5250: } else {
5251: xmlRegExecCtxtPtr exec;
5252:
5253: if (!xmlRegexpIsDeterminist(elemDecl->contModel)) {
5254: return(-1);
5255: }
5256: ctxt->nodeMax = 0;
5257: ctxt->nodeNr = 0;
5258: ctxt->nodeTab = NULL;
5259: 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:
5282: /* TODO */
5283: ret = 0;
5284: goto fail;
5285: case XML_ELEMENT_NODE:
5286: if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
5287: xmlChar fn[50];
5288: xmlChar *fullname;
5289:
5290: fullname = xmlBuildQName(cur->name,
5291: cur->ns->prefix, fn, 50);
5292: if (fullname == NULL) {
5293: ret = -1;
5294: goto fail;
5295: }
5296: ret = xmlRegExecPushString(exec, fullname, NULL);
5297: if ((fullname != fn) && (fullname != cur->name))
5298: xmlFree(fullname);
5299: } 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);
5318: fail:
5319: xmlRegFreeExecCtxt(exec);
5320: }
5321: }
5322: #else /* LIBXML_REGEXP_ENABLED */
5323: /*
5324: * Allocate the stack
5325: */
5326: ctxt->vstateMax = 8;
5327: ctxt->vstateTab = (xmlValidState *) xmlMalloc(
5328: ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
5329: if (ctxt->vstateTab == NULL) {
5330: xmlVErrMemory(ctxt, "malloc failed");
5331: return(-1);
5332: }
5333: /*
5334: * The first entry in the stack is reserved to the current state
5335: */
5336: ctxt->nodeMax = 0;
5337: ctxt->nodeNr = 0;
5338: ctxt->nodeTab = NULL;
5339: 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);
5347: if ((ret == -3) && (warn)) {
5348: xmlErrValidWarning(ctxt, child, XML_DTD_CONTENT_NOT_DETERMINIST,
5349: "Content model for Element %s is ambiguous\n",
5350: name, NULL, NULL);
5351: } else if (ret == -2) {
5352: /*
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");
5358: cur = child;
5359: while (cur != NULL) {
5360: switch (cur->type) {
5361: case XML_ENTITY_REF_NODE:
5362: /*
5363: * Push the current node to be able to roll back
5364: * and process within the entity
5365: */
5366: if ((cur->children != NULL) &&
5367: (cur->children->children != NULL)) {
5368: nodeVPush(ctxt, cur);
5369: cur = cur->children->children;
5370: continue;
5371: }
5372: break;
5373: case XML_TEXT_NODE:
5374: if (xmlIsBlankNode(cur))
5375: break;
5376: /* no break on purpose */
5377: case XML_CDATA_SECTION_NODE:
5378: /* no break on purpose */
5379: 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) {
5386: xmlVErrMemory(ctxt, "malloc failed");
5387: xmlFreeNodeList(repl);
5388: ret = -1;
5389: goto done;
5390: }
5391: tmp->type = cur->type;
5392: tmp->name = cur->name;
5393: tmp->ns = cur->ns;
5394: tmp->next = NULL;
5395: tmp->content = NULL;
5396: if (repl == NULL)
5397: repl = last = tmp;
5398: else {
5399: last->next = tmp;
5400: last = tmp;
5401: }
5402: if (cur->type == XML_CDATA_SECTION_NODE) {
5403: /*
5404: * E59 spaces in CDATA does not match the
5405: * nonterminal S
5406: */
5407: tmp->content = xmlStrdup(BAD_CAST "CDATA");
5408: }
5409: break;
5410: default:
5411: break;
5412: }
5413: /*
5414: * Switch to next element
5415: */
5416: cur = cur->next;
5417: while (cur == NULL) {
5418: cur = nodeVPop(ctxt);
5419: if (cur == NULL)
5420: break;
5421: cur = cur->next;
5422: }
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: }
5437: #endif /* LIBXML_REGEXP_ENABLED */
5438: if ((warn) && ((ret != 1) && (ret != -3))) {
5439: if (ctxt != NULL) {
5440: char expr[5000];
5441: char list[5000];
5442:
5443: expr[0] = 0;
5444: xmlSnprintfElementContent(&expr[0], 5000, cont, 1);
5445: list[0] = 0;
5446: #ifndef LIBXML_REGEXP_ENABLED
5447: if (repl != NULL)
5448: xmlSnprintfElements(&list[0], 5000, repl, 1);
5449: else
5450: #endif /* LIBXML_REGEXP_ENABLED */
5451: xmlSnprintfElements(&list[0], 5000, child, 1);
5452:
5453: if (name != NULL) {
5454: 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);
5457: } else {
5458: 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);
5461: }
5462: } else {
5463: if (name != NULL) {
5464: xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
5465: "Element %s content does not follow the DTD\n",
5466: name, NULL, NULL);
5467: } else {
5468: xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
5469: "Element content does not follow the DTD\n",
5470: NULL, NULL, NULL);
5471: }
5472: }
5473: ret = 0;
5474: }
5475: if (ret == -3)
5476: ret = 1;
5477:
5478: #ifndef LIBXML_REGEXP_ENABLED
5479: done:
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: }
5488: ctxt->vstateMax = 0;
5489: if (ctxt->vstateTab != NULL) {
5490: xmlFree(ctxt->vstateTab);
5491: ctxt->vstateTab = NULL;
5492: }
5493: #endif
5494: ctxt->nodeMax = 0;
5495: ctxt->nodeNr = 0;
5496: if (ctxt->nodeTab != NULL) {
5497: xmlFree(ctxt->nodeTab);
5498: ctxt->nodeTab = NULL;
5499: }
5500: return(ret);
5501:
5502: }
5503:
5504: /**
5505: * 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: */
5514: static int
5515: xmlValidateOneCdataElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5516: xmlNodePtr elem) {
5517: int ret = 1;
5518: xmlNodePtr cur, child;
5519:
5520: if ((ctxt == NULL) || (doc == NULL) || (elem == NULL) ||
5521: (elem->type != XML_ELEMENT_NODE))
5522: 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: }
5561: done:
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: /**
5572: * 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: */
5581: static int
5582: xmlValidateCheckMixed(xmlValidCtxtPtr ctxt,
5583: xmlElementContentPtr cont, const xmlChar *qname) {
5584: 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)){
5602: xmlErrValid(NULL, XML_DTD_MIXED_CORRUPT,
5603: "Internal: MIXED struct corrupted\n",
5604: NULL);
5605: break;
5606: }
5607: cont = cont->c2;
5608: }
5609: } 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)){
5626: xmlErrValid(ctxt, XML_DTD_MIXED_CORRUPT,
5627: "Internal: MIXED struct corrupted\n",
5628: NULL);
5629: break;
5630: }
5631: cont = cont->c2;
5632: }
5633: }
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: */
5649: static xmlElementPtr
5650: xmlValidGetElemDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5651: xmlNodePtr elem, int *extsubset) {
5652: xmlElementPtr elemDecl = NULL;
5653: const xmlChar *prefix = NULL;
5654:
5655: if ((ctxt == NULL) || (doc == NULL) ||
5656: (elem == NULL) || (elem->name == NULL))
5657: return(NULL);
5658: 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) {
5692: xmlErrValidNode(ctxt, elem,
5693: XML_DTD_UNKNOWN_ELEM,
5694: "No declaration for element %s\n",
5695: elem->name, NULL, NULL);
5696: }
5697: return(elemDecl);
5698: }
5699:
5700: #ifdef LIBXML_REGEXP_ENABLED
5701: /**
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: */
5712: int
5713: xmlValidatePushElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5714: xmlNodePtr elem, const xmlChar *qname) {
5715: int ret = 1;
5716: xmlElementPtr eDecl;
5717: int extsubset = 0;
5718:
5719: if (ctxt == NULL)
5720: return(0);
5721: /* printf("PushElem %s\n", qname); */
5722: 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:
5737: xmlErrValidNode(ctxt, state->node,
5738: XML_DTD_NOT_EMPTY,
5739: "Element %s was declared EMPTY this one has content\n",
5740: state->node->name, NULL, NULL);
5741: 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)) {
5751: xmlErrValidNode(ctxt, state->node,
5752: XML_DTD_NOT_PCDATA,
5753: "Element %s was declared #PCDATA but contains non text nodes\n",
5754: state->node->name, NULL, NULL);
5755: ret = 0;
5756: } else {
5757: ret = xmlValidateCheckMixed(ctxt, elemDecl->content,
5758: qname);
5759: if (ret != 1) {
5760: xmlErrValidNode(ctxt, state->node,
5761: XML_DTD_INVALID_CHILD,
5762: "Element %s is not declared in %s list of possible children\n",
5763: qname, state->node->name, NULL);
5764: }
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) {
5777: 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);
5781: 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
5799: * @len: the length of the data
5800: *
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: */
5805: int
5806: xmlValidatePushCData(xmlValidCtxtPtr ctxt, const xmlChar *data, int len) {
5807: int ret = 1;
5808:
5809: /* printf("CDATA %s %d\n", data, len); */
5810: if (ctxt == NULL)
5811: return(0);
5812: 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:
5829: xmlErrValidNode(ctxt, state->node,
5830: XML_DTD_NOT_EMPTY,
5831: "Element %s was declared EMPTY this one has content\n",
5832: state->node->name, NULL, NULL);
5833: 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++) {
5844: if (!IS_BLANK_CH(data[i])) {
5845: 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);
5849: 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: }
5864: done:
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: */
5879: int
5880: xmlValidatePopElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc ATTRIBUTE_UNUSED,
5881: xmlNodePtr elem ATTRIBUTE_UNUSED,
5882: const xmlChar *qname ATTRIBUTE_UNUSED) {
5883: int ret = 1;
5884:
5885: if (ctxt == NULL)
5886: return(0);
5887: /* printf("PopElem %s\n", qname); */
5888: 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) {
5902: 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);
5906: } 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: }
5920: #endif /* LIBXML_REGEXP_ENABLED */
5921:
5922: /**
5923: * 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:
5940: int
5941: xmlValidateOneElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5942: xmlNodePtr elem) {
5943: xmlElementPtr elemDecl = NULL;
5944: xmlElementContentPtr cont;
5945: xmlAttributePtr attr;
5946: xmlNodePtr child;
5947: int ret = 1, tmp;
5948: const xmlChar *name;
5949: int extsubset = 0;
5950:
5951: CHECK_DTD;
5952:
5953: if (elem == NULL) return(0);
5954: switch (elem->type) {
5955: case XML_ATTRIBUTE_NODE:
5956: xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5957: "Attribute element not expected\n", NULL, NULL ,NULL);
5958: return(0);
5959: case XML_TEXT_NODE:
5960: if (elem->children != NULL) {
5961: xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5962: "Text element has children !\n",
5963: NULL,NULL,NULL);
5964: return(0);
5965: }
5966: if (elem->ns != NULL) {
5967: xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5968: "Text element has namespace !\n",
5969: NULL,NULL,NULL);
5970: return(0);
5971: }
5972: if (elem->content == NULL) {
5973: xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5974: "Text element has no content !\n",
5975: NULL,NULL,NULL);
5976: 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:
5988: xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5989: "Entity element not expected\n", NULL, NULL ,NULL);
5990: return(0);
5991: case XML_NOTATION_NODE:
5992: xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5993: "Notation element not expected\n", NULL, NULL ,NULL);
5994: return(0);
5995: case XML_DOCUMENT_NODE:
5996: case XML_DOCUMENT_TYPE_NODE:
5997: case XML_DOCUMENT_FRAG_NODE:
5998: xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
5999: "Document element not expected\n", NULL, NULL ,NULL);
6000: return(0);
6001: case XML_HTML_DOCUMENT_NODE:
6002: xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
6003: "HTML Document not expected\n", NULL, NULL ,NULL);
6004: return(0);
6005: case XML_ELEMENT_NODE:
6006: break;
6007: default:
6008: xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
6009: "unknown element type\n", NULL, NULL ,NULL);
6010: return(0);
6011: }
6012:
6013: /*
6014: * Fetch the declaration
6015: */
6016: elemDecl = xmlValidGetElemDecl(ctxt, doc, elem, &extsubset);
6017: if (elemDecl == NULL)
6018: return(0);
6019:
6020: /*
6021: * If vstateNr is not zero that means continuous validation is
6022: * activated, do not try to check the content model at that level.
6023: */
6024: if (ctxt->vstateNr == 0) {
6025: /* Check that the element content matches the definition */
6026: switch (elemDecl->etype) {
6027: case XML_ELEMENT_TYPE_UNDEFINED:
6028: xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ELEM,
6029: "No declaration for element %s\n",
6030: elem->name, NULL, NULL);
6031: return(0);
6032: case XML_ELEMENT_TYPE_EMPTY:
6033: if (elem->children != NULL) {
6034: xmlErrValidNode(ctxt, elem, XML_DTD_NOT_EMPTY,
6035: "Element %s was declared EMPTY this one has content\n",
6036: elem->name, NULL, NULL);
6037: 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:
6044:
6045: /* 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) {
6050: xmlErrValidNode(ctxt, elem, XML_DTD_NOT_PCDATA,
6051: "Element %s was declared #PCDATA but contains non text nodes\n",
6052: elem->name, NULL, NULL);
6053: }
6054: break;
6055: }
6056: child = elem->children;
6057: /* Hum, this start to get messy */
6058: while (child != NULL) {
6059: if (child->type == XML_ELEMENT_NODE) {
6060: name = child->name;
6061: if ((child->ns != NULL) && (child->ns->prefix != NULL)) {
6062: xmlChar fn[50];
6063: xmlChar *fullname;
6064:
6065: fullname = xmlBuildQName(child->name, child->ns->prefix,
6066: fn, 50);
6067: if (fullname == NULL)
6068: return(0);
6069: cont = elemDecl->content;
6070: while (cont != NULL) {
6071: if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
6072: if (xmlStrEqual(cont->name, fullname))
6073: break;
6074: } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
6075: (cont->c1 != NULL) &&
6076: (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
6077: if (xmlStrEqual(cont->c1->name, fullname))
6078: break;
6079: } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
6080: (cont->c1 == NULL) ||
6081: (cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
6082: xmlErrValid(NULL, XML_DTD_MIXED_CORRUPT,
6083: "Internal: MIXED struct corrupted\n",
6084: NULL);
6085: break;
6086: }
6087: cont = cont->c2;
6088: }
6089: if ((fullname != fn) && (fullname != child->name))
6090: xmlFree(fullname);
6091: 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)) {
6105: xmlErrValid(ctxt, XML_DTD_MIXED_CORRUPT,
6106: "Internal: MIXED struct corrupted\n",
6107: NULL);
6108: break;
6109: }
6110: cont = cont->c2;
6111: }
6112: if (cont == NULL) {
6113: xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_CHILD,
6114: "Element %s is not declared in %s list of possible children\n",
6115: name, elem->name, NULL);
6116: ret = 0;
6117: }
6118: }
6119: child_ok:
6120: child = child->next;
6121: }
6122: break;
6123: case XML_ELEMENT_TYPE_ELEMENT:
6124: 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:
6135: while (IS_BLANK_CH(*content))
6136: content++;
6137: if (*content == 0) {
6138: xmlErrValidNode(ctxt, elem,
6139: XML_DTD_STANDALONE_WHITE_SPACE,
6140: "standalone: %s declared in the external subset contains white spaces nodes\n",
6141: elem->name, NULL, NULL);
6142: ret = 0;
6143: break;
6144: }
6145: }
6146: child =child->next;
6147: }
6148: }
6149: child = elem->children;
6150: cont = elemDecl->content;
6151: tmp = xmlValidateElementContent(ctxt, child, elemDecl, 1, elem);
6152: if (tmp <= 0)
6153: ret = tmp;
6154: break;
6155: }
6156: } /* not continuous */
6157:
6158: /* [ VC: Required Attribute ] */
6159: attr = elemDecl->attributes;
6160: while (attr != NULL) {
6161: if (attr->def == XML_ATTRIBUTE_REQUIRED) {
6162: int qualified = -1;
6163:
6164: 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)
6171: goto found;
6172: ns = ns->next;
6173: }
6174: } 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;
6185:
6186: 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) {
6200: if (qualified < 0)
6201: qualified = 0;
6202: } else if (!xmlStrEqual(nameSpace->prefix,
6203: attr->prefix)) {
6204: if (qualified < 1)
6205: qualified = 1;
6206: } else
6207: goto found;
6208: } else {
6209: /*
6210: * We should allow applications to define namespaces
6211: * for their application even if the DTD doesn't
6212: * carry one, otherwise, basically we would always
6213: * break.
6214: */
6215: goto found;
6216: }
6217: }
6218: attrib = attrib->next;
6219: }
6220: }
6221: if (qualified == -1) {
6222: if (attr->prefix == NULL) {
6223: xmlErrValidNode(ctxt, elem, XML_DTD_MISSING_ATTRIBUTE,
6224: "Element %s does not carry attribute %s\n",
6225: elem->name, attr->name, NULL);
6226: ret = 0;
6227: } else {
6228: xmlErrValidNode(ctxt, elem, XML_DTD_MISSING_ATTRIBUTE,
6229: "Element %s does not carry attribute %s:%s\n",
6230: elem->name, attr->prefix,attr->name);
6231: ret = 0;
6232: }
6233: } else if (qualified == 0) {
6234: xmlErrValidWarning(ctxt, elem, XML_DTD_NO_PREFIX,
6235: "Element %s required attribute %s:%s has no prefix\n",
6236: elem->name, attr->prefix, attr->name);
6237: } else if (qualified == 1) {
6238: xmlErrValidWarning(ctxt, elem, XML_DTD_DIFFERENT_PREFIX,
6239: "Element %s required attribute %s:%s has different prefix\n",
6240: elem->name, attr->prefix, attr->name);
6241: }
6242: } 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)) {
6256: xmlErrValidNode(ctxt, elem,
6257: XML_DTD_ELEM_DEFAULT_NAMESPACE,
6258: "Element %s namespace name for default namespace does not match the DTD\n",
6259: elem->name, NULL, NULL);
6260: ret = 0;
6261: }
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)) {
6273: xmlErrValidNode(ctxt, elem, XML_DTD_ELEM_NAMESPACE,
6274: "Element %s namespace name for %s does not match the DTD\n",
6275: elem->name, ns->prefix, NULL);
6276: ret = 0;
6277: }
6278: goto found;
6279: }
6280: ns = ns->next;
6281: }
6282: }
6283: }
6284: found:
6285: 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:
6304: int
6305: xmlValidateRoot(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6306: xmlNodePtr root;
6307: int ret;
6308:
6309: if (doc == NULL) return(0);
6310:
6311: root = xmlDocGetRootElement(doc);
6312: if ((root == NULL) || (root->name == NULL)) {
6313: xmlErrValid(ctxt, XML_DTD_NO_ROOT,
6314: "no root element\n", NULL);
6315: 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)) {
6329: xmlChar fn[50];
6330: xmlChar *fullname;
6331:
6332: fullname = xmlBuildQName(root->name, root->ns->prefix, fn, 50);
6333: if (fullname == NULL) {
6334: xmlVErrMemory(ctxt, NULL);
6335: return(0);
6336: }
6337: ret = xmlStrEqual(doc->intSubset->name, fullname);
6338: if ((fullname != fn) && (fullname != root->name))
6339: xmlFree(fullname);
6340: if (ret == 1)
6341: goto name_ok;
6342: }
6343: if ((xmlStrEqual(doc->intSubset->name, BAD_CAST "HTML")) &&
6344: (xmlStrEqual(root->name, BAD_CAST "html")))
6345: goto name_ok;
6346: 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);
6349: return(0);
6350: }
6351: }
6352: name_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: *
6363: * Try to validate the subtree under an element
6364: *
6365: * returns 1 if valid or 0 otherwise
6366: */
6367:
6368: int
6369: xmlValidateElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr elem) {
6370: xmlNodePtr child;
6371: xmlAttrPtr attr;
6372: xmlNsPtr ns;
6373: const xmlChar *value;
6374: 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) ||
6383: (elem->type == XML_XINCLUDE_END) ||
6384: (elem->type == XML_NAMESPACE_DECL))
6385: return(1);
6386:
6387: CHECK_DTD;
6388:
6389: /*
6390: * Entities references have to be handled separately
6391: */
6392: if (elem->type == XML_ENTITY_REF_NODE) {
6393: return(1);
6394: }
6395:
6396: ret &= xmlValidateOneElement(ctxt, doc, elem);
6397: 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: }
6416: }
6417: child = elem->children;
6418: while (child != NULL) {
6419: ret &= xmlValidateElement(ctxt, doc, child);
6420: child = child->next;
6421: }
6422:
6423: return(ret);
6424: }
6425:
6426: /**
6427: * xmlValidateRef:
6428: * @ref: A reference to be validated
6429: * @ctxt: Validation context
6430: * @name: Name of ID we are searching for
6431: *
6432: */
6433: static void
6434: xmlValidateRef(xmlRefPtr ref, xmlValidCtxtPtr ctxt,
6435: const xmlChar *name) {
6436: xmlAttrPtr id;
6437: xmlAttrPtr attr;
6438:
6439: if (ref == NULL)
6440: return;
6441: if ((ref->attr == NULL) && (ref->name == NULL))
6442: return;
6443: 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;
6455: while ((*cur != 0) && (!IS_BLANK_CH(*cur))) cur++;
6456: save = *cur;
6457: *cur = 0;
6458: id = xmlGetID(ctxt->doc, str);
6459: if (id == NULL) {
6460: xmlErrValidNodeNr(ctxt, NULL, XML_DTD_UNKNOWN_ID,
6461: "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;
6468: while (IS_BLANK_CH(*cur)) cur++;
6469: }
6470: xmlFree(dup);
6471: } else if (attr->atype == XML_ATTRIBUTE_IDREF) {
6472: id = xmlGetID(ctxt->doc, name);
6473: if (id == NULL) {
6474: xmlErrValidNode(ctxt, attr->parent, XML_DTD_UNKNOWN_ID,
6475: "IDREF attribute %s references an unknown ID \"%s\"\n",
6476: attr->name, name, NULL);
6477: 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) {
6484: xmlVErrMemory(ctxt, "IDREFS split");
6485: ctxt->valid = 0;
6486: return;
6487: }
6488: cur = dup;
6489: while (*cur != 0) {
6490: str = cur;
6491: while ((*cur != 0) && (!IS_BLANK_CH(*cur))) cur++;
6492: save = *cur;
6493: *cur = 0;
6494: id = xmlGetID(ctxt->doc, str);
6495: if (id == NULL) {
6496: xmlErrValidNode(ctxt, attr->parent, XML_DTD_UNKNOWN_ID,
6497: "IDREFS attribute %s references an unknown ID \"%s\"\n",
6498: attr->name, str, NULL);
6499: ctxt->valid = 0;
6500: }
6501: if (save == 0)
6502: break;
6503: *cur = save;
6504: while (IS_BLANK_CH(*cur)) cur++;
6505: }
6506: xmlFree(dup);
6507: }
6508: }
6509:
6510: /**
6511: * xmlWalkValidateList:
6512: * @data: Contents of current link
6513: * @user: Value supplied by the user
6514: *
6515: * Returns 0 to abort the walk or 1 to continue
6516: */
6517: static int
6518: xmlWalkValidateList(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: */
6532: static void
6533: xmlValidateCheckRefCallback(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);
6543:
6544: }
6545:
6546: /**
6547: * 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
6555: *
6556: * Check all the IDREF/IDREFS attributes definition for validity
6557: *
6558: * returns 1 if valid or 0 otherwise
6559: */
6560:
6561: int
6562: xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6563: xmlRefTablePtr table;
6564: unsigned int save;
6565:
6566: if (ctxt == NULL)
6567: return(0);
6568: if (doc == NULL) {
6569: xmlErrValid(ctxt, XML_DTD_NO_DOC,
6570: "xmlValidateDocumentFinal: doc == NULL\n", NULL);
6571: return(0);
6572: }
6573:
6574: /* trick to get correct line id report */
6575: save = ctxt->finishDtd;
6576: ctxt->finishDtd = 0;
6577:
6578: /*
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);
6591:
6592: ctxt->finishDtd = save;
6593: 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: *
6604: * 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.
6608: *
6609: * returns 1 if valid or 0 otherwise
6610: */
6611:
6612: int
6613: xmlValidateDtd(xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlDtdPtr dtd) {
6614: int ret;
6615: xmlDtdPtr oldExt, oldInt;
6616: xmlNodePtr root;
6617:
6618: if (dtd == NULL) return(0);
6619: if (doc == NULL) return(0);
6620: oldExt = doc->extSubset;
6621: oldInt = doc->intSubset;
6622: doc->extSubset = dtd;
6623: doc->intSubset = NULL;
6624: ret = xmlValidateRoot(ctxt, doc);
6625: if (ret == 0) {
6626: doc->extSubset = oldExt;
6627: doc->intSubset = oldInt;
6628: 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;
6642: doc->intSubset = oldInt;
6643: return(ret);
6644: }
6645:
6646: static void
6647: xmlValidateNotationCallback(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:
6654: if (notation != NULL) {
6655: int ret;
6656:
6657: ret = xmlValidateNotationUse(ctxt, cur->doc, notation);
6658: if (ret != 1) {
6659: ctxt->valid = 0;
6660: }
6661: }
6662: }
6663: }
6664:
6665: static void
6666: xmlValidateAttributeCallback(xmlAttributePtr cur, xmlValidCtxtPtr ctxt,
6667: const xmlChar *name ATTRIBUTE_UNUSED) {
6668: int ret;
6669: xmlDocPtr doc;
6670: xmlElementPtr elem = NULL;
6671:
6672: 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) {
6687:
6688: ret = xmlValidateAttributeValue2(ctxt, ctxt->doc, cur->name,
6689: cur->atype, cur->defaultValue);
6690: if ((ret == 0) && (ctxt->valid == 1))
6691: ctxt->valid = 0;
6692: }
6693: if (cur->tree != NULL) {
6694: xmlEnumerationPtr tree = cur->tree;
6695: while (tree != NULL) {
6696: ret = xmlValidateAttributeValue2(ctxt, ctxt->doc,
6697: cur->name, cur->atype, tree->name);
6698: if ((ret == 0) && (ctxt->valid == 1))
6699: ctxt->valid = 0;
6700: tree = tree->next;
6701: }
6702: }
6703: }
6704: if (cur->atype == XML_ATTRIBUTE_NOTATION) {
6705: doc = cur->doc;
6706: if (cur->elem == NULL) {
6707: xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
6708: "xmlValidateAttributeCallback(%s): internal error\n",
6709: (const char *) cur->name);
6710: return;
6711: }
6712:
6713: if (doc != NULL)
6714: elem = xmlGetDtdElementDesc(doc->intSubset, cur->elem);
6715: if ((elem == NULL) && (doc != NULL))
6716: elem = xmlGetDtdElementDesc(doc->extSubset, cur->elem);
6717: if ((elem == NULL) && (cur->parent != NULL) &&
6718: (cur->parent->type == XML_DTD_NODE))
6719: elem = xmlGetDtdElementDesc((xmlDtdPtr) cur->parent, cur->elem);
6720: if (elem == NULL) {
6721: xmlErrValidNode(ctxt, NULL, XML_DTD_UNKNOWN_ELEM,
6722: "attribute %s: could not find decl for element %s\n",
6723: cur->name, cur->elem, NULL);
6724: return;
6725: }
6726: if (elem->etype == XML_ELEMENT_TYPE_EMPTY) {
6727: xmlErrValidNode(ctxt, NULL, XML_DTD_EMPTY_NOTATION,
6728: "NOTATION attribute %s declared for EMPTY element %s\n",
6729: cur->name, cur->elem, NULL);
6730: ctxt->valid = 0;
6731: }
6732: }
6733: }
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
6744: * - check that ENTITY and ENTITIES type attributes default or
6745: * possible values matches one of the defined entities.
6746: * - check that NOTATION type attributes default or
6747: * possible values matches one of the defined notations.
6748: *
6749: * returns 1 if valid or 0 if invalid and -1 if not well-formed
6750: */
6751:
6752: int
6753: xmlValidateDtdFinal(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6754: xmlDtdPtr dtd;
6755: xmlAttributeTablePtr table;
6756: xmlEntitiesTablePtr entities;
6757:
6758: if ((doc == NULL) || (ctxt == NULL)) return(0);
6759: if ((doc->intSubset == NULL) && (doc->extSubset == NULL))
6760: return(0);
6761: ctxt->doc = doc;
6762: ctxt->valid = 1;
6763: dtd = doc->intSubset;
6764: if ((dtd != NULL) && (dtd->attributes != NULL)) {
6765: table = (xmlAttributeTablePtr) dtd->attributes;
6766: xmlHashScan(table, (xmlHashScanner) xmlValidateAttributeCallback, ctxt);
6767: }
6768: if ((dtd != NULL) && (dtd->entities != NULL)) {
6769: entities = (xmlEntitiesTablePtr) dtd->entities;
6770: xmlHashScan(entities, (xmlHashScanner) xmlValidateNotationCallback,
6771: ctxt);
6772: }
6773: dtd = doc->extSubset;
6774: if ((dtd != NULL) && (dtd->attributes != NULL)) {
6775: table = (xmlAttributeTablePtr) dtd->attributes;
6776: xmlHashScan(table, (xmlHashScanner) xmlValidateAttributeCallback, ctxt);
6777: }
6778: if ((dtd != NULL) && (dtd->entities != NULL)) {
6779: entities = (xmlEntitiesTablePtr) dtd->entities;
6780: xmlHashScan(entities, (xmlHashScanner) xmlValidateNotationCallback,
6781: ctxt);
6782: }
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:
6800: int
6801: xmlValidateDocument(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6802: int ret;
6803: xmlNodePtr root;
6804:
6805: if (doc == NULL)
6806: return(0);
6807: if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
6808: xmlErrValid(ctxt, XML_DTD_NO_DTD,
6809: "no DTD found!\n", NULL);
6810: return(0);
6811: }
6812: if ((doc->intSubset != NULL) && ((doc->intSubset->SystemID != NULL) ||
6813: (doc->intSubset->ExternalID != NULL)) && (doc->extSubset == NULL)) {
6814: xmlChar *sysID;
6815: if (doc->intSubset->SystemID != NULL) {
6816: sysID = xmlBuildURI(doc->intSubset->SystemID,
6817: doc->URL);
6818: 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
6825: sysID = NULL;
6826: doc->extSubset = xmlParseDTD(doc->intSubset->ExternalID,
6827: (const xmlChar *)sysID);
6828: if (sysID != NULL)
6829: xmlFree(sysID);
6830: if (doc->extSubset == NULL) {
6831: if (doc->intSubset->SystemID != NULL) {
6832: xmlErrValid(ctxt, XML_DTD_LOAD_ERROR,
6833: "Could not load the external subset \"%s\"\n",
6834: (const char *) doc->intSubset->SystemID);
6835: } else {
6836: xmlErrValid(ctxt, XML_DTD_LOAD_ERROR,
6837: "Could not load the external subset \"%s\"\n",
6838: (const char *) doc->intSubset->ExternalID);
6839: }
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:
6861: /************************************************************************
6862: * *
6863: * Routines for dynamic validation editing *
6864: * *
6865: ************************************************************************/
6866:
6867: /**
6868: * xmlValidGetPotentialChildren:
6869: * @ctree: an element content tree
6870: * @names: an array to store the list of child names
6871: * @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:
6879: int
6880: xmlValidGetPotentialChildren(xmlElementContent *ctree,
6881: const xmlChar **names,
6882: int *len, int max) {
6883: int i;
6884:
6885: if ((ctree == NULL) || (names == NULL) || (len == NULL))
6886: return(-1);
6887: if (*len >= max) return(*len);
6888:
6889: switch (ctree->type) {
6890: case XML_ELEMENT_CONTENT_PCDATA:
6891: for (i = 0; i < *len;i++)
6892: if (xmlStrEqual(BAD_CAST "#PCDATA", names[i])) return(*len);
6893: names[(*len)++] = BAD_CAST "#PCDATA";
6894: break;
6895: case XML_ELEMENT_CONTENT_ELEMENT:
6896: for (i = 0; i < *len;i++)
6897: if (xmlStrEqual(ctree->name, names[i])) return(*len);
6898: names[(*len)++] = ctree->name;
6899: break;
6900: case XML_ELEMENT_CONTENT_SEQ:
6901: xmlValidGetPotentialChildren(ctree->c1, names, len, max);
6902: xmlValidGetPotentialChildren(ctree->c2, names, len, max);
6903: break;
6904: case XML_ELEMENT_CONTENT_OR:
6905: xmlValidGetPotentialChildren(ctree->c1, names, len, max);
6906: xmlValidGetPotentialChildren(ctree->c2, names, len, max);
6907: break;
6908: }
6909:
6910: return(*len);
6911: }
6912:
6913: /*
6914: * Dummy function to suppress messages while we try out valid elements
6915: */
6916: static void XMLCDECL xmlNoValidityErr(void *ctx ATTRIBUTE_UNUSED,
6917: const char *msg ATTRIBUTE_UNUSED, ...) {
6918: return;
6919: }
6920:
6921: /**
6922: * xmlValidGetValidElements:
6923: * @prev: an element to insert after
6924: * @next: an element to insert next
6925: * @names: an array to store the list of child names
6926: * @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:
6946: int
6947: xmlValidGetValidElements(xmlNode *prev, xmlNode *next, const xmlChar **names,
6948: int max) {
6949: xmlValidCtxt vctxt;
6950: int nb_valid_elements = 0;
6951: const xmlChar *elements[256];
6952: int nb_elements = 0, i;
6953: const xmlChar *name;
6954:
6955: xmlNode *ref_node;
6956: xmlNode *parent;
6957: xmlNode *test_node;
6958:
6959: xmlNode *prev_next;
6960: xmlNode *next_prev;
6961: xmlNode *parent_childs;
6962: xmlNode *parent_last;
6963:
6964: xmlElement *element_desc;
6965:
6966: if (prev == NULL && next == NULL)
6967: return(-1);
6968:
6969: if (names == NULL) return(-1);
6970: if (max <= 0) return(-1);
6971:
6972: memset(&vctxt, 0, sizeof (xmlValidCtxt));
6973: vctxt.error = xmlNoValidityErr; /* this suppresses err/warn output */
6974:
6975: 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);
6988:
6989: /*
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
6999: */
7000: test_node = xmlNewDocNode (ref_node->doc, NULL, BAD_CAST "<!dummy?>", NULL);
7001: test_node->parent = parent;
7002: test_node->prev = prev;
7003: test_node->next = next;
7004: name = test_node->name;
7005:
7006: if (prev) prev->next = test_node;
7007: else parent->children = test_node;
7008:
7009: 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);
7018:
7019: for (i = 0;i < nb_elements;i++) {
7020: test_node->name = elements[i];
7021: if (xmlValidateOneElement(&vctxt, parent->doc, parent)) {
7022: int j;
7023:
7024: for (j = 0; j < nb_valid_elements;j++)
7025: if (xmlStrEqual(elements[i], names[j])) break;
7026: names[nb_valid_elements++] = elements[i];
7027: 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;
7038:
7039: /*
7040: * Free up the dummy node
7041: */
7042: test_node->name = name;
7043: xmlFreeNode(test_node);
7044:
7045: return(nb_valid_elements);
7046: }
7047: #endif /* LIBXML_VALID_ENABLED */
7048:
7049: #define bottom_valid
7050: #include "elfgcchack.h"
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to valid.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2