Return to valid.h CVS log

Up to [Public] / XML

Annotation of XML/valid.h, revision 1.11

1.1       daniel      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@w3.org
                      7:  */
                      8: 
                      9: 
                     10: #ifndef __XML_VALID_H__
                     11: #define __XML_VALID_H__
                     12: #include "tree.h"
                     13: 
1.9       daniel     14: /**
                     15:  * an xmlValidCtxt is used for error reporting when validating
                     16:  */
                     17: 
                     18: typedef void (*xmlValidityErrorFunc) (void *ctx, const char *msg, ...);
                     19: typedef void (*xmlValidityWarningFunc) (void *ctx, const char *msg, ...);
                     20: 
                     21: typedef struct xmlValidCtxt {
                     22:     void *userData;                    /* user specific data block */
                     23:     xmlValidityErrorFunc error;                /* the callback in case of errors */
                     24:     xmlValidityWarningFunc warning;    /* the callback in case of warning */
                     25: } xmlValidCtxt, *xmlValidCtxtPtr;
                     26: 
                     27: extern void xmlParserValidityError(void *ctx, const char *msg, ...);
                     28: extern void xmlParserValidityWarning(void *ctx, const char *msg, ...);
                     29: 
1.2       daniel     30: /*
1.5       daniel     31:  * ALl notation declarations are stored in a table
                     32:  * there is one table per DTD
                     33:  */
                     34: 
                     35: #define XML_MIN_NOTATION_TABLE 32
                     36: 
                     37: typedef struct xmlNotationTable {
                     38:     int nb_notations;          /* number of notations stored */
                     39:     int max_notations;         /* maximum number of notations */
1.10      daniel     40:     xmlNotationPtr *table;     /* the table of attributes */
1.6       daniel     41: } xmlNotationTable;
                     42: typedef xmlNotationTable *xmlNotationTablePtr;
1.5       daniel     43: 
                     44: /*
1.2       daniel     45:  * ALl element declarations are stored in a table
                     46:  * there is one table per DTD
                     47:  */
                     48: 
                     49: #define XML_MIN_ELEMENT_TABLE  32
                     50: 
                     51: typedef struct xmlElementTable {
                     52:     int nb_elements;           /* number of elements stored */
                     53:     int max_elements;          /* maximum number of elements */
1.10      daniel     54:     xmlElementPtr *table;      /* the table of elements */
1.6       daniel     55: } xmlElementTable;
                     56: typedef xmlElementTable *xmlElementTablePtr;
1.2       daniel     57: 
1.5       daniel     58: /*
                     59:  * ALl attribute declarations are stored in a table
                     60:  * there is one table per DTD
                     61:  */
                     62: 
1.4       daniel     63: #define XML_MIN_ATTRIBUTE_TABLE        32
                     64: 
                     65: typedef struct xmlAttributeTable {
                     66:     int nb_attributes;         /* number of attributes stored */
                     67:     int max_attributes;                /* maximum number of attributes */
1.10      daniel     68:     xmlAttributePtr *table;    /* the table of attributes */
1.6       daniel     69: } xmlAttributeTable;
                     70: typedef xmlAttributeTable *xmlAttributeTablePtr;
1.4       daniel     71: 
1.5       daniel     72: /* Notation */
1.11    ! daniel     73: xmlNotationPtr xmlAddNotationDecl(xmlValidCtxtPtr ctxt, xmlDtdPtr dtd,
        !            74:           const CHAR *name, const CHAR *PublicID, const CHAR *SystemID);
1.6       daniel     75: xmlNotationTablePtr xmlCopyNotationTable(xmlNotationTablePtr table);
                     76: void xmlFreeNotationTable(xmlNotationTablePtr table);
1.8       daniel     77: void xmlDumpNotationTable(xmlBufferPtr buf, xmlNotationTablePtr table);
1.5       daniel     78: 
                     79: /* Element Content */
1.6       daniel     80: xmlElementContentPtr xmlNewElementContent(CHAR *name, int type);
                     81: xmlElementContentPtr xmlCopyElementContent(xmlElementContentPtr content);
                     82: void xmlFreeElementContent(xmlElementContentPtr cur);
1.2       daniel     83: 
1.5       daniel     84: /* Element */
1.11    ! daniel     85: xmlElementPtr xmlAddElementDecl(xmlValidCtxtPtr ctxt, xmlDtdPtr dtd,
        !            86:          const CHAR *name, int type, xmlElementContentPtr content);
1.6       daniel     87: xmlElementTablePtr xmlCopyElementTable(xmlElementTablePtr table);
                     88: void xmlFreeElementTable(xmlElementTablePtr table);
1.8       daniel     89: void xmlDumpElementTable(xmlBufferPtr buf, xmlElementTablePtr table);
1.5       daniel     90: 
                     91: /* Enumeration */
1.6       daniel     92: xmlEnumerationPtr xmlCreateEnumeration(CHAR *name);
                     93: void xmlFreeEnumeration(xmlEnumerationPtr cur);
                     94: xmlEnumerationPtr xmlCopyEnumeration(xmlEnumerationPtr cur);
1.5       daniel     95: 
                     96: /* Attribute */
1.11    ! daniel     97: xmlAttributePtr xmlAddAttributeDecl(xmlValidCtxtPtr ctxt, xmlDtdPtr dtd,
        !            98:                const CHAR *elem, const CHAR *name, int type, int def,
1.7       daniel     99:               const CHAR *defaultValue, xmlEnumerationPtr tree);
1.6       daniel    100: xmlAttributeTablePtr xmlCopyAttributeTable(xmlAttributeTablePtr table);
                    101: void xmlFreeAttributeTable(xmlAttributeTablePtr table);
1.8       daniel    102: void xmlDumpAttributeTable(xmlBufferPtr buf, xmlAttributeTablePtr table);
1.9       daniel    103: 
                    104: /**
                    105:  * The public function calls related to validity checking
                    106:  */
                    107: 
                    108: int xmlValidateRoot(xmlValidCtxtPtr ctxt, xmlDocPtr doc);
1.11    ! daniel    109: int xmlValidateElementDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
        !           110:                            xmlElementPtr elem);
        !           111: int xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
        !           112:                              xmlAttributePtr attr);
        !           113: int xmlValidateNotationDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
        !           114:                             xmlNotationPtr nota);
        !           115: int xmlValidateDocument(xmlValidCtxtPtr ctxt, xmlDocPtr doc);
        !           116: int xmlValidateDtd(xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlDtdPtr dtd);
        !           117: int xmlValidateElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
        !           118:                        xmlElementPtr elem);
        !           119: int xmlValidateOneElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
        !           120:                           xmlElementPtr elem);
        !           121: int xmlValidateOneAttribute(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
        !           122:                             xmlElementPtr elem, xmlAttributePtr attr);
1.1       daniel    123: #endif /* __XML_VALID_H__ */