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