Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 1 | /* |
Daniel Veillard | 52d8ade | 2012-07-30 10:08:45 +0800 | [diff] [blame] | 2 | * Summary: internals routines and limits exported by the parser. |
Daniel Veillard | be58697 | 2003-11-18 20:56:51 +0000 | [diff] [blame] | 3 | * Description: this module exports a number of internal parsing routines |
| 4 | * they are not really all intended for applications but |
| 5 | * can prove useful doing low level processing. |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 6 | * |
Daniel Veillard | be58697 | 2003-11-18 20:56:51 +0000 | [diff] [blame] | 7 | * Copy: See Copyright for the status of this software. |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 8 | * |
Daniel Veillard | be58697 | 2003-11-18 20:56:51 +0000 | [diff] [blame] | 9 | * Author: Daniel Veillard |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 10 | */ |
| 11 | |
| 12 | #ifndef __XML_PARSER_INTERNALS_H__ |
| 13 | #define __XML_PARSER_INTERNALS_H__ |
| 14 | |
Igor Zlatkovic | 76874e4 | 2003-08-25 09:05:12 +0000 | [diff] [blame] | 15 | #include <libxml/xmlversion.h> |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 16 | #include <libxml/parser.h> |
Daniel Veillard | 56a4cb8 | 2001-03-24 17:00:36 +0000 | [diff] [blame] | 17 | #include <libxml/HTMLparser.h> |
William M. Brack | 68aca05 | 2003-10-11 15:22:13 +0000 | [diff] [blame] | 18 | #include <libxml/chvalid.h> |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 19 | |
| 20 | #ifdef __cplusplus |
| 21 | extern "C" { |
| 22 | #endif |
| 23 | |
Daniel Veillard | 4aede2e | 2003-10-17 12:43:59 +0000 | [diff] [blame] | 24 | /** |
| 25 | * xmlParserMaxDepth: |
| 26 | * |
Daniel Veillard | 1fb2e0d | 2009-01-18 14:08:36 +0000 | [diff] [blame] | 27 | * arbitrary depth limit for the XML documents that we allow to |
| 28 | * process. This is not a limitation of the parser but a safety |
| 29 | * boundary feature, use XML_PARSE_HUGE option to override it. |
Daniel Veillard | 4aede2e | 2003-10-17 12:43:59 +0000 | [diff] [blame] | 30 | */ |
| 31 | XMLPUBVAR unsigned int xmlParserMaxDepth; |
| 32 | |
Daniel Veillard | 1fb2e0d | 2009-01-18 14:08:36 +0000 | [diff] [blame] | 33 | /** |
Daniel Veillard | 97ff9b3 | 2009-01-18 21:43:30 +0000 | [diff] [blame] | 34 | * XML_MAX_TEXT_LENGTH: |
Daniel Veillard | 1fb2e0d | 2009-01-18 14:08:36 +0000 | [diff] [blame] | 35 | * |
| 36 | * Maximum size allowed for a single text node when building a tree. |
| 37 | * This is not a limitation of the parser but a safety boundary feature, |
| 38 | * use XML_PARSE_HUGE option to override it. |
Daniel Veillard | 52d8ade | 2012-07-30 10:08:45 +0800 | [diff] [blame] | 39 | * Introduced in 2.9.0 |
Daniel Veillard | 1fb2e0d | 2009-01-18 14:08:36 +0000 | [diff] [blame] | 40 | */ |
Daniel Veillard | 97ff9b3 | 2009-01-18 21:43:30 +0000 | [diff] [blame] | 41 | #define XML_MAX_TEXT_LENGTH 10000000 |
Daniel Veillard | 1fb2e0d | 2009-01-18 14:08:36 +0000 | [diff] [blame] | 42 | |
| 43 | /** |
Daniel Veillard | 52d8ade | 2012-07-30 10:08:45 +0800 | [diff] [blame] | 44 | * XML_MAX_NAME_LENGTH: |
| 45 | * |
| 46 | * Maximum size allowed for a markup identitier |
| 47 | * This is not a limitation of the parser but a safety boundary feature, |
| 48 | * use XML_PARSE_HUGE option to override it. |
| 49 | * Note that with the use of parsing dictionaries overriding the limit |
| 50 | * may result in more runtime memory usage in face of "unfriendly' content |
| 51 | * Introduced in 2.9.0 |
| 52 | */ |
| 53 | #define XML_MAX_NAME_LENGTH 50000 |
| 54 | |
| 55 | /** |
| 56 | * XML_MAX_DICTIONARY_LIMIT: |
| 57 | * |
| 58 | * Maximum size allowed by the parser for a dictionary by default |
| 59 | * This is not a limitation of the parser but a safety boundary feature, |
| 60 | * use XML_PARSE_HUGE option to override it. |
| 61 | * Introduced in 2.9.0 |
| 62 | */ |
| 63 | #define XML_MAX_DICTIONARY_LIMIT 10000000 |
| 64 | |
| 65 | /** |
| 66 | * XML_MAX_LOOKUP_LIMIT: |
| 67 | * |
| 68 | * Maximum size allowed by the parser for ahead lookup |
| 69 | * This is an upper boundary enforced by the parser to avoid bad |
| 70 | * behaviour on "unfriendly' content |
| 71 | * Introduced in 2.9.0 |
| 72 | */ |
| 73 | #define XML_MAX_LOOKUP_LIMIT 10000000 |
| 74 | |
| 75 | /** |
Daniel Veillard | 1fb2e0d | 2009-01-18 14:08:36 +0000 | [diff] [blame] | 76 | * XML_MAX_NAMELEN: |
| 77 | * |
| 78 | * Identifiers can be longer, but this will be more costly |
| 79 | * at runtime. |
| 80 | */ |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 81 | #define XML_MAX_NAMELEN 100 |
| 82 | |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 83 | /** |
| 84 | * INPUT_CHUNK: |
| 85 | * |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 86 | * The parser tries to always have that amount of input ready. |
| 87 | * One of the point is providing context when reporting errors. |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 88 | */ |
| 89 | #define INPUT_CHUNK 250 |
| 90 | |
| 91 | /************************************************************************ |
| 92 | * * |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 93 | * UNICODE version of the macros. * |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 94 | * * |
| 95 | ************************************************************************/ |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 96 | /** |
Daniel Veillard | 73b013f | 2003-09-30 12:36:01 +0000 | [diff] [blame] | 97 | * IS_BYTE_CHAR: |
| 98 | * @c: an byte value (int) |
| 99 | * |
| 100 | * Macro to check the following production in the XML spec: |
| 101 | * |
| 102 | * [2] Char ::= #x9 | #xA | #xD | [#x20...] |
| 103 | * any byte character in the accepted range |
| 104 | */ |
William M. Brack | 68aca05 | 2003-10-11 15:22:13 +0000 | [diff] [blame] | 105 | #define IS_BYTE_CHAR(c) xmlIsChar_ch(c) |
Daniel Veillard | 73b013f | 2003-09-30 12:36:01 +0000 | [diff] [blame] | 106 | |
| 107 | /** |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 108 | * IS_CHAR: |
| 109 | * @c: an UNICODE value (int) |
| 110 | * |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 111 | * Macro to check the following production in the XML spec: |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 112 | * |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 113 | * [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] |
| 114 | * | [#x10000-#x10FFFF] |
| 115 | * any Unicode character, excluding the surrogate blocks, FFFE, and FFFF. |
| 116 | */ |
William M. Brack | 871611b | 2003-10-18 04:53:14 +0000 | [diff] [blame] | 117 | #define IS_CHAR(c) xmlIsCharQ(c) |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 118 | |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 119 | /** |
William M. Brack | 76e95df | 2003-10-18 16:20:14 +0000 | [diff] [blame] | 120 | * IS_CHAR_CH: |
| 121 | * @c: an xmlChar (usually an unsigned char) |
| 122 | * |
| 123 | * Behaves like IS_CHAR on single-byte value |
| 124 | */ |
| 125 | #define IS_CHAR_CH(c) xmlIsChar_ch(c) |
| 126 | |
| 127 | /** |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 128 | * IS_BLANK: |
| 129 | * @c: an UNICODE value (int) |
| 130 | * |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 131 | * Macro to check the following production in the XML spec: |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 132 | * |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 133 | * [3] S ::= (#x20 | #x9 | #xD | #xA)+ |
| 134 | */ |
William M. Brack | 871611b | 2003-10-18 04:53:14 +0000 | [diff] [blame] | 135 | #define IS_BLANK(c) xmlIsBlankQ(c) |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 136 | |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 137 | /** |
William M. Brack | 76e95df | 2003-10-18 16:20:14 +0000 | [diff] [blame] | 138 | * IS_BLANK_CH: |
| 139 | * @c: an xmlChar value (normally unsigned char) |
| 140 | * |
| 141 | * Behaviour same as IS_BLANK |
| 142 | */ |
| 143 | #define IS_BLANK_CH(c) xmlIsBlank_ch(c) |
| 144 | |
| 145 | /** |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 146 | * IS_BASECHAR: |
| 147 | * @c: an UNICODE value (int) |
| 148 | * |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 149 | * Macro to check the following production in the XML spec: |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 150 | * |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 151 | * [85] BaseChar ::= ... long list see REC ... |
| 152 | */ |
William M. Brack | 871611b | 2003-10-18 04:53:14 +0000 | [diff] [blame] | 153 | #define IS_BASECHAR(c) xmlIsBaseCharQ(c) |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 154 | |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 155 | /** |
| 156 | * IS_DIGIT: |
| 157 | * @c: an UNICODE value (int) |
| 158 | * |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 159 | * Macro to check the following production in the XML spec: |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 160 | * |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 161 | * [88] Digit ::= ... long list see REC ... |
| 162 | */ |
William M. Brack | 871611b | 2003-10-18 04:53:14 +0000 | [diff] [blame] | 163 | #define IS_DIGIT(c) xmlIsDigitQ(c) |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 164 | |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 165 | /** |
William M. Brack | 76e95df | 2003-10-18 16:20:14 +0000 | [diff] [blame] | 166 | * IS_DIGIT_CH: |
| 167 | * @c: an xmlChar value (usually an unsigned char) |
| 168 | * |
| 169 | * Behaves like IS_DIGIT but with a single byte argument |
| 170 | */ |
| 171 | #define IS_DIGIT_CH(c) xmlIsDigit_ch(c) |
| 172 | |
| 173 | /** |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 174 | * IS_COMBINING: |
| 175 | * @c: an UNICODE value (int) |
| 176 | * |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 177 | * Macro to check the following production in the XML spec: |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 178 | * |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 179 | * [87] CombiningChar ::= ... long list see REC ... |
| 180 | */ |
William M. Brack | 871611b | 2003-10-18 04:53:14 +0000 | [diff] [blame] | 181 | #define IS_COMBINING(c) xmlIsCombiningQ(c) |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 182 | |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 183 | /** |
William M. Brack | 76e95df | 2003-10-18 16:20:14 +0000 | [diff] [blame] | 184 | * IS_COMBINING_CH: |
| 185 | * @c: an xmlChar (usually an unsigned char) |
| 186 | * |
| 187 | * Always false (all combining chars > 0xff) |
| 188 | */ |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 189 | #define IS_COMBINING_CH(c) 0 |
William M. Brack | 76e95df | 2003-10-18 16:20:14 +0000 | [diff] [blame] | 190 | |
| 191 | /** |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 192 | * IS_EXTENDER: |
| 193 | * @c: an UNICODE value (int) |
| 194 | * |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 195 | * Macro to check the following production in the XML spec: |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 196 | * |
| 197 | * |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 198 | * [89] Extender ::= #x00B7 | #x02D0 | #x02D1 | #x0387 | #x0640 | |
| 199 | * #x0E46 | #x0EC6 | #x3005 | [#x3031-#x3035] | |
| 200 | * [#x309D-#x309E] | [#x30FC-#x30FE] |
| 201 | */ |
William M. Brack | 871611b | 2003-10-18 04:53:14 +0000 | [diff] [blame] | 202 | #define IS_EXTENDER(c) xmlIsExtenderQ(c) |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 203 | |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 204 | /** |
William M. Brack | 76e95df | 2003-10-18 16:20:14 +0000 | [diff] [blame] | 205 | * IS_EXTENDER_CH: |
| 206 | * @c: an xmlChar value (usually an unsigned char) |
| 207 | * |
| 208 | * Behaves like IS_EXTENDER but with a single-byte argument |
| 209 | */ |
| 210 | #define IS_EXTENDER_CH(c) xmlIsExtender_ch(c) |
| 211 | |
| 212 | /** |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 213 | * IS_IDEOGRAPHIC: |
| 214 | * @c: an UNICODE value (int) |
| 215 | * |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 216 | * Macro to check the following production in the XML spec: |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 217 | * |
| 218 | * |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 219 | * [86] Ideographic ::= [#x4E00-#x9FA5] | #x3007 | [#x3021-#x3029] |
| 220 | */ |
William M. Brack | 871611b | 2003-10-18 04:53:14 +0000 | [diff] [blame] | 221 | #define IS_IDEOGRAPHIC(c) xmlIsIdeographicQ(c) |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 222 | |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 223 | /** |
| 224 | * IS_LETTER: |
| 225 | * @c: an UNICODE value (int) |
| 226 | * |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 227 | * Macro to check the following production in the XML spec: |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 228 | * |
| 229 | * |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 230 | * [84] Letter ::= BaseChar | Ideographic |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 231 | */ |
| 232 | #define IS_LETTER(c) (IS_BASECHAR(c) || IS_IDEOGRAPHIC(c)) |
| 233 | |
William M. Brack | 76e95df | 2003-10-18 16:20:14 +0000 | [diff] [blame] | 234 | /** |
| 235 | * IS_LETTER_CH: |
| 236 | * @c: an xmlChar value (normally unsigned char) |
| 237 | * |
| 238 | * Macro behaves like IS_LETTER, but only check base chars |
| 239 | * |
| 240 | */ |
| 241 | #define IS_LETTER_CH(c) xmlIsBaseChar_ch(c) |
William M. Brack | d1757ab | 2004-10-02 22:07:48 +0000 | [diff] [blame] | 242 | |
| 243 | /** |
William M. Brack | 21e4ef2 | 2005-01-02 09:53:13 +0000 | [diff] [blame] | 244 | * IS_ASCII_LETTER: |
William M. Brack | d1757ab | 2004-10-02 22:07:48 +0000 | [diff] [blame] | 245 | * @c: an xmlChar value |
| 246 | * |
| 247 | * Macro to check [a-zA-Z] |
| 248 | * |
| 249 | */ |
| 250 | #define IS_ASCII_LETTER(c) (((0x41 <= (c)) && ((c) <= 0x5a)) || \ |
| 251 | ((0x61 <= (c)) && ((c) <= 0x7a))) |
| 252 | |
| 253 | /** |
William M. Brack | 21e4ef2 | 2005-01-02 09:53:13 +0000 | [diff] [blame] | 254 | * IS_ASCII_DIGIT: |
William M. Brack | d1757ab | 2004-10-02 22:07:48 +0000 | [diff] [blame] | 255 | * @c: an xmlChar value |
| 256 | * |
| 257 | * Macro to check [0-9] |
| 258 | * |
| 259 | */ |
| 260 | #define IS_ASCII_DIGIT(c) ((0x30 <= (c)) && ((c) <= 0x39)) |
| 261 | |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 262 | /** |
| 263 | * IS_PUBIDCHAR: |
| 264 | * @c: an UNICODE value (int) |
| 265 | * |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 266 | * Macro to check the following production in the XML spec: |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 267 | * |
| 268 | * |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 269 | * [13] PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%] |
| 270 | */ |
William M. Brack | 871611b | 2003-10-18 04:53:14 +0000 | [diff] [blame] | 271 | #define IS_PUBIDCHAR(c) xmlIsPubidCharQ(c) |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 272 | |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 273 | /** |
William M. Brack | 76e95df | 2003-10-18 16:20:14 +0000 | [diff] [blame] | 274 | * IS_PUBIDCHAR_CH: |
| 275 | * @c: an xmlChar value (normally unsigned char) |
| 276 | * |
| 277 | * Same as IS_PUBIDCHAR but for single-byte value |
| 278 | */ |
| 279 | #define IS_PUBIDCHAR_CH(c) xmlIsPubidChar_ch(c) |
| 280 | |
| 281 | /** |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 282 | * SKIP_EOL: |
| 283 | * @p: and UTF8 string pointer |
| 284 | * |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 285 | * Skips the end of line chars. |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 286 | */ |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 287 | #define SKIP_EOL(p) \ |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 288 | if (*(p) == 0x13) { p++ ; if (*(p) == 0x10) p++; } \ |
| 289 | if (*(p) == 0x10) { p++ ; if (*(p) == 0x13) p++; } |
| 290 | |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 291 | /** |
| 292 | * MOVETO_ENDTAG: |
| 293 | * @p: and UTF8 string pointer |
| 294 | * |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 295 | * Skips to the next '>' char. |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 296 | */ |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 297 | #define MOVETO_ENDTAG(p) \ |
| 298 | while ((*p) && (*(p) != '>')) (p)++ |
| 299 | |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 300 | /** |
| 301 | * MOVETO_STARTTAG: |
| 302 | * @p: and UTF8 string pointer |
| 303 | * |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 304 | * Skips to the next '<' char. |
Daniel Veillard | bed7b05 | 2001-05-19 14:59:49 +0000 | [diff] [blame] | 305 | */ |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 306 | #define MOVETO_STARTTAG(p) \ |
| 307 | while ((*p) && (*(p) != '<')) (p)++ |
| 308 | |
| 309 | /** |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 310 | * Global variables used for predefined strings. |
Daniel Veillard | 2209073 | 2001-07-16 00:06:07 +0000 | [diff] [blame] | 311 | */ |
Igor Zlatkovic | 76874e4 | 2003-08-25 09:05:12 +0000 | [diff] [blame] | 312 | XMLPUBVAR const xmlChar xmlStringText[]; |
| 313 | XMLPUBVAR const xmlChar xmlStringTextNoenc[]; |
| 314 | XMLPUBVAR const xmlChar xmlStringComment[]; |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 315 | |
| 316 | /* |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 317 | * Function to finish the work of the macros where needed. |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 318 | */ |
William M. Brack | 68aca05 | 2003-10-11 15:22:13 +0000 | [diff] [blame] | 319 | XMLPUBFUN int XMLCALL xmlIsLetter (int c); |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 320 | |
| 321 | /** |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 322 | * Parser context. |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 323 | */ |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 324 | XMLPUBFUN xmlParserCtxtPtr XMLCALL |
Igor Zlatkovic | 76874e4 | 2003-08-25 09:05:12 +0000 | [diff] [blame] | 325 | xmlCreateFileParserCtxt (const char *filename); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 326 | XMLPUBFUN xmlParserCtxtPtr XMLCALL |
Daniel Veillard | 61b9338 | 2003-11-03 14:28:31 +0000 | [diff] [blame] | 327 | xmlCreateURLParserCtxt (const char *filename, |
| 328 | int options); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 329 | XMLPUBFUN xmlParserCtxtPtr XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 330 | xmlCreateMemoryParserCtxt(const char *buffer, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 331 | int size); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 332 | XMLPUBFUN xmlParserCtxtPtr XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 333 | xmlCreateEntityParserCtxt(const xmlChar *URL, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 334 | const xmlChar *ID, |
| 335 | const xmlChar *base); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 336 | XMLPUBFUN int XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 337 | xmlSwitchEncoding (xmlParserCtxtPtr ctxt, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 338 | xmlCharEncoding enc); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 339 | XMLPUBFUN int XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 340 | xmlSwitchToEncoding (xmlParserCtxtPtr ctxt, |
Daniel Veillard | a840b69 | 2003-10-19 13:35:37 +0000 | [diff] [blame] | 341 | xmlCharEncodingHandlerPtr handler); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 342 | XMLPUBFUN int XMLCALL |
Daniel Veillard | a840b69 | 2003-10-19 13:35:37 +0000 | [diff] [blame] | 343 | xmlSwitchInputEncoding (xmlParserCtxtPtr ctxt, |
| 344 | xmlParserInputPtr input, |
| 345 | xmlCharEncodingHandlerPtr handler); |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 346 | |
Daniel Veillard | a840b69 | 2003-10-19 13:35:37 +0000 | [diff] [blame] | 347 | #ifdef IN_LIBXML |
| 348 | /* internal error reporting */ |
| 349 | XMLPUBFUN void XMLCALL |
| 350 | __xmlErrEncoding (xmlParserCtxtPtr ctxt, |
Daniel Veillard | 29b1748 | 2004-08-16 00:39:03 +0000 | [diff] [blame] | 351 | xmlParserErrors xmlerr, |
Daniel Veillard | a840b69 | 2003-10-19 13:35:37 +0000 | [diff] [blame] | 352 | const char *msg, |
| 353 | const xmlChar * str1, |
| 354 | const xmlChar * str2); |
| 355 | #endif |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 356 | |
| 357 | /** |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 358 | * Input Streams. |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 359 | */ |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 360 | XMLPUBFUN xmlParserInputPtr XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 361 | xmlNewStringInputStream (xmlParserCtxtPtr ctxt, |
Daniel Veillard | 56a4cb8 | 2001-03-24 17:00:36 +0000 | [diff] [blame] | 362 | const xmlChar *buffer); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 363 | XMLPUBFUN xmlParserInputPtr XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 364 | xmlNewEntityInputStream (xmlParserCtxtPtr ctxt, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 365 | xmlEntityPtr entity); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 366 | XMLPUBFUN int XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 367 | xmlPushInput (xmlParserCtxtPtr ctxt, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 368 | xmlParserInputPtr input); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 369 | XMLPUBFUN xmlChar XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 370 | xmlPopInput (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 371 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 372 | xmlFreeInputStream (xmlParserInputPtr input); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 373 | XMLPUBFUN xmlParserInputPtr XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 374 | xmlNewInputFromFile (xmlParserCtxtPtr ctxt, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 375 | const char *filename); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 376 | XMLPUBFUN xmlParserInputPtr XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 377 | xmlNewInputStream (xmlParserCtxtPtr ctxt); |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 378 | |
| 379 | /** |
| 380 | * Namespaces. |
| 381 | */ |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 382 | XMLPUBFUN xmlChar * XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 383 | xmlSplitQName (xmlParserCtxtPtr ctxt, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 384 | const xmlChar *name, |
| 385 | xmlChar **prefix); |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 386 | |
| 387 | /** |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 388 | * Generic production rules. |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 389 | */ |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 390 | XMLPUBFUN const xmlChar * XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 391 | xmlParseName (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 392 | XMLPUBFUN xmlChar * XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 393 | xmlParseNmtoken (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 394 | XMLPUBFUN xmlChar * XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 395 | xmlParseEntityValue (xmlParserCtxtPtr ctxt, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 396 | xmlChar **orig); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 397 | XMLPUBFUN xmlChar * XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 398 | xmlParseAttValue (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 399 | XMLPUBFUN xmlChar * XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 400 | xmlParseSystemLiteral (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 401 | XMLPUBFUN xmlChar * XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 402 | xmlParsePubidLiteral (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 403 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 404 | xmlParseCharData (xmlParserCtxtPtr ctxt, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 405 | int cdata); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 406 | XMLPUBFUN xmlChar * XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 407 | xmlParseExternalID (xmlParserCtxtPtr ctxt, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 408 | xmlChar **publicID, |
| 409 | int strict); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 410 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 411 | xmlParseComment (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 412 | XMLPUBFUN const xmlChar * XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 413 | xmlParsePITarget (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 414 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 415 | xmlParsePI (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 416 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 417 | xmlParseNotationDecl (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 418 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 419 | xmlParseEntityDecl (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 420 | XMLPUBFUN int XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 421 | xmlParseDefaultDecl (xmlParserCtxtPtr ctxt, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 422 | xmlChar **value); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 423 | XMLPUBFUN xmlEnumerationPtr XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 424 | xmlParseNotationType (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 425 | XMLPUBFUN xmlEnumerationPtr XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 426 | xmlParseEnumerationType (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 427 | XMLPUBFUN int XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 428 | xmlParseEnumeratedType (xmlParserCtxtPtr ctxt, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 429 | xmlEnumerationPtr *tree); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 430 | XMLPUBFUN int XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 431 | xmlParseAttributeType (xmlParserCtxtPtr ctxt, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 432 | xmlEnumerationPtr *tree); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 433 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 434 | xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 435 | XMLPUBFUN xmlElementContentPtr XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 436 | xmlParseElementMixedContentDecl |
Daniel Veillard | 8dc16a6 | 2002-02-19 21:08:48 +0000 | [diff] [blame] | 437 | (xmlParserCtxtPtr ctxt, |
Daniel Veillard | bdbe0d4 | 2003-09-14 19:56:14 +0000 | [diff] [blame] | 438 | int inputchk); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 439 | XMLPUBFUN xmlElementContentPtr XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 440 | xmlParseElementChildrenContentDecl |
Daniel Veillard | 8dc16a6 | 2002-02-19 21:08:48 +0000 | [diff] [blame] | 441 | (xmlParserCtxtPtr ctxt, |
Daniel Veillard | bdbe0d4 | 2003-09-14 19:56:14 +0000 | [diff] [blame] | 442 | int inputchk); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 443 | XMLPUBFUN int XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 444 | xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, |
Daniel Veillard | 2fdbd32 | 2003-08-18 12:15:38 +0000 | [diff] [blame] | 445 | const xmlChar *name, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 446 | xmlElementContentPtr *result); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 447 | XMLPUBFUN int XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 448 | xmlParseElementDecl (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 449 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 450 | xmlParseMarkupDecl (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 451 | XMLPUBFUN int XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 452 | xmlParseCharRef (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 453 | XMLPUBFUN xmlEntityPtr XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 454 | xmlParseEntityRef (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 455 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 456 | xmlParseReference (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 457 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 458 | xmlParsePEReference (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 459 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 460 | xmlParseDocTypeDecl (xmlParserCtxtPtr ctxt); |
William M. Brack | 21e4ef2 | 2005-01-02 09:53:13 +0000 | [diff] [blame] | 461 | #ifdef LIBXML_SAX1_ENABLED |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 462 | XMLPUBFUN const xmlChar * XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 463 | xmlParseAttribute (xmlParserCtxtPtr ctxt, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 464 | xmlChar **value); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 465 | XMLPUBFUN const xmlChar * XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 466 | xmlParseStartTag (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 467 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 468 | xmlParseEndTag (xmlParserCtxtPtr ctxt); |
William M. Brack | 21e4ef2 | 2005-01-02 09:53:13 +0000 | [diff] [blame] | 469 | #endif /* LIBXML_SAX1_ENABLED */ |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 470 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 471 | xmlParseCDSect (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 472 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 473 | xmlParseContent (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 474 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 475 | xmlParseElement (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 476 | XMLPUBFUN xmlChar * XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 477 | xmlParseVersionNum (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 478 | XMLPUBFUN xmlChar * XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 479 | xmlParseVersionInfo (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 480 | XMLPUBFUN xmlChar * XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 481 | xmlParseEncName (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 482 | XMLPUBFUN const xmlChar * XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 483 | xmlParseEncodingDecl (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 484 | XMLPUBFUN int XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 485 | xmlParseSDDecl (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 486 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 487 | xmlParseXMLDecl (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 488 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 489 | xmlParseTextDecl (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 490 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 491 | xmlParseMisc (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 492 | XMLPUBFUN void XMLCALL |
Igor Zlatkovic | 93f984a | 2003-08-25 10:34:41 +0000 | [diff] [blame] | 493 | xmlParseExternalSubset (xmlParserCtxtPtr ctxt, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 494 | const xmlChar *ExternalID, |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 495 | const xmlChar *SystemID); |
Daniel Veillard | 5e2dace | 2001-07-18 19:30:27 +0000 | [diff] [blame] | 496 | /** |
| 497 | * XML_SUBSTITUTE_NONE: |
| 498 | * |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 499 | * If no entities need to be substituted. |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 500 | */ |
| 501 | #define XML_SUBSTITUTE_NONE 0 |
Daniel Veillard | 5e2dace | 2001-07-18 19:30:27 +0000 | [diff] [blame] | 502 | /** |
| 503 | * XML_SUBSTITUTE_REF: |
| 504 | * |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 505 | * Whether general entities need to be substituted. |
Daniel Veillard | 5e2dace | 2001-07-18 19:30:27 +0000 | [diff] [blame] | 506 | */ |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 507 | #define XML_SUBSTITUTE_REF 1 |
Daniel Veillard | 5e2dace | 2001-07-18 19:30:27 +0000 | [diff] [blame] | 508 | /** |
| 509 | * XML_SUBSTITUTE_PEREF: |
| 510 | * |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 511 | * Whether parameter entities need to be substituted. |
Daniel Veillard | 5e2dace | 2001-07-18 19:30:27 +0000 | [diff] [blame] | 512 | */ |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 513 | #define XML_SUBSTITUTE_PEREF 2 |
Daniel Veillard | 5e2dace | 2001-07-18 19:30:27 +0000 | [diff] [blame] | 514 | /** |
| 515 | * XML_SUBSTITUTE_BOTH: |
| 516 | * |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 517 | * Both general and parameter entities need to be substituted. |
Daniel Veillard | 5e2dace | 2001-07-18 19:30:27 +0000 | [diff] [blame] | 518 | */ |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 519 | #define XML_SUBSTITUTE_BOTH 3 |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 520 | |
Daniel Veillard | 07cb822 | 2003-09-10 10:51:05 +0000 | [diff] [blame] | 521 | XMLPUBFUN xmlChar * XMLCALL |
Daniel Veillard | 07cb822 | 2003-09-10 10:51:05 +0000 | [diff] [blame] | 522 | xmlStringDecodeEntities (xmlParserCtxtPtr ctxt, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 523 | const xmlChar *str, |
| 524 | int what, |
| 525 | xmlChar end, |
| 526 | xmlChar end2, |
| 527 | xmlChar end3); |
Daniel Veillard | 07cb822 | 2003-09-10 10:51:05 +0000 | [diff] [blame] | 528 | XMLPUBFUN xmlChar * XMLCALL |
| 529 | xmlStringLenDecodeEntities (xmlParserCtxtPtr ctxt, |
| 530 | const xmlChar *str, |
| 531 | int len, |
| 532 | int what, |
| 533 | xmlChar end, |
| 534 | xmlChar end2, |
| 535 | xmlChar end3); |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 536 | |
| 537 | /* |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 538 | * Generated by MACROS on top of parser.c c.f. PUSH_AND_POP. |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 539 | */ |
Igor Zlatkovic | 76874e4 | 2003-08-25 09:05:12 +0000 | [diff] [blame] | 540 | XMLPUBFUN int XMLCALL nodePush (xmlParserCtxtPtr ctxt, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 541 | xmlNodePtr value); |
Igor Zlatkovic | 76874e4 | 2003-08-25 09:05:12 +0000 | [diff] [blame] | 542 | XMLPUBFUN xmlNodePtr XMLCALL nodePop (xmlParserCtxtPtr ctxt); |
| 543 | XMLPUBFUN int XMLCALL inputPush (xmlParserCtxtPtr ctxt, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 544 | xmlParserInputPtr value); |
Igor Zlatkovic | 76874e4 | 2003-08-25 09:05:12 +0000 | [diff] [blame] | 545 | XMLPUBFUN xmlParserInputPtr XMLCALL inputPop (xmlParserCtxtPtr ctxt); |
| 546 | XMLPUBFUN const xmlChar * XMLCALL namePop (xmlParserCtxtPtr ctxt); |
| 547 | XMLPUBFUN int XMLCALL namePush (xmlParserCtxtPtr ctxt, |
Daniel Veillard | 2fdbd32 | 2003-08-18 12:15:38 +0000 | [diff] [blame] | 548 | const xmlChar *value); |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 549 | |
| 550 | /* |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 551 | * other commodities shared between parser.c and parserInternals. |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 552 | */ |
Igor Zlatkovic | 76874e4 | 2003-08-25 09:05:12 +0000 | [diff] [blame] | 553 | XMLPUBFUN int XMLCALL xmlSkipBlankChars (xmlParserCtxtPtr ctxt); |
| 554 | XMLPUBFUN int XMLCALL xmlStringCurrentChar (xmlParserCtxtPtr ctxt, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 555 | const xmlChar *cur, |
| 556 | int *len); |
Igor Zlatkovic | 76874e4 | 2003-08-25 09:05:12 +0000 | [diff] [blame] | 557 | XMLPUBFUN void XMLCALL xmlParserHandlePEReference(xmlParserCtxtPtr ctxt); |
Igor Zlatkovic | 76874e4 | 2003-08-25 09:05:12 +0000 | [diff] [blame] | 558 | XMLPUBFUN int XMLCALL xmlCheckLanguageID (const xmlChar *lang); |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 559 | |
| 560 | /* |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 561 | * Really core function shared with HTML parser. |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 562 | */ |
Igor Zlatkovic | 76874e4 | 2003-08-25 09:05:12 +0000 | [diff] [blame] | 563 | XMLPUBFUN int XMLCALL xmlCurrentChar (xmlParserCtxtPtr ctxt, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 564 | int *len); |
Igor Zlatkovic | 76874e4 | 2003-08-25 09:05:12 +0000 | [diff] [blame] | 565 | XMLPUBFUN int XMLCALL xmlCopyCharMultiByte (xmlChar *out, |
Daniel Veillard | 56a4cb8 | 2001-03-24 17:00:36 +0000 | [diff] [blame] | 566 | int val); |
Igor Zlatkovic | 76874e4 | 2003-08-25 09:05:12 +0000 | [diff] [blame] | 567 | XMLPUBFUN int XMLCALL xmlCopyChar (int len, |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 568 | xmlChar *out, |
| 569 | int val); |
Igor Zlatkovic | 76874e4 | 2003-08-25 09:05:12 +0000 | [diff] [blame] | 570 | XMLPUBFUN void XMLCALL xmlNextChar (xmlParserCtxtPtr ctxt); |
| 571 | XMLPUBFUN void XMLCALL xmlParserInputShrink (xmlParserInputPtr in); |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 572 | |
| 573 | #ifdef LIBXML_HTML_ENABLED |
| 574 | /* |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 575 | * Actually comes from the HTML parser but launched from the init stuff. |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 576 | */ |
Igor Zlatkovic | 76874e4 | 2003-08-25 09:05:12 +0000 | [diff] [blame] | 577 | XMLPUBFUN void XMLCALL htmlInitAutoClose (void); |
| 578 | XMLPUBFUN htmlParserCtxtPtr XMLCALL htmlCreateFileParserCtxt(const char *filename, |
Daniel Veillard | 56a4cb8 | 2001-03-24 17:00:36 +0000 | [diff] [blame] | 579 | const char *encoding); |
Daniel Veillard | 7839e16 | 2002-02-20 18:54:48 +0000 | [diff] [blame] | 580 | #endif |
Daniel Veillard | 8107a22 | 2002-01-13 14:10:10 +0000 | [diff] [blame] | 581 | |
| 582 | /* |
| 583 | * Specific function to keep track of entities references |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 584 | * and used by the XSLT debugger. |
Daniel Veillard | 8107a22 | 2002-01-13 14:10:10 +0000 | [diff] [blame] | 585 | */ |
William M. Brack | 21e4ef2 | 2005-01-02 09:53:13 +0000 | [diff] [blame] | 586 | #ifdef LIBXML_LEGACY_ENABLED |
Daniel Veillard | 9d06d30 | 2002-01-22 18:15:52 +0000 | [diff] [blame] | 587 | /** |
| 588 | * xmlEntityReferenceFunc: |
| 589 | * @ent: the entity |
| 590 | * @firstNode: the fist node in the chunk |
| 591 | * @lastNode: the last nod in the chunk |
| 592 | * |
Daniel Veillard | 61f2617 | 2002-03-12 18:46:39 +0000 | [diff] [blame] | 593 | * Callback function used when one needs to be able to track back the |
| 594 | * provenance of a chunk of nodes inherited from an entity replacement. |
Daniel Veillard | 9d06d30 | 2002-01-22 18:15:52 +0000 | [diff] [blame] | 595 | */ |
Daniel Veillard | 8107a22 | 2002-01-13 14:10:10 +0000 | [diff] [blame] | 596 | typedef void (*xmlEntityReferenceFunc) (xmlEntityPtr ent, |
| 597 | xmlNodePtr firstNode, |
| 598 | xmlNodePtr lastNode); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 599 | |
Igor Zlatkovic | 76874e4 | 2003-08-25 09:05:12 +0000 | [diff] [blame] | 600 | XMLPUBFUN void XMLCALL xmlSetEntityReferenceFunc (xmlEntityReferenceFunc func); |
Daniel Veillard | 8107a22 | 2002-01-13 14:10:10 +0000 | [diff] [blame] | 601 | |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 602 | XMLPUBFUN xmlChar * XMLCALL |
William M. Brack | 21e4ef2 | 2005-01-02 09:53:13 +0000 | [diff] [blame] | 603 | xmlParseQuotedString (xmlParserCtxtPtr ctxt); |
| 604 | XMLPUBFUN void XMLCALL |
| 605 | xmlParseNamespace (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 606 | XMLPUBFUN xmlChar * XMLCALL |
William M. Brack | 21e4ef2 | 2005-01-02 09:53:13 +0000 | [diff] [blame] | 607 | xmlNamespaceParseNSDef (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 608 | XMLPUBFUN xmlChar * XMLCALL |
William M. Brack | 21e4ef2 | 2005-01-02 09:53:13 +0000 | [diff] [blame] | 609 | xmlScanName (xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 610 | XMLPUBFUN xmlChar * XMLCALL |
William M. Brack | 21e4ef2 | 2005-01-02 09:53:13 +0000 | [diff] [blame] | 611 | xmlNamespaceParseNCName (xmlParserCtxtPtr ctxt); |
| 612 | XMLPUBFUN void XMLCALL xmlParserHandleReference(xmlParserCtxtPtr ctxt); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 613 | XMLPUBFUN xmlChar * XMLCALL |
William M. Brack | 21e4ef2 | 2005-01-02 09:53:13 +0000 | [diff] [blame] | 614 | xmlNamespaceParseQName (xmlParserCtxtPtr ctxt, |
| 615 | xmlChar **prefix); |
| 616 | /** |
| 617 | * Entities |
| 618 | */ |
| 619 | XMLPUBFUN xmlChar * XMLCALL |
| 620 | xmlDecodeEntities (xmlParserCtxtPtr ctxt, |
| 621 | int len, |
| 622 | int what, |
| 623 | xmlChar end, |
| 624 | xmlChar end2, |
| 625 | xmlChar end3); |
Daniel Veillard | f8e3db0 | 2012-09-11 13:26:36 +0800 | [diff] [blame^] | 626 | XMLPUBFUN void XMLCALL |
William M. Brack | 21e4ef2 | 2005-01-02 09:53:13 +0000 | [diff] [blame] | 627 | xmlHandleEntity (xmlParserCtxtPtr ctxt, |
| 628 | xmlEntityPtr entity); |
| 629 | |
| 630 | #endif /* LIBXML_LEGACY_ENABLED */ |
| 631 | |
Daniel Veillard | ce9457f | 2003-10-05 21:33:18 +0000 | [diff] [blame] | 632 | #ifdef IN_LIBXML |
| 633 | /* |
| 634 | * internal only |
| 635 | */ |
| 636 | XMLPUBFUN void XMLCALL |
| 637 | xmlErrMemory (xmlParserCtxtPtr ctxt, |
| 638 | const char *extra); |
| 639 | #endif |
Daniel Veillard | 8107a22 | 2002-01-13 14:10:10 +0000 | [diff] [blame] | 640 | |
Owen Taylor | 3473f88 | 2001-02-23 17:55:21 +0000 | [diff] [blame] | 641 | #ifdef __cplusplus |
| 642 | } |
| 643 | #endif |
| 644 | #endif /* __XML_PARSER_INTERNALS_H__ */ |