Home | History | Annotate | Download | only in libxml
      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
     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  * 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  */
    312 XMLPUBVAR const xmlChar xmlStringText[];
    313 XMLPUBVAR const xmlChar xmlStringTextNoenc[];
    314 XMLPUBVAR const xmlChar xmlStringComment[];
    315 
    316 /*
    317  * Function to finish the work of the macros where needed.
    318  */
    319 XMLPUBFUN int XMLCALL                   xmlIsLetter     (int c);
    320 
    321 /**
    322  * Parser context.
    323  */
    324 XMLPUBFUN xmlParserCtxtPtr XMLCALL
    325 			xmlCreateFileParserCtxt	(const char *filename);
    326 XMLPUBFUN xmlParserCtxtPtr XMLCALL
    327 			xmlCreateURLParserCtxt	(const char *filename,
    328 						 int options);
    329 XMLPUBFUN xmlParserCtxtPtr XMLCALL
    330 			xmlCreateMemoryParserCtxt(const char *buffer,
    331 						 int size);
    332 XMLPUBFUN xmlParserCtxtPtr XMLCALL
    333 			xmlCreateEntityParserCtxt(const xmlChar *URL,
    334 						 const xmlChar *ID,
    335 						 const xmlChar *base);
    336 XMLPUBFUN int XMLCALL
    337 			xmlSwitchEncoding	(xmlParserCtxtPtr ctxt,
    338 						 xmlCharEncoding enc);
    339 XMLPUBFUN int XMLCALL
    340 			xmlSwitchToEncoding	(xmlParserCtxtPtr ctxt,
    341 					 xmlCharEncodingHandlerPtr handler);
    342 XMLPUBFUN int XMLCALL
    343 			xmlSwitchInputEncoding	(xmlParserCtxtPtr ctxt,
    344 						 xmlParserInputPtr input,
    345 					 xmlCharEncodingHandlerPtr handler);
    346 
    347 #ifdef IN_LIBXML
    348 /* internal error reporting */
    349 XMLPUBFUN 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  */
    360 XMLPUBFUN xmlParserInputPtr XMLCALL
    361 			xmlNewStringInputStream	(xmlParserCtxtPtr ctxt,
    362 						 const xmlChar *buffer);
    363 XMLPUBFUN xmlParserInputPtr XMLCALL
    364 			xmlNewEntityInputStream	(xmlParserCtxtPtr ctxt,
    365 						 xmlEntityPtr entity);
    366 XMLPUBFUN int XMLCALL
    367 			xmlPushInput		(xmlParserCtxtPtr ctxt,
    368 						 xmlParserInputPtr input);
    369 XMLPUBFUN xmlChar XMLCALL
    370 			xmlPopInput		(xmlParserCtxtPtr ctxt);
    371 XMLPUBFUN void XMLCALL
    372 			xmlFreeInputStream	(xmlParserInputPtr input);
    373 XMLPUBFUN xmlParserInputPtr XMLCALL
    374 			xmlNewInputFromFile	(xmlParserCtxtPtr ctxt,
    375 						 const char *filename);
    376 XMLPUBFUN xmlParserInputPtr XMLCALL
    377 			xmlNewInputStream	(xmlParserCtxtPtr ctxt);
    378 
    379 /**
    380  * Namespaces.
    381  */
    382 XMLPUBFUN xmlChar * XMLCALL
    383 			xmlSplitQName		(xmlParserCtxtPtr ctxt,
    384 						 const xmlChar *name,
    385 						 xmlChar **prefix);
    386 
    387 /**
    388  * Generic production rules.
    389  */
    390 XMLPUBFUN const xmlChar * XMLCALL
    391 			xmlParseName		(xmlParserCtxtPtr ctxt);
    392 XMLPUBFUN xmlChar * XMLCALL
    393 			xmlParseNmtoken		(xmlParserCtxtPtr ctxt);
    394 XMLPUBFUN xmlChar * XMLCALL
    395 			xmlParseEntityValue	(xmlParserCtxtPtr ctxt,
    396 						 xmlChar **orig);
    397 XMLPUBFUN xmlChar * XMLCALL
    398 			xmlParseAttValue	(xmlParserCtxtPtr ctxt);
    399 XMLPUBFUN xmlChar * XMLCALL
    400 			xmlParseSystemLiteral	(xmlParserCtxtPtr ctxt);
    401 XMLPUBFUN xmlChar * XMLCALL
    402 			xmlParsePubidLiteral	(xmlParserCtxtPtr ctxt);
    403 XMLPUBFUN void XMLCALL
    404 			xmlParseCharData	(xmlParserCtxtPtr ctxt,
    405 						 int cdata);
    406 XMLPUBFUN xmlChar * XMLCALL
    407 			xmlParseExternalID	(xmlParserCtxtPtr ctxt,
    408 						 xmlChar **publicID,
    409 						 int strict);
    410 XMLPUBFUN void XMLCALL
    411 			xmlParseComment		(xmlParserCtxtPtr ctxt);
    412 XMLPUBFUN const xmlChar * XMLCALL
    413 			xmlParsePITarget	(xmlParserCtxtPtr ctxt);
    414 XMLPUBFUN void XMLCALL
    415 			xmlParsePI		(xmlParserCtxtPtr ctxt);
    416 XMLPUBFUN void XMLCALL
    417 			xmlParseNotationDecl	(xmlParserCtxtPtr ctxt);
    418 XMLPUBFUN void XMLCALL
    419 			xmlParseEntityDecl	(xmlParserCtxtPtr ctxt);
    420 XMLPUBFUN int XMLCALL
    421 			xmlParseDefaultDecl	(xmlParserCtxtPtr ctxt,
    422 						 xmlChar **value);
    423 XMLPUBFUN xmlEnumerationPtr XMLCALL
    424 			xmlParseNotationType	(xmlParserCtxtPtr ctxt);
    425 XMLPUBFUN xmlEnumerationPtr XMLCALL
    426 			xmlParseEnumerationType	(xmlParserCtxtPtr ctxt);
    427 XMLPUBFUN int XMLCALL
    428 			xmlParseEnumeratedType	(xmlParserCtxtPtr ctxt,
    429 						 xmlEnumerationPtr *tree);
    430 XMLPUBFUN int XMLCALL
    431 			xmlParseAttributeType	(xmlParserCtxtPtr ctxt,
    432 						 xmlEnumerationPtr *tree);
    433 XMLPUBFUN void XMLCALL
    434 			xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt);
    435 XMLPUBFUN xmlElementContentPtr XMLCALL
    436 			xmlParseElementMixedContentDecl
    437 						(xmlParserCtxtPtr ctxt,
    438 						 int inputchk);
    439 XMLPUBFUN xmlElementContentPtr XMLCALL
    440 			xmlParseElementChildrenContentDecl
    441 						(xmlParserCtxtPtr ctxt,
    442 						 int inputchk);
    443 XMLPUBFUN int XMLCALL
    444 			xmlParseElementContentDecl(xmlParserCtxtPtr ctxt,
    445 						 const xmlChar *name,
    446 						 xmlElementContentPtr *result);
    447 XMLPUBFUN int XMLCALL
    448 			xmlParseElementDecl	(xmlParserCtxtPtr ctxt);
    449 XMLPUBFUN void XMLCALL
    450 			xmlParseMarkupDecl	(xmlParserCtxtPtr ctxt);
    451 XMLPUBFUN int XMLCALL
    452 			xmlParseCharRef		(xmlParserCtxtPtr ctxt);
    453 XMLPUBFUN xmlEntityPtr XMLCALL
    454 			xmlParseEntityRef	(xmlParserCtxtPtr ctxt);
    455 XMLPUBFUN void XMLCALL
    456 			xmlParseReference	(xmlParserCtxtPtr ctxt);
    457 XMLPUBFUN void XMLCALL
    458 			xmlParsePEReference	(xmlParserCtxtPtr ctxt);
    459 XMLPUBFUN void XMLCALL
    460 			xmlParseDocTypeDecl	(xmlParserCtxtPtr ctxt);
    461 #ifdef LIBXML_SAX1_ENABLED
    462 XMLPUBFUN const xmlChar * XMLCALL
    463 			xmlParseAttribute	(xmlParserCtxtPtr ctxt,
    464 						 xmlChar **value);
    465 XMLPUBFUN const xmlChar * XMLCALL
    466 			xmlParseStartTag	(xmlParserCtxtPtr ctxt);
    467 XMLPUBFUN void XMLCALL
    468 			xmlParseEndTag		(xmlParserCtxtPtr ctxt);
    469 #endif /* LIBXML_SAX1_ENABLED */
    470 XMLPUBFUN void XMLCALL
    471 			xmlParseCDSect		(xmlParserCtxtPtr ctxt);
    472 XMLPUBFUN void XMLCALL
    473 			xmlParseContent		(xmlParserCtxtPtr ctxt);
    474 XMLPUBFUN void XMLCALL
    475 			xmlParseElement		(xmlParserCtxtPtr ctxt);
    476 XMLPUBFUN xmlChar * XMLCALL
    477 			xmlParseVersionNum	(xmlParserCtxtPtr ctxt);
    478 XMLPUBFUN xmlChar * XMLCALL
    479 			xmlParseVersionInfo	(xmlParserCtxtPtr ctxt);
    480 XMLPUBFUN xmlChar * XMLCALL
    481 			xmlParseEncName		(xmlParserCtxtPtr ctxt);
    482 XMLPUBFUN const xmlChar * XMLCALL
    483 			xmlParseEncodingDecl	(xmlParserCtxtPtr ctxt);
    484 XMLPUBFUN int XMLCALL
    485 			xmlParseSDDecl		(xmlParserCtxtPtr ctxt);
    486 XMLPUBFUN void XMLCALL
    487 			xmlParseXMLDecl		(xmlParserCtxtPtr ctxt);
    488 XMLPUBFUN void XMLCALL
    489 			xmlParseTextDecl	(xmlParserCtxtPtr ctxt);
    490 XMLPUBFUN void XMLCALL
    491 			xmlParseMisc		(xmlParserCtxtPtr ctxt);
    492 XMLPUBFUN 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 
    521 XMLPUBFUN xmlChar * XMLCALL
    522 		xmlStringDecodeEntities		(xmlParserCtxtPtr ctxt,
    523 						 const xmlChar *str,
    524 						 int what,
    525 						 xmlChar end,
    526 						 xmlChar  end2,
    527 						 xmlChar end3);
    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);
    536 
    537 /*
    538  * Generated by MACROS on top of parser.c c.f. PUSH_AND_POP.
    539  */
    540 XMLPUBFUN int XMLCALL			nodePush		(xmlParserCtxtPtr ctxt,
    541 						 xmlNodePtr value);
    542 XMLPUBFUN xmlNodePtr XMLCALL		nodePop			(xmlParserCtxtPtr ctxt);
    543 XMLPUBFUN int XMLCALL			inputPush		(xmlParserCtxtPtr ctxt,
    544 						 xmlParserInputPtr value);
    545 XMLPUBFUN xmlParserInputPtr XMLCALL	inputPop		(xmlParserCtxtPtr ctxt);
    546 XMLPUBFUN const xmlChar * XMLCALL	namePop			(xmlParserCtxtPtr ctxt);
    547 XMLPUBFUN int XMLCALL			namePush		(xmlParserCtxtPtr ctxt,
    548 						 const xmlChar *value);
    549 
    550 /*
    551  * other commodities shared between parser.c and parserInternals.
    552  */
    553 XMLPUBFUN int XMLCALL			xmlSkipBlankChars	(xmlParserCtxtPtr ctxt);
    554 XMLPUBFUN int XMLCALL			xmlStringCurrentChar	(xmlParserCtxtPtr ctxt,
    555 						 const xmlChar *cur,
    556 						 int *len);
    557 XMLPUBFUN void XMLCALL			xmlParserHandlePEReference(xmlParserCtxtPtr ctxt);
    558 XMLPUBFUN int XMLCALL			xmlCheckLanguageID	(const xmlChar *lang);
    559 
    560 /*
    561  * Really core function shared with HTML parser.
    562  */
    563 XMLPUBFUN int XMLCALL			xmlCurrentChar		(xmlParserCtxtPtr ctxt,
    564 						 int *len);
    565 XMLPUBFUN int XMLCALL		xmlCopyCharMultiByte	(xmlChar *out,
    566 						 int val);
    567 XMLPUBFUN int XMLCALL			xmlCopyChar		(int len,
    568 						 xmlChar *out,
    569 						 int val);
    570 XMLPUBFUN void XMLCALL			xmlNextChar		(xmlParserCtxtPtr ctxt);
    571 XMLPUBFUN 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  */
    577 XMLPUBFUN void XMLCALL			htmlInitAutoClose	(void);
    578 XMLPUBFUN 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  */
    596 typedef	void	(*xmlEntityReferenceFunc)	(xmlEntityPtr ent,
    597 						 xmlNodePtr firstNode,
    598 						 xmlNodePtr lastNode);
    599 
    600 XMLPUBFUN void XMLCALL		xmlSetEntityReferenceFunc	(xmlEntityReferenceFunc func);
    601 
    602 XMLPUBFUN xmlChar * XMLCALL
    603 			xmlParseQuotedString	(xmlParserCtxtPtr ctxt);
    604 XMLPUBFUN void XMLCALL
    605                         xmlParseNamespace       (xmlParserCtxtPtr ctxt);
    606 XMLPUBFUN xmlChar * XMLCALL
    607 			xmlNamespaceParseNSDef	(xmlParserCtxtPtr ctxt);
    608 XMLPUBFUN xmlChar * XMLCALL
    609 			xmlScanName		(xmlParserCtxtPtr ctxt);
    610 XMLPUBFUN xmlChar * XMLCALL
    611 			xmlNamespaceParseNCName	(xmlParserCtxtPtr ctxt);
    612 XMLPUBFUN void XMLCALL	xmlParserHandleReference(xmlParserCtxtPtr ctxt);
    613 XMLPUBFUN xmlChar * XMLCALL
    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);
    626 XMLPUBFUN 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  */
    636 XMLPUBFUN 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