| 1 | /* | 
|---|
| 2 | * Summary: The DTD validation | 
|---|
| 3 | * Description: API for the DTD handling and the validity checking | 
|---|
| 4 | * | 
|---|
| 5 | * Copy: See Copyright for the status of this software. | 
|---|
| 6 | * | 
|---|
| 7 | * Author: Daniel Veillard | 
|---|
| 8 | */ | 
|---|
| 9 |  | 
|---|
| 10 |  | 
|---|
| 11 | #ifndef __XML_VALID_H__ | 
|---|
| 12 | #define __XML_VALID_H__ | 
|---|
| 13 |  | 
|---|
| 14 | #include <libxml/xmlversion.h> | 
|---|
| 15 | #include <libxml/xmlerror.h> | 
|---|
| 16 | #include <libxml/tree.h> | 
|---|
| 17 | #include <libxml/list.h> | 
|---|
| 18 | #include <libxml/xmlautomata.h> | 
|---|
| 19 | #include <libxml/xmlregexp.h> | 
|---|
| 20 |  | 
|---|
| 21 | #ifdef __cplusplus | 
|---|
| 22 | extern "C"{ | 
|---|
| 23 | #endif | 
|---|
| 24 |  | 
|---|
| 25 | /* | 
|---|
| 26 | * Validation state added for non-determinist content model. | 
|---|
| 27 | */ | 
|---|
| 28 | typedef struct _xmlValidState xmlValidState; | 
|---|
| 29 | typedef xmlValidState *xmlValidStatePtr; | 
|---|
| 30 |  | 
|---|
| 31 | /** | 
|---|
| 32 | * xmlValidityErrorFunc: | 
|---|
| 33 | * @ctx:  usually an xmlValidCtxtPtr to a validity error context, | 
|---|
| 34 | *        but comes from ctxt->userData (which normally contains such | 
|---|
| 35 | *        a pointer); ctxt->userData can be changed by the user. | 
|---|
| 36 | * @msg:  the string to format *printf like vararg | 
|---|
| 37 | * @...:  remaining arguments to the format | 
|---|
| 38 | * | 
|---|
| 39 | * Callback called when a validity error is found. This is a message | 
|---|
| 40 | * oriented function similar to an *printf function. | 
|---|
| 41 | */ | 
|---|
| 42 | typedef void (XMLCDECL *xmlValidityErrorFunc) (void *ctx, | 
|---|
| 43 | const char *msg, | 
|---|
| 44 | ...) LIBXML_ATTR_FORMAT(2,3); | 
|---|
| 45 |  | 
|---|
| 46 | /** | 
|---|
| 47 | * xmlValidityWarningFunc: | 
|---|
| 48 | * @ctx:  usually an xmlValidCtxtPtr to a validity error context, | 
|---|
| 49 | *        but comes from ctxt->userData (which normally contains such | 
|---|
| 50 | *        a pointer); ctxt->userData can be changed by the user. | 
|---|
| 51 | * @msg:  the string to format *printf like vararg | 
|---|
| 52 | * @...:  remaining arguments to the format | 
|---|
| 53 | * | 
|---|
| 54 | * Callback called when a validity warning is found. This is a message | 
|---|
| 55 | * oriented function similar to an *printf function. | 
|---|
| 56 | */ | 
|---|
| 57 | typedef void (XMLCDECL *xmlValidityWarningFunc) (void *ctx, | 
|---|
| 58 | const char *msg, | 
|---|
| 59 | ...) LIBXML_ATTR_FORMAT(2,3); | 
|---|
| 60 |  | 
|---|
| 61 | #ifdef IN_LIBXML | 
|---|
| 62 | /** | 
|---|
| 63 | * XML_CTXT_FINISH_DTD_0: | 
|---|
| 64 | * | 
|---|
| 65 | * Special value for finishDtd field when embedded in an xmlParserCtxt | 
|---|
| 66 | */ | 
|---|
| 67 | #define XML_CTXT_FINISH_DTD_0 0xabcd1234 | 
|---|
| 68 | /** | 
|---|
| 69 | * XML_CTXT_FINISH_DTD_1: | 
|---|
| 70 | * | 
|---|
| 71 | * Special value for finishDtd field when embedded in an xmlParserCtxt | 
|---|
| 72 | */ | 
|---|
| 73 | #define XML_CTXT_FINISH_DTD_1 0xabcd1235 | 
|---|
| 74 | #endif | 
|---|
| 75 |  | 
|---|
| 76 | /* | 
|---|
| 77 | * xmlValidCtxt: | 
|---|
| 78 | * An xmlValidCtxt is used for error reporting when validating. | 
|---|
| 79 | */ | 
|---|
| 80 | typedef struct _xmlValidCtxt xmlValidCtxt; | 
|---|
| 81 | typedef xmlValidCtxt *xmlValidCtxtPtr; | 
|---|
| 82 | struct _xmlValidCtxt { | 
|---|
| 83 | void *userData;			/* user specific data block */ | 
|---|
| 84 | xmlValidityErrorFunc error;		/* the callback in case of errors */ | 
|---|
| 85 | xmlValidityWarningFunc warning;	/* the callback in case of warning */ | 
|---|
| 86 |  | 
|---|
| 87 | /* Node analysis stack used when validating within entities */ | 
|---|
| 88 | xmlNodePtr         node;          /* Current parsed Node */ | 
|---|
| 89 | int                nodeNr;        /* Depth of the parsing stack */ | 
|---|
| 90 | int                nodeMax;       /* Max depth of the parsing stack */ | 
|---|
| 91 | xmlNodePtr        *nodeTab;       /* array of nodes */ | 
|---|
| 92 |  | 
|---|
| 93 | unsigned int     finishDtd;       /* finished validating the Dtd ? */ | 
|---|
| 94 | xmlDocPtr              doc;       /* the document */ | 
|---|
| 95 | int                  valid;       /* temporary validity check result */ | 
|---|
| 96 |  | 
|---|
| 97 | /* state state used for non-determinist content validation */ | 
|---|
| 98 | xmlValidState     *vstate;        /* current state */ | 
|---|
| 99 | int                vstateNr;      /* Depth of the validation stack */ | 
|---|
| 100 | int                vstateMax;     /* Max depth of the validation stack */ | 
|---|
| 101 | xmlValidState     *vstateTab;     /* array of validation states */ | 
|---|
| 102 |  | 
|---|
| 103 | #ifdef LIBXML_REGEXP_ENABLED | 
|---|
| 104 | xmlAutomataPtr            am;     /* the automata */ | 
|---|
| 105 | xmlAutomataStatePtr    state;     /* used to build the automata */ | 
|---|
| 106 | #else | 
|---|
| 107 | void                     *am; | 
|---|
| 108 | void                  *state; | 
|---|
| 109 | #endif | 
|---|
| 110 | }; | 
|---|
| 111 |  | 
|---|
| 112 | /* | 
|---|
| 113 | * ALL notation declarations are stored in a table. | 
|---|
| 114 | * There is one table per DTD. | 
|---|
| 115 | */ | 
|---|
| 116 |  | 
|---|
| 117 | typedef struct _xmlHashTable xmlNotationTable; | 
|---|
| 118 | typedef xmlNotationTable *xmlNotationTablePtr; | 
|---|
| 119 |  | 
|---|
| 120 | /* | 
|---|
| 121 | * ALL element declarations are stored in a table. | 
|---|
| 122 | * There is one table per DTD. | 
|---|
| 123 | */ | 
|---|
| 124 |  | 
|---|
| 125 | typedef struct _xmlHashTable xmlElementTable; | 
|---|
| 126 | typedef xmlElementTable *xmlElementTablePtr; | 
|---|
| 127 |  | 
|---|
| 128 | /* | 
|---|
| 129 | * ALL attribute declarations are stored in a table. | 
|---|
| 130 | * There is one table per DTD. | 
|---|
| 131 | */ | 
|---|
| 132 |  | 
|---|
| 133 | typedef struct _xmlHashTable xmlAttributeTable; | 
|---|
| 134 | typedef xmlAttributeTable *xmlAttributeTablePtr; | 
|---|
| 135 |  | 
|---|
| 136 | /* | 
|---|
| 137 | * ALL IDs attributes are stored in a table. | 
|---|
| 138 | * There is one table per document. | 
|---|
| 139 | */ | 
|---|
| 140 |  | 
|---|
| 141 | typedef struct _xmlHashTable xmlIDTable; | 
|---|
| 142 | typedef xmlIDTable *xmlIDTablePtr; | 
|---|
| 143 |  | 
|---|
| 144 | /* | 
|---|
| 145 | * ALL Refs attributes are stored in a table. | 
|---|
| 146 | * There is one table per document. | 
|---|
| 147 | */ | 
|---|
| 148 |  | 
|---|
| 149 | typedef struct _xmlHashTable xmlRefTable; | 
|---|
| 150 | typedef xmlRefTable *xmlRefTablePtr; | 
|---|
| 151 |  | 
|---|
| 152 | /* Notation */ | 
|---|
| 153 | XMLPUBFUN xmlNotationPtr XMLCALL | 
|---|
| 154 | xmlAddNotationDecl	(xmlValidCtxtPtr ctxt, | 
|---|
| 155 | xmlDtdPtr dtd, | 
|---|
| 156 | const xmlChar *name, | 
|---|
| 157 | const xmlChar *PublicID, | 
|---|
| 158 | const xmlChar *SystemID); | 
|---|
| 159 | #ifdef LIBXML_TREE_ENABLED | 
|---|
| 160 | XMLPUBFUN xmlNotationTablePtr XMLCALL | 
|---|
| 161 | xmlCopyNotationTable	(xmlNotationTablePtr table); | 
|---|
| 162 | #endif /* LIBXML_TREE_ENABLED */ | 
|---|
| 163 | XMLPUBFUN void XMLCALL | 
|---|
| 164 | xmlFreeNotationTable	(xmlNotationTablePtr table); | 
|---|
| 165 | #ifdef LIBXML_OUTPUT_ENABLED | 
|---|
| 166 | XMLPUBFUN void XMLCALL | 
|---|
| 167 | xmlDumpNotationDecl	(xmlBufferPtr buf, | 
|---|
| 168 | xmlNotationPtr nota); | 
|---|
| 169 | XMLPUBFUN void XMLCALL | 
|---|
| 170 | xmlDumpNotationTable	(xmlBufferPtr buf, | 
|---|
| 171 | xmlNotationTablePtr table); | 
|---|
| 172 | #endif /* LIBXML_OUTPUT_ENABLED */ | 
|---|
| 173 |  | 
|---|
| 174 | /* Element Content */ | 
|---|
| 175 | /* the non Doc version are being deprecated */ | 
|---|
| 176 | XMLPUBFUN xmlElementContentPtr XMLCALL | 
|---|
| 177 | xmlNewElementContent	(const xmlChar *name, | 
|---|
| 178 | xmlElementContentType type); | 
|---|
| 179 | XMLPUBFUN xmlElementContentPtr XMLCALL | 
|---|
| 180 | xmlCopyElementContent	(xmlElementContentPtr content); | 
|---|
| 181 | XMLPUBFUN void XMLCALL | 
|---|
| 182 | xmlFreeElementContent	(xmlElementContentPtr cur); | 
|---|
| 183 | /* the new versions with doc argument */ | 
|---|
| 184 | XMLPUBFUN xmlElementContentPtr XMLCALL | 
|---|
| 185 | xmlNewDocElementContent	(xmlDocPtr doc, | 
|---|
| 186 | const xmlChar *name, | 
|---|
| 187 | xmlElementContentType type); | 
|---|
| 188 | XMLPUBFUN xmlElementContentPtr XMLCALL | 
|---|
| 189 | xmlCopyDocElementContent(xmlDocPtr doc, | 
|---|
| 190 | xmlElementContentPtr content); | 
|---|
| 191 | XMLPUBFUN void XMLCALL | 
|---|
| 192 | xmlFreeDocElementContent(xmlDocPtr doc, | 
|---|
| 193 | xmlElementContentPtr cur); | 
|---|
| 194 | XMLPUBFUN void XMLCALL | 
|---|
| 195 | xmlSnprintfElementContent(char *buf, | 
|---|
| 196 | int size, | 
|---|
| 197 | xmlElementContentPtr content, | 
|---|
| 198 | int englob); | 
|---|
| 199 | #ifdef LIBXML_OUTPUT_ENABLED | 
|---|
| 200 | /* DEPRECATED */ | 
|---|
| 201 | XMLPUBFUN void XMLCALL | 
|---|
| 202 | xmlSprintfElementContent(char *buf, | 
|---|
| 203 | xmlElementContentPtr content, | 
|---|
| 204 | int englob); | 
|---|
| 205 | #endif /* LIBXML_OUTPUT_ENABLED */ | 
|---|
| 206 | /* DEPRECATED */ | 
|---|
| 207 |  | 
|---|
| 208 | /* Element */ | 
|---|
| 209 | XMLPUBFUN xmlElementPtr XMLCALL | 
|---|
| 210 | xmlAddElementDecl	(xmlValidCtxtPtr ctxt, | 
|---|
| 211 | xmlDtdPtr dtd, | 
|---|
| 212 | const xmlChar *name, | 
|---|
| 213 | xmlElementTypeVal type, | 
|---|
| 214 | xmlElementContentPtr content); | 
|---|
| 215 | #ifdef LIBXML_TREE_ENABLED | 
|---|
| 216 | XMLPUBFUN xmlElementTablePtr XMLCALL | 
|---|
| 217 | xmlCopyElementTable	(xmlElementTablePtr table); | 
|---|
| 218 | #endif /* LIBXML_TREE_ENABLED */ | 
|---|
| 219 | XMLPUBFUN void XMLCALL | 
|---|
| 220 | xmlFreeElementTable	(xmlElementTablePtr table); | 
|---|
| 221 | #ifdef LIBXML_OUTPUT_ENABLED | 
|---|
| 222 | XMLPUBFUN void XMLCALL | 
|---|
| 223 | xmlDumpElementTable	(xmlBufferPtr buf, | 
|---|
| 224 | xmlElementTablePtr table); | 
|---|
| 225 | XMLPUBFUN void XMLCALL | 
|---|
| 226 | xmlDumpElementDecl	(xmlBufferPtr buf, | 
|---|
| 227 | xmlElementPtr elem); | 
|---|
| 228 | #endif /* LIBXML_OUTPUT_ENABLED */ | 
|---|
| 229 |  | 
|---|
| 230 | /* Enumeration */ | 
|---|
| 231 | XMLPUBFUN xmlEnumerationPtr XMLCALL | 
|---|
| 232 | xmlCreateEnumeration	(const xmlChar *name); | 
|---|
| 233 | XMLPUBFUN void XMLCALL | 
|---|
| 234 | xmlFreeEnumeration	(xmlEnumerationPtr cur); | 
|---|
| 235 | #ifdef LIBXML_TREE_ENABLED | 
|---|
| 236 | XMLPUBFUN xmlEnumerationPtr XMLCALL | 
|---|
| 237 | xmlCopyEnumeration	(xmlEnumerationPtr cur); | 
|---|
| 238 | #endif /* LIBXML_TREE_ENABLED */ | 
|---|
| 239 |  | 
|---|
| 240 | /* Attribute */ | 
|---|
| 241 | XMLPUBFUN xmlAttributePtr XMLCALL | 
|---|
| 242 | xmlAddAttributeDecl	(xmlValidCtxtPtr ctxt, | 
|---|
| 243 | xmlDtdPtr dtd, | 
|---|
| 244 | const xmlChar *elem, | 
|---|
| 245 | const xmlChar *name, | 
|---|
| 246 | const xmlChar *ns, | 
|---|
| 247 | xmlAttributeType type, | 
|---|
| 248 | xmlAttributeDefault def, | 
|---|
| 249 | const xmlChar *defaultValue, | 
|---|
| 250 | xmlEnumerationPtr tree); | 
|---|
| 251 | #ifdef LIBXML_TREE_ENABLED | 
|---|
| 252 | XMLPUBFUN xmlAttributeTablePtr XMLCALL | 
|---|
| 253 | xmlCopyAttributeTable  (xmlAttributeTablePtr table); | 
|---|
| 254 | #endif /* LIBXML_TREE_ENABLED */ | 
|---|
| 255 | XMLPUBFUN void XMLCALL | 
|---|
| 256 | xmlFreeAttributeTable  (xmlAttributeTablePtr table); | 
|---|
| 257 | #ifdef LIBXML_OUTPUT_ENABLED | 
|---|
| 258 | XMLPUBFUN void XMLCALL | 
|---|
| 259 | xmlDumpAttributeTable  (xmlBufferPtr buf, | 
|---|
| 260 | xmlAttributeTablePtr table); | 
|---|
| 261 | XMLPUBFUN void XMLCALL | 
|---|
| 262 | xmlDumpAttributeDecl   (xmlBufferPtr buf, | 
|---|
| 263 | xmlAttributePtr attr); | 
|---|
| 264 | #endif /* LIBXML_OUTPUT_ENABLED */ | 
|---|
| 265 |  | 
|---|
| 266 | /* IDs */ | 
|---|
| 267 | XMLPUBFUN xmlIDPtr XMLCALL | 
|---|
| 268 | xmlAddID	       (xmlValidCtxtPtr ctxt, | 
|---|
| 269 | xmlDocPtr doc, | 
|---|
| 270 | const xmlChar *value, | 
|---|
| 271 | xmlAttrPtr attr); | 
|---|
| 272 | XMLPUBFUN void XMLCALL | 
|---|
| 273 | xmlFreeIDTable	       (xmlIDTablePtr table); | 
|---|
| 274 | XMLPUBFUN xmlAttrPtr XMLCALL | 
|---|
| 275 | xmlGetID	       (xmlDocPtr doc, | 
|---|
| 276 | const xmlChar *ID); | 
|---|
| 277 | XMLPUBFUN int XMLCALL | 
|---|
| 278 | xmlIsID		       (xmlDocPtr doc, | 
|---|
| 279 | xmlNodePtr elem, | 
|---|
| 280 | xmlAttrPtr attr); | 
|---|
| 281 | XMLPUBFUN int XMLCALL | 
|---|
| 282 | xmlRemoveID	       (xmlDocPtr doc, | 
|---|
| 283 | xmlAttrPtr attr); | 
|---|
| 284 |  | 
|---|
| 285 | /* IDREFs */ | 
|---|
| 286 | XMLPUBFUN xmlRefPtr XMLCALL | 
|---|
| 287 | xmlAddRef	       (xmlValidCtxtPtr ctxt, | 
|---|
| 288 | xmlDocPtr doc, | 
|---|
| 289 | const xmlChar *value, | 
|---|
| 290 | xmlAttrPtr attr); | 
|---|
| 291 | XMLPUBFUN void XMLCALL | 
|---|
| 292 | xmlFreeRefTable	       (xmlRefTablePtr table); | 
|---|
| 293 | XMLPUBFUN int XMLCALL | 
|---|
| 294 | xmlIsRef	       (xmlDocPtr doc, | 
|---|
| 295 | xmlNodePtr elem, | 
|---|
| 296 | xmlAttrPtr attr); | 
|---|
| 297 | XMLPUBFUN int XMLCALL | 
|---|
| 298 | xmlRemoveRef	       (xmlDocPtr doc, | 
|---|
| 299 | xmlAttrPtr attr); | 
|---|
| 300 | XMLPUBFUN xmlListPtr XMLCALL | 
|---|
| 301 | xmlGetRefs	       (xmlDocPtr doc, | 
|---|
| 302 | const xmlChar *ID); | 
|---|
| 303 |  | 
|---|
| 304 | /** | 
|---|
| 305 | * The public function calls related to validity checking. | 
|---|
| 306 | */ | 
|---|
| 307 | #ifdef LIBXML_VALID_ENABLED | 
|---|
| 308 | /* Allocate/Release Validation Contexts */ | 
|---|
| 309 | XMLPUBFUN xmlValidCtxtPtr XMLCALL | 
|---|
| 310 | xmlNewValidCtxt(void); | 
|---|
| 311 | XMLPUBFUN void XMLCALL | 
|---|
| 312 | xmlFreeValidCtxt(xmlValidCtxtPtr); | 
|---|
| 313 |  | 
|---|
| 314 | XMLPUBFUN int XMLCALL | 
|---|
| 315 | xmlValidateRoot		(xmlValidCtxtPtr ctxt, | 
|---|
| 316 | xmlDocPtr doc); | 
|---|
| 317 | XMLPUBFUN int XMLCALL | 
|---|
| 318 | xmlValidateElementDecl	(xmlValidCtxtPtr ctxt, | 
|---|
| 319 | xmlDocPtr doc, | 
|---|
| 320 | xmlElementPtr elem); | 
|---|
| 321 | XMLPUBFUN xmlChar * XMLCALL | 
|---|
| 322 | xmlValidNormalizeAttributeValue(xmlDocPtr doc, | 
|---|
| 323 | xmlNodePtr elem, | 
|---|
| 324 | const xmlChar *name, | 
|---|
| 325 | const xmlChar *value); | 
|---|
| 326 | XMLPUBFUN xmlChar * XMLCALL | 
|---|
| 327 | xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt, | 
|---|
| 328 | xmlDocPtr doc, | 
|---|
| 329 | xmlNodePtr elem, | 
|---|
| 330 | const xmlChar *name, | 
|---|
| 331 | const xmlChar *value); | 
|---|
| 332 | XMLPUBFUN int XMLCALL | 
|---|
| 333 | xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt, | 
|---|
| 334 | xmlDocPtr doc, | 
|---|
| 335 | xmlAttributePtr attr); | 
|---|
| 336 | XMLPUBFUN int XMLCALL | 
|---|
| 337 | xmlValidateAttributeValue(xmlAttributeType type, | 
|---|
| 338 | const xmlChar *value); | 
|---|
| 339 | XMLPUBFUN int XMLCALL | 
|---|
| 340 | xmlValidateNotationDecl	(xmlValidCtxtPtr ctxt, | 
|---|
| 341 | xmlDocPtr doc, | 
|---|
| 342 | xmlNotationPtr nota); | 
|---|
| 343 | XMLPUBFUN int XMLCALL | 
|---|
| 344 | xmlValidateDtd		(xmlValidCtxtPtr ctxt, | 
|---|
| 345 | xmlDocPtr doc, | 
|---|
| 346 | xmlDtdPtr dtd); | 
|---|
| 347 | XMLPUBFUN int XMLCALL | 
|---|
| 348 | xmlValidateDtdFinal	(xmlValidCtxtPtr ctxt, | 
|---|
| 349 | xmlDocPtr doc); | 
|---|
| 350 | XMLPUBFUN int XMLCALL | 
|---|
| 351 | xmlValidateDocument	(xmlValidCtxtPtr ctxt, | 
|---|
| 352 | xmlDocPtr doc); | 
|---|
| 353 | XMLPUBFUN int XMLCALL | 
|---|
| 354 | xmlValidateElement	(xmlValidCtxtPtr ctxt, | 
|---|
| 355 | xmlDocPtr doc, | 
|---|
| 356 | xmlNodePtr elem); | 
|---|
| 357 | XMLPUBFUN int XMLCALL | 
|---|
| 358 | xmlValidateOneElement	(xmlValidCtxtPtr ctxt, | 
|---|
| 359 | xmlDocPtr doc, | 
|---|
| 360 | xmlNodePtr elem); | 
|---|
| 361 | XMLPUBFUN int XMLCALL | 
|---|
| 362 | xmlValidateOneAttribute	(xmlValidCtxtPtr ctxt, | 
|---|
| 363 | xmlDocPtr doc, | 
|---|
| 364 | xmlNodePtr	elem, | 
|---|
| 365 | xmlAttrPtr attr, | 
|---|
| 366 | const xmlChar *value); | 
|---|
| 367 | XMLPUBFUN int XMLCALL | 
|---|
| 368 | xmlValidateOneNamespace	(xmlValidCtxtPtr ctxt, | 
|---|
| 369 | xmlDocPtr doc, | 
|---|
| 370 | xmlNodePtr elem, | 
|---|
| 371 | const xmlChar *prefix, | 
|---|
| 372 | xmlNsPtr ns, | 
|---|
| 373 | const xmlChar *value); | 
|---|
| 374 | XMLPUBFUN int XMLCALL | 
|---|
| 375 | xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt, | 
|---|
| 376 | xmlDocPtr doc); | 
|---|
| 377 | #endif /* LIBXML_VALID_ENABLED */ | 
|---|
| 378 |  | 
|---|
| 379 | #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) | 
|---|
| 380 | XMLPUBFUN int XMLCALL | 
|---|
| 381 | xmlValidateNotationUse	(xmlValidCtxtPtr ctxt, | 
|---|
| 382 | xmlDocPtr doc, | 
|---|
| 383 | const xmlChar *notationName); | 
|---|
| 384 | #endif /* LIBXML_VALID_ENABLED or LIBXML_SCHEMAS_ENABLED */ | 
|---|
| 385 |  | 
|---|
| 386 | XMLPUBFUN int XMLCALL | 
|---|
| 387 | xmlIsMixedElement	(xmlDocPtr doc, | 
|---|
| 388 | const xmlChar *name); | 
|---|
| 389 | XMLPUBFUN xmlAttributePtr XMLCALL | 
|---|
| 390 | xmlGetDtdAttrDesc	(xmlDtdPtr dtd, | 
|---|
| 391 | const xmlChar *elem, | 
|---|
| 392 | const xmlChar *name); | 
|---|
| 393 | XMLPUBFUN xmlAttributePtr XMLCALL | 
|---|
| 394 | xmlGetDtdQAttrDesc	(xmlDtdPtr dtd, | 
|---|
| 395 | const xmlChar *elem, | 
|---|
| 396 | const xmlChar *name, | 
|---|
| 397 | const xmlChar *prefix); | 
|---|
| 398 | XMLPUBFUN xmlNotationPtr XMLCALL | 
|---|
| 399 | xmlGetDtdNotationDesc	(xmlDtdPtr dtd, | 
|---|
| 400 | const xmlChar *name); | 
|---|
| 401 | XMLPUBFUN xmlElementPtr XMLCALL | 
|---|
| 402 | xmlGetDtdQElementDesc	(xmlDtdPtr dtd, | 
|---|
| 403 | const xmlChar *name, | 
|---|
| 404 | const xmlChar *prefix); | 
|---|
| 405 | XMLPUBFUN xmlElementPtr XMLCALL | 
|---|
| 406 | xmlGetDtdElementDesc	(xmlDtdPtr dtd, | 
|---|
| 407 | const xmlChar *name); | 
|---|
| 408 |  | 
|---|
| 409 | #ifdef LIBXML_VALID_ENABLED | 
|---|
| 410 |  | 
|---|
| 411 | XMLPUBFUN int XMLCALL | 
|---|
| 412 | xmlValidGetPotentialChildren(xmlElementContent *ctree, | 
|---|
| 413 | const xmlChar **names, | 
|---|
| 414 | int *len, | 
|---|
| 415 | int max); | 
|---|
| 416 |  | 
|---|
| 417 | XMLPUBFUN int XMLCALL | 
|---|
| 418 | xmlValidGetValidElements(xmlNode *prev, | 
|---|
| 419 | xmlNode *next, | 
|---|
| 420 | const xmlChar **names, | 
|---|
| 421 | int max); | 
|---|
| 422 | XMLPUBFUN int XMLCALL | 
|---|
| 423 | xmlValidateNameValue	(const xmlChar *value); | 
|---|
| 424 | XMLPUBFUN int XMLCALL | 
|---|
| 425 | xmlValidateNamesValue	(const xmlChar *value); | 
|---|
| 426 | XMLPUBFUN int XMLCALL | 
|---|
| 427 | xmlValidateNmtokenValue	(const xmlChar *value); | 
|---|
| 428 | XMLPUBFUN int XMLCALL | 
|---|
| 429 | xmlValidateNmtokensValue(const xmlChar *value); | 
|---|
| 430 |  | 
|---|
| 431 | #ifdef LIBXML_REGEXP_ENABLED | 
|---|
| 432 | /* | 
|---|
| 433 | * Validation based on the regexp support | 
|---|
| 434 | */ | 
|---|
| 435 | XMLPUBFUN int XMLCALL | 
|---|
| 436 | xmlValidBuildContentModel(xmlValidCtxtPtr ctxt, | 
|---|
| 437 | xmlElementPtr elem); | 
|---|
| 438 |  | 
|---|
| 439 | XMLPUBFUN int XMLCALL | 
|---|
| 440 | xmlValidatePushElement	(xmlValidCtxtPtr ctxt, | 
|---|
| 441 | xmlDocPtr doc, | 
|---|
| 442 | xmlNodePtr elem, | 
|---|
| 443 | const xmlChar *qname); | 
|---|
| 444 | XMLPUBFUN int XMLCALL | 
|---|
| 445 | xmlValidatePushCData	(xmlValidCtxtPtr ctxt, | 
|---|
| 446 | const xmlChar *data, | 
|---|
| 447 | int len); | 
|---|
| 448 | XMLPUBFUN int XMLCALL | 
|---|
| 449 | xmlValidatePopElement	(xmlValidCtxtPtr ctxt, | 
|---|
| 450 | xmlDocPtr doc, | 
|---|
| 451 | xmlNodePtr elem, | 
|---|
| 452 | const xmlChar *qname); | 
|---|
| 453 | #endif /* LIBXML_REGEXP_ENABLED */ | 
|---|
| 454 | #endif /* LIBXML_VALID_ENABLED */ | 
|---|
| 455 | #ifdef __cplusplus | 
|---|
| 456 | } | 
|---|
| 457 | #endif | 
|---|
| 458 | #endif /* __XML_VALID_H__ */ | 
|---|
| 459 |  | 
|---|