← Back to branch summary

~inkscape.dev/inkscape-devlibs64/trunk

« back to all changes in this revision

Viewing changes to python/Lib/site-packages/lxml/includes/libxml/valid.h

  • Committer: Eduard Braun
  • Date: 2016-10-22 16:51:19 UTC
  • Revision ID: eduard.braun2@gmx.de-20161022165119-9eosgy6lp8j1kzli
Update Python to version 2.7.12

Included modules:
  coverage 4.2
  lxml 3.6.4
  numpy 1.11.2
  scour 0.35
  six 1.10.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
python/Lib/site-packages/lxml/includes/libxml/valid.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
 
                             ...) 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__ */