Browse code

bundle libxmls for win to address CI build issue

mikejiang authored on 18/11/2020 20:46:39
Showing 56 changed files

... ...
@@ -2,32 +2,13 @@
2 2
 CXX_STD = CXX11
3 3
 #libxml is an odd ball with extra nested path(libxml2/libxml/xxx) that doesn't conform to the include path as the rest 
4 4
 #so can't use the default libs shipped with Rtools4
5
-PKG_CPPFLAGS =-DROUT -I../inst/include/ -I$(LIB_XML2)/$(R_ARCH)/include/libxml2 -DLIBXML_STATIC -fpermissive -DRCPP_PARALLEL_USE_TBB=1
5
+VERSION=2.9.8
6
+RWINLIB=../windows/libxml2-$(VERSION)
7
+PKG_CPPFLAGS =-DROUT -I../inst/include/ -I$(RWINLIB)/include/libxml2 -DLIBXML_STATIC -fpermissive -DRCPP_PARALLEL_USE_TBB=1
6 8
 
7 9
 #needs to wrap in $(shell) to strip the quotes returned by rhdf5lib::pkgconfig
8 10
 RHDF5_LIBS= $(shell "${R_HOME}/bin/Rscript" -e "Rhdf5lib::pkgconfig('PKG_CXX_LIBS')")
11
+libxmllibs=-L$(RWINLIB)/lib${R_ARCH} -lxml2 -llzma -liconv -lz
9 12
 
10
-PKG_LIBS += $(LAPACK_LIBS) $(BLAS_LIBS) $(FLIBS) $(LIB_XML2)/$(R_ARCH)/lib/libxml2.a `${R_HOME}/bin/Rscript -e "cytolib:::cytolib_LdFlags();cat(' ');RProtoBufLib:::LdFlags();cat(' ');RcppParallel::RcppParallelLibs()"` ${RHDF5_LIBS} -lws2_32
11
-
12
-USERDIR = ${R_PACKAGE_DIR}/lib${R_ARCH}
13
-PKGLIB = ${USERDIR}/libflowWorkspace.a
14
-
15
-
16
-all:  $(SHLIB)
17
- 
18
-$(SHLIB): $(PKGLIB)
19
-
20
-
21
-#expose static lib for other package to link to 
22
-$(PKGLIB): $(OBJECTS)
23
-	mkdir -p "${USERDIR}"
24
-	$(AR) rs "${PKGLIB}" $(OBJECTS)
25
-
26
-
27
-.PHONY: 	all clean 
28
-
29
-clean:
30
-		rm -f $(OBJECTS) $(SHLIB)
31
- 
32
-
13
+PKG_LIBS += $(LAPACK_LIBS) $(BLAS_LIBS) $(FLIBS) $(libxmllibs) `${R_HOME}/bin/Rscript -e "cytolib:::cytolib_LdFlags();cat(' ');RProtoBufLib:::LdFlags();cat(' ');RcppParallel::RcppParallelLibs()"` ${RHDF5_LIBS} -lws2_32
33 14
 
34 15
new file mode 100644
... ...
@@ -0,0 +1,96 @@
1
+/*
2
+ * Summary: old DocBook SGML parser
3
+ * Description: interface for a DocBook SGML non-verifying parser
4
+ * This code is DEPRECATED, and should not be used anymore.
5
+ *
6
+ * Copy: See Copyright for the status of this software.
7
+ *
8
+ * Author: Daniel Veillard
9
+ */
10
+
11
+#ifndef __DOCB_PARSER_H__
12
+#define __DOCB_PARSER_H__
13
+#include <libxml/xmlversion.h>
14
+
15
+#ifdef LIBXML_DOCB_ENABLED
16
+
17
+#include <libxml/parser.h>
18
+#include <libxml/parserInternals.h>
19
+
20
+#ifndef IN_LIBXML
21
+#ifdef __GNUC__
22
+#warning "The DOCBparser module has been deprecated in libxml2-2.6.0"
23
+#endif
24
+#endif
25
+
26
+#ifdef __cplusplus
27
+extern "C" {
28
+#endif
29
+
30
+/*
31
+ * Most of the back-end structures from XML and SGML are shared.
32
+ */
33
+typedef xmlParserCtxt docbParserCtxt;
34
+typedef xmlParserCtxtPtr docbParserCtxtPtr;
35
+typedef xmlSAXHandler docbSAXHandler;
36
+typedef xmlSAXHandlerPtr docbSAXHandlerPtr;
37
+typedef xmlParserInput docbParserInput;
38
+typedef xmlParserInputPtr docbParserInputPtr;
39
+typedef xmlDocPtr docbDocPtr;
40
+
41
+/*
42
+ * There is only few public functions.
43
+ */
44
+XMLPUBFUN int XMLCALL
45
+		     docbEncodeEntities(unsigned char *out,
46
+                                        int *outlen,
47
+                                        const unsigned char *in,
48
+                                        int *inlen, int quoteChar);
49
+
50
+XMLPUBFUN docbDocPtr XMLCALL
51
+		     docbSAXParseDoc   (xmlChar *cur,
52
+                                        const char *encoding,
53
+                                        docbSAXHandlerPtr sax,
54
+                                        void *userData);
55
+XMLPUBFUN docbDocPtr XMLCALL
56
+		     docbParseDoc      (xmlChar *cur,
57
+                                        const char *encoding);
58
+XMLPUBFUN docbDocPtr XMLCALL
59
+		     docbSAXParseFile  (const char *filename,
60
+                                        const char *encoding,
61
+                                        docbSAXHandlerPtr sax,
62
+                                        void *userData);
63
+XMLPUBFUN docbDocPtr XMLCALL
64
+		     docbParseFile     (const char *filename,
65
+                                        const char *encoding);
66
+
67
+/**
68
+ * Interfaces for the Push mode.
69
+ */
70
+XMLPUBFUN void XMLCALL
71
+		     docbFreeParserCtxt      (docbParserCtxtPtr ctxt);
72
+XMLPUBFUN docbParserCtxtPtr XMLCALL
73
+		     docbCreatePushParserCtxt(docbSAXHandlerPtr sax,
74
+                                              void *user_data,
75
+                                              const char *chunk,
76
+                                              int size,
77
+                                              const char *filename,
78
+                                              xmlCharEncoding enc);
79
+XMLPUBFUN int XMLCALL
80
+		     docbParseChunk          (docbParserCtxtPtr ctxt,
81
+                                              const char *chunk,
82
+                                              int size,
83
+                                              int terminate);
84
+XMLPUBFUN docbParserCtxtPtr XMLCALL
85
+		     docbCreateFileParserCtxt(const char *filename,
86
+                                              const char *encoding);
87
+XMLPUBFUN int XMLCALL
88
+		     docbParseDocument       (docbParserCtxtPtr ctxt);
89
+
90
+#ifdef __cplusplus
91
+}
92
+#endif
93
+
94
+#endif /* LIBXML_DOCB_ENABLED */
95
+
96
+#endif /* __DOCB_PARSER_H__ */
0 97
new file mode 100644
... ...
@@ -0,0 +1,306 @@
1
+/*
2
+ * Summary: interface for an HTML 4.0 non-verifying parser
3
+ * Description: this module implements an HTML 4.0 non-verifying parser
4
+ *              with API compatible with the XML parser ones. It should
5
+ *              be able to parse "real world" HTML, even if severely
6
+ *              broken from a specification point of view.
7
+ *
8
+ * Copy: See Copyright for the status of this software.
9
+ *
10
+ * Author: Daniel Veillard
11
+ */
12
+
13
+#ifndef __HTML_PARSER_H__
14
+#define __HTML_PARSER_H__
15
+#include <libxml/xmlversion.h>
16
+#include <libxml/parser.h>
17
+
18
+#ifdef LIBXML_HTML_ENABLED
19
+
20
+#ifdef __cplusplus
21
+extern "C" {
22
+#endif
23
+
24
+/*
25
+ * Most of the back-end structures from XML and HTML are shared.
26
+ */
27
+typedef xmlParserCtxt htmlParserCtxt;
28
+typedef xmlParserCtxtPtr htmlParserCtxtPtr;
29
+typedef xmlParserNodeInfo htmlParserNodeInfo;
30
+typedef xmlSAXHandler htmlSAXHandler;
31
+typedef xmlSAXHandlerPtr htmlSAXHandlerPtr;
32
+typedef xmlParserInput htmlParserInput;
33
+typedef xmlParserInputPtr htmlParserInputPtr;
34
+typedef xmlDocPtr htmlDocPtr;
35
+typedef xmlNodePtr htmlNodePtr;
36
+
37
+/*
38
+ * Internal description of an HTML element, representing HTML 4.01
39
+ * and XHTML 1.0 (which share the same structure).
40
+ */
41
+typedef struct _htmlElemDesc htmlElemDesc;
42
+typedef htmlElemDesc *htmlElemDescPtr;
43
+struct _htmlElemDesc {
44
+    const char *name;	/* The tag name */
45
+    char startTag;      /* Whether the start tag can be implied */
46
+    char endTag;        /* Whether the end tag can be implied */
47
+    char saveEndTag;    /* Whether the end tag should be saved */
48
+    char empty;         /* Is this an empty element ? */
49
+    char depr;          /* Is this a deprecated element ? */
50
+    char dtd;           /* 1: only in Loose DTD, 2: only Frameset one */
51
+    char isinline;      /* is this a block 0 or inline 1 element */
52
+    const char *desc;   /* the description */
53
+
54
+/* NRK Jan.2003
55
+ * New fields encapsulating HTML structure
56
+ *
57
+ * Bugs:
58
+ *	This is a very limited representation.  It fails to tell us when
59
+ *	an element *requires* subelements (we only have whether they're
60
+ *	allowed or not), and it doesn't tell us where CDATA and PCDATA
61
+ *	are allowed.  Some element relationships are not fully represented:
62
+ *	these are flagged with the word MODIFIER
63
+ */
64
+    const char** subelts;		/* allowed sub-elements of this element */
65
+    const char* defaultsubelt;	/* subelement for suggested auto-repair
66
+					   if necessary or NULL */
67
+    const char** attrs_opt;		/* Optional Attributes */
68
+    const char** attrs_depr;		/* Additional deprecated attributes */
69
+    const char** attrs_req;		/* Required attributes */
70
+};
71
+
72
+/*
73
+ * Internal description of an HTML entity.
74
+ */
75
+typedef struct _htmlEntityDesc htmlEntityDesc;
76
+typedef htmlEntityDesc *htmlEntityDescPtr;
77
+struct _htmlEntityDesc {
78
+    unsigned int value;	/* the UNICODE value for the character */
79
+    const char *name;	/* The entity name */
80
+    const char *desc;   /* the description */
81
+};
82
+
83
+/*
84
+ * There is only few public functions.
85
+ */
86
+XMLPUBFUN const htmlElemDesc * XMLCALL
87
+			htmlTagLookup	(const xmlChar *tag);
88
+XMLPUBFUN const htmlEntityDesc * XMLCALL
89
+			htmlEntityLookup(const xmlChar *name);
90
+XMLPUBFUN const htmlEntityDesc * XMLCALL
91
+			htmlEntityValueLookup(unsigned int value);
92
+
93
+XMLPUBFUN int XMLCALL
94
+			htmlIsAutoClosed(htmlDocPtr doc,
95
+					 htmlNodePtr elem);
96
+XMLPUBFUN int XMLCALL
97
+			htmlAutoCloseTag(htmlDocPtr doc,
98
+					 const xmlChar *name,
99
+					 htmlNodePtr elem);
100
+XMLPUBFUN const htmlEntityDesc * XMLCALL
101
+			htmlParseEntityRef(htmlParserCtxtPtr ctxt,
102
+					 const xmlChar **str);
103
+XMLPUBFUN int XMLCALL
104
+			htmlParseCharRef(htmlParserCtxtPtr ctxt);
105
+XMLPUBFUN void XMLCALL
106
+			htmlParseElement(htmlParserCtxtPtr ctxt);
107
+
108
+XMLPUBFUN htmlParserCtxtPtr XMLCALL
109
+			htmlNewParserCtxt(void);
110
+
111
+XMLPUBFUN htmlParserCtxtPtr XMLCALL
112
+			htmlCreateMemoryParserCtxt(const char *buffer,
113
+						   int size);
114
+
115
+XMLPUBFUN int XMLCALL
116
+			htmlParseDocument(htmlParserCtxtPtr ctxt);
117
+XMLPUBFUN htmlDocPtr XMLCALL
118
+			htmlSAXParseDoc	(xmlChar *cur,
119
+					 const char *encoding,
120
+					 htmlSAXHandlerPtr sax,
121
+					 void *userData);
122
+XMLPUBFUN htmlDocPtr XMLCALL
123
+			htmlParseDoc	(xmlChar *cur,
124
+					 const char *encoding);
125
+XMLPUBFUN htmlDocPtr XMLCALL
126
+			htmlSAXParseFile(const char *filename,
127
+					 const char *encoding,
128
+					 htmlSAXHandlerPtr sax,
129
+					 void *userData);
130
+XMLPUBFUN htmlDocPtr XMLCALL
131
+			htmlParseFile	(const char *filename,
132
+					 const char *encoding);
133
+XMLPUBFUN int XMLCALL
134
+			UTF8ToHtml	(unsigned char *out,
135
+					 int *outlen,
136
+					 const unsigned char *in,
137
+					 int *inlen);
138
+XMLPUBFUN int XMLCALL
139
+			htmlEncodeEntities(unsigned char *out,
140
+					 int *outlen,
141
+					 const unsigned char *in,
142
+					 int *inlen, int quoteChar);
143
+XMLPUBFUN int XMLCALL
144
+			htmlIsScriptAttribute(const xmlChar *name);
145
+XMLPUBFUN int XMLCALL
146
+			htmlHandleOmittedElem(int val);
147
+
148
+#ifdef LIBXML_PUSH_ENABLED
149
+/**
150
+ * Interfaces for the Push mode.
151
+ */
152
+XMLPUBFUN htmlParserCtxtPtr XMLCALL
153
+			htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax,
154
+						 void *user_data,
155
+						 const char *chunk,
156
+						 int size,
157
+						 const char *filename,
158
+						 xmlCharEncoding enc);
159
+XMLPUBFUN int XMLCALL
160
+			htmlParseChunk		(htmlParserCtxtPtr ctxt,
161
+						 const char *chunk,
162
+						 int size,
163
+						 int terminate);
164
+#endif /* LIBXML_PUSH_ENABLED */
165
+
166
+XMLPUBFUN void XMLCALL
167
+			htmlFreeParserCtxt	(htmlParserCtxtPtr ctxt);
168
+
169
+/*
170
+ * New set of simpler/more flexible APIs
171
+ */
172
+/**
173
+ * xmlParserOption:
174
+ *
175
+ * This is the set of XML parser options that can be passed down
176
+ * to the xmlReadDoc() and similar calls.
177
+ */
178
+typedef enum {
179
+    HTML_PARSE_RECOVER  = 1<<0, /* Relaxed parsing */
180
+    HTML_PARSE_NODEFDTD = 1<<2, /* do not default a doctype if not found */
181
+    HTML_PARSE_NOERROR	= 1<<5,	/* suppress error reports */
182
+    HTML_PARSE_NOWARNING= 1<<6,	/* suppress warning reports */
183
+    HTML_PARSE_PEDANTIC	= 1<<7,	/* pedantic error reporting */
184
+    HTML_PARSE_NOBLANKS	= 1<<8,	/* remove blank nodes */
185
+    HTML_PARSE_NONET	= 1<<11,/* Forbid network access */
186
+    HTML_PARSE_NOIMPLIED= 1<<13,/* Do not add implied html/body... elements */
187
+    HTML_PARSE_COMPACT  = 1<<16,/* compact small text nodes */
188
+    HTML_PARSE_IGNORE_ENC=1<<21 /* ignore internal document encoding hint */
189
+} htmlParserOption;
190
+
191
+XMLPUBFUN void XMLCALL
192
+		htmlCtxtReset		(htmlParserCtxtPtr ctxt);
193
+XMLPUBFUN int XMLCALL
194
+		htmlCtxtUseOptions	(htmlParserCtxtPtr ctxt,
195
+					 int options);
196
+XMLPUBFUN htmlDocPtr XMLCALL
197
+		htmlReadDoc		(const xmlChar *cur,
198
+					 const char *URL,
199
+					 const char *encoding,
200
+					 int options);
201
+XMLPUBFUN htmlDocPtr XMLCALL
202
+		htmlReadFile		(const char *URL,
203
+					 const char *encoding,
204
+					 int options);
205
+XMLPUBFUN htmlDocPtr XMLCALL
206
+		htmlReadMemory		(const char *buffer,
207
+					 int size,
208
+					 const char *URL,
209
+					 const char *encoding,
210
+					 int options);
211
+XMLPUBFUN htmlDocPtr XMLCALL
212
+		htmlReadFd		(int fd,
213
+					 const char *URL,
214
+					 const char *encoding,
215
+					 int options);
216
+XMLPUBFUN htmlDocPtr XMLCALL
217
+		htmlReadIO		(xmlInputReadCallback ioread,
218
+					 xmlInputCloseCallback ioclose,
219
+					 void *ioctx,
220
+					 const char *URL,
221
+					 const char *encoding,
222
+					 int options);
223
+XMLPUBFUN htmlDocPtr XMLCALL
224
+		htmlCtxtReadDoc		(xmlParserCtxtPtr ctxt,
225
+					 const xmlChar *cur,
226
+					 const char *URL,
227
+					 const char *encoding,
228
+					 int options);
229
+XMLPUBFUN htmlDocPtr XMLCALL
230
+		htmlCtxtReadFile		(xmlParserCtxtPtr ctxt,
231
+					 const char *filename,
232
+					 const char *encoding,
233
+					 int options);
234
+XMLPUBFUN htmlDocPtr XMLCALL
235
+		htmlCtxtReadMemory		(xmlParserCtxtPtr ctxt,
236
+					 const char *buffer,
237
+					 int size,
238
+					 const char *URL,
239
+					 const char *encoding,
240
+					 int options);
241
+XMLPUBFUN htmlDocPtr XMLCALL
242
+		htmlCtxtReadFd		(xmlParserCtxtPtr ctxt,
243
+					 int fd,
244
+					 const char *URL,
245
+					 const char *encoding,
246
+					 int options);
247
+XMLPUBFUN htmlDocPtr XMLCALL
248
+		htmlCtxtReadIO		(xmlParserCtxtPtr ctxt,
249
+					 xmlInputReadCallback ioread,
250
+					 xmlInputCloseCallback ioclose,
251
+					 void *ioctx,
252
+					 const char *URL,
253
+					 const char *encoding,
254
+					 int options);
255
+
256
+/* NRK/Jan2003: further knowledge of HTML structure
257
+ */
258
+typedef enum {
259
+  HTML_NA = 0 ,		/* something we don't check at all */
260
+  HTML_INVALID = 0x1 ,
261
+  HTML_DEPRECATED = 0x2 ,
262
+  HTML_VALID = 0x4 ,
263
+  HTML_REQUIRED = 0xc /* VALID bit set so ( & HTML_VALID ) is TRUE */
264
+} htmlStatus ;
265
+
266
+/* Using htmlElemDesc rather than name here, to emphasise the fact
267
+   that otherwise there's a lookup overhead
268
+*/
269
+XMLPUBFUN htmlStatus XMLCALL htmlAttrAllowed(const htmlElemDesc*, const xmlChar*, int) ;
270
+XMLPUBFUN int XMLCALL htmlElementAllowedHere(const htmlElemDesc*, const xmlChar*) ;
271
+XMLPUBFUN htmlStatus XMLCALL htmlElementStatusHere(const htmlElemDesc*, const htmlElemDesc*) ;
272
+XMLPUBFUN htmlStatus XMLCALL htmlNodeStatus(const htmlNodePtr, int) ;
273
+/**
274
+ * htmlDefaultSubelement:
275
+ * @elt: HTML element
276
+ *
277
+ * Returns the default subelement for this element
278
+ */
279
+#define htmlDefaultSubelement(elt) elt->defaultsubelt
280
+/**
281
+ * htmlElementAllowedHereDesc:
282
+ * @parent: HTML parent element
283
+ * @elt: HTML element
284
+ *
285
+ * Checks whether an HTML element description may be a
286
+ * direct child of the specified element.
287
+ *
288
+ * Returns 1 if allowed; 0 otherwise.
289
+ */
290
+#define htmlElementAllowedHereDesc(parent,elt) \
291
+	htmlElementAllowedHere((parent), (elt)->name)
292
+/**
293
+ * htmlRequiredAttrs:
294
+ * @elt: HTML element
295
+ *
296
+ * Returns the attributes required for the specified element.
297
+ */
298
+#define htmlRequiredAttrs(elt) (elt)->attrs_req
299
+
300
+
301
+#ifdef __cplusplus
302
+}
303
+#endif
304
+
305
+#endif /* LIBXML_HTML_ENABLED */
306
+#endif /* __HTML_PARSER_H__ */
0 307
new file mode 100644
... ...
@@ -0,0 +1,147 @@
1
+/*
2
+ * Summary: specific APIs to process HTML tree, especially serialization
3
+ * Description: this module implements a few function needed to process
4
+ *              tree in an HTML specific way.
5
+ *
6
+ * Copy: See Copyright for the status of this software.
7
+ *
8
+ * Author: Daniel Veillard
9
+ */
10
+
11
+#ifndef __HTML_TREE_H__
12
+#define __HTML_TREE_H__
13
+
14
+#include <stdio.h>
15
+#include <libxml/xmlversion.h>
16
+#include <libxml/tree.h>
17
+#include <libxml/HTMLparser.h>
18
+
19
+#ifdef LIBXML_HTML_ENABLED
20
+
21
+#ifdef __cplusplus
22
+extern "C" {
23
+#endif
24
+
25
+
26
+/**
27
+ * HTML_TEXT_NODE:
28
+ *
29
+ * Macro. A text node in a HTML document is really implemented
30
+ * the same way as a text node in an XML document.
31
+ */
32
+#define HTML_TEXT_NODE		XML_TEXT_NODE
33
+/**
34
+ * HTML_ENTITY_REF_NODE:
35
+ *
36
+ * Macro. An entity reference in a HTML document is really implemented
37
+ * the same way as an entity reference in an XML document.
38
+ */
39
+#define HTML_ENTITY_REF_NODE	XML_ENTITY_REF_NODE
40
+/**
41
+ * HTML_COMMENT_NODE:
42
+ *
43
+ * Macro. A comment in a HTML document is really implemented
44
+ * the same way as a comment in an XML document.
45
+ */
46
+#define HTML_COMMENT_NODE	XML_COMMENT_NODE
47
+/**
48
+ * HTML_PRESERVE_NODE:
49
+ *
50
+ * Macro. A preserved node in a HTML document is really implemented
51
+ * the same way as a CDATA section in an XML document.
52
+ */
53
+#define HTML_PRESERVE_NODE	XML_CDATA_SECTION_NODE
54
+/**
55
+ * HTML_PI_NODE:
56
+ *
57
+ * Macro. A processing instruction in a HTML document is really implemented
58
+ * the same way as a processing instruction in an XML document.
59
+ */
60
+#define HTML_PI_NODE		XML_PI_NODE
61
+
62
+XMLPUBFUN htmlDocPtr XMLCALL
63
+		htmlNewDoc		(const xmlChar *URI,
64
+					 const xmlChar *ExternalID);
65
+XMLPUBFUN htmlDocPtr XMLCALL
66
+		htmlNewDocNoDtD		(const xmlChar *URI,
67
+					 const xmlChar *ExternalID);
68
+XMLPUBFUN const xmlChar * XMLCALL
69
+		htmlGetMetaEncoding	(htmlDocPtr doc);
70
+XMLPUBFUN int XMLCALL
71
+		htmlSetMetaEncoding	(htmlDocPtr doc,
72
+					 const xmlChar *encoding);
73
+#ifdef LIBXML_OUTPUT_ENABLED
74
+XMLPUBFUN void XMLCALL
75
+		htmlDocDumpMemory	(xmlDocPtr cur,
76
+					 xmlChar **mem,
77
+					 int *size);
78
+XMLPUBFUN void XMLCALL
79
+		htmlDocDumpMemoryFormat	(xmlDocPtr cur,
80
+					 xmlChar **mem,
81
+					 int *size,
82
+					 int format);
83
+XMLPUBFUN int XMLCALL
84
+		htmlDocDump		(FILE *f,
85
+					 xmlDocPtr cur);
86
+XMLPUBFUN int XMLCALL
87
+		htmlSaveFile		(const char *filename,
88
+					 xmlDocPtr cur);
89
+XMLPUBFUN int XMLCALL
90
+		htmlNodeDump		(xmlBufferPtr buf,
91
+					 xmlDocPtr doc,
92
+					 xmlNodePtr cur);
93
+XMLPUBFUN void XMLCALL
94
+		htmlNodeDumpFile	(FILE *out,
95
+					 xmlDocPtr doc,
96
+					 xmlNodePtr cur);
97
+XMLPUBFUN int XMLCALL
98
+		htmlNodeDumpFileFormat	(FILE *out,
99
+					 xmlDocPtr doc,
100
+					 xmlNodePtr cur,
101
+					 const char *encoding,
102
+					 int format);
103
+XMLPUBFUN int XMLCALL
104
+		htmlSaveFileEnc		(const char *filename,
105
+					 xmlDocPtr cur,
106
+					 const char *encoding);
107
+XMLPUBFUN int XMLCALL
108
+		htmlSaveFileFormat	(const char *filename,
109
+					 xmlDocPtr cur,
110
+					 const char *encoding,
111
+					 int format);
112
+
113
+XMLPUBFUN void XMLCALL
114
+		htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf,
115
+					 xmlDocPtr doc,
116
+					 xmlNodePtr cur,
117
+					 const char *encoding,
118
+					 int format);
119
+XMLPUBFUN void XMLCALL
120
+		htmlDocContentDumpOutput(xmlOutputBufferPtr buf,
121
+					 xmlDocPtr cur,
122
+					 const char *encoding);
123
+XMLPUBFUN void XMLCALL
124
+		htmlDocContentDumpFormatOutput(xmlOutputBufferPtr buf,
125
+					 xmlDocPtr cur,
126
+					 const char *encoding,
127
+					 int format);
128
+XMLPUBFUN void XMLCALL
129
+		htmlNodeDumpOutput	(xmlOutputBufferPtr buf,
130
+					 xmlDocPtr doc,
131
+					 xmlNodePtr cur,
132
+					 const char *encoding);
133
+
134
+#endif /* LIBXML_OUTPUT_ENABLED */
135
+
136
+XMLPUBFUN int XMLCALL
137
+		htmlIsBooleanAttr	(const xmlChar *name);
138
+
139
+
140
+#ifdef __cplusplus
141
+}
142
+#endif
143
+
144
+#endif /* LIBXML_HTML_ENABLED */
145
+
146
+#endif /* __HTML_TREE_H__ */
147
+
0 148
new file mode 100644
... ...
@@ -0,0 +1,173 @@
1
+/*
2
+ * Summary: Old SAX version 1 handler, deprecated
3
+ * Description: DEPRECATED set of SAX version 1 interfaces used to
4
+ *              build the DOM tree.
5
+ *
6
+ * Copy: See Copyright for the status of this software.
7
+ *
8
+ * Author: Daniel Veillard
9
+ */
10
+
11
+
12
+#ifndef __XML_SAX_H__
13
+#define __XML_SAX_H__
14
+
15
+#include <stdio.h>
16
+#include <stdlib.h>
17
+#include <libxml/xmlversion.h>
18
+#include <libxml/parser.h>
19
+#include <libxml/xlink.h>
20
+
21
+#ifdef LIBXML_LEGACY_ENABLED
22
+
23
+#ifdef __cplusplus
24
+extern "C" {
25
+#endif
26
+XMLPUBFUN const xmlChar * XMLCALL
27
+		getPublicId			(void *ctx);
28
+XMLPUBFUN const xmlChar * XMLCALL
29
+		getSystemId			(void *ctx);
30
+XMLPUBFUN void XMLCALL
31
+		setDocumentLocator		(void *ctx,
32
+						 xmlSAXLocatorPtr loc);
33
+
34
+XMLPUBFUN int XMLCALL
35
+		getLineNumber			(void *ctx);
36
+XMLPUBFUN int XMLCALL
37
+		getColumnNumber			(void *ctx);
38
+
39
+XMLPUBFUN int XMLCALL
40
+		isStandalone			(void *ctx);
41
+XMLPUBFUN int XMLCALL
42
+		hasInternalSubset		(void *ctx);
43
+XMLPUBFUN int XMLCALL
44
+		hasExternalSubset		(void *ctx);
45
+
46
+XMLPUBFUN void XMLCALL
47
+		internalSubset			(void *ctx,
48
+						 const xmlChar *name,
49
+						 const xmlChar *ExternalID,
50
+						 const xmlChar *SystemID);
51
+XMLPUBFUN void XMLCALL
52
+		externalSubset			(void *ctx,
53
+						 const xmlChar *name,
54
+						 const xmlChar *ExternalID,
55
+						 const xmlChar *SystemID);
56
+XMLPUBFUN xmlEntityPtr XMLCALL
57
+		getEntity			(void *ctx,
58
+						 const xmlChar *name);
59
+XMLPUBFUN xmlEntityPtr XMLCALL
60
+		getParameterEntity		(void *ctx,
61
+						 const xmlChar *name);
62
+XMLPUBFUN xmlParserInputPtr XMLCALL
63
+		resolveEntity			(void *ctx,
64
+						 const xmlChar *publicId,
65
+						 const xmlChar *systemId);
66
+
67
+XMLPUBFUN void XMLCALL
68
+		entityDecl			(void *ctx,
69
+						 const xmlChar *name,
70
+						 int type,
71
+						 const xmlChar *publicId,
72
+						 const xmlChar *systemId,
73
+						 xmlChar *content);
74
+XMLPUBFUN void XMLCALL
75
+		attributeDecl			(void *ctx,
76
+						 const xmlChar *elem,
77
+						 const xmlChar *fullname,
78
+						 int type,
79
+						 int def,
80
+						 const xmlChar *defaultValue,
81
+						 xmlEnumerationPtr tree);
82
+XMLPUBFUN void XMLCALL
83
+		elementDecl			(void *ctx,
84
+						 const xmlChar *name,
85
+						 int type,
86
+						 xmlElementContentPtr content);
87
+XMLPUBFUN void XMLCALL
88
+		notationDecl			(void *ctx,
89
+						 const xmlChar *name,
90
+						 const xmlChar *publicId,
91
+						 const xmlChar *systemId);
92
+XMLPUBFUN void XMLCALL
93
+		unparsedEntityDecl		(void *ctx,
94
+						 const xmlChar *name,
95
+						 const xmlChar *publicId,
96
+						 const xmlChar *systemId,
97
+						 const xmlChar *notationName);
98
+
99
+XMLPUBFUN void XMLCALL
100
+		startDocument			(void *ctx);
101
+XMLPUBFUN void XMLCALL
102
+		endDocument			(void *ctx);
103
+XMLPUBFUN void XMLCALL
104
+		attribute			(void *ctx,
105
+						 const xmlChar *fullname,
106
+						 const xmlChar *value);
107
+XMLPUBFUN void XMLCALL
108
+		startElement			(void *ctx,
109
+						 const xmlChar *fullname,
110
+						 const xmlChar **atts);
111
+XMLPUBFUN void XMLCALL
112
+		endElement			(void *ctx,
113
+						 const xmlChar *name);
114
+XMLPUBFUN void XMLCALL
115
+		reference			(void *ctx,
116
+						 const xmlChar *name);
117
+XMLPUBFUN void XMLCALL
118
+		characters			(void *ctx,
119
+						 const xmlChar *ch,
120
+						 int len);
121
+XMLPUBFUN void XMLCALL
122
+		ignorableWhitespace		(void *ctx,
123
+						 const xmlChar *ch,
124
+						 int len);
125
+XMLPUBFUN void XMLCALL
126
+		processingInstruction		(void *ctx,
127
+						 const xmlChar *target,
128
+						 const xmlChar *data);
129
+XMLPUBFUN void XMLCALL
130
+		globalNamespace			(void *ctx,
131
+						 const xmlChar *href,
132
+						 const xmlChar *prefix);
133
+XMLPUBFUN void XMLCALL
134
+		setNamespace			(void *ctx,
135
+						 const xmlChar *name);
136
+XMLPUBFUN xmlNsPtr XMLCALL
137
+		getNamespace			(void *ctx);
138
+XMLPUBFUN int XMLCALL
139
+		checkNamespace			(void *ctx,
140
+						 xmlChar *nameSpace);
141
+XMLPUBFUN void XMLCALL
142
+		namespaceDecl			(void *ctx,
143
+						 const xmlChar *href,
144
+						 const xmlChar *prefix);
145
+XMLPUBFUN void XMLCALL
146
+		comment				(void *ctx,
147
+						 const xmlChar *value);
148
+XMLPUBFUN void XMLCALL
149
+		cdataBlock			(void *ctx,
150
+						 const xmlChar *value,
151
+						 int len);
152
+
153
+#ifdef LIBXML_SAX1_ENABLED
154
+XMLPUBFUN void XMLCALL
155
+		initxmlDefaultSAXHandler	(xmlSAXHandlerV1 *hdlr,
156
+						 int warning);
157
+#ifdef LIBXML_HTML_ENABLED
158
+XMLPUBFUN void XMLCALL
159
+		inithtmlDefaultSAXHandler	(xmlSAXHandlerV1 *hdlr);
160
+#endif
161
+#ifdef LIBXML_DOCB_ENABLED
162
+XMLPUBFUN void XMLCALL
163
+		initdocbDefaultSAXHandler	(xmlSAXHandlerV1 *hdlr);
164
+#endif
165
+#endif /* LIBXML_SAX1_ENABLED */
166
+
167
+#ifdef __cplusplus
168
+}
169
+#endif
170
+
171
+#endif /* LIBXML_LEGACY_ENABLED */
172
+
173
+#endif /* __XML_SAX_H__ */
0 174
new file mode 100644
... ...
@@ -0,0 +1,178 @@
1
+/*
2
+ * Summary: SAX2 parser interface used to build the DOM tree
3
+ * Description: those are the default SAX2 interfaces used by
4
+ *              the library when building DOM tree.
5
+ *
6
+ * Copy: See Copyright for the status of this software.
7
+ *
8
+ * Author: Daniel Veillard
9
+ */
10
+
11
+
12
+#ifndef __XML_SAX2_H__
13
+#define __XML_SAX2_H__
14
+
15
+#include <stdio.h>
16
+#include <stdlib.h>
17
+#include <libxml/xmlversion.h>
18
+#include <libxml/parser.h>
19
+#include <libxml/xlink.h>
20
+
21
+#ifdef __cplusplus
22
+extern "C" {
23
+#endif
24
+XMLPUBFUN const xmlChar * XMLCALL
25
+		xmlSAX2GetPublicId		(void *ctx);
26
+XMLPUBFUN const xmlChar * XMLCALL
27
+		xmlSAX2GetSystemId		(void *ctx);
28
+XMLPUBFUN void XMLCALL
29
+		xmlSAX2SetDocumentLocator	(void *ctx,
30
+						 xmlSAXLocatorPtr loc);
31
+
32
+XMLPUBFUN int XMLCALL
33
+		xmlSAX2GetLineNumber		(void *ctx);
34
+XMLPUBFUN int XMLCALL
35
+		xmlSAX2GetColumnNumber		(void *ctx);
36
+
37
+XMLPUBFUN int XMLCALL
38
+		xmlSAX2IsStandalone		(void *ctx);
39
+XMLPUBFUN int XMLCALL
40
+		xmlSAX2HasInternalSubset	(void *ctx);
41
+XMLPUBFUN int XMLCALL
42
+		xmlSAX2HasExternalSubset	(void *ctx);
43
+
44
+XMLPUBFUN void XMLCALL
45
+		xmlSAX2InternalSubset		(void *ctx,
46
+						 const xmlChar *name,
47
+						 const xmlChar *ExternalID,
48
+						 const xmlChar *SystemID);
49
+XMLPUBFUN void XMLCALL
50
+		xmlSAX2ExternalSubset		(void *ctx,
51
+						 const xmlChar *name,
52
+						 const xmlChar *ExternalID,
53
+						 const xmlChar *SystemID);
54
+XMLPUBFUN xmlEntityPtr XMLCALL
55
+		xmlSAX2GetEntity		(void *ctx,
56
+						 const xmlChar *name);
57
+XMLPUBFUN xmlEntityPtr XMLCALL
58
+		xmlSAX2GetParameterEntity	(void *ctx,
59
+						 const xmlChar *name);
60
+XMLPUBFUN xmlParserInputPtr XMLCALL
61
+		xmlSAX2ResolveEntity		(void *ctx,
62
+						 const xmlChar *publicId,
63
+						 const xmlChar *systemId);
64
+
65
+XMLPUBFUN void XMLCALL
66
+		xmlSAX2EntityDecl		(void *ctx,
67
+						 const xmlChar *name,
68
+						 int type,
69
+						 const xmlChar *publicId,
70
+						 const xmlChar *systemId,
71
+						 xmlChar *content);
72
+XMLPUBFUN void XMLCALL
73
+		xmlSAX2AttributeDecl		(void *ctx,
74
+						 const xmlChar *elem,
75
+						 const xmlChar *fullname,
76
+						 int type,
77
+						 int def,
78
+						 const xmlChar *defaultValue,
79
+						 xmlEnumerationPtr tree);
80
+XMLPUBFUN void XMLCALL
81
+		xmlSAX2ElementDecl		(void *ctx,
82
+						 const xmlChar *name,
83
+						 int type,
84
+						 xmlElementContentPtr content);
85
+XMLPUBFUN void XMLCALL
86
+		xmlSAX2NotationDecl		(void *ctx,
87
+						 const xmlChar *name,
88
+						 const xmlChar *publicId,
89
+						 const xmlChar *systemId);
90
+XMLPUBFUN void XMLCALL
91
+		xmlSAX2UnparsedEntityDecl	(void *ctx,
92
+						 const xmlChar *name,
93
+						 const xmlChar *publicId,
94
+						 const xmlChar *systemId,
95
+						 const xmlChar *notationName);
96
+
97
+XMLPUBFUN void XMLCALL
98
+		xmlSAX2StartDocument		(void *ctx);
99
+XMLPUBFUN void XMLCALL
100
+		xmlSAX2EndDocument		(void *ctx);
101
+#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || \
102
+    defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED) || \
103
+    defined(LIBXML_LEGACY_ENABLED)
104
+XMLPUBFUN void XMLCALL
105
+		xmlSAX2StartElement		(void *ctx,
106
+						 const xmlChar *fullname,
107
+						 const xmlChar **atts);
108
+XMLPUBFUN void XMLCALL
109
+		xmlSAX2EndElement		(void *ctx,
110
+						 const xmlChar *name);
111
+#endif /* LIBXML_SAX1_ENABLED or LIBXML_HTML_ENABLED or LIBXML_LEGACY_ENABLED */
112
+XMLPUBFUN void XMLCALL
113
+		xmlSAX2StartElementNs		(void *ctx,
114
+						 const xmlChar *localname,
115
+						 const xmlChar *prefix,
116
+						 const xmlChar *URI,
117
+						 int nb_namespaces,
118
+						 const xmlChar **namespaces,
119
+						 int nb_attributes,
120
+						 int nb_defaulted,
121
+						 const xmlChar **attributes);
122
+XMLPUBFUN void XMLCALL
123
+		xmlSAX2EndElementNs		(void *ctx,
124
+						 const xmlChar *localname,
125
+						 const xmlChar *prefix,
126
+						 const xmlChar *URI);
127
+XMLPUBFUN void XMLCALL
128
+		xmlSAX2Reference		(void *ctx,
129
+						 const xmlChar *name);
130
+XMLPUBFUN void XMLCALL
131
+		xmlSAX2Characters		(void *ctx,
132
+						 const xmlChar *ch,
133
+						 int len);
134
+XMLPUBFUN void XMLCALL
135
+		xmlSAX2IgnorableWhitespace	(void *ctx,
136
+						 const xmlChar *ch,
137
+						 int len);
138
+XMLPUBFUN void XMLCALL
139
+		xmlSAX2ProcessingInstruction	(void *ctx,
140
+						 const xmlChar *target,
141
+						 const xmlChar *data);
142
+XMLPUBFUN void XMLCALL
143
+		xmlSAX2Comment			(void *ctx,
144
+						 const xmlChar *value);
145
+XMLPUBFUN void XMLCALL
146
+		xmlSAX2CDataBlock		(void *ctx,
147
+						 const xmlChar *value,
148
+						 int len);
149
+
150
+#ifdef LIBXML_SAX1_ENABLED
151
+XMLPUBFUN int XMLCALL
152
+		xmlSAXDefaultVersion		(int version);
153
+#endif /* LIBXML_SAX1_ENABLED */
154
+
155
+XMLPUBFUN int XMLCALL
156
+		xmlSAXVersion			(xmlSAXHandler *hdlr,
157
+						 int version);
158
+XMLPUBFUN void XMLCALL
159
+		xmlSAX2InitDefaultSAXHandler    (xmlSAXHandler *hdlr,
160
+						 int warning);
161
+#ifdef LIBXML_HTML_ENABLED
162
+XMLPUBFUN void XMLCALL
163
+		xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr);
164
+XMLPUBFUN void XMLCALL
165
+		htmlDefaultSAXHandlerInit	(void);
166
+#endif
167
+#ifdef LIBXML_DOCB_ENABLED
168
+XMLPUBFUN void XMLCALL
169
+		xmlSAX2InitDocbDefaultSAXHandler(xmlSAXHandler *hdlr);
170
+XMLPUBFUN void XMLCALL
171
+		docbDefaultSAXHandlerInit	(void);
172
+#endif
173
+XMLPUBFUN void XMLCALL
174
+		xmlDefaultSAXHandlerInit	(void);
175
+#ifdef __cplusplus
176
+}
177
+#endif
178
+#endif /* __XML_SAX2_H__ */
0 179
new file mode 100644
... ...
@@ -0,0 +1,126 @@
1
+/*
2
+ * Summary: Provide Canonical XML and Exclusive XML Canonicalization
3
+ * Description: the c14n modules provides a
4
+ *
5
+ * "Canonical XML" implementation
6
+ * http://www.w3.org/TR/xml-c14n
7
+ *
8
+ * and an
9
+ *
10
+ * "Exclusive XML Canonicalization" implementation
11
+ * http://www.w3.org/TR/xml-exc-c14n
12
+
13
+ * Copy: See Copyright for the status of this software.
14
+ *
15
+ * Author: Aleksey Sanin <aleksey@aleksey.com>
16
+ */
17
+#ifndef __XML_C14N_H__
18
+#define __XML_C14N_H__
19
+#ifdef LIBXML_C14N_ENABLED
20
+#ifdef LIBXML_OUTPUT_ENABLED
21
+
22
+#ifdef __cplusplus
23
+extern "C" {
24
+#endif /* __cplusplus */
25
+
26
+#include <libxml/xmlversion.h>
27
+#include <libxml/tree.h>
28
+#include <libxml/xpath.h>
29
+
30
+/*
31
+ * XML Canonicazation
32
+ * http://www.w3.org/TR/xml-c14n
33
+ *
34
+ * Exclusive XML Canonicazation
35
+ * http://www.w3.org/TR/xml-exc-c14n
36
+ *
37
+ * Canonical form of an XML document could be created if and only if
38
+ *  a) default attributes (if any) are added to all nodes
39
+ *  b) all character and parsed entity references are resolved
40
+ * In order to achive this in libxml2 the document MUST be loaded with
41
+ * following global setings:
42
+ *
43
+ *    xmlLoadExtDtdDefaultValue = XML_DETECT_IDS | XML_COMPLETE_ATTRS;
44
+ *    xmlSubstituteEntitiesDefault(1);
45
+ *
46
+ * or corresponding parser context setting:
47
+ *    xmlParserCtxtPtr ctxt;
48
+ *
49
+ *    ...
50
+ *    ctxt->loadsubset = XML_DETECT_IDS | XML_COMPLETE_ATTRS;
51
+ *    ctxt->replaceEntities = 1;
52
+ *    ...
53
+ */
54
+
55
+/*
56
+ * xmlC14NMode:
57
+ *
58
+ * Predefined values for C14N modes
59
+ *
60
+ */
61
+typedef enum {
62
+    XML_C14N_1_0            = 0,    /* Origianal C14N 1.0 spec */
63
+    XML_C14N_EXCLUSIVE_1_0  = 1,    /* Exclusive C14N 1.0 spec */
64
+    XML_C14N_1_1            = 2     /* C14N 1.1 spec */
65
+} xmlC14NMode;
66
+
67
+XMLPUBFUN int XMLCALL
68
+		xmlC14NDocSaveTo	(xmlDocPtr doc,
69
+					 xmlNodeSetPtr nodes,
70
+					 int mode, /* a xmlC14NMode */
71
+					 xmlChar **inclusive_ns_prefixes,
72
+					 int with_comments,
73
+					 xmlOutputBufferPtr buf);
74
+
75
+XMLPUBFUN int XMLCALL
76
+		xmlC14NDocDumpMemory	(xmlDocPtr doc,
77
+					 xmlNodeSetPtr nodes,
78
+					 int mode, /* a xmlC14NMode */
79
+					 xmlChar **inclusive_ns_prefixes,
80
+					 int with_comments,
81
+					 xmlChar **doc_txt_ptr);
82
+
83
+XMLPUBFUN int XMLCALL
84
+		xmlC14NDocSave		(xmlDocPtr doc,
85
+					 xmlNodeSetPtr nodes,
86
+					 int mode, /* a xmlC14NMode */
87
+					 xmlChar **inclusive_ns_prefixes,
88
+					 int with_comments,
89
+					 const char* filename,
90
+					 int compression);
91
+
92
+
93
+/**
94
+ * This is the core C14N function
95
+ */
96
+/**
97
+ * xmlC14NIsVisibleCallback:
98
+ * @user_data: user data
99
+ * @node: the curent node
100
+ * @parent: the parent node
101
+ *
102
+ * Signature for a C14N callback on visible nodes
103
+ *
104
+ * Returns 1 if the node should be included
105
+ */
106
+typedef int (*xmlC14NIsVisibleCallback)	(void* user_data,
107
+					 xmlNodePtr node,
108
+					 xmlNodePtr parent);
109
+
110
+XMLPUBFUN int XMLCALL
111
+		xmlC14NExecute		(xmlDocPtr doc,
112
+					 xmlC14NIsVisibleCallback is_visible_callback,
113
+					 void* user_data,
114
+					 int mode, /* a xmlC14NMode */
115
+					 xmlChar **inclusive_ns_prefixes,
116
+					 int with_comments,
117
+					 xmlOutputBufferPtr buf);
118
+
119
+#ifdef __cplusplus
120
+}
121
+#endif /* __cplusplus */
122
+
123
+#endif /* LIBXML_OUTPUT_ENABLED */
124
+#endif /* LIBXML_C14N_ENABLED */
125
+#endif /* __XML_C14N_H__ */
126
+
0 127
new file mode 100644
... ...
@@ -0,0 +1,182 @@
1
+/**
2
+ * Summary: interfaces to the Catalog handling system
3
+ * Description: the catalog module implements the support for
4
+ * XML Catalogs and SGML catalogs
5
+ *
6
+ * SGML Open Technical Resolution TR9401:1997.
7
+ * http://www.jclark.com/sp/catalog.htm
8
+ *
9
+ * XML Catalogs Working Draft 06 August 2001
10
+ * http://www.oasis-open.org/committees/entity/spec-2001-08-06.html
11
+ *
12
+ * Copy: See Copyright for the status of this software.
13
+ *
14
+ * Author: Daniel Veillard
15
+ */
16
+
17
+#ifndef __XML_CATALOG_H__
18
+#define __XML_CATALOG_H__
19
+
20
+#include <stdio.h>
21
+
22
+#include <libxml/xmlversion.h>
23
+#include <libxml/xmlstring.h>
24
+#include <libxml/tree.h>
25
+
26
+#ifdef LIBXML_CATALOG_ENABLED
27
+
28
+#ifdef __cplusplus
29
+extern "C" {
30
+#endif
31
+
32
+/**
33
+ * XML_CATALOGS_NAMESPACE:
34
+ *
35
+ * The namespace for the XML Catalogs elements.
36
+ */
37
+#define XML_CATALOGS_NAMESPACE					\
38
+    (const xmlChar *) "urn:oasis:names:tc:entity:xmlns:xml:catalog"
39
+/**
40
+ * XML_CATALOG_PI:
41
+ *
42
+ * The specific XML Catalog Processing Instuction name.
43
+ */
44
+#define XML_CATALOG_PI						\
45
+    (const xmlChar *) "oasis-xml-catalog"
46
+
47
+/*
48
+ * The API is voluntarily limited to general cataloging.
49
+ */
50
+typedef enum {
51
+    XML_CATA_PREFER_NONE = 0,
52
+    XML_CATA_PREFER_PUBLIC = 1,
53
+    XML_CATA_PREFER_SYSTEM
54
+} xmlCatalogPrefer;
55
+
56
+typedef enum {
57
+    XML_CATA_ALLOW_NONE = 0,
58
+    XML_CATA_ALLOW_GLOBAL = 1,
59
+    XML_CATA_ALLOW_DOCUMENT = 2,
60
+    XML_CATA_ALLOW_ALL = 3
61
+} xmlCatalogAllow;
62
+
63
+typedef struct _xmlCatalog xmlCatalog;
64
+typedef xmlCatalog *xmlCatalogPtr;
65
+
66
+/*
67
+ * Operations on a given catalog.
68
+ */
69
+XMLPUBFUN xmlCatalogPtr XMLCALL
70
+		xmlNewCatalog		(int sgml);
71
+XMLPUBFUN xmlCatalogPtr XMLCALL
72
+		xmlLoadACatalog		(const char *filename);
73
+XMLPUBFUN xmlCatalogPtr XMLCALL
74
+		xmlLoadSGMLSuperCatalog	(const char *filename);
75
+XMLPUBFUN int XMLCALL
76
+		xmlConvertSGMLCatalog	(xmlCatalogPtr catal);
77
+XMLPUBFUN int XMLCALL
78
+		xmlACatalogAdd		(xmlCatalogPtr catal,
79
+					 const xmlChar *type,
80
+					 const xmlChar *orig,
81
+					 const xmlChar *replace);
82
+XMLPUBFUN int XMLCALL
83
+		xmlACatalogRemove	(xmlCatalogPtr catal,
84
+					 const xmlChar *value);
85
+XMLPUBFUN xmlChar * XMLCALL
86
+		xmlACatalogResolve	(xmlCatalogPtr catal,
87
+					 const xmlChar *pubID,
88
+	                                 const xmlChar *sysID);
89
+XMLPUBFUN xmlChar * XMLCALL
90
+		xmlACatalogResolveSystem(xmlCatalogPtr catal,
91
+					 const xmlChar *sysID);
92
+XMLPUBFUN xmlChar * XMLCALL
93
+		xmlACatalogResolvePublic(xmlCatalogPtr catal,
94
+					 const xmlChar *pubID);
95
+XMLPUBFUN xmlChar * XMLCALL
96
+		xmlACatalogResolveURI	(xmlCatalogPtr catal,
97
+					 const xmlChar *URI);
98
+#ifdef LIBXML_OUTPUT_ENABLED
99
+XMLPUBFUN void XMLCALL
100
+		xmlACatalogDump		(xmlCatalogPtr catal,
101
+					 FILE *out);
102
+#endif /* LIBXML_OUTPUT_ENABLED */
103
+XMLPUBFUN void XMLCALL
104
+		xmlFreeCatalog		(xmlCatalogPtr catal);
105
+XMLPUBFUN int XMLCALL
106
+		xmlCatalogIsEmpty	(xmlCatalogPtr catal);
107
+
108
+/*
109
+ * Global operations.
110
+ */
111
+XMLPUBFUN void XMLCALL
112
+		xmlInitializeCatalog	(void);
113
+XMLPUBFUN int XMLCALL
114
+		xmlLoadCatalog		(const char *filename);
115
+XMLPUBFUN void XMLCALL
116
+		xmlLoadCatalogs		(const char *paths);
117
+XMLPUBFUN void XMLCALL
118
+		xmlCatalogCleanup	(void);
119
+#ifdef LIBXML_OUTPUT_ENABLED
120
+XMLPUBFUN void XMLCALL
121
+		xmlCatalogDump		(FILE *out);
122
+#endif /* LIBXML_OUTPUT_ENABLED */
123
+XMLPUBFUN xmlChar * XMLCALL
124
+		xmlCatalogResolve	(const xmlChar *pubID,
125
+	                                 const xmlChar *sysID);
126
+XMLPUBFUN xmlChar * XMLCALL
127
+		xmlCatalogResolveSystem	(const xmlChar *sysID);
128
+XMLPUBFUN xmlChar * XMLCALL
129
+		xmlCatalogResolvePublic	(const xmlChar *pubID);
130
+XMLPUBFUN xmlChar * XMLCALL
131
+		xmlCatalogResolveURI	(const xmlChar *URI);
132
+XMLPUBFUN int XMLCALL
133
+		xmlCatalogAdd		(const xmlChar *type,
134
+					 const xmlChar *orig,
135
+					 const xmlChar *replace);
136
+XMLPUBFUN int XMLCALL
137
+		xmlCatalogRemove	(const xmlChar *value);
138
+XMLPUBFUN xmlDocPtr XMLCALL
139
+		xmlParseCatalogFile	(const char *filename);
140
+XMLPUBFUN int XMLCALL
141
+		xmlCatalogConvert	(void);
142
+
143
+/*
144
+ * Strictly minimal interfaces for per-document catalogs used
145
+ * by the parser.
146
+ */
147
+XMLPUBFUN void XMLCALL
148
+		xmlCatalogFreeLocal	(void *catalogs);
149
+XMLPUBFUN void * XMLCALL
150
+		xmlCatalogAddLocal	(void *catalogs,
151
+					 const xmlChar *URL);
152
+XMLPUBFUN xmlChar * XMLCALL
153
+		xmlCatalogLocalResolve	(void *catalogs,
154
+					 const xmlChar *pubID,
155
+	                                 const xmlChar *sysID);
156
+XMLPUBFUN xmlChar * XMLCALL
157
+		xmlCatalogLocalResolveURI(void *catalogs,
158
+					 const xmlChar *URI);
159
+/*
160
+ * Preference settings.
161
+ */
162
+XMLPUBFUN int XMLCALL
163
+		xmlCatalogSetDebug	(int level);
164
+XMLPUBFUN xmlCatalogPrefer XMLCALL
165
+		xmlCatalogSetDefaultPrefer(xmlCatalogPrefer prefer);
166
+XMLPUBFUN void XMLCALL
167
+		xmlCatalogSetDefaults	(xmlCatalogAllow allow);
168
+XMLPUBFUN xmlCatalogAllow XMLCALL
169
+		xmlCatalogGetDefaults	(void);
170
+
171
+
172
+/* DEPRECATED interfaces */
173
+XMLPUBFUN const xmlChar * XMLCALL
174
+		xmlCatalogGetSystem	(const xmlChar *sysID);
175
+XMLPUBFUN const xmlChar * XMLCALL
176
+		xmlCatalogGetPublic	(const xmlChar *pubID);
177
+
178
+#ifdef __cplusplus
179
+}
180
+#endif
181
+#endif /* LIBXML_CATALOG_ENABLED */
182
+#endif /* __XML_CATALOG_H__ */
0 183
new file mode 100644
... ...
@@ -0,0 +1,230 @@
1
+/*
2
+ * Summary: Unicode character range checking
3
+ * Description: this module exports interfaces for the character
4
+ *               range validation APIs
5
+ *
6
+ * This file is automatically generated from the cvs source
7
+ * definition files using the genChRanges.py Python script
8
+ *
9
+ * Generation date: Mon Mar 27 11:09:48 2006
10
+ * Sources: chvalid.def
11
+ * Author: William Brack <wbrack@mmm.com.hk>
12
+ */
13
+
14
+#ifndef __XML_CHVALID_H__
15
+#define __XML_CHVALID_H__
16
+
17
+#include <libxml/xmlversion.h>
18
+#include <libxml/xmlstring.h>
19
+
20
+#ifdef __cplusplus
21
+extern "C" {
22
+#endif
23
+
24
+/*
25
+ * Define our typedefs and structures
26
+ *
27
+ */
28
+typedef struct _xmlChSRange xmlChSRange;
29
+typedef xmlChSRange *xmlChSRangePtr;
30
+struct _xmlChSRange {
31
+    unsigned short	low;
32
+    unsigned short	high;
33
+};
34
+
35
+typedef struct _xmlChLRange xmlChLRange;
36
+typedef xmlChLRange *xmlChLRangePtr;
37
+struct _xmlChLRange {
38
+    unsigned int	low;
39
+    unsigned int	high;
40
+};
41
+
42
+typedef struct _xmlChRangeGroup xmlChRangeGroup;
43
+typedef xmlChRangeGroup *xmlChRangeGroupPtr;
44
+struct _xmlChRangeGroup {
45
+    int			nbShortRange;
46
+    int			nbLongRange;
47
+    const xmlChSRange	*shortRange;	/* points to an array of ranges */
48
+    const xmlChLRange	*longRange;
49
+};
50
+
51
+/**
52
+ * Range checking routine
53
+ */
54
+XMLPUBFUN int XMLCALL
55
+		xmlCharInRange(unsigned int val, const xmlChRangeGroup *group);
56
+
57
+
58
+/**
59
+ * xmlIsBaseChar_ch:
60
+ * @c: char to validate
61
+ *
62
+ * Automatically generated by genChRanges.py
63
+ */
64
+#define xmlIsBaseChar_ch(c)	(((0x41 <= (c)) && ((c) <= 0x5a)) || \
65
+				 ((0x61 <= (c)) && ((c) <= 0x7a)) || \
66
+				 ((0xc0 <= (c)) && ((c) <= 0xd6)) || \
67
+				 ((0xd8 <= (c)) && ((c) <= 0xf6)) || \
68
+				  (0xf8 <= (c)))
69
+
70
+/**
71
+ * xmlIsBaseCharQ:
72
+ * @c: char to validate
73
+ *
74
+ * Automatically generated by genChRanges.py
75
+ */
76
+#define xmlIsBaseCharQ(c)	(((c) < 0x100) ? \
77
+				 xmlIsBaseChar_ch((c)) : \
78
+				 xmlCharInRange((c), &xmlIsBaseCharGroup))
79
+
80
+XMLPUBVAR const xmlChRangeGroup xmlIsBaseCharGroup;
81
+
82
+/**
83
+ * xmlIsBlank_ch:
84
+ * @c: char to validate
85
+ *
86
+ * Automatically generated by genChRanges.py
87
+ */
88
+#define xmlIsBlank_ch(c)	(((c) == 0x20) || \
89
+				 ((0x9 <= (c)) && ((c) <= 0xa)) || \
90
+				 ((c) == 0xd))
91
+
92
+/**
93
+ * xmlIsBlankQ:
94
+ * @c: char to validate
95
+ *
96
+ * Automatically generated by genChRanges.py
97
+ */
98
+#define xmlIsBlankQ(c)		(((c) < 0x100) ? \
99
+				 xmlIsBlank_ch((c)) : 0)
100
+
101
+
102
+/**
103
+ * xmlIsChar_ch:
104
+ * @c: char to validate
105
+ *
106
+ * Automatically generated by genChRanges.py
107
+ */
108
+#define xmlIsChar_ch(c)		(((0x9 <= (c)) && ((c) <= 0xa)) || \
109
+				 ((c) == 0xd) || \
110
+				  (0x20 <= (c)))
111
+
112
+/**
113
+ * xmlIsCharQ:
114
+ * @c: char to validate
115
+ *
116
+ * Automatically generated by genChRanges.py
117
+ */
118
+#define xmlIsCharQ(c)		(((c) < 0x100) ? \
119
+				 xmlIsChar_ch((c)) :\
120
+				(((0x100 <= (c)) && ((c) <= 0xd7ff)) || \
121
+				 ((0xe000 <= (c)) && ((c) <= 0xfffd)) || \
122
+				 ((0x10000 <= (c)) && ((c) <= 0x10ffff))))
123
+
124
+XMLPUBVAR const xmlChRangeGroup xmlIsCharGroup;
125
+
126
+/**
127
+ * xmlIsCombiningQ:
128
+ * @c: char to validate
129
+ *
130
+ * Automatically generated by genChRanges.py
131
+ */
132
+#define xmlIsCombiningQ(c)	(((c) < 0x100) ? \
133
+				 0 : \
134
+				 xmlCharInRange((c), &xmlIsCombiningGroup))
135
+
136
+XMLPUBVAR const xmlChRangeGroup xmlIsCombiningGroup;
137
+
138
+/**
139
+ * xmlIsDigit_ch: