1/* 2 * Summary: internals routines and limits 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 21extern "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 */ 31XMLPUBVAR 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 * Introduced in 2.9.0 40 */ 41#define XML_MAX_TEXT_LENGTH 10000000 42 43/** 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/** 76 * XML_MAX_NAMELEN: 77 * 78 * Identifiers can be longer, but this will be more costly 79 * at runtime. 80 */ 81#define XML_MAX_NAMELEN 100 82 83/** 84 * INPUT_CHUNK: 85 * 86 * The parser tries to always have that amount of input ready. 87 * One of the point is providing context when reporting errors. 88 */ 89#define INPUT_CHUNK 250 90 91/************************************************************************ 92 * * 93 * UNICODE version of the macros. * 94 * * 95 ************************************************************************/ 96/** 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 */ 105#define IS_BYTE_CHAR(c) xmlIsChar_ch(c) 106 107/** 108 * IS_CHAR: 109 * @c: an UNICODE value (int) 110 * 111 * Macro to check the following production in the XML spec: 112 * 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 */ 117#define IS_CHAR(c) xmlIsCharQ(c) 118 119/** 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/** 128 * IS_BLANK: 129 * @c: an UNICODE value (int) 130 * 131 * Macro to check the following production in the XML spec: 132 * 133 * [3] S ::= (#x20 | #x9 | #xD | #xA)+ 134 */ 135#define IS_BLANK(c) xmlIsBlankQ(c) 136 137/** 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/** 146 * IS_BASECHAR: 147 * @c: an UNICODE value (int) 148 * 149 * Macro to check the following production in the XML spec: 150 * 151 * [85] BaseChar ::= ... long list see REC ... 152 */ 153#define IS_BASECHAR(c) xmlIsBaseCharQ(c) 154 155/** 156 * IS_DIGIT: 157 * @c: an UNICODE value (int) 158 * 159 * Macro to check the following production in the XML spec: 160 * 161 * [88] Digit ::= ... long list see REC ... 162 */ 163#define IS_DIGIT(c) xmlIsDigitQ(c) 164 165/** 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/** 174 * IS_COMBINING: 175 * @c: an UNICODE value (int) 176 * 177 * Macro to check the following production in the XML spec: 178 * 179 * [87] CombiningChar ::= ... long list see REC ... 180 */ 181#define IS_COMBINING(c) xmlIsCombiningQ(c) 182 183/** 184 * IS_COMBINING_CH: 185 * @c: an xmlChar (usually an unsigned char) 186 * 187 * Always false (all combining chars > 0xff) 188 */ 189#define IS_COMBINING_CH(c) 0 190 191/** 192 * IS_EXTENDER: 193 * @c: an UNICODE value (int) 194 * 195 * Macro to check the following production in the XML spec: 196 * 197 * 198 * [89] Extender ::= #x00B7 | #x02D0 | #x02D1 | #x0387 | #x0640 | 199 * #x0E46 | #x0EC6 | #x3005 | [#x3031-#x3035] | 200 * [#x309D-#x309E] | [#x30FC-#x30FE] 201 */ 202#define IS_EXTENDER(c) xmlIsExtenderQ(c) 203 204/** 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/** 213 * IS_IDEOGRAPHIC: 214 * @c: an UNICODE value (int) 215 * 216 * Macro to check the following production in the XML spec: 217 * 218 * 219 * [86] Ideographic ::= [#x4E00-#x9FA5] | #x3007 | [#x3021-#x3029] 220 */ 221#define IS_IDEOGRAPHIC(c) xmlIsIdeographicQ(c) 222 223/** 224 * IS_LETTER: 225 * @c: an UNICODE value (int) 226 * 227 * Macro to check the following production in the XML spec: 228 * 229 * 230 * [84] Letter ::= BaseChar | Ideographic 231 */ 232#define IS_LETTER(c) (IS_BASECHAR(c) || IS_IDEOGRAPHIC(c)) 233 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) 242 243/** 244 * IS_ASCII_LETTER: 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/** 254 * IS_ASCII_DIGIT: 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 262/** 263 * IS_PUBIDCHAR: 264 * @c: an UNICODE value (int) 265 * 266 * Macro to check the following production in the XML spec: 267 * 268 * 269 * [13] PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%] 270 */ 271#define IS_PUBIDCHAR(c) xmlIsPubidCharQ(c) 272 273/** 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/** 282 * SKIP_EOL: 283 * @p: and UTF8 string pointer 284 * 285 * Skips the end of line chars. 286 */ 287#define SKIP_EOL(p) \ 288 if (*(p) == 0x13) { p++ ; if (*(p) == 0x10) p++; } \ 289 if (*(p) == 0x10) { p++ ; if (*(p) == 0x13) p++; } 290 291/** 292 * MOVETO_ENDTAG: 293 * @p: and UTF8 string pointer 294 * 295 * Skips to the next '>' char. 296 */ 297#define MOVETO_ENDTAG(p) \ 298 while ((*p) && (*(p) != '>')) (p)++ 299 300/** 301 * MOVETO_STARTTAG: 302 * @p: and UTF8 string pointer 303 * 304 * Skips to the next '<' char. 305 */ 306#define MOVETO_STARTTAG(p) \ 307 while ((*p) && (*(p) != '<')) (p)++ 308 309/** 310 * Global variables used for predefined strings. 311 */ 312XMLPUBVAR const xmlChar xmlStringText[]; 313XMLPUBVAR const xmlChar xmlStringTextNoenc[]; 314XMLPUBVAR const xmlChar xmlStringComment[]; 315 316/* 317 * Function to finish the work of the macros where needed. 318 */ 319XMLPUBFUN int XMLCALL xmlIsLetter (int c); 320 321/** 322 * Parser context. 323 */ 324XMLPUBFUN xmlParserCtxtPtr XMLCALL 325 xmlCreateFileParserCtxt (const char *filename); 326XMLPUBFUN xmlParserCtxtPtr XMLCALL 327 xmlCreateURLParserCtxt (const char *filename, 328 int options); 329XMLPUBFUN xmlParserCtxtPtr XMLCALL 330 xmlCreateMemoryParserCtxt(const char *buffer, 331 int size); 332XMLPUBFUN xmlParserCtxtPtr XMLCALL 333 xmlCreateEntityParserCtxt(const xmlChar *URL, 334 const xmlChar *ID, 335 const xmlChar *base); 336XMLPUBFUN int XMLCALL 337 xmlSwitchEncoding (xmlParserCtxtPtr ctxt, 338 xmlCharEncoding enc); 339XMLPUBFUN int XMLCALL 340 xmlSwitchToEncoding (xmlParserCtxtPtr ctxt, 341 xmlCharEncodingHandlerPtr handler); 342XMLPUBFUN int XMLCALL 343 xmlSwitchInputEncoding (xmlParserCtxtPtr ctxt, 344 xmlParserInputPtr input, 345 xmlCharEncodingHandlerPtr handler); 346 347#ifdef IN_LIBXML 348/* internal error reporting */ 349XMLPUBFUN void XMLCALL 350 __xmlErrEncoding (xmlParserCtxtPtr ctxt, 351 xmlParserErrors xmlerr, 352 const char *msg, 353 const xmlChar * str1, 354 const xmlChar * str2); 355#endif 356 357/** 358 * Input Streams. 359 */ 360XMLPUBFUN xmlParserInputPtr XMLCALL 361 xmlNewStringInputStream (xmlParserCtxtPtr ctxt, 362 const xmlChar *buffer); 363XMLPUBFUN xmlParserInputPtr XMLCALL 364 xmlNewEntityInputStream (xmlParserCtxtPtr ctxt, 365 xmlEntityPtr entity); 366XMLPUBFUN int XMLCALL 367 xmlPushInput (xmlParserCtxtPtr ctxt, 368 xmlParserInputPtr input); 369XMLPUBFUN xmlChar XMLCALL 370 xmlPopInput (xmlParserCtxtPtr ctxt); 371XMLPUBFUN void XMLCALL 372 xmlFreeInputStream (xmlParserInputPtr input); 373XMLPUBFUN xmlParserInputPtr XMLCALL 374 xmlNewInputFromFile (xmlParserCtxtPtr ctxt, 375 const char *filename); 376XMLPUBFUN xmlParserInputPtr XMLCALL 377 xmlNewInputStream (xmlParserCtxtPtr ctxt); 378 379/** 380 * Namespaces. 381 */ 382XMLPUBFUN xmlChar * XMLCALL 383 xmlSplitQName (xmlParserCtxtPtr ctxt, 384 const xmlChar *name, 385 xmlChar **prefix); 386 387/** 388 * Generic production rules. 389 */ 390XMLPUBFUN const xmlChar * XMLCALL 391 xmlParseName (xmlParserCtxtPtr ctxt); 392XMLPUBFUN xmlChar * XMLCALL 393 xmlParseNmtoken (xmlParserCtxtPtr ctxt); 394XMLPUBFUN xmlChar * XMLCALL 395 xmlParseEntityValue (xmlParserCtxtPtr ctxt, 396 xmlChar **orig); 397XMLPUBFUN xmlChar * XMLCALL 398 xmlParseAttValue (xmlParserCtxtPtr ctxt); 399XMLPUBFUN xmlChar * XMLCALL 400 xmlParseSystemLiteral (xmlParserCtxtPtr ctxt); 401XMLPUBFUN xmlChar * XMLCALL 402 xmlParsePubidLiteral (xmlParserCtxtPtr ctxt); 403XMLPUBFUN void XMLCALL 404 xmlParseCharData (xmlParserCtxtPtr ctxt, 405 int cdata); 406XMLPUBFUN xmlChar * XMLCALL 407 xmlParseExternalID (xmlParserCtxtPtr ctxt, 408 xmlChar **publicID, 409 int strict); 410XMLPUBFUN void XMLCALL 411 xmlParseComment (xmlParserCtxtPtr ctxt); 412XMLPUBFUN const xmlChar * XMLCALL 413 xmlParsePITarget (xmlParserCtxtPtr ctxt); 414XMLPUBFUN void XMLCALL 415 xmlParsePI (xmlParserCtxtPtr ctxt); 416XMLPUBFUN void XMLCALL 417 xmlParseNotationDecl (xmlParserCtxtPtr ctxt); 418XMLPUBFUN void XMLCALL 419 xmlParseEntityDecl (xmlParserCtxtPtr ctxt); 420XMLPUBFUN int XMLCALL 421 xmlParseDefaultDecl (xmlParserCtxtPtr ctxt, 422 xmlChar **value); 423XMLPUBFUN xmlEnumerationPtr XMLCALL 424 xmlParseNotationType (xmlParserCtxtPtr ctxt); 425XMLPUBFUN xmlEnumerationPtr XMLCALL 426 xmlParseEnumerationType (xmlParserCtxtPtr ctxt); 427XMLPUBFUN int XMLCALL 428 xmlParseEnumeratedType (xmlParserCtxtPtr ctxt, 429 xmlEnumerationPtr *tree); 430XMLPUBFUN int XMLCALL 431 xmlParseAttributeType (xmlParserCtxtPtr ctxt, 432 xmlEnumerationPtr *tree); 433XMLPUBFUN void XMLCALL 434 xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt); 435XMLPUBFUN xmlElementContentPtr XMLCALL 436 xmlParseElementMixedContentDecl 437 (xmlParserCtxtPtr ctxt, 438 int inputchk); 439XMLPUBFUN xmlElementContentPtr XMLCALL 440 xmlParseElementChildrenContentDecl 441 (xmlParserCtxtPtr ctxt, 442 int inputchk); 443XMLPUBFUN int XMLCALL 444 xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, 445 const xmlChar *name, 446 xmlElementContentPtr *result); 447XMLPUBFUN int XMLCALL 448 xmlParseElementDecl (xmlParserCtxtPtr ctxt); 449XMLPUBFUN void XMLCALL 450 xmlParseMarkupDecl (xmlParserCtxtPtr ctxt); 451XMLPUBFUN int XMLCALL 452 xmlParseCharRef (xmlParserCtxtPtr ctxt); 453XMLPUBFUN xmlEntityPtr XMLCALL 454 xmlParseEntityRef (xmlParserCtxtPtr ctxt); 455XMLPUBFUN void XMLCALL 456 xmlParseReference (xmlParserCtxtPtr ctxt); 457XMLPUBFUN void XMLCALL 458 xmlParsePEReference (xmlParserCtxtPtr ctxt); 459XMLPUBFUN void XMLCALL 460 xmlParseDocTypeDecl (xmlParserCtxtPtr ctxt); 461#ifdef LIBXML_SAX1_ENABLED 462XMLPUBFUN const xmlChar * XMLCALL 463 xmlParseAttribute (xmlParserCtxtPtr ctxt, 464 xmlChar **value); 465XMLPUBFUN const xmlChar * XMLCALL 466 xmlParseStartTag (xmlParserCtxtPtr ctxt); 467XMLPUBFUN void XMLCALL 468 xmlParseEndTag (xmlParserCtxtPtr ctxt); 469#endif /* LIBXML_SAX1_ENABLED */ 470XMLPUBFUN void XMLCALL 471 xmlParseCDSect (xmlParserCtxtPtr ctxt); 472XMLPUBFUN void XMLCALL 473 xmlParseContent (xmlParserCtxtPtr ctxt); 474XMLPUBFUN void XMLCALL 475 xmlParseElement (xmlParserCtxtPtr ctxt); 476XMLPUBFUN xmlChar * XMLCALL 477 xmlParseVersionNum (xmlParserCtxtPtr ctxt); 478XMLPUBFUN xmlChar * XMLCALL 479 xmlParseVersionInfo (xmlParserCtxtPtr ctxt); 480XMLPUBFUN xmlChar * XMLCALL 481 xmlParseEncName (xmlParserCtxtPtr ctxt); 482XMLPUBFUN const xmlChar * XMLCALL 483 xmlParseEncodingDecl (xmlParserCtxtPtr ctxt); 484XMLPUBFUN int XMLCALL 485 xmlParseSDDecl (xmlParserCtxtPtr ctxt); 486XMLPUBFUN void XMLCALL 487 xmlParseXMLDecl (xmlParserCtxtPtr ctxt); 488XMLPUBFUN void XMLCALL 489 xmlParseTextDecl (xmlParserCtxtPtr ctxt); 490XMLPUBFUN void XMLCALL 491 xmlParseMisc (xmlParserCtxtPtr ctxt); 492XMLPUBFUN void XMLCALL 493 xmlParseExternalSubset (xmlParserCtxtPtr ctxt, 494 const xmlChar *ExternalID, 495 const xmlChar *SystemID); 496/** 497 * XML_SUBSTITUTE_NONE: 498 * 499 * If no entities need to be substituted. 500 */ 501#define XML_SUBSTITUTE_NONE 0 502/** 503 * XML_SUBSTITUTE_REF: 504 * 505 * Whether general entities need to be substituted. 506 */ 507#define XML_SUBSTITUTE_REF 1 508/** 509 * XML_SUBSTITUTE_PEREF: 510 * 511 * Whether parameter entities need to be substituted. 512 */ 513#define XML_SUBSTITUTE_PEREF 2 514/** 515 * XML_SUBSTITUTE_BOTH: 516 * 517 * Both general and parameter entities need to be substituted. 518 */ 519#define XML_SUBSTITUTE_BOTH 3 520 521XMLPUBFUN xmlChar * XMLCALL 522 xmlStringDecodeEntities (xmlParserCtxtPtr ctxt, 523 const xmlChar *str, 524 int what, 525 xmlChar end, 526 xmlChar end2, 527 xmlChar end3); 528XMLPUBFUN 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); 536 537/* 538 * Generated by MACROS on top of parser.c c.f. PUSH_AND_POP. 539 */ 540XMLPUBFUN int XMLCALL nodePush (xmlParserCtxtPtr ctxt, 541 xmlNodePtr value); 542XMLPUBFUN xmlNodePtr XMLCALL nodePop (xmlParserCtxtPtr ctxt); 543XMLPUBFUN int XMLCALL inputPush (xmlParserCtxtPtr ctxt, 544 xmlParserInputPtr value); 545XMLPUBFUN xmlParserInputPtr XMLCALL inputPop (xmlParserCtxtPtr ctxt); 546XMLPUBFUN const xmlChar * XMLCALL namePop (xmlParserCtxtPtr ctxt); 547XMLPUBFUN int XMLCALL namePush (xmlParserCtxtPtr ctxt, 548 const xmlChar *value); 549 550/* 551 * other commodities shared between parser.c and parserInternals. 552 */ 553XMLPUBFUN int XMLCALL xmlSkipBlankChars (xmlParserCtxtPtr ctxt); 554XMLPUBFUN int XMLCALL xmlStringCurrentChar (xmlParserCtxtPtr ctxt, 555 const xmlChar *cur, 556 int *len); 557XMLPUBFUN void XMLCALL xmlParserHandlePEReference(xmlParserCtxtPtr ctxt); 558XMLPUBFUN int XMLCALL xmlCheckLanguageID (const xmlChar *lang); 559 560/* 561 * Really core function shared with HTML parser. 562 */ 563XMLPUBFUN int XMLCALL xmlCurrentChar (xmlParserCtxtPtr ctxt, 564 int *len); 565XMLPUBFUN int XMLCALL xmlCopyCharMultiByte (xmlChar *out, 566 int val); 567XMLPUBFUN int XMLCALL xmlCopyChar (int len, 568 xmlChar *out, 569 int val); 570XMLPUBFUN void XMLCALL xmlNextChar (xmlParserCtxtPtr ctxt); 571XMLPUBFUN void XMLCALL xmlParserInputShrink (xmlParserInputPtr in); 572 573#ifdef LIBXML_HTML_ENABLED 574/* 575 * Actually comes from the HTML parser but launched from the init stuff. 576 */ 577XMLPUBFUN void XMLCALL htmlInitAutoClose (void); 578XMLPUBFUN htmlParserCtxtPtr XMLCALL htmlCreateFileParserCtxt(const char *filename, 579 const char *encoding); 580#endif 581 582/* 583 * Specific function to keep track of entities references 584 * and used by the XSLT debugger. 585 */ 586#ifdef LIBXML_LEGACY_ENABLED 587/** 588 * xmlEntityReferenceFunc: 589 * @ent: the entity 590 * @firstNode: the fist node in the chunk 591 * @lastNode: the last nod in the chunk 592 * 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. 595 */ 596typedef void (*xmlEntityReferenceFunc) (xmlEntityPtr ent, 597 xmlNodePtr firstNode, 598 xmlNodePtr lastNode); 599 600XMLPUBFUN void XMLCALL xmlSetEntityReferenceFunc (xmlEntityReferenceFunc func); 601 602XMLPUBFUN xmlChar * XMLCALL 603 xmlParseQuotedString (xmlParserCtxtPtr ctxt); 604XMLPUBFUN void XMLCALL 605 xmlParseNamespace (xmlParserCtxtPtr ctxt); 606XMLPUBFUN xmlChar * XMLCALL 607 xmlNamespaceParseNSDef (xmlParserCtxtPtr ctxt); 608XMLPUBFUN xmlChar * XMLCALL 609 xmlScanName (xmlParserCtxtPtr ctxt); 610XMLPUBFUN xmlChar * XMLCALL 611 xmlNamespaceParseNCName (xmlParserCtxtPtr ctxt); 612XMLPUBFUN void XMLCALL xmlParserHandleReference(xmlParserCtxtPtr ctxt); 613XMLPUBFUN xmlChar * XMLCALL 614 xmlNamespaceParseQName (xmlParserCtxtPtr ctxt, 615 xmlChar **prefix); 616/** 617 * Entities 618 */ 619XMLPUBFUN xmlChar * XMLCALL 620 xmlDecodeEntities (xmlParserCtxtPtr ctxt, 621 int len, 622 int what, 623 xmlChar end, 624 xmlChar end2, 625 xmlChar end3); 626XMLPUBFUN void XMLCALL 627 xmlHandleEntity (xmlParserCtxtPtr ctxt, 628 xmlEntityPtr entity); 629 630#endif /* LIBXML_LEGACY_ENABLED */ 631 632#ifdef IN_LIBXML 633/* 634 * internal only 635 */ 636XMLPUBFUN void XMLCALL 637 xmlErrMemory (xmlParserCtxtPtr ctxt, 638 const char *extra); 639#endif 640 641#ifdef __cplusplus 642} 643#endif 644#endif /* __XML_PARSER_INTERNALS_H__ */ 645