include/libxml/parserInternals.h

   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__ */