valid.h
1 /*
2 * valid.h : interface to the DTD handling and the validity checking
3 *
4 * See Copyright for the status of this software.
5 *
6 * daniel@veillard.com
7 */
8
9
10 #ifndef __XML_VALID_H__
11 #define __XML_VALID_H__
12
13 #include
14 #include
15 #include
16 #include
17
18 #ifdef __cplusplus
19 extern "C" {
20 #endif
21
22 /*
23 * Validation state added for non-determinist content model.
24 */
25 typedef struct _xmlValidState xmlValidState; <typedef:xmlValidState>
26 typedef xmlValidState *xmlValidStatePtr; <typedef:xmlValidStatePtr>
27
28 /**
29 * xmlValidityErrorFunc:
30 * @ctx: an xmlValidCtxtPtr validity error context
31 * @msg: the string to format *printf like vararg
32 * @...: remaining arguments to the format
33 *
34 * Callback called when a validity error is found. This is a message
35 * oriented function similar to an *printf function.
36 */
37 typedef void (*xmlValidityErrorFunc) (void *ctx,
38 const char *msg,
39 ...); <typedef:xmlValidityErrorFunc>
40
41 /**
42 * xmlValidityWarningFunc:
43 * @ctx: an xmlValidCtxtPtr validity error context
44 * @msg: the string to format *printf like vararg
45 * @...: remaining arguments to the format
46 *
47 * Callback called when a validity warning is found. This is a message
48 * oriented function similar to an *printf function.
49 */
50 typedef void (*xmlValidityWarningFunc) (void *ctx,
51 const char *msg,
52 ...); <typedef:xmlValidityWarningFunc>
53
54 /**
55 * xmlValidCtxt:
56 * An xmlValidCtxt is used for error reporting when validating.
57 */
58 typedef struct _xmlValidCtxt xmlValidCtxt; <_xmlValidCtxt>
59 typedef xmlValidCtxt *xmlValidCtxtPtr; <typedef:xmlValidCtxtPtr>
60 struct _xmlValidCtxt {
61 void *userData; /* user specific data block */
62 xmlValidityErrorFunc error; /* the callback in case of errors */
63 xmlValidityWarningFunc warning; /* the callback in case of warning */
64
65 /* Node analysis stack used when validating within entities */
66 xmlNodePtr node; /* Current parsed Node */
67 int nodeNr; /* Depth of the parsing stack */
68 int nodeMax; /* Max depth of the parsing stack */
69 xmlNodePtr *nodeTab; /* array of nodes */
70
71 int finishDtd; /* finished validating the Dtd ? */
72 xmlDocPtr doc; /* the document */
73 int valid; /* temporary validity check result */
74
75 /* state state used for non-determinist content validation */
76 xmlValidState *vstate; /* current state */
77 int vstateNr; /* Depth of the validation stack */
78 int vstateMax; /* Max depth of the validation stack */
79 xmlValidState *vstateTab; /* array of validation states */
80
81 #ifdef LIBXML_REGEXP_ENABLED
82 xmlAutomataPtr am; /* the automata */
83 xmlAutomataStatePtr state; /* used to build the automata */
84 #else
85 void *am;
86 void *state;
87 #endif
88 };
89
90 /*
91 * ALL notation declarations are stored in a table.
92 * There is one table per DTD.
93 */
94
95 typedef struct _xmlHashTable xmlNotationTable; <typedef:xmlNotationTable>
96 typedef xmlNotationTable *xmlNotationTablePtr; <typedef:xmlNotationTablePtr>
97
98 /*
99 * ALL element declarations are stored in a table.
100 * There is one table per DTD.
101 */
102
103 typedef struct _xmlHashTable xmlElementTable; <typedef:xmlElementTable>
104 typedef xmlElementTable *xmlElementTablePtr; <typedef:xmlElementTablePtr>
105
106 /*
107 * ALL attribute declarations are stored in a table.
108 * There is one table per DTD.
109 */
110
111 typedef struct _xmlHashTable xmlAttributeTable; <typedef:xmlAttributeTable>
112 typedef xmlAttributeTable *xmlAttributeTablePtr; <typedef:xmlAttributeTablePtr>
113
114 /*
115 * ALL IDs attributes are stored in a table.
116 * There is one table per document.
117 */
118
119 typedef struct _xmlHashTable xmlIDTable; <typedef:xmlIDTable>
120 typedef xmlIDTable *xmlIDTablePtr; <typedef:xmlIDTablePtr>
121
122 /*
123 * ALL Refs attributes are stored in a table.
124 * There is one table per document.
125 */
126
127 typedef struct _xmlHashTable xmlRefTable; <typedef:xmlRefTable>
128 typedef xmlRefTable *xmlRefTablePtr; <typedef:xmlRefTablePtr>
129
130 /* helper */
131 xmlChar * xmlSplitQName2 (const xmlChar *name,
132 xmlChar **prefix);
133
134 /* Notation */
135 xmlNotationPtr xmlAddNotationDecl (xmlValidCtxtPtr ctxt,
136 xmlDtdPtr dtd,
137 const xmlChar *name,
138 const xmlChar *PublicID,
139 const xmlChar *SystemID);
140 xmlNotationTablePtr xmlCopyNotationTable(xmlNotationTablePtr table);
141 void xmlFreeNotationTable(xmlNotationTablePtr table);
142 void xmlDumpNotationDecl (xmlBufferPtr buf,
143 xmlNotationPtr nota);
144 void xmlDumpNotationTable(xmlBufferPtr buf,
145 xmlNotationTablePtr table);
146
147 /* Element Content */
148 xmlElementContentPtr xmlNewElementContent (xmlChar *name,
149 xmlElementContentType type);
150 xmlElementContentPtr xmlCopyElementContent(xmlElementContentPtr content);
151 void xmlFreeElementContent(xmlElementContentPtr cur);
152 void xmlSnprintfElementContent(char *buf,
153 int size,
154 xmlElementContentPtr content,
155 int glob);
156 /* DEPRECATED */
157 void xmlSprintfElementContent(char *buf,
158 xmlElementContentPtr content,
159 int glob);
160 /* DEPRECATED */
161
162 /* Element */
163 xmlElementPtr xmlAddElementDecl (xmlValidCtxtPtr ctxt,
164 xmlDtdPtr dtd,
165 const xmlChar *name,
166 xmlElementTypeVal type,
167 xmlElementContentPtr content);
168 xmlElementTablePtr xmlCopyElementTable (xmlElementTablePtr table);
169 void xmlFreeElementTable (xmlElementTablePtr table);
170 void xmlDumpElementTable (xmlBufferPtr buf,
171 xmlElementTablePtr table);
172 void xmlDumpElementDecl (xmlBufferPtr buf,
173 xmlElementPtr elem);
174
175 /* Enumeration */
176 xmlEnumerationPtr xmlCreateEnumeration (xmlChar *name);
177 void xmlFreeEnumeration (xmlEnumerationPtr cur);
178 xmlEnumerationPtr xmlCopyEnumeration (xmlEnumerationPtr cur);
179
180 /* Attribute */
181 xmlAttributePtr xmlAddAttributeDecl (xmlValidCtxtPtr ctxt,
182 xmlDtdPtr dtd,
183 const xmlChar *elem,
184 const xmlChar *name,
185 const xmlChar *ns,
186 xmlAttributeType type,
187 xmlAttributeDefault def,
188 const xmlChar *defaultValue,
189 xmlEnumerationPtr tree);
190 xmlAttributeTablePtr xmlCopyAttributeTable (xmlAttributeTablePtr table);
191 void xmlFreeAttributeTable (xmlAttributeTablePtr table);
192 void xmlDumpAttributeTable (xmlBufferPtr buf,
193 xmlAttributeTablePtr table);
194 void xmlDumpAttributeDecl (xmlBufferPtr buf,
195 xmlAttributePtr attr);
196
197 /* IDs */
198 xmlIDPtr xmlAddID (xmlValidCtxtPtr ctxt,
199 xmlDocPtr doc,
200 const xmlChar *value,
201 xmlAttrPtr attr);
202 void xmlFreeIDTable (xmlIDTablePtr table);
203 xmlAttrPtr xmlGetID (xmlDocPtr doc,
204 const xmlChar *ID);
205 int xmlIsID (xmlDocPtr doc,
206 xmlNodePtr elem,
207 xmlAttrPtr attr);
208 int xmlRemoveID (xmlDocPtr doc, xmlAttrPtr attr);
209
210 /* IDREFs */
211 xmlRefPtr xmlAddRef (xmlValidCtxtPtr ctxt,
212 xmlDocPtr doc,
213 const xmlChar *value,
214 xmlAttrPtr attr);
215 void xmlFreeRefTable (xmlRefTablePtr table);
216 int xmlIsRef (xmlDocPtr doc,
217 xmlNodePtr elem,
218 xmlAttrPtr attr);
219 int xmlRemoveRef (xmlDocPtr doc, xmlAttrPtr attr);
220 xmlListPtr xmlGetRefs (xmlDocPtr doc,
221 const xmlChar *ID);
222
223 /**
224 * The public function calls related to validity checking.
225 */
226
227 int xmlValidateRoot (xmlValidCtxtPtr ctxt,
228 xmlDocPtr doc);
229 int xmlValidateElementDecl (xmlValidCtxtPtr ctxt,
230 xmlDocPtr doc,
231 xmlElementPtr elem);
232 xmlChar * xmlValidNormalizeAttributeValue(xmlDocPtr doc,
233 xmlNodePtr elem,
234 const xmlChar *name,
235 const xmlChar *value);
236 xmlChar * xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt,
237 xmlDocPtr doc,
238 xmlNodePtr elem,
239 const xmlChar *name,
240 const xmlChar *value);
241 int xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt,
242 xmlDocPtr doc,
243 xmlAttributePtr attr);
244 int xmlValidateAttributeValue(xmlAttributeType type,
245 const xmlChar *value);
246 int xmlValidateNotationDecl (xmlValidCtxtPtr ctxt,
247 xmlDocPtr doc,
248 xmlNotationPtr nota);
249 int xmlValidateDtd (xmlValidCtxtPtr ctxt,
250 xmlDocPtr doc,
251 xmlDtdPtr dtd);
252 int xmlValidateDtdFinal (xmlValidCtxtPtr ctxt,
253 xmlDocPtr doc);
254 int xmlValidateDocument (xmlValidCtxtPtr ctxt,
255 xmlDocPtr doc);
256 int xmlValidateElement (xmlValidCtxtPtr ctxt,
257 xmlDocPtr doc,
258 xmlNodePtr elem);
259 int xmlValidateOneElement (xmlValidCtxtPtr ctxt,
260 xmlDocPtr doc,
261 xmlNodePtr elem);
262 int xmlValidateOneAttribute (xmlValidCtxtPtr ctxt,
263 xmlDocPtr doc,
264 xmlNodePtr elem,
265 xmlAttrPtr attr,
266 const xmlChar *value);
267 int xmlValidateOneNamespace (xmlValidCtxtPtr ctxt,
268 xmlDocPtr doc,
269 xmlNodePtr elem,
270 const xmlChar *prefix,
271 xmlNsPtr ns,
272 const xmlChar *value);
273 int xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt,
274 xmlDocPtr doc);
275 int xmlValidateNotationUse (xmlValidCtxtPtr ctxt,
276 xmlDocPtr doc,
277 const xmlChar *notationName);
278 int xmlIsMixedElement (xmlDocPtr doc,
279 const xmlChar *name);
280 xmlAttributePtr xmlGetDtdAttrDesc (xmlDtdPtr dtd,
281 const xmlChar *elem,
282 const xmlChar *name);
283 xmlAttributePtr xmlGetDtdQAttrDesc (xmlDtdPtr dtd,
284 const xmlChar *elem,
285 const xmlChar *name,
286 const xmlChar *prefix);
287 xmlNotationPtr xmlGetDtdNotationDesc (xmlDtdPtr dtd,
288 const xmlChar *name);
289 xmlElementPtr xmlGetDtdQElementDesc (xmlDtdPtr dtd,
290 const xmlChar *name,
291 const xmlChar *prefix);
292 xmlElementPtr xmlGetDtdElementDesc (xmlDtdPtr dtd,
293 const xmlChar *name);
294
295 int xmlValidGetValidElements(xmlNode *prev,
296 xmlNode *next,
297 const xmlChar **list,
298 int max);
299 int xmlValidGetPotentialChildren(xmlElementContent *ctree,
300 const xmlChar **list,
301 int *len,
302 int max);
303 int xmlValidateNameValue (const xmlChar *value);
304 int xmlValidateNamesValue (const xmlChar *value);
305 int xmlValidateNmtokenValue (const xmlChar *value);
306 int xmlValidateNmtokensValue(const xmlChar *value);
307
308 #ifdef LIBXML_REGEXP_ENABLED
309 /*
310 * Validation based on the regexp support
311 */
312 int xmlValidBuildContentModel(xmlValidCtxtPtr ctxt,
313 xmlElementPtr elem);
314
315 #endif /* LIBXML_REGEXP_ENABLED */
316 #ifdef __cplusplus
317 }
318 #endif
319 #endif /* __XML_VALID_H__ */