gnulib-local/lib/libxml/valid.in.h

   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                              ...);
  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                                ...);
  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__ */