nokogiri 1.10.10-x64-mingw32 → 1.11.0-x64-mingw32

Sign up to get free protection for your applications and to get access to all the features.

Potentially problematic release.


This version of nokogiri might be problematic. Click here for more details.

Files changed (164) hide show
  1. checksums.yaml +4 -4
  2. data/Gemfile +3 -0
  3. data/LICENSE-DEPENDENCIES.md +1015 -947
  4. data/README.md +165 -91
  5. data/ext/nokogiri/depend +476 -357
  6. data/ext/nokogiri/extconf.rb +507 -357
  7. data/ext/nokogiri/html_document.c +79 -78
  8. data/ext/nokogiri/html_sax_parser_context.c +2 -2
  9. data/ext/nokogiri/include/libexslt/exslt.h +102 -0
  10. data/ext/nokogiri/include/libexslt/exsltconfig.h +70 -0
  11. data/ext/nokogiri/include/libexslt/exsltexports.h +140 -0
  12. data/ext/nokogiri/include/libxml2/libxml/DOCBparser.h +96 -0
  13. data/ext/nokogiri/include/libxml2/libxml/HTMLparser.h +306 -0
  14. data/ext/nokogiri/include/libxml2/libxml/HTMLtree.h +147 -0
  15. data/ext/nokogiri/include/libxml2/libxml/SAX.h +173 -0
  16. data/ext/nokogiri/include/libxml2/libxml/SAX2.h +178 -0
  17. data/ext/nokogiri/include/libxml2/libxml/c14n.h +126 -0
  18. data/ext/nokogiri/include/libxml2/libxml/catalog.h +182 -0
  19. data/ext/nokogiri/include/libxml2/libxml/chvalid.h +230 -0
  20. data/ext/nokogiri/include/libxml2/libxml/debugXML.h +217 -0
  21. data/ext/nokogiri/include/libxml2/libxml/dict.h +79 -0
  22. data/ext/nokogiri/include/libxml2/libxml/encoding.h +245 -0
  23. data/ext/nokogiri/include/libxml2/libxml/entities.h +151 -0
  24. data/ext/nokogiri/include/libxml2/libxml/globals.h +508 -0
  25. data/ext/nokogiri/include/libxml2/libxml/hash.h +236 -0
  26. data/ext/nokogiri/include/libxml2/libxml/list.h +137 -0
  27. data/ext/nokogiri/include/libxml2/libxml/nanoftp.h +163 -0
  28. data/ext/nokogiri/include/libxml2/libxml/nanohttp.h +81 -0
  29. data/ext/nokogiri/include/libxml2/libxml/parser.h +1241 -0
  30. data/ext/nokogiri/include/libxml2/libxml/parserInternals.h +644 -0
  31. data/ext/nokogiri/include/libxml2/libxml/pattern.h +100 -0
  32. data/ext/nokogiri/include/libxml2/libxml/relaxng.h +217 -0
  33. data/ext/nokogiri/include/libxml2/libxml/schemasInternals.h +958 -0
  34. data/ext/nokogiri/include/libxml2/libxml/schematron.h +142 -0
  35. data/ext/nokogiri/include/libxml2/libxml/threads.h +89 -0
  36. data/ext/nokogiri/include/libxml2/libxml/tree.h +1311 -0
  37. data/ext/nokogiri/include/libxml2/libxml/uri.h +94 -0
  38. data/ext/nokogiri/include/libxml2/libxml/valid.h +458 -0
  39. data/ext/nokogiri/include/libxml2/libxml/xinclude.h +129 -0
  40. data/ext/nokogiri/include/libxml2/libxml/xlink.h +189 -0
  41. data/ext/nokogiri/include/libxml2/libxml/xmlIO.h +366 -0
  42. data/ext/nokogiri/include/libxml2/libxml/xmlautomata.h +146 -0
  43. data/ext/nokogiri/include/libxml2/libxml/xmlerror.h +945 -0
  44. data/ext/nokogiri/include/libxml2/libxml/xmlexports.h +153 -0
  45. data/ext/nokogiri/include/libxml2/libxml/xmlmemory.h +224 -0
  46. data/ext/nokogiri/include/libxml2/libxml/xmlmodule.h +57 -0
  47. data/ext/nokogiri/include/libxml2/libxml/xmlreader.h +428 -0
  48. data/ext/nokogiri/include/libxml2/libxml/xmlregexp.h +222 -0
  49. data/ext/nokogiri/include/libxml2/libxml/xmlsave.h +88 -0
  50. data/ext/nokogiri/include/libxml2/libxml/xmlschemas.h +246 -0
  51. data/ext/nokogiri/include/libxml2/libxml/xmlschemastypes.h +151 -0
  52. data/ext/nokogiri/include/libxml2/libxml/xmlstring.h +140 -0
  53. data/ext/nokogiri/include/libxml2/libxml/xmlunicode.h +202 -0
  54. data/ext/nokogiri/include/libxml2/libxml/xmlversion.h +485 -0
  55. data/ext/nokogiri/include/libxml2/libxml/xmlwriter.h +488 -0
  56. data/ext/nokogiri/include/libxml2/libxml/xpath.h +566 -0
  57. data/ext/nokogiri/include/libxml2/libxml/xpathInternals.h +632 -0
  58. data/ext/nokogiri/include/libxml2/libxml/xpointer.h +114 -0
  59. data/ext/nokogiri/include/libxslt/attributes.h +38 -0
  60. data/ext/nokogiri/include/libxslt/documents.h +93 -0
  61. data/ext/nokogiri/include/libxslt/extensions.h +262 -0
  62. data/ext/nokogiri/include/libxslt/extra.h +72 -0
  63. data/ext/nokogiri/include/libxslt/functions.h +78 -0
  64. data/ext/nokogiri/include/libxslt/imports.h +75 -0
  65. data/ext/nokogiri/include/libxslt/keys.h +53 -0
  66. data/ext/nokogiri/include/libxslt/namespaces.h +68 -0
  67. data/ext/nokogiri/include/libxslt/numbersInternals.h +73 -0
  68. data/ext/nokogiri/include/libxslt/pattern.h +84 -0
  69. data/ext/nokogiri/include/libxslt/preproc.h +43 -0
  70. data/ext/nokogiri/include/libxslt/security.h +104 -0
  71. data/ext/nokogiri/include/libxslt/templates.h +77 -0
  72. data/ext/nokogiri/include/libxslt/transform.h +207 -0
  73. data/ext/nokogiri/include/libxslt/variables.h +118 -0
  74. data/ext/nokogiri/include/libxslt/xslt.h +110 -0
  75. data/ext/nokogiri/include/libxslt/xsltInternals.h +1978 -0
  76. data/ext/nokogiri/include/libxslt/xsltconfig.h +180 -0
  77. data/ext/nokogiri/include/libxslt/xsltexports.h +142 -0
  78. data/ext/nokogiri/include/libxslt/xsltlocale.h +76 -0
  79. data/ext/nokogiri/include/libxslt/xsltutils.h +313 -0
  80. data/ext/nokogiri/nokogiri.c +34 -40
  81. data/ext/nokogiri/nokogiri.h +26 -17
  82. data/ext/nokogiri/xml_document.c +18 -4
  83. data/ext/nokogiri/xml_io.c +8 -6
  84. data/ext/nokogiri/xml_node.c +21 -1
  85. data/ext/nokogiri/xml_node_set.c +1 -1
  86. data/ext/nokogiri/xml_reader.c +6 -17
  87. data/ext/nokogiri/xml_relax_ng.c +29 -11
  88. data/ext/nokogiri/xml_sax_parser.c +2 -7
  89. data/ext/nokogiri/xml_sax_parser_context.c +2 -2
  90. data/ext/nokogiri/xml_schema.c +55 -13
  91. data/ext/nokogiri/xml_xpath_context.c +80 -4
  92. data/ext/nokogiri/xslt_stylesheet.c +1 -8
  93. data/lib/nokogiri.rb +22 -22
  94. data/lib/nokogiri/2.5/nokogiri.so +0 -0
  95. data/lib/nokogiri/2.6/nokogiri.so +0 -0
  96. data/lib/nokogiri/2.7/nokogiri.so +0 -0
  97. data/lib/nokogiri/3.0/nokogiri.so +0 -0
  98. data/lib/nokogiri/css.rb +1 -0
  99. data/lib/nokogiri/css/node.rb +1 -0
  100. data/lib/nokogiri/css/parser.rb +63 -62
  101. data/lib/nokogiri/css/parser.y +2 -2
  102. data/lib/nokogiri/css/parser_extras.rb +39 -36
  103. data/lib/nokogiri/css/syntax_error.rb +1 -0
  104. data/lib/nokogiri/css/tokenizer.rb +1 -0
  105. data/lib/nokogiri/css/xpath_visitor.rb +73 -43
  106. data/lib/nokogiri/decorators/slop.rb +1 -0
  107. data/lib/nokogiri/html.rb +1 -0
  108. data/lib/nokogiri/html/builder.rb +1 -0
  109. data/lib/nokogiri/html/document.rb +13 -26
  110. data/lib/nokogiri/html/document_fragment.rb +1 -0
  111. data/lib/nokogiri/html/element_description.rb +1 -0
  112. data/lib/nokogiri/html/element_description_defaults.rb +1 -0
  113. data/lib/nokogiri/html/entity_lookup.rb +1 -0
  114. data/lib/nokogiri/html/sax/parser.rb +1 -0
  115. data/lib/nokogiri/html/sax/parser_context.rb +1 -0
  116. data/lib/nokogiri/html/sax/push_parser.rb +1 -0
  117. data/lib/nokogiri/jruby/dependencies.rb +20 -0
  118. data/lib/nokogiri/syntax_error.rb +1 -0
  119. data/lib/nokogiri/version.rb +3 -109
  120. data/lib/nokogiri/version/constant.rb +5 -0
  121. data/lib/nokogiri/version/info.rb +182 -0
  122. data/lib/nokogiri/xml.rb +1 -0
  123. data/lib/nokogiri/xml/attr.rb +1 -0
  124. data/lib/nokogiri/xml/attribute_decl.rb +1 -0
  125. data/lib/nokogiri/xml/builder.rb +3 -2
  126. data/lib/nokogiri/xml/cdata.rb +1 -0
  127. data/lib/nokogiri/xml/character_data.rb +1 -0
  128. data/lib/nokogiri/xml/document.rb +20 -15
  129. data/lib/nokogiri/xml/document_fragment.rb +5 -6
  130. data/lib/nokogiri/xml/dtd.rb +1 -0
  131. data/lib/nokogiri/xml/element_content.rb +1 -0
  132. data/lib/nokogiri/xml/element_decl.rb +1 -0
  133. data/lib/nokogiri/xml/entity_decl.rb +1 -0
  134. data/lib/nokogiri/xml/entity_reference.rb +1 -0
  135. data/lib/nokogiri/xml/namespace.rb +1 -0
  136. data/lib/nokogiri/xml/node.rb +587 -249
  137. data/lib/nokogiri/xml/node/save_options.rb +1 -0
  138. data/lib/nokogiri/xml/node_set.rb +1 -0
  139. data/lib/nokogiri/xml/notation.rb +1 -0
  140. data/lib/nokogiri/xml/parse_options.rb +10 -3
  141. data/lib/nokogiri/xml/pp.rb +1 -0
  142. data/lib/nokogiri/xml/pp/character_data.rb +1 -0
  143. data/lib/nokogiri/xml/pp/node.rb +1 -0
  144. data/lib/nokogiri/xml/processing_instruction.rb +1 -0
  145. data/lib/nokogiri/xml/reader.rb +7 -3
  146. data/lib/nokogiri/xml/relax_ng.rb +7 -2
  147. data/lib/nokogiri/xml/sax.rb +1 -0
  148. data/lib/nokogiri/xml/sax/document.rb +1 -0
  149. data/lib/nokogiri/xml/sax/parser.rb +1 -0
  150. data/lib/nokogiri/xml/sax/parser_context.rb +1 -0
  151. data/lib/nokogiri/xml/sax/push_parser.rb +1 -0
  152. data/lib/nokogiri/xml/schema.rb +13 -4
  153. data/lib/nokogiri/xml/searchable.rb +25 -16
  154. data/lib/nokogiri/xml/syntax_error.rb +1 -0
  155. data/lib/nokogiri/xml/text.rb +1 -0
  156. data/lib/nokogiri/xml/xpath.rb +1 -0
  157. data/lib/nokogiri/xml/xpath/syntax_error.rb +1 -0
  158. data/lib/nokogiri/xml/xpath_context.rb +1 -0
  159. data/lib/nokogiri/xslt.rb +1 -0
  160. data/lib/nokogiri/xslt/stylesheet.rb +1 -0
  161. data/lib/xsd/xmlparser/nokogiri.rb +1 -0
  162. metadata +148 -131
  163. data/lib/nokogiri/2.3/nokogiri.so +0 -0
  164. data/lib/nokogiri/2.4/nokogiri.so +0 -0
@@ -0,0 +1,81 @@
1
+ /*
2
+ * Summary: minimal HTTP implementation
3
+ * Description: minimal HTTP implementation allowing to fetch resources
4
+ * like external subset.
5
+ *
6
+ * Copy: See Copyright for the status of this software.
7
+ *
8
+ * Author: Daniel Veillard
9
+ */
10
+
11
+ #ifndef __NANO_HTTP_H__
12
+ #define __NANO_HTTP_H__
13
+
14
+ #include <libxml/xmlversion.h>
15
+
16
+ #ifdef LIBXML_HTTP_ENABLED
17
+
18
+ #ifdef __cplusplus
19
+ extern "C" {
20
+ #endif
21
+ XMLPUBFUN void XMLCALL
22
+ xmlNanoHTTPInit (void);
23
+ XMLPUBFUN void XMLCALL
24
+ xmlNanoHTTPCleanup (void);
25
+ XMLPUBFUN void XMLCALL
26
+ xmlNanoHTTPScanProxy (const char *URL);
27
+ XMLPUBFUN int XMLCALL
28
+ xmlNanoHTTPFetch (const char *URL,
29
+ const char *filename,
30
+ char **contentType);
31
+ XMLPUBFUN void * XMLCALL
32
+ xmlNanoHTTPMethod (const char *URL,
33
+ const char *method,
34
+ const char *input,
35
+ char **contentType,
36
+ const char *headers,
37
+ int ilen);
38
+ XMLPUBFUN void * XMLCALL
39
+ xmlNanoHTTPMethodRedir (const char *URL,
40
+ const char *method,
41
+ const char *input,
42
+ char **contentType,
43
+ char **redir,
44
+ const char *headers,
45
+ int ilen);
46
+ XMLPUBFUN void * XMLCALL
47
+ xmlNanoHTTPOpen (const char *URL,
48
+ char **contentType);
49
+ XMLPUBFUN void * XMLCALL
50
+ xmlNanoHTTPOpenRedir (const char *URL,
51
+ char **contentType,
52
+ char **redir);
53
+ XMLPUBFUN int XMLCALL
54
+ xmlNanoHTTPReturnCode (void *ctx);
55
+ XMLPUBFUN const char * XMLCALL
56
+ xmlNanoHTTPAuthHeader (void *ctx);
57
+ XMLPUBFUN const char * XMLCALL
58
+ xmlNanoHTTPRedir (void *ctx);
59
+ XMLPUBFUN int XMLCALL
60
+ xmlNanoHTTPContentLength( void * ctx );
61
+ XMLPUBFUN const char * XMLCALL
62
+ xmlNanoHTTPEncoding (void *ctx);
63
+ XMLPUBFUN const char * XMLCALL
64
+ xmlNanoHTTPMimeType (void *ctx);
65
+ XMLPUBFUN int XMLCALL
66
+ xmlNanoHTTPRead (void *ctx,
67
+ void *dest,
68
+ int len);
69
+ #ifdef LIBXML_OUTPUT_ENABLED
70
+ XMLPUBFUN int XMLCALL
71
+ xmlNanoHTTPSave (void *ctxt,
72
+ const char *filename);
73
+ #endif /* LIBXML_OUTPUT_ENABLED */
74
+ XMLPUBFUN void XMLCALL
75
+ xmlNanoHTTPClose (void *ctx);
76
+ #ifdef __cplusplus
77
+ }
78
+ #endif
79
+
80
+ #endif /* LIBXML_HTTP_ENABLED */
81
+ #endif /* __NANO_HTTP_H__ */
@@ -0,0 +1,1241 @@
1
+ /*
2
+ * Summary: the core parser module
3
+ * Description: Interfaces, constants and types related to the XML parser
4
+ *
5
+ * Copy: See Copyright for the status of this software.
6
+ *
7
+ * Author: Daniel Veillard
8
+ */
9
+
10
+ #ifndef __XML_PARSER_H__
11
+ #define __XML_PARSER_H__
12
+
13
+ #include <stdarg.h>
14
+
15
+ #include <libxml/xmlversion.h>
16
+ #include <libxml/tree.h>
17
+ #include <libxml/dict.h>
18
+ #include <libxml/hash.h>
19
+ #include <libxml/valid.h>
20
+ #include <libxml/entities.h>
21
+ #include <libxml/xmlerror.h>
22
+ #include <libxml/xmlstring.h>
23
+
24
+ #ifdef __cplusplus
25
+ extern "C" {
26
+ #endif
27
+
28
+ /**
29
+ * XML_DEFAULT_VERSION:
30
+ *
31
+ * The default version of XML used: 1.0
32
+ */
33
+ #define XML_DEFAULT_VERSION "1.0"
34
+
35
+ /**
36
+ * xmlParserInput:
37
+ *
38
+ * An xmlParserInput is an input flow for the XML processor.
39
+ * Each entity parsed is associated an xmlParserInput (except the
40
+ * few predefined ones). This is the case both for internal entities
41
+ * - in which case the flow is already completely in memory - or
42
+ * external entities - in which case we use the buf structure for
43
+ * progressive reading and I18N conversions to the internal UTF-8 format.
44
+ */
45
+
46
+ /**
47
+ * xmlParserInputDeallocate:
48
+ * @str: the string to deallocate
49
+ *
50
+ * Callback for freeing some parser input allocations.
51
+ */
52
+ typedef void (* xmlParserInputDeallocate)(xmlChar *str);
53
+
54
+ struct _xmlParserInput {
55
+ /* Input buffer */
56
+ xmlParserInputBufferPtr buf; /* UTF-8 encoded buffer */
57
+
58
+ const char *filename; /* The file analyzed, if any */
59
+ const char *directory; /* the directory/base of the file */
60
+ const xmlChar *base; /* Base of the array to parse */
61
+ const xmlChar *cur; /* Current char being parsed */
62
+ const xmlChar *end; /* end of the array to parse */
63
+ int length; /* length if known */
64
+ int line; /* Current line */
65
+ int col; /* Current column */
66
+ /*
67
+ * NOTE: consumed is only tested for equality in the parser code,
68
+ * so even if there is an overflow this should not give troubles
69
+ * for parsing very large instances.
70
+ */
71
+ unsigned long consumed; /* How many xmlChars already consumed */
72
+ xmlParserInputDeallocate free; /* function to deallocate the base */
73
+ const xmlChar *encoding; /* the encoding string for entity */
74
+ const xmlChar *version; /* the version string for entity */
75
+ int standalone; /* Was that entity marked standalone */
76
+ int id; /* an unique identifier for the entity */
77
+ };
78
+
79
+ /**
80
+ * xmlParserNodeInfo:
81
+ *
82
+ * The parser can be asked to collect Node informations, i.e. at what
83
+ * place in the file they were detected.
84
+ * NOTE: This is off by default and not very well tested.
85
+ */
86
+ typedef struct _xmlParserNodeInfo xmlParserNodeInfo;
87
+ typedef xmlParserNodeInfo *xmlParserNodeInfoPtr;
88
+
89
+ struct _xmlParserNodeInfo {
90
+ const struct _xmlNode* node;
91
+ /* Position & line # that text that created the node begins & ends on */
92
+ unsigned long begin_pos;
93
+ unsigned long begin_line;
94
+ unsigned long end_pos;
95
+ unsigned long end_line;
96
+ };
97
+
98
+ typedef struct _xmlParserNodeInfoSeq xmlParserNodeInfoSeq;
99
+ typedef xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr;
100
+ struct _xmlParserNodeInfoSeq {
101
+ unsigned long maximum;
102
+ unsigned long length;
103
+ xmlParserNodeInfo* buffer;
104
+ };
105
+
106
+ /**
107
+ * xmlParserInputState:
108
+ *
109
+ * The parser is now working also as a state based parser.
110
+ * The recursive one use the state info for entities processing.
111
+ */
112
+ typedef enum {
113
+ XML_PARSER_EOF = -1, /* nothing is to be parsed */
114
+ XML_PARSER_START = 0, /* nothing has been parsed */
115
+ XML_PARSER_MISC, /* Misc* before int subset */
116
+ XML_PARSER_PI, /* Within a processing instruction */
117
+ XML_PARSER_DTD, /* within some DTD content */
118
+ XML_PARSER_PROLOG, /* Misc* after internal subset */
119
+ XML_PARSER_COMMENT, /* within a comment */
120
+ XML_PARSER_START_TAG, /* within a start tag */
121
+ XML_PARSER_CONTENT, /* within the content */
122
+ XML_PARSER_CDATA_SECTION, /* within a CDATA section */
123
+ XML_PARSER_END_TAG, /* within a closing tag */
124
+ XML_PARSER_ENTITY_DECL, /* within an entity declaration */
125
+ XML_PARSER_ENTITY_VALUE, /* within an entity value in a decl */
126
+ XML_PARSER_ATTRIBUTE_VALUE, /* within an attribute value */
127
+ XML_PARSER_SYSTEM_LITERAL, /* within a SYSTEM value */
128
+ XML_PARSER_EPILOG, /* the Misc* after the last end tag */
129
+ XML_PARSER_IGNORE, /* within an IGNORED section */
130
+ XML_PARSER_PUBLIC_LITERAL /* within a PUBLIC value */
131
+ } xmlParserInputState;
132
+
133
+ /**
134
+ * XML_DETECT_IDS:
135
+ *
136
+ * Bit in the loadsubset context field to tell to do ID/REFs lookups.
137
+ * Use it to initialize xmlLoadExtDtdDefaultValue.
138
+ */
139
+ #define XML_DETECT_IDS 2
140
+
141
+ /**
142
+ * XML_COMPLETE_ATTRS:
143
+ *
144
+ * Bit in the loadsubset context field to tell to do complete the
145
+ * elements attributes lists with the ones defaulted from the DTDs.
146
+ * Use it to initialize xmlLoadExtDtdDefaultValue.
147
+ */
148
+ #define XML_COMPLETE_ATTRS 4
149
+
150
+ /**
151
+ * XML_SKIP_IDS:
152
+ *
153
+ * Bit in the loadsubset context field to tell to not do ID/REFs registration.
154
+ * Used to initialize xmlLoadExtDtdDefaultValue in some special cases.
155
+ */
156
+ #define XML_SKIP_IDS 8
157
+
158
+ /**
159
+ * xmlParserMode:
160
+ *
161
+ * A parser can operate in various modes
162
+ */
163
+ typedef enum {
164
+ XML_PARSE_UNKNOWN = 0,
165
+ XML_PARSE_DOM = 1,
166
+ XML_PARSE_SAX = 2,
167
+ XML_PARSE_PUSH_DOM = 3,
168
+ XML_PARSE_PUSH_SAX = 4,
169
+ XML_PARSE_READER = 5
170
+ } xmlParserMode;
171
+
172
+ /**
173
+ * xmlParserCtxt:
174
+ *
175
+ * The parser context.
176
+ * NOTE This doesn't completely define the parser state, the (current ?)
177
+ * design of the parser uses recursive function calls since this allow
178
+ * and easy mapping from the production rules of the specification
179
+ * to the actual code. The drawback is that the actual function call
180
+ * also reflect the parser state. However most of the parsing routines
181
+ * takes as the only argument the parser context pointer, so migrating
182
+ * to a state based parser for progressive parsing shouldn't be too hard.
183
+ */
184
+ struct _xmlParserCtxt {
185
+ struct _xmlSAXHandler *sax; /* The SAX handler */
186
+ void *userData; /* For SAX interface only, used by DOM build */
187
+ xmlDocPtr myDoc; /* the document being built */
188
+ int wellFormed; /* is the document well formed */
189
+ int replaceEntities; /* shall we replace entities ? */
190
+ const xmlChar *version; /* the XML version string */
191
+ const xmlChar *encoding; /* the declared encoding, if any */
192
+ int standalone; /* standalone document */
193
+ int html; /* an HTML(1)/Docbook(2) document
194
+ * 3 is HTML after <head>
195
+ * 10 is HTML after <body>
196
+ */
197
+
198
+ /* Input stream stack */
199
+ xmlParserInputPtr input; /* Current input stream */
200
+ int inputNr; /* Number of current input streams */
201
+ int inputMax; /* Max number of input streams */
202
+ xmlParserInputPtr *inputTab; /* stack of inputs */
203
+
204
+ /* Node analysis stack only used for DOM building */
205
+ xmlNodePtr node; /* Current parsed Node */
206
+ int nodeNr; /* Depth of the parsing stack */
207
+ int nodeMax; /* Max depth of the parsing stack */
208
+ xmlNodePtr *nodeTab; /* array of nodes */
209
+
210
+ int record_info; /* Whether node info should be kept */
211
+ xmlParserNodeInfoSeq node_seq; /* info about each node parsed */
212
+
213
+ int errNo; /* error code */
214
+
215
+ int hasExternalSubset; /* reference and external subset */
216
+ int hasPErefs; /* the internal subset has PE refs */
217
+ int external; /* are we parsing an external entity */
218
+
219
+ int valid; /* is the document valid */
220
+ int validate; /* shall we try to validate ? */
221
+ xmlValidCtxt vctxt; /* The validity context */
222
+
223
+ xmlParserInputState instate; /* current type of input */
224
+ int token; /* next char look-ahead */
225
+
226
+ char *directory; /* the data directory */
227
+
228
+ /* Node name stack */
229
+ const xmlChar *name; /* Current parsed Node */
230
+ int nameNr; /* Depth of the parsing stack */
231
+ int nameMax; /* Max depth of the parsing stack */
232
+ const xmlChar * *nameTab; /* array of nodes */
233
+
234
+ long nbChars; /* number of xmlChar processed */
235
+ long checkIndex; /* used by progressive parsing lookup */
236
+ int keepBlanks; /* ugly but ... */
237
+ int disableSAX; /* SAX callbacks are disabled */
238
+ int inSubset; /* Parsing is in int 1/ext 2 subset */
239
+ const xmlChar * intSubName; /* name of subset */
240
+ xmlChar * extSubURI; /* URI of external subset */
241
+ xmlChar * extSubSystem; /* SYSTEM ID of external subset */
242
+
243
+ /* xml:space values */
244
+ int * space; /* Should the parser preserve spaces */
245
+ int spaceNr; /* Depth of the parsing stack */
246
+ int spaceMax; /* Max depth of the parsing stack */
247
+ int * spaceTab; /* array of space infos */
248
+
249
+ int depth; /* to prevent entity substitution loops */
250
+ xmlParserInputPtr entity; /* used to check entities boundaries */
251
+ int charset; /* encoding of the in-memory content
252
+ actually an xmlCharEncoding */
253
+ int nodelen; /* Those two fields are there to */
254
+ int nodemem; /* Speed up large node parsing */
255
+ int pedantic; /* signal pedantic warnings */
256
+ void *_private; /* For user data, libxml won't touch it */
257
+
258
+ int loadsubset; /* should the external subset be loaded */
259
+ int linenumbers; /* set line number in element content */
260
+ void *catalogs; /* document's own catalog */
261
+ int recovery; /* run in recovery mode */
262
+ int progressive; /* is this a progressive parsing */
263
+ xmlDictPtr dict; /* dictionary for the parser */
264
+ const xmlChar * *atts; /* array for the attributes callbacks */
265
+ int maxatts; /* the size of the array */
266
+ int docdict; /* use strings from dict to build tree */
267
+
268
+ /*
269
+ * pre-interned strings
270
+ */
271
+ const xmlChar *str_xml;
272
+ const xmlChar *str_xmlns;
273
+ const xmlChar *str_xml_ns;
274
+
275
+ /*
276
+ * Everything below is used only by the new SAX mode
277
+ */
278
+ int sax2; /* operating in the new SAX mode */
279
+ int nsNr; /* the number of inherited namespaces */
280
+ int nsMax; /* the size of the arrays */
281
+ const xmlChar * *nsTab; /* the array of prefix/namespace name */
282
+ int *attallocs; /* which attribute were allocated */
283
+ void * *pushTab; /* array of data for push */
284
+ xmlHashTablePtr attsDefault; /* defaulted attributes if any */
285
+ xmlHashTablePtr attsSpecial; /* non-CDATA attributes if any */
286
+ int nsWellFormed; /* is the document XML Namespace okay */
287
+ int options; /* Extra options */
288
+
289
+ /*
290
+ * Those fields are needed only for streaming parsing so far
291
+ */
292
+ int dictNames; /* Use dictionary names for the tree */
293
+ int freeElemsNr; /* number of freed element nodes */
294
+ xmlNodePtr freeElems; /* List of freed element nodes */
295
+ int freeAttrsNr; /* number of freed attributes nodes */
296
+ xmlAttrPtr freeAttrs; /* List of freed attributes nodes */
297
+
298
+ /*
299
+ * the complete error informations for the last error.
300
+ */
301
+ xmlError lastError;
302
+ xmlParserMode parseMode; /* the parser mode */
303
+ unsigned long nbentities; /* number of entities references */
304
+ unsigned long sizeentities; /* size of parsed entities */
305
+
306
+ /* for use by HTML non-recursive parser */
307
+ xmlParserNodeInfo *nodeInfo; /* Current NodeInfo */
308
+ int nodeInfoNr; /* Depth of the parsing stack */
309
+ int nodeInfoMax; /* Max depth of the parsing stack */
310
+ xmlParserNodeInfo *nodeInfoTab; /* array of nodeInfos */
311
+
312
+ int input_id; /* we need to label inputs */
313
+ unsigned long sizeentcopy; /* volume of entity copy */
314
+ };
315
+
316
+ /**
317
+ * xmlSAXLocator:
318
+ *
319
+ * A SAX Locator.
320
+ */
321
+ struct _xmlSAXLocator {
322
+ const xmlChar *(*getPublicId)(void *ctx);
323
+ const xmlChar *(*getSystemId)(void *ctx);
324
+ int (*getLineNumber)(void *ctx);
325
+ int (*getColumnNumber)(void *ctx);
326
+ };
327
+
328
+ /**
329
+ * xmlSAXHandler:
330
+ *
331
+ * A SAX handler is bunch of callbacks called by the parser when processing
332
+ * of the input generate data or structure informations.
333
+ */
334
+
335
+ /**
336
+ * resolveEntitySAXFunc:
337
+ * @ctx: the user data (XML parser context)
338
+ * @publicId: The public ID of the entity
339
+ * @systemId: The system ID of the entity
340
+ *
341
+ * Callback:
342
+ * The entity loader, to control the loading of external entities,
343
+ * the application can either:
344
+ * - override this resolveEntity() callback in the SAX block
345
+ * - or better use the xmlSetExternalEntityLoader() function to
346
+ * set up it's own entity resolution routine
347
+ *
348
+ * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
349
+ */
350
+ typedef xmlParserInputPtr (*resolveEntitySAXFunc) (void *ctx,
351
+ const xmlChar *publicId,
352
+ const xmlChar *systemId);
353
+ /**
354
+ * internalSubsetSAXFunc:
355
+ * @ctx: the user data (XML parser context)
356
+ * @name: the root element name
357
+ * @ExternalID: the external ID
358
+ * @SystemID: the SYSTEM ID (e.g. filename or URL)
359
+ *
360
+ * Callback on internal subset declaration.
361
+ */
362
+ typedef void (*internalSubsetSAXFunc) (void *ctx,
363
+ const xmlChar *name,
364
+ const xmlChar *ExternalID,
365
+ const xmlChar *SystemID);
366
+ /**
367
+ * externalSubsetSAXFunc:
368
+ * @ctx: the user data (XML parser context)
369
+ * @name: the root element name
370
+ * @ExternalID: the external ID
371
+ * @SystemID: the SYSTEM ID (e.g. filename or URL)
372
+ *
373
+ * Callback on external subset declaration.
374
+ */
375
+ typedef void (*externalSubsetSAXFunc) (void *ctx,
376
+ const xmlChar *name,
377
+ const xmlChar *ExternalID,
378
+ const xmlChar *SystemID);
379
+ /**
380
+ * getEntitySAXFunc:
381
+ * @ctx: the user data (XML parser context)
382
+ * @name: The entity name
383
+ *
384
+ * Get an entity by name.
385
+ *
386
+ * Returns the xmlEntityPtr if found.
387
+ */
388
+ typedef xmlEntityPtr (*getEntitySAXFunc) (void *ctx,
389
+ const xmlChar *name);
390
+ /**
391
+ * getParameterEntitySAXFunc:
392
+ * @ctx: the user data (XML parser context)
393
+ * @name: The entity name
394
+ *
395
+ * Get a parameter entity by name.
396
+ *
397
+ * Returns the xmlEntityPtr if found.
398
+ */
399
+ typedef xmlEntityPtr (*getParameterEntitySAXFunc) (void *ctx,
400
+ const xmlChar *name);
401
+ /**
402
+ * entityDeclSAXFunc:
403
+ * @ctx: the user data (XML parser context)
404
+ * @name: the entity name
405
+ * @type: the entity type
406
+ * @publicId: The public ID of the entity
407
+ * @systemId: The system ID of the entity
408
+ * @content: the entity value (without processing).
409
+ *
410
+ * An entity definition has been parsed.
411
+ */
412
+ typedef void (*entityDeclSAXFunc) (void *ctx,
413
+ const xmlChar *name,
414
+ int type,
415
+ const xmlChar *publicId,
416
+ const xmlChar *systemId,
417
+ xmlChar *content);
418
+ /**
419
+ * notationDeclSAXFunc:
420
+ * @ctx: the user data (XML parser context)
421
+ * @name: The name of the notation
422
+ * @publicId: The public ID of the entity
423
+ * @systemId: The system ID of the entity
424
+ *
425
+ * What to do when a notation declaration has been parsed.
426
+ */
427
+ typedef void (*notationDeclSAXFunc)(void *ctx,
428
+ const xmlChar *name,
429
+ const xmlChar *publicId,
430
+ const xmlChar *systemId);
431
+ /**
432
+ * attributeDeclSAXFunc:
433
+ * @ctx: the user data (XML parser context)
434
+ * @elem: the name of the element
435
+ * @fullname: the attribute name
436
+ * @type: the attribute type
437
+ * @def: the type of default value
438
+ * @defaultValue: the attribute default value
439
+ * @tree: the tree of enumerated value set
440
+ *
441
+ * An attribute definition has been parsed.
442
+ */
443
+ typedef void (*attributeDeclSAXFunc)(void *ctx,
444
+ const xmlChar *elem,
445
+ const xmlChar *fullname,
446
+ int type,
447
+ int def,
448
+ const xmlChar *defaultValue,
449
+ xmlEnumerationPtr tree);
450
+ /**
451
+ * elementDeclSAXFunc:
452
+ * @ctx: the user data (XML parser context)
453
+ * @name: the element name
454
+ * @type: the element type
455
+ * @content: the element value tree
456
+ *
457
+ * An element definition has been parsed.
458
+ */
459
+ typedef void (*elementDeclSAXFunc)(void *ctx,
460
+ const xmlChar *name,
461
+ int type,
462
+ xmlElementContentPtr content);
463
+ /**
464
+ * unparsedEntityDeclSAXFunc:
465
+ * @ctx: the user data (XML parser context)
466
+ * @name: The name of the entity
467
+ * @publicId: The public ID of the entity
468
+ * @systemId: The system ID of the entity
469
+ * @notationName: the name of the notation
470
+ *
471
+ * What to do when an unparsed entity declaration is parsed.
472
+ */
473
+ typedef void (*unparsedEntityDeclSAXFunc)(void *ctx,
474
+ const xmlChar *name,
475
+ const xmlChar *publicId,
476
+ const xmlChar *systemId,
477
+ const xmlChar *notationName);
478
+ /**
479
+ * setDocumentLocatorSAXFunc:
480
+ * @ctx: the user data (XML parser context)
481
+ * @loc: A SAX Locator
482
+ *
483
+ * Receive the document locator at startup, actually xmlDefaultSAXLocator.
484
+ * Everything is available on the context, so this is useless in our case.
485
+ */
486
+ typedef void (*setDocumentLocatorSAXFunc) (void *ctx,
487
+ xmlSAXLocatorPtr loc);
488
+ /**
489
+ * startDocumentSAXFunc:
490
+ * @ctx: the user data (XML parser context)
491
+ *
492
+ * Called when the document start being processed.
493
+ */
494
+ typedef void (*startDocumentSAXFunc) (void *ctx);
495
+ /**
496
+ * endDocumentSAXFunc:
497
+ * @ctx: the user data (XML parser context)
498
+ *
499
+ * Called when the document end has been detected.
500
+ */
501
+ typedef void (*endDocumentSAXFunc) (void *ctx);
502
+ /**
503
+ * startElementSAXFunc:
504
+ * @ctx: the user data (XML parser context)
505
+ * @name: The element name, including namespace prefix
506
+ * @atts: An array of name/value attributes pairs, NULL terminated
507
+ *
508
+ * Called when an opening tag has been processed.
509
+ */
510
+ typedef void (*startElementSAXFunc) (void *ctx,
511
+ const xmlChar *name,
512
+ const xmlChar **atts);
513
+ /**
514
+ * endElementSAXFunc:
515
+ * @ctx: the user data (XML parser context)
516
+ * @name: The element name
517
+ *
518
+ * Called when the end of an element has been detected.
519
+ */
520
+ typedef void (*endElementSAXFunc) (void *ctx,
521
+ const xmlChar *name);
522
+ /**
523
+ * attributeSAXFunc:
524
+ * @ctx: the user data (XML parser context)
525
+ * @name: The attribute name, including namespace prefix
526
+ * @value: The attribute value
527
+ *
528
+ * Handle an attribute that has been read by the parser.
529
+ * The default handling is to convert the attribute into an
530
+ * DOM subtree and past it in a new xmlAttr element added to
531
+ * the element.
532
+ */
533
+ typedef void (*attributeSAXFunc) (void *ctx,
534
+ const xmlChar *name,
535
+ const xmlChar *value);
536
+ /**
537
+ * referenceSAXFunc:
538
+ * @ctx: the user data (XML parser context)
539
+ * @name: The entity name
540
+ *
541
+ * Called when an entity reference is detected.
542
+ */
543
+ typedef void (*referenceSAXFunc) (void *ctx,
544
+ const xmlChar *name);
545
+ /**
546
+ * charactersSAXFunc:
547
+ * @ctx: the user data (XML parser context)
548
+ * @ch: a xmlChar string
549
+ * @len: the number of xmlChar
550
+ *
551
+ * Receiving some chars from the parser.
552
+ */
553
+ typedef void (*charactersSAXFunc) (void *ctx,
554
+ const xmlChar *ch,
555
+ int len);
556
+ /**
557
+ * ignorableWhitespaceSAXFunc:
558
+ * @ctx: the user data (XML parser context)
559
+ * @ch: a xmlChar string
560
+ * @len: the number of xmlChar
561
+ *
562
+ * Receiving some ignorable whitespaces from the parser.
563
+ * UNUSED: by default the DOM building will use characters.
564
+ */
565
+ typedef void (*ignorableWhitespaceSAXFunc) (void *ctx,
566
+ const xmlChar *ch,
567
+ int len);
568
+ /**
569
+ * processingInstructionSAXFunc:
570
+ * @ctx: the user data (XML parser context)
571
+ * @target: the target name
572
+ * @data: the PI data's
573
+ *
574
+ * A processing instruction has been parsed.
575
+ */
576
+ typedef void (*processingInstructionSAXFunc) (void *ctx,
577
+ const xmlChar *target,
578
+ const xmlChar *data);
579
+ /**
580
+ * commentSAXFunc:
581
+ * @ctx: the user data (XML parser context)
582
+ * @value: the comment content
583
+ *
584
+ * A comment has been parsed.
585
+ */
586
+ typedef void (*commentSAXFunc) (void *ctx,
587
+ const xmlChar *value);
588
+ /**
589
+ * cdataBlockSAXFunc:
590
+ * @ctx: the user data (XML parser context)
591
+ * @value: The pcdata content
592
+ * @len: the block length
593
+ *
594
+ * Called when a pcdata block has been parsed.
595
+ */
596
+ typedef void (*cdataBlockSAXFunc) (
597
+ void *ctx,
598
+ const xmlChar *value,
599
+ int len);
600
+ /**
601
+ * warningSAXFunc:
602
+ * @ctx: an XML parser context
603
+ * @msg: the message to display/transmit
604
+ * @...: extra parameters for the message display
605
+ *
606
+ * Display and format a warning messages, callback.
607
+ */
608
+ typedef void (XMLCDECL *warningSAXFunc) (void *ctx,
609
+ const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
610
+ /**
611
+ * errorSAXFunc:
612
+ * @ctx: an XML parser context
613
+ * @msg: the message to display/transmit
614
+ * @...: extra parameters for the message display
615
+ *
616
+ * Display and format an error messages, callback.
617
+ */
618
+ typedef void (XMLCDECL *errorSAXFunc) (void *ctx,
619
+ const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
620
+ /**
621
+ * fatalErrorSAXFunc:
622
+ * @ctx: an XML parser context
623
+ * @msg: the message to display/transmit
624
+ * @...: extra parameters for the message display
625
+ *
626
+ * Display and format fatal error messages, callback.
627
+ * Note: so far fatalError() SAX callbacks are not used, error()
628
+ * get all the callbacks for errors.
629
+ */
630
+ typedef void (XMLCDECL *fatalErrorSAXFunc) (void *ctx,
631
+ const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
632
+ /**
633
+ * isStandaloneSAXFunc:
634
+ * @ctx: the user data (XML parser context)
635
+ *
636
+ * Is this document tagged standalone?
637
+ *
638
+ * Returns 1 if true
639
+ */
640
+ typedef int (*isStandaloneSAXFunc) (void *ctx);
641
+ /**
642
+ * hasInternalSubsetSAXFunc:
643
+ * @ctx: the user data (XML parser context)
644
+ *
645
+ * Does this document has an internal subset.
646
+ *
647
+ * Returns 1 if true
648
+ */
649
+ typedef int (*hasInternalSubsetSAXFunc) (void *ctx);
650
+
651
+ /**
652
+ * hasExternalSubsetSAXFunc:
653
+ * @ctx: the user data (XML parser context)
654
+ *
655
+ * Does this document has an external subset?
656
+ *
657
+ * Returns 1 if true
658
+ */
659
+ typedef int (*hasExternalSubsetSAXFunc) (void *ctx);
660
+
661
+ /************************************************************************
662
+ * *
663
+ * The SAX version 2 API extensions *
664
+ * *
665
+ ************************************************************************/
666
+ /**
667
+ * XML_SAX2_MAGIC:
668
+ *
669
+ * Special constant found in SAX2 blocks initialized fields
670
+ */
671
+ #define XML_SAX2_MAGIC 0xDEEDBEAF
672
+
673
+ /**
674
+ * startElementNsSAX2Func:
675
+ * @ctx: the user data (XML parser context)
676
+ * @localname: the local name of the element
677
+ * @prefix: the element namespace prefix if available
678
+ * @URI: the element namespace name if available
679
+ * @nb_namespaces: number of namespace definitions on that node
680
+ * @namespaces: pointer to the array of prefix/URI pairs namespace definitions
681
+ * @nb_attributes: the number of attributes on that node
682
+ * @nb_defaulted: the number of defaulted attributes. The defaulted
683
+ * ones are at the end of the array
684
+ * @attributes: pointer to the array of (localname/prefix/URI/value/end)
685
+ * attribute values.
686
+ *
687
+ * SAX2 callback when an element start has been detected by the parser.
688
+ * It provides the namespace informations for the element, as well as
689
+ * the new namespace declarations on the element.
690
+ */
691
+
692
+ typedef void (*startElementNsSAX2Func) (void *ctx,
693
+ const xmlChar *localname,
694
+ const xmlChar *prefix,
695
+ const xmlChar *URI,
696
+ int nb_namespaces,
697
+ const xmlChar **namespaces,
698
+ int nb_attributes,
699
+ int nb_defaulted,
700
+ const xmlChar **attributes);
701
+
702
+ /**
703
+ * endElementNsSAX2Func:
704
+ * @ctx: the user data (XML parser context)
705
+ * @localname: the local name of the element
706
+ * @prefix: the element namespace prefix if available
707
+ * @URI: the element namespace name if available
708
+ *
709
+ * SAX2 callback when an element end has been detected by the parser.
710
+ * It provides the namespace informations for the element.
711
+ */
712
+
713
+ typedef void (*endElementNsSAX2Func) (void *ctx,
714
+ const xmlChar *localname,
715
+ const xmlChar *prefix,
716
+ const xmlChar *URI);
717
+
718
+
719
+ struct _xmlSAXHandler {
720
+ internalSubsetSAXFunc internalSubset;
721
+ isStandaloneSAXFunc isStandalone;
722
+ hasInternalSubsetSAXFunc hasInternalSubset;
723
+ hasExternalSubsetSAXFunc hasExternalSubset;
724
+ resolveEntitySAXFunc resolveEntity;
725
+ getEntitySAXFunc getEntity;
726
+ entityDeclSAXFunc entityDecl;
727
+ notationDeclSAXFunc notationDecl;
728
+ attributeDeclSAXFunc attributeDecl;
729
+ elementDeclSAXFunc elementDecl;
730
+ unparsedEntityDeclSAXFunc unparsedEntityDecl;
731
+ setDocumentLocatorSAXFunc setDocumentLocator;
732
+ startDocumentSAXFunc startDocument;
733
+ endDocumentSAXFunc endDocument;
734
+ startElementSAXFunc startElement;
735
+ endElementSAXFunc endElement;
736
+ referenceSAXFunc reference;
737
+ charactersSAXFunc characters;
738
+ ignorableWhitespaceSAXFunc ignorableWhitespace;
739
+ processingInstructionSAXFunc processingInstruction;
740
+ commentSAXFunc comment;
741
+ warningSAXFunc warning;
742
+ errorSAXFunc error;
743
+ fatalErrorSAXFunc fatalError; /* unused error() get all the errors */
744
+ getParameterEntitySAXFunc getParameterEntity;
745
+ cdataBlockSAXFunc cdataBlock;
746
+ externalSubsetSAXFunc externalSubset;
747
+ unsigned int initialized;
748
+ /* The following fields are extensions available only on version 2 */
749
+ void *_private;
750
+ startElementNsSAX2Func startElementNs;
751
+ endElementNsSAX2Func endElementNs;
752
+ xmlStructuredErrorFunc serror;
753
+ };
754
+
755
+ /*
756
+ * SAX Version 1
757
+ */
758
+ typedef struct _xmlSAXHandlerV1 xmlSAXHandlerV1;
759
+ typedef xmlSAXHandlerV1 *xmlSAXHandlerV1Ptr;
760
+ struct _xmlSAXHandlerV1 {
761
+ internalSubsetSAXFunc internalSubset;
762
+ isStandaloneSAXFunc isStandalone;
763
+ hasInternalSubsetSAXFunc hasInternalSubset;
764
+ hasExternalSubsetSAXFunc hasExternalSubset;
765
+ resolveEntitySAXFunc resolveEntity;
766
+ getEntitySAXFunc getEntity;
767
+ entityDeclSAXFunc entityDecl;
768
+ notationDeclSAXFunc notationDecl;
769
+ attributeDeclSAXFunc attributeDecl;
770
+ elementDeclSAXFunc elementDecl;
771
+ unparsedEntityDeclSAXFunc unparsedEntityDecl;
772
+ setDocumentLocatorSAXFunc setDocumentLocator;
773
+ startDocumentSAXFunc startDocument;
774
+ endDocumentSAXFunc endDocument;
775
+ startElementSAXFunc startElement;
776
+ endElementSAXFunc endElement;
777
+ referenceSAXFunc reference;
778
+ charactersSAXFunc characters;
779
+ ignorableWhitespaceSAXFunc ignorableWhitespace;
780
+ processingInstructionSAXFunc processingInstruction;
781
+ commentSAXFunc comment;
782
+ warningSAXFunc warning;
783
+ errorSAXFunc error;
784
+ fatalErrorSAXFunc fatalError; /* unused error() get all the errors */
785
+ getParameterEntitySAXFunc getParameterEntity;
786
+ cdataBlockSAXFunc cdataBlock;
787
+ externalSubsetSAXFunc externalSubset;
788
+ unsigned int initialized;
789
+ };
790
+
791
+
792
+ /**
793
+ * xmlExternalEntityLoader:
794
+ * @URL: The System ID of the resource requested
795
+ * @ID: The Public ID of the resource requested
796
+ * @context: the XML parser context
797
+ *
798
+ * External entity loaders types.
799
+ *
800
+ * Returns the entity input parser.
801
+ */
802
+ typedef xmlParserInputPtr (*xmlExternalEntityLoader) (const char *URL,
803
+ const char *ID,
804
+ xmlParserCtxtPtr context);
805
+
806
+ #ifdef __cplusplus
807
+ }
808
+ #endif
809
+
810
+ #include <libxml/encoding.h>
811
+ #include <libxml/xmlIO.h>
812
+ #include <libxml/globals.h>
813
+
814
+ #ifdef __cplusplus
815
+ extern "C" {
816
+ #endif
817
+
818
+
819
+ /*
820
+ * Init/Cleanup
821
+ */
822
+ XMLPUBFUN void XMLCALL
823
+ xmlInitParser (void);
824
+ XMLPUBFUN void XMLCALL
825
+ xmlCleanupParser (void);
826
+
827
+ /*
828
+ * Input functions
829
+ */
830
+ XMLPUBFUN int XMLCALL
831
+ xmlParserInputRead (xmlParserInputPtr in,
832
+ int len);
833
+ XMLPUBFUN int XMLCALL
834
+ xmlParserInputGrow (xmlParserInputPtr in,
835
+ int len);
836
+
837
+ /*
838
+ * Basic parsing Interfaces
839
+ */
840
+ #ifdef LIBXML_SAX1_ENABLED
841
+ XMLPUBFUN xmlDocPtr XMLCALL
842
+ xmlParseDoc (const xmlChar *cur);
843
+ XMLPUBFUN xmlDocPtr XMLCALL
844
+ xmlParseFile (const char *filename);
845
+ XMLPUBFUN xmlDocPtr XMLCALL
846
+ xmlParseMemory (const char *buffer,
847
+ int size);
848
+ #endif /* LIBXML_SAX1_ENABLED */
849
+ XMLPUBFUN int XMLCALL
850
+ xmlSubstituteEntitiesDefault(int val);
851
+ XMLPUBFUN int XMLCALL
852
+ xmlKeepBlanksDefault (int val);
853
+ XMLPUBFUN void XMLCALL
854
+ xmlStopParser (xmlParserCtxtPtr ctxt);
855
+ XMLPUBFUN int XMLCALL
856
+ xmlPedanticParserDefault(int val);
857
+ XMLPUBFUN int XMLCALL
858
+ xmlLineNumbersDefault (int val);
859
+
860
+ #ifdef LIBXML_SAX1_ENABLED
861
+ /*
862
+ * Recovery mode
863
+ */
864
+ XMLPUBFUN xmlDocPtr XMLCALL
865
+ xmlRecoverDoc (const xmlChar *cur);
866
+ XMLPUBFUN xmlDocPtr XMLCALL
867
+ xmlRecoverMemory (const char *buffer,
868
+ int size);
869
+ XMLPUBFUN xmlDocPtr XMLCALL
870
+ xmlRecoverFile (const char *filename);
871
+ #endif /* LIBXML_SAX1_ENABLED */
872
+
873
+ /*
874
+ * Less common routines and SAX interfaces
875
+ */
876
+ XMLPUBFUN int XMLCALL
877
+ xmlParseDocument (xmlParserCtxtPtr ctxt);
878
+ XMLPUBFUN int XMLCALL
879
+ xmlParseExtParsedEnt (xmlParserCtxtPtr ctxt);
880
+ #ifdef LIBXML_SAX1_ENABLED
881
+ XMLPUBFUN int XMLCALL
882
+ xmlSAXUserParseFile (xmlSAXHandlerPtr sax,
883
+ void *user_data,
884
+ const char *filename);
885
+ XMLPUBFUN int XMLCALL
886
+ xmlSAXUserParseMemory (xmlSAXHandlerPtr sax,
887
+ void *user_data,
888
+ const char *buffer,
889
+ int size);
890
+ XMLPUBFUN xmlDocPtr XMLCALL
891
+ xmlSAXParseDoc (xmlSAXHandlerPtr sax,
892
+ const xmlChar *cur,
893
+ int recovery);
894
+ XMLPUBFUN xmlDocPtr XMLCALL
895
+ xmlSAXParseMemory (xmlSAXHandlerPtr sax,
896
+ const char *buffer,
897
+ int size,
898
+ int recovery);
899
+ XMLPUBFUN xmlDocPtr XMLCALL
900
+ xmlSAXParseMemoryWithData (xmlSAXHandlerPtr sax,
901
+ const char *buffer,
902
+ int size,
903
+ int recovery,
904
+ void *data);
905
+ XMLPUBFUN xmlDocPtr XMLCALL
906
+ xmlSAXParseFile (xmlSAXHandlerPtr sax,
907
+ const char *filename,
908
+ int recovery);
909
+ XMLPUBFUN xmlDocPtr XMLCALL
910
+ xmlSAXParseFileWithData (xmlSAXHandlerPtr sax,
911
+ const char *filename,
912
+ int recovery,
913
+ void *data);
914
+ XMLPUBFUN xmlDocPtr XMLCALL
915
+ xmlSAXParseEntity (xmlSAXHandlerPtr sax,
916
+ const char *filename);
917
+ XMLPUBFUN xmlDocPtr XMLCALL
918
+ xmlParseEntity (const char *filename);
919
+ #endif /* LIBXML_SAX1_ENABLED */
920
+
921
+ #ifdef LIBXML_VALID_ENABLED
922
+ XMLPUBFUN xmlDtdPtr XMLCALL
923
+ xmlSAXParseDTD (xmlSAXHandlerPtr sax,
924
+ const xmlChar *ExternalID,
925
+ const xmlChar *SystemID);
926
+ XMLPUBFUN xmlDtdPtr XMLCALL
927
+ xmlParseDTD (const xmlChar *ExternalID,
928
+ const xmlChar *SystemID);
929
+ XMLPUBFUN xmlDtdPtr XMLCALL
930
+ xmlIOParseDTD (xmlSAXHandlerPtr sax,
931
+ xmlParserInputBufferPtr input,
932
+ xmlCharEncoding enc);
933
+ #endif /* LIBXML_VALID_ENABLE */
934
+ #ifdef LIBXML_SAX1_ENABLED
935
+ XMLPUBFUN int XMLCALL
936
+ xmlParseBalancedChunkMemory(xmlDocPtr doc,
937
+ xmlSAXHandlerPtr sax,
938
+ void *user_data,
939
+ int depth,
940
+ const xmlChar *string,
941
+ xmlNodePtr *lst);
942
+ #endif /* LIBXML_SAX1_ENABLED */
943
+ XMLPUBFUN xmlParserErrors XMLCALL
944
+ xmlParseInNodeContext (xmlNodePtr node,
945
+ const char *data,
946
+ int datalen,
947
+ int options,
948
+ xmlNodePtr *lst);
949
+ #ifdef LIBXML_SAX1_ENABLED
950
+ XMLPUBFUN int XMLCALL
951
+ xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc,
952
+ xmlSAXHandlerPtr sax,
953
+ void *user_data,
954
+ int depth,
955
+ const xmlChar *string,
956
+ xmlNodePtr *lst,
957
+ int recover);
958
+ XMLPUBFUN int XMLCALL
959
+ xmlParseExternalEntity (xmlDocPtr doc,
960
+ xmlSAXHandlerPtr sax,
961
+ void *user_data,
962
+ int depth,
963
+ const xmlChar *URL,
964
+ const xmlChar *ID,
965
+ xmlNodePtr *lst);
966
+ #endif /* LIBXML_SAX1_ENABLED */
967
+ XMLPUBFUN int XMLCALL
968
+ xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx,
969
+ const xmlChar *URL,
970
+ const xmlChar *ID,
971
+ xmlNodePtr *lst);
972
+
973
+ /*
974
+ * Parser contexts handling.
975
+ */
976
+ XMLPUBFUN xmlParserCtxtPtr XMLCALL
977
+ xmlNewParserCtxt (void);
978
+ XMLPUBFUN int XMLCALL
979
+ xmlInitParserCtxt (xmlParserCtxtPtr ctxt);
980
+ XMLPUBFUN void XMLCALL
981
+ xmlClearParserCtxt (xmlParserCtxtPtr ctxt);
982
+ XMLPUBFUN void XMLCALL
983
+ xmlFreeParserCtxt (xmlParserCtxtPtr ctxt);
984
+ #ifdef LIBXML_SAX1_ENABLED
985
+ XMLPUBFUN void XMLCALL
986
+ xmlSetupParserForBuffer (xmlParserCtxtPtr ctxt,
987
+ const xmlChar* buffer,
988
+ const char *filename);
989
+ #endif /* LIBXML_SAX1_ENABLED */
990
+ XMLPUBFUN xmlParserCtxtPtr XMLCALL
991
+ xmlCreateDocParserCtxt (const xmlChar *cur);
992
+
993
+ #ifdef LIBXML_LEGACY_ENABLED
994
+ /*
995
+ * Reading/setting optional parsing features.
996
+ */
997
+ XMLPUBFUN int XMLCALL
998
+ xmlGetFeaturesList (int *len,
999
+ const char **result);
1000
+ XMLPUBFUN int XMLCALL
1001
+ xmlGetFeature (xmlParserCtxtPtr ctxt,
1002
+ const char *name,
1003
+ void *result);
1004
+ XMLPUBFUN int XMLCALL
1005
+ xmlSetFeature (xmlParserCtxtPtr ctxt,
1006
+ const char *name,
1007
+ void *value);
1008
+ #endif /* LIBXML_LEGACY_ENABLED */
1009
+
1010
+ #ifdef LIBXML_PUSH_ENABLED
1011
+ /*
1012
+ * Interfaces for the Push mode.
1013
+ */
1014
+ XMLPUBFUN xmlParserCtxtPtr XMLCALL
1015
+ xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax,
1016
+ void *user_data,
1017
+ const char *chunk,
1018
+ int size,
1019
+ const char *filename);
1020
+ XMLPUBFUN int XMLCALL
1021
+ xmlParseChunk (xmlParserCtxtPtr ctxt,
1022
+ const char *chunk,
1023
+ int size,
1024
+ int terminate);
1025
+ #endif /* LIBXML_PUSH_ENABLED */
1026
+
1027
+ /*
1028
+ * Special I/O mode.
1029
+ */
1030
+
1031
+ XMLPUBFUN xmlParserCtxtPtr XMLCALL
1032
+ xmlCreateIOParserCtxt (xmlSAXHandlerPtr sax,
1033
+ void *user_data,
1034
+ xmlInputReadCallback ioread,
1035
+ xmlInputCloseCallback ioclose,
1036
+ void *ioctx,
1037
+ xmlCharEncoding enc);
1038
+
1039
+ XMLPUBFUN xmlParserInputPtr XMLCALL
1040
+ xmlNewIOInputStream (xmlParserCtxtPtr ctxt,
1041
+ xmlParserInputBufferPtr input,
1042
+ xmlCharEncoding enc);
1043
+
1044
+ /*
1045
+ * Node infos.
1046
+ */
1047
+ XMLPUBFUN const xmlParserNodeInfo* XMLCALL
1048
+ xmlParserFindNodeInfo (const xmlParserCtxtPtr ctxt,
1049
+ const xmlNodePtr node);
1050
+ XMLPUBFUN void XMLCALL
1051
+ xmlInitNodeInfoSeq (xmlParserNodeInfoSeqPtr seq);
1052
+ XMLPUBFUN void XMLCALL
1053
+ xmlClearNodeInfoSeq (xmlParserNodeInfoSeqPtr seq);
1054
+ XMLPUBFUN unsigned long XMLCALL
1055
+ xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq,
1056
+ const xmlNodePtr node);
1057
+ XMLPUBFUN void XMLCALL
1058
+ xmlParserAddNodeInfo (xmlParserCtxtPtr ctxt,
1059
+ const xmlParserNodeInfoPtr info);
1060
+
1061
+ /*
1062
+ * External entities handling actually implemented in xmlIO.
1063
+ */
1064
+
1065
+ XMLPUBFUN void XMLCALL
1066
+ xmlSetExternalEntityLoader(xmlExternalEntityLoader f);
1067
+ XMLPUBFUN xmlExternalEntityLoader XMLCALL
1068
+ xmlGetExternalEntityLoader(void);
1069
+ XMLPUBFUN xmlParserInputPtr XMLCALL
1070
+ xmlLoadExternalEntity (const char *URL,
1071
+ const char *ID,
1072
+ xmlParserCtxtPtr ctxt);
1073
+
1074
+ /*
1075
+ * Index lookup, actually implemented in the encoding module
1076
+ */
1077
+ XMLPUBFUN long XMLCALL
1078
+ xmlByteConsumed (xmlParserCtxtPtr ctxt);
1079
+
1080
+ /*
1081
+ * New set of simpler/more flexible APIs
1082
+ */
1083
+ /**
1084
+ * xmlParserOption:
1085
+ *
1086
+ * This is the set of XML parser options that can be passed down
1087
+ * to the xmlReadDoc() and similar calls.
1088
+ */
1089
+ typedef enum {
1090
+ XML_PARSE_RECOVER = 1<<0, /* recover on errors */
1091
+ XML_PARSE_NOENT = 1<<1, /* substitute entities */
1092
+ XML_PARSE_DTDLOAD = 1<<2, /* load the external subset */
1093
+ XML_PARSE_DTDATTR = 1<<3, /* default DTD attributes */
1094
+ XML_PARSE_DTDVALID = 1<<4, /* validate with the DTD */
1095
+ XML_PARSE_NOERROR = 1<<5, /* suppress error reports */
1096
+ XML_PARSE_NOWARNING = 1<<6, /* suppress warning reports */
1097
+ XML_PARSE_PEDANTIC = 1<<7, /* pedantic error reporting */
1098
+ XML_PARSE_NOBLANKS = 1<<8, /* remove blank nodes */
1099
+ XML_PARSE_SAX1 = 1<<9, /* use the SAX1 interface internally */
1100
+ XML_PARSE_XINCLUDE = 1<<10,/* Implement XInclude substitution */
1101
+ XML_PARSE_NONET = 1<<11,/* Forbid network access */
1102
+ XML_PARSE_NODICT = 1<<12,/* Do not reuse the context dictionary */
1103
+ XML_PARSE_NSCLEAN = 1<<13,/* remove redundant namespaces declarations */
1104
+ XML_PARSE_NOCDATA = 1<<14,/* merge CDATA as text nodes */
1105
+ XML_PARSE_NOXINCNODE= 1<<15,/* do not generate XINCLUDE START/END nodes */
1106
+ XML_PARSE_COMPACT = 1<<16,/* compact small text nodes; no modification of
1107
+ the tree allowed afterwards (will possibly
1108
+ crash if you try to modify the tree) */
1109
+ XML_PARSE_OLD10 = 1<<17,/* parse using XML-1.0 before update 5 */
1110
+ XML_PARSE_NOBASEFIX = 1<<18,/* do not fixup XINCLUDE xml:base uris */
1111
+ XML_PARSE_HUGE = 1<<19,/* relax any hardcoded limit from the parser */
1112
+ XML_PARSE_OLDSAX = 1<<20,/* parse using SAX2 interface before 2.7.0 */
1113
+ XML_PARSE_IGNORE_ENC= 1<<21,/* ignore internal document encoding hint */
1114
+ XML_PARSE_BIG_LINES = 1<<22 /* Store big lines numbers in text PSVI field */
1115
+ } xmlParserOption;
1116
+
1117
+ XMLPUBFUN void XMLCALL
1118
+ xmlCtxtReset (xmlParserCtxtPtr ctxt);
1119
+ XMLPUBFUN int XMLCALL
1120
+ xmlCtxtResetPush (xmlParserCtxtPtr ctxt,
1121
+ const char *chunk,
1122
+ int size,
1123
+ const char *filename,
1124
+ const char *encoding);
1125
+ XMLPUBFUN int XMLCALL
1126
+ xmlCtxtUseOptions (xmlParserCtxtPtr ctxt,
1127
+ int options);
1128
+ XMLPUBFUN xmlDocPtr XMLCALL
1129
+ xmlReadDoc (const xmlChar *cur,
1130
+ const char *URL,
1131
+ const char *encoding,
1132
+ int options);
1133
+ XMLPUBFUN xmlDocPtr XMLCALL
1134
+ xmlReadFile (const char *URL,
1135
+ const char *encoding,
1136
+ int options);
1137
+ XMLPUBFUN xmlDocPtr XMLCALL
1138
+ xmlReadMemory (const char *buffer,
1139
+ int size,
1140
+ const char *URL,
1141
+ const char *encoding,
1142
+ int options);
1143
+ XMLPUBFUN xmlDocPtr XMLCALL
1144
+ xmlReadFd (int fd,
1145
+ const char *URL,
1146
+ const char *encoding,
1147
+ int options);
1148
+ XMLPUBFUN xmlDocPtr XMLCALL
1149
+ xmlReadIO (xmlInputReadCallback ioread,
1150
+ xmlInputCloseCallback ioclose,
1151
+ void *ioctx,
1152
+ const char *URL,
1153
+ const char *encoding,
1154
+ int options);
1155
+ XMLPUBFUN xmlDocPtr XMLCALL
1156
+ xmlCtxtReadDoc (xmlParserCtxtPtr ctxt,
1157
+ const xmlChar *cur,
1158
+ const char *URL,
1159
+ const char *encoding,
1160
+ int options);
1161
+ XMLPUBFUN xmlDocPtr XMLCALL
1162
+ xmlCtxtReadFile (xmlParserCtxtPtr ctxt,
1163
+ const char *filename,
1164
+ const char *encoding,
1165
+ int options);
1166
+ XMLPUBFUN xmlDocPtr XMLCALL
1167
+ xmlCtxtReadMemory (xmlParserCtxtPtr ctxt,
1168
+ const char *buffer,
1169
+ int size,
1170
+ const char *URL,
1171
+ const char *encoding,
1172
+ int options);
1173
+ XMLPUBFUN xmlDocPtr XMLCALL
1174
+ xmlCtxtReadFd (xmlParserCtxtPtr ctxt,
1175
+ int fd,
1176
+ const char *URL,
1177
+ const char *encoding,
1178
+ int options);
1179
+ XMLPUBFUN xmlDocPtr XMLCALL
1180
+ xmlCtxtReadIO (xmlParserCtxtPtr ctxt,
1181
+ xmlInputReadCallback ioread,
1182
+ xmlInputCloseCallback ioclose,
1183
+ void *ioctx,
1184
+ const char *URL,
1185
+ const char *encoding,
1186
+ int options);
1187
+
1188
+ /*
1189
+ * Library wide options
1190
+ */
1191
+ /**
1192
+ * xmlFeature:
1193
+ *
1194
+ * Used to examine the existence of features that can be enabled
1195
+ * or disabled at compile-time.
1196
+ * They used to be called XML_FEATURE_xxx but this clashed with Expat
1197
+ */
1198
+ typedef enum {
1199
+ XML_WITH_THREAD = 1,
1200
+ XML_WITH_TREE = 2,
1201
+ XML_WITH_OUTPUT = 3,
1202
+ XML_WITH_PUSH = 4,
1203
+ XML_WITH_READER = 5,
1204
+ XML_WITH_PATTERN = 6,
1205
+ XML_WITH_WRITER = 7,
1206
+ XML_WITH_SAX1 = 8,
1207
+ XML_WITH_FTP = 9,
1208
+ XML_WITH_HTTP = 10,
1209
+ XML_WITH_VALID = 11,
1210
+ XML_WITH_HTML = 12,
1211
+ XML_WITH_LEGACY = 13,
1212
+ XML_WITH_C14N = 14,
1213
+ XML_WITH_CATALOG = 15,
1214
+ XML_WITH_XPATH = 16,
1215
+ XML_WITH_XPTR = 17,
1216
+ XML_WITH_XINCLUDE = 18,
1217
+ XML_WITH_ICONV = 19,
1218
+ XML_WITH_ISO8859X = 20,
1219
+ XML_WITH_UNICODE = 21,
1220
+ XML_WITH_REGEXP = 22,
1221
+ XML_WITH_AUTOMATA = 23,
1222
+ XML_WITH_EXPR = 24,
1223
+ XML_WITH_SCHEMAS = 25,
1224
+ XML_WITH_SCHEMATRON = 26,
1225
+ XML_WITH_MODULES = 27,
1226
+ XML_WITH_DEBUG = 28,
1227
+ XML_WITH_DEBUG_MEM = 29,
1228
+ XML_WITH_DEBUG_RUN = 30,
1229
+ XML_WITH_ZLIB = 31,
1230
+ XML_WITH_ICU = 32,
1231
+ XML_WITH_LZMA = 33,
1232
+ XML_WITH_NONE = 99999 /* just to be sure of allocation size */
1233
+ } xmlFeature;
1234
+
1235
+ XMLPUBFUN int XMLCALL
1236
+ xmlHasFeature (xmlFeature feature);
1237
+
1238
+ #ifdef __cplusplus
1239
+ }
1240
+ #endif
1241
+ #endif /* __XML_PARSER_H__ */