valid.h 10 KB
Newer Older
1 2 3 4 5
/*
 * valid.h : interface to the DTD handling and the validity checking
 *
 * See Copyright for the status of this software.
 *
6
 * daniel@veillard.com
7 8 9 10 11 12 13
 */


#ifndef __XML_VALID_H__
#define __XML_VALID_H__

#include <libxml/tree.h>
14
#include <libxml/list.h>
15 16
#include <libxml/xmlautomata.h>
#include <libxml/xmlregexp.h>
17 18 19 20 21

#ifdef __cplusplus
extern "C" {
#endif

22
/*
23
 * Validation state added for non-determinist content model.
24 25 26 27
 */
typedef struct _xmlValidState xmlValidState;
typedef xmlValidState *xmlValidStatePtr;

28
/**
29 30 31 32 33
 * xmlValidityErrorFunc:
 * @ctx:  an xmlValidCtxtPtr validity error context
 * @msg:  the string to format *printf like vararg
 * @...:  remaining arguments to the format
 *
34
 * Callback called when a validity error is found. This is a message
35
 * oriented function similar to an *printf function.
36
 */
37 38 39
typedef void (*xmlValidityErrorFunc) (void *ctx,
			     const char *msg,
			     ...);
40

41 42 43 44 45 46
/**
 * xmlValidityWarningFunc:
 * @ctx:  an xmlValidCtxtPtr validity error context
 * @msg:  the string to format *printf like vararg
 * @...:  remaining arguments to the format
 *
47
 * Callback called when a validity warning is found. This is a message
48 49 50 51 52
 * oriented function similar to an *printf function.
 */
typedef void (*xmlValidityWarningFunc) (void *ctx,
			       const char *msg,
			       ...);
53

54 55
/**
 * xmlValidCtxt:
56
 * An xmlValidCtxt is used for error reporting when validating.
57
 */
58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
typedef struct _xmlValidCtxt xmlValidCtxt;
typedef xmlValidCtxt *xmlValidCtxtPtr;
struct _xmlValidCtxt {
    void *userData;			/* user specific data block */
    xmlValidityErrorFunc error;		/* the callback in case of errors */
    xmlValidityWarningFunc warning;	/* the callback in case of warning */

    /* Node analysis stack used when validating within entities */
    xmlNodePtr         node;          /* Current parsed Node */
    int                nodeNr;        /* Depth of the parsing stack */
    int                nodeMax;       /* Max depth of the parsing stack */
    xmlNodePtr        *nodeTab;       /* array of nodes */

    int              finishDtd;       /* finished validating the Dtd ? */
    xmlDocPtr              doc;       /* the document */
    int                  valid;       /* temporary validity check result */
74 75 76 77 78 79

    /* state state used for non-determinist content validation */
    xmlValidState     *vstate;        /* current state */
    int                vstateNr;      /* Depth of the validation stack */
    int                vstateMax;     /* Max depth of the validation stack */
    xmlValidState     *vstateTab;     /* array of validation states */
80 81 82 83 84 85 86 87

#ifdef LIBXML_REGEXP_ENABLED
    xmlAutomataPtr            am;     /* the automata */
    xmlAutomataStatePtr    state;     /* used to build the automata */
#else
    void                     *am;
    void                  *state;
#endif
88 89 90
};

/*
91 92
 * ALL notation declarations are stored in a table.
 * There is one table per DTD.
93 94 95 96 97 98
 */

typedef struct _xmlHashTable xmlNotationTable;
typedef xmlNotationTable *xmlNotationTablePtr;

/*
99 100
 * ALL element declarations are stored in a table.
 * There is one table per DTD.
101 102 103 104 105 106
 */

typedef struct _xmlHashTable xmlElementTable;
typedef xmlElementTable *xmlElementTablePtr;

/*
107 108
 * ALL attribute declarations are stored in a table.
 * There is one table per DTD.
109 110 111 112 113 114
 */

typedef struct _xmlHashTable xmlAttributeTable;
typedef xmlAttributeTable *xmlAttributeTablePtr;

/*
115 116
 * ALL IDs attributes are stored in a table.
 * There is one table per document.
117 118 119 120 121 122
 */

typedef struct _xmlHashTable xmlIDTable;
typedef xmlIDTable *xmlIDTablePtr;

/*
123 124
 * ALL Refs attributes are stored in a table.
 * There is one table per document.
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
 */

typedef struct _xmlHashTable xmlRefTable;
typedef xmlRefTable *xmlRefTablePtr;

/* Notation */
xmlNotationPtr	    xmlAddNotationDecl	(xmlValidCtxtPtr ctxt,
					 xmlDtdPtr dtd,
					 const xmlChar *name,
					 const xmlChar *PublicID,
					 const xmlChar *SystemID);
xmlNotationTablePtr xmlCopyNotationTable(xmlNotationTablePtr table);
void		    xmlFreeNotationTable(xmlNotationTablePtr table);
void		    xmlDumpNotationDecl	(xmlBufferPtr buf,
					 xmlNotationPtr nota);
void		    xmlDumpNotationTable(xmlBufferPtr buf,
					 xmlNotationTablePtr table);

/* Element Content */
xmlElementContentPtr xmlNewElementContent (xmlChar *name,
					   xmlElementContentType type);
xmlElementContentPtr xmlCopyElementContent(xmlElementContentPtr content);
void		     xmlFreeElementContent(xmlElementContentPtr cur);
148 149 150 151 152
void		     xmlSnprintfElementContent(char *buf,
					   int size,
	                                   xmlElementContentPtr content,
					   int glob);
/* DEPRECATED */
153 154 155
void		     xmlSprintfElementContent(char *buf,
	                                   xmlElementContentPtr content,
					   int glob);
156
/* DEPRECATED */
157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215

/* Element */
xmlElementPtr	   xmlAddElementDecl	(xmlValidCtxtPtr ctxt,
					 xmlDtdPtr dtd,
					 const xmlChar *name,
					 xmlElementTypeVal type,
					 xmlElementContentPtr content);
xmlElementTablePtr xmlCopyElementTable	(xmlElementTablePtr table);
void		   xmlFreeElementTable	(xmlElementTablePtr table);
void		   xmlDumpElementTable	(xmlBufferPtr buf,
					 xmlElementTablePtr table);
void		   xmlDumpElementDecl	(xmlBufferPtr buf,
					 xmlElementPtr elem);

/* Enumeration */
xmlEnumerationPtr  xmlCreateEnumeration	(xmlChar *name);
void		   xmlFreeEnumeration	(xmlEnumerationPtr cur);
xmlEnumerationPtr  xmlCopyEnumeration	(xmlEnumerationPtr cur);

/* Attribute */
xmlAttributePtr	    xmlAddAttributeDecl	    (xmlValidCtxtPtr ctxt,
					     xmlDtdPtr dtd,
					     const xmlChar *elem,
					     const xmlChar *name,
					     const xmlChar *ns,
					     xmlAttributeType type,
					     xmlAttributeDefault def,
					     const xmlChar *defaultValue,
					     xmlEnumerationPtr tree);
xmlAttributeTablePtr xmlCopyAttributeTable  (xmlAttributeTablePtr table);
void		     xmlFreeAttributeTable  (xmlAttributeTablePtr table);
void		     xmlDumpAttributeTable  (xmlBufferPtr buf,
					     xmlAttributeTablePtr table);
void		     xmlDumpAttributeDecl   (xmlBufferPtr buf,
					     xmlAttributePtr attr);

/* IDs */
xmlIDPtr	xmlAddID	(xmlValidCtxtPtr ctxt,
				 xmlDocPtr doc,
				 const xmlChar *value,
				 xmlAttrPtr attr);
void		xmlFreeIDTable	(xmlIDTablePtr table);
xmlAttrPtr	xmlGetID	(xmlDocPtr doc,
				 const xmlChar *ID);
int		xmlIsID		(xmlDocPtr doc,
				 xmlNodePtr elem,
				 xmlAttrPtr attr);
int		xmlRemoveID	(xmlDocPtr doc, xmlAttrPtr attr);

/* IDREFs */
xmlRefPtr	xmlAddRef	(xmlValidCtxtPtr ctxt,
				 xmlDocPtr doc,
				 const xmlChar *value,
				 xmlAttrPtr attr);
void		xmlFreeRefTable	(xmlRefTablePtr table);
int		xmlIsRef	(xmlDocPtr doc,
				 xmlNodePtr elem,
				 xmlAttrPtr attr);
int		xmlRemoveRef	(xmlDocPtr doc, xmlAttrPtr attr);
216 217
xmlListPtr	xmlGetRefs	(xmlDocPtr doc,
				 const xmlChar *ID);
218 219

/**
220
 * The public function calls related to validity checking.
221 222 223 224 225 226 227 228
 */

int		xmlValidateRoot		(xmlValidCtxtPtr ctxt,
					 xmlDocPtr doc);
int		xmlValidateElementDecl	(xmlValidCtxtPtr ctxt,
					 xmlDocPtr doc,
		                         xmlElementPtr elem);
xmlChar *	xmlValidNormalizeAttributeValue(xmlDocPtr doc,
229 230 231 232 233
					 xmlNodePtr elem,
					 const xmlChar *name,
					 const xmlChar *value);
xmlChar *	xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt,
					 xmlDocPtr doc,
234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
					 xmlNodePtr elem,
					 const xmlChar *name,
					 const xmlChar *value);
int		xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt,
					 xmlDocPtr doc,
		                         xmlAttributePtr attr);
int		xmlValidateAttributeValue(xmlAttributeType type,
					 const xmlChar *value);
int		xmlValidateNotationDecl	(xmlValidCtxtPtr ctxt,
					 xmlDocPtr doc,
		                         xmlNotationPtr nota);
int		xmlValidateDtd		(xmlValidCtxtPtr ctxt,
					 xmlDocPtr doc,
					 xmlDtdPtr dtd);
int		xmlValidateDtdFinal	(xmlValidCtxtPtr ctxt,
					 xmlDocPtr doc);
int		xmlValidateDocument	(xmlValidCtxtPtr ctxt,
					 xmlDocPtr doc);
int		xmlValidateElement	(xmlValidCtxtPtr ctxt,
					 xmlDocPtr doc,
					 xmlNodePtr elem);
int		xmlValidateOneElement	(xmlValidCtxtPtr ctxt,
					 xmlDocPtr doc,
		                         xmlNodePtr elem);
int		xmlValidateOneAttribute	(xmlValidCtxtPtr ctxt,
					 xmlDocPtr doc,
					 xmlNodePtr	elem,
					 xmlAttrPtr attr,
					 const xmlChar *value);
263 264 265 266 267 268
int		xmlValidateOneNamespace	(xmlValidCtxtPtr ctxt,
					 xmlDocPtr doc,
					 xmlNodePtr elem,
					 const xmlChar *prefix,
					 xmlNsPtr ns,
					 const xmlChar *value);
269 270 271 272 273 274 275 276 277 278
int		xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt,
					 xmlDocPtr doc);
int		xmlValidateNotationUse	(xmlValidCtxtPtr ctxt,
					 xmlDocPtr doc,
					 const xmlChar *notationName);
int		xmlIsMixedElement	(xmlDocPtr doc,
					 const xmlChar *name);
xmlAttributePtr	xmlGetDtdAttrDesc	(xmlDtdPtr dtd,
					 const xmlChar *elem,
					 const xmlChar *name);
279 280 281 282
xmlAttributePtr	xmlGetDtdQAttrDesc	(xmlDtdPtr dtd,
					 const xmlChar *elem,
					 const xmlChar *name,
					 const xmlChar *prefix);
283 284
xmlNotationPtr	xmlGetDtdNotationDesc	(xmlDtdPtr dtd,
					 const xmlChar *name);
285 286 287
xmlElementPtr	xmlGetDtdQElementDesc	(xmlDtdPtr dtd,
					 const xmlChar *name,
					 const xmlChar *prefix);
288 289 290 291 292 293 294 295 296 297 298
xmlElementPtr	xmlGetDtdElementDesc	(xmlDtdPtr dtd,
					 const xmlChar *name);

int		xmlValidGetValidElements(xmlNode *prev,
					 xmlNode *next,
					 const xmlChar **list,
					 int max);
int		xmlValidGetPotentialChildren(xmlElementContent *ctree,
					 const xmlChar **list,
					 int *len,
					 int max);
Daniel Veillard's avatar
Daniel Veillard committed
299 300 301 302
int		xmlValidateNameValue	(const xmlChar *value);
int		xmlValidateNamesValue	(const xmlChar *value);
int		xmlValidateNmtokenValue	(const xmlChar *value);
int		xmlValidateNmtokensValue(const xmlChar *value);
303 304 305 306 307 308 309 310

#ifdef LIBXML_REGEXP_ENABLED
/*
 * Validation based on the regexp support
 */
int		xmlValidBuildContentModel(xmlValidCtxtPtr ctxt,
					 xmlElementPtr elem);

311 312 313 314 315 316 317 318 319 320 321
int		xmlValidatePushElement	(xmlValidCtxtPtr ctxt,
					 xmlDocPtr doc,
					 xmlNodePtr elem,
					 const xmlChar *qname);
int		xmlValidatePushCData	(xmlValidCtxtPtr ctxt,
					 const xmlChar *data,
					 int len);
int		xmlValidatePopElement	(xmlValidCtxtPtr ctxt,
					 xmlDocPtr doc,
					 xmlNodePtr elem,
					 const xmlChar *qname);
322
#endif /* LIBXML_REGEXP_ENABLED */
323 324 325 326
#ifdef __cplusplus
}
#endif
#endif /* __XML_VALID_H__ */