1 /* 2 * parserInternals.c : Internal routines (and obsolete ones) needed for the 3 * XML and HTML parsers. 4 * 5 * See Copyright for the status of this software. 6 * 7 * daniel (at) veillard.com 8 */ 9 10 #define IN_LIBXML 11 #include "libxml.h" 12 13 #if defined(WIN32) && !defined (__CYGWIN__) 14 #define XML_DIR_SEP '\\' 15 #else 16 #define XML_DIR_SEP '/' 17 #endif 18 19 #include <string.h> 20 #ifdef HAVE_CTYPE_H 21 #include <ctype.h> 22 #endif 23 #ifdef HAVE_STDLIB_H 24 #include <stdlib.h> 25 #endif 26 #ifdef HAVE_SYS_STAT_H 27 #include <sys/stat.h> 28 #endif 29 #ifdef HAVE_FCNTL_H 30 #include <fcntl.h> 31 #endif 32 #ifdef HAVE_UNISTD_H 33 #include <unistd.h> 34 #endif 35 #ifdef HAVE_ZLIB_H 36 #include <zlib.h> 37 #endif 38 39 #include <libxml/xmlmemory.h> 40 #include <libxml/tree.h> 41 #include <libxml/parser.h> 42 #include <libxml/parserInternals.h> 43 #include <libxml/valid.h> 44 #include <libxml/entities.h> 45 #include <libxml/xmlerror.h> 46 #include <libxml/encoding.h> 47 #include <libxml/valid.h> 48 #include <libxml/xmlIO.h> 49 #include <libxml/uri.h> 50 #include <libxml/dict.h> 51 #include <libxml/SAX.h> 52 #ifdef LIBXML_CATALOG_ENABLED 53 #include <libxml/catalog.h> 54 #endif 55 #include <libxml/globals.h> 56 #include <libxml/chvalid.h> 57 58 /* 59 * Various global defaults for parsing 60 */ 61 62 /** 63 * xmlCheckVersion: 64 * @version: the include version number 65 * 66 * check the compiled lib version against the include one. 67 * This can warn or immediately kill the application 68 */ 69 void 70 xmlCheckVersion(int version) { 71 int myversion = (int) LIBXML_VERSION; 72 73 xmlInitParser(); 74 75 if ((myversion / 10000) != (version / 10000)) { 76 xmlGenericError(xmlGenericErrorContext, 77 "Fatal: program compiled against libxml %d using libxml %d\n", 78 (version / 10000), (myversion / 10000)); 79 fprintf(stderr, 80 "Fatal: program compiled against libxml %d using libxml %d\n", 81 (version / 10000), (myversion / 10000)); 82 } 83 if ((myversion / 100) < (version / 100)) { 84 xmlGenericError(xmlGenericErrorContext, 85 "Warning: program compiled against libxml %d using older %d\n", 86 (version / 100), (myversion / 100)); 87 } 88 } 89 90 91 /************************************************************************ 92 * * 93 * Some factorized error routines * 94 * * 95 ************************************************************************/ 96 97 98 /** 99 * xmlErrMemory: 100 * @ctxt: an XML parser context 101 * @extra: extra informations 102 * 103 * Handle a redefinition of attribute error 104 */ 105 void 106 xmlErrMemory(xmlParserCtxtPtr ctxt, const char *extra) 107 { 108 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 109 (ctxt->instate == XML_PARSER_EOF)) 110 return; 111 if (ctxt != NULL) { 112 ctxt->errNo = XML_ERR_NO_MEMORY; 113 ctxt->instate = XML_PARSER_EOF; 114 ctxt->disableSAX = 1; 115 } 116 if (extra) 117 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, 118 XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra, 119 NULL, NULL, 0, 0, 120 "Memory allocation failed : %s\n", extra); 121 else 122 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, 123 XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL, 124 NULL, NULL, 0, 0, "Memory allocation failed\n"); 125 } 126 127 /** 128 * __xmlErrEncoding: 129 * @ctxt: an XML parser context 130 * @xmlerr: the error number 131 * @msg: the error message 132 * @str1: an string info 133 * @str2: an string info 134 * 135 * Handle an encoding error 136 */ 137 void 138 __xmlErrEncoding(xmlParserCtxtPtr ctxt, xmlParserErrors xmlerr, 139 const char *msg, const xmlChar * str1, const xmlChar * str2) 140 { 141 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 142 (ctxt->instate == XML_PARSER_EOF)) 143 return; 144 if (ctxt != NULL) 145 ctxt->errNo = xmlerr; 146 __xmlRaiseError(NULL, NULL, NULL, 147 ctxt, NULL, XML_FROM_PARSER, xmlerr, XML_ERR_FATAL, 148 NULL, 0, (const char *) str1, (const char *) str2, 149 NULL, 0, 0, msg, str1, str2); 150 if (ctxt != NULL) { 151 ctxt->wellFormed = 0; 152 if (ctxt->recovery == 0) 153 ctxt->disableSAX = 1; 154 } 155 } 156 157 /** 158 * xmlErrInternal: 159 * @ctxt: an XML parser context 160 * @msg: the error message 161 * @str: error informations 162 * 163 * Handle an internal error 164 */ 165 static void 166 xmlErrInternal(xmlParserCtxtPtr ctxt, const char *msg, const xmlChar * str) 167 { 168 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 169 (ctxt->instate == XML_PARSER_EOF)) 170 return; 171 if (ctxt != NULL) 172 ctxt->errNo = XML_ERR_INTERNAL_ERROR; 173 __xmlRaiseError(NULL, NULL, NULL, 174 ctxt, NULL, XML_FROM_PARSER, XML_ERR_INTERNAL_ERROR, 175 XML_ERR_FATAL, NULL, 0, (const char *) str, NULL, NULL, 176 0, 0, msg, str); 177 if (ctxt != NULL) { 178 ctxt->wellFormed = 0; 179 if (ctxt->recovery == 0) 180 ctxt->disableSAX = 1; 181 } 182 } 183 184 /** 185 * xmlErrEncodingInt: 186 * @ctxt: an XML parser context 187 * @error: the error number 188 * @msg: the error message 189 * @val: an integer value 190 * 191 * n encoding error 192 */ 193 static void 194 xmlErrEncodingInt(xmlParserCtxtPtr ctxt, xmlParserErrors error, 195 const char *msg, int val) 196 { 197 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 198 (ctxt->instate == XML_PARSER_EOF)) 199 return; 200 if (ctxt != NULL) 201 ctxt->errNo = error; 202 __xmlRaiseError(NULL, NULL, NULL, 203 ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL, 204 NULL, 0, NULL, NULL, NULL, val, 0, msg, val); 205 if (ctxt != NULL) { 206 ctxt->wellFormed = 0; 207 if (ctxt->recovery == 0) 208 ctxt->disableSAX = 1; 209 } 210 } 211 212 /** 213 * xmlIsLetter: 214 * @c: an unicode character (int) 215 * 216 * Check whether the character is allowed by the production 217 * [84] Letter ::= BaseChar | Ideographic 218 * 219 * Returns 0 if not, non-zero otherwise 220 */ 221 int 222 xmlIsLetter(int c) { 223 return(IS_BASECHAR(c) || IS_IDEOGRAPHIC(c)); 224 } 225 226 /************************************************************************ 227 * * 228 * Input handling functions for progressive parsing * 229 * * 230 ************************************************************************/ 231 232 /* #define DEBUG_INPUT */ 233 /* #define DEBUG_STACK */ 234 /* #define DEBUG_PUSH */ 235 236 237 /* we need to keep enough input to show errors in context */ 238 #define LINE_LEN 80 239 240 #ifdef DEBUG_INPUT 241 #define CHECK_BUFFER(in) check_buffer(in) 242 243 static 244 void check_buffer(xmlParserInputPtr in) { 245 if (in->base != in->buf->buffer->content) { 246 xmlGenericError(xmlGenericErrorContext, 247 "xmlParserInput: base mismatch problem\n"); 248 } 249 if (in->cur < in->base) { 250 xmlGenericError(xmlGenericErrorContext, 251 "xmlParserInput: cur < base problem\n"); 252 } 253 if (in->cur > in->base + in->buf->buffer->use) { 254 xmlGenericError(xmlGenericErrorContext, 255 "xmlParserInput: cur > base + use problem\n"); 256 } 257 xmlGenericError(xmlGenericErrorContext,"buffer %x : content %x, cur %d, use %d, size %d\n", 258 (int) in, (int) in->buf->buffer->content, in->cur - in->base, 259 in->buf->buffer->use, in->buf->buffer->size); 260 } 261 262 #else 263 #define CHECK_BUFFER(in) 264 #endif 265 266 267 /** 268 * xmlParserInputRead: 269 * @in: an XML parser input 270 * @len: an indicative size for the lookahead 271 * 272 * This function refresh the input for the parser. It doesn't try to 273 * preserve pointers to the input buffer, and discard already read data 274 * 275 * Returns the number of xmlChars read, or -1 in case of error, 0 indicate the 276 * end of this entity 277 */ 278 int 279 xmlParserInputRead(xmlParserInputPtr in, int len) { 280 int ret; 281 int used; 282 int indx; 283 284 if (in == NULL) return(-1); 285 #ifdef DEBUG_INPUT 286 xmlGenericError(xmlGenericErrorContext, "Read\n"); 287 #endif 288 if (in->buf == NULL) return(-1); 289 if (in->base == NULL) return(-1); 290 if (in->cur == NULL) return(-1); 291 if (in->buf->buffer == NULL) return(-1); 292 if (in->buf->readcallback == NULL) return(-1); 293 294 CHECK_BUFFER(in); 295 296 used = in->cur - in->buf->buffer->content; 297 ret = xmlBufferShrink(in->buf->buffer, used); 298 if (ret > 0) { 299 in->cur -= ret; 300 in->consumed += ret; 301 } 302 ret = xmlParserInputBufferRead(in->buf, len); 303 if (in->base != in->buf->buffer->content) { 304 /* 305 * the buffer has been reallocated 306 */ 307 indx = in->cur - in->base; 308 in->base = in->buf->buffer->content; 309 in->cur = &in->buf->buffer->content[indx]; 310 } 311 in->end = &in->buf->buffer->content[in->buf->buffer->use]; 312 313 CHECK_BUFFER(in); 314 315 return(ret); 316 } 317 318 /** 319 * xmlParserInputGrow: 320 * @in: an XML parser input 321 * @len: an indicative size for the lookahead 322 * 323 * This function increase the input for the parser. It tries to 324 * preserve pointers to the input buffer, and keep already read data 325 * 326 * Returns the number of xmlChars read, or -1 in case of error, 0 indicate the 327 * end of this entity 328 */ 329 int 330 xmlParserInputGrow(xmlParserInputPtr in, int len) { 331 int ret; 332 int indx; 333 334 if (in == NULL) return(-1); 335 #ifdef DEBUG_INPUT 336 xmlGenericError(xmlGenericErrorContext, "Grow\n"); 337 #endif 338 if (in->buf == NULL) return(-1); 339 if (in->base == NULL) return(-1); 340 if (in->cur == NULL) return(-1); 341 if (in->buf->buffer == NULL) return(-1); 342 343 CHECK_BUFFER(in); 344 345 indx = in->cur - in->base; 346 if (in->buf->buffer->use > (unsigned int) indx + INPUT_CHUNK) { 347 348 CHECK_BUFFER(in); 349 350 return(0); 351 } 352 if (in->buf->readcallback != NULL) 353 ret = xmlParserInputBufferGrow(in->buf, len); 354 else 355 return(0); 356 357 /* 358 * NOTE : in->base may be a "dangling" i.e. freed pointer in this 359 * block, but we use it really as an integer to do some 360 * pointer arithmetic. Insure will raise it as a bug but in 361 * that specific case, that's not ! 362 */ 363 if (in->base != in->buf->buffer->content) { 364 /* 365 * the buffer has been reallocated 366 */ 367 indx = in->cur - in->base; 368 in->base = in->buf->buffer->content; 369 in->cur = &in->buf->buffer->content[indx]; 370 } 371 in->end = &in->buf->buffer->content[in->buf->buffer->use]; 372 373 CHECK_BUFFER(in); 374 375 return(ret); 376 } 377 378 /** 379 * xmlParserInputShrink: 380 * @in: an XML parser input 381 * 382 * This function removes used input for the parser. 383 */ 384 void 385 xmlParserInputShrink(xmlParserInputPtr in) { 386 int used; 387 int ret; 388 int indx; 389 390 #ifdef DEBUG_INPUT 391 xmlGenericError(xmlGenericErrorContext, "Shrink\n"); 392 #endif 393 if (in == NULL) return; 394 if (in->buf == NULL) return; 395 if (in->base == NULL) return; 396 if (in->cur == NULL) return; 397 if (in->buf->buffer == NULL) return; 398 399 CHECK_BUFFER(in); 400 401 used = in->cur - in->buf->buffer->content; 402 /* 403 * Do not shrink on large buffers whose only a tiny fraction 404 * was consumed 405 */ 406 if (used > INPUT_CHUNK) { 407 ret = xmlBufferShrink(in->buf->buffer, used - LINE_LEN); 408 if (ret > 0) { 409 in->cur -= ret; 410 in->consumed += ret; 411 } 412 in->end = &in->buf->buffer->content[in->buf->buffer->use]; 413 } 414 415 CHECK_BUFFER(in); 416 417 if (in->buf->buffer->use > INPUT_CHUNK) { 418 return; 419 } 420 xmlParserInputBufferRead(in->buf, 2 * INPUT_CHUNK); 421 if (in->base != in->buf->buffer->content) { 422 /* 423 * the buffer has been reallocated 424 */ 425 indx = in->cur - in->base; 426 in->base = in->buf->buffer->content; 427 in->cur = &in->buf->buffer->content[indx]; 428 } 429 in->end = &in->buf->buffer->content[in->buf->buffer->use]; 430 431 CHECK_BUFFER(in); 432 } 433 434 /************************************************************************ 435 * * 436 * UTF8 character input and related functions * 437 * * 438 ************************************************************************/ 439 440 /** 441 * xmlNextChar: 442 * @ctxt: the XML parser context 443 * 444 * Skip to the next char input char. 445 */ 446 447 void 448 xmlNextChar(xmlParserCtxtPtr ctxt) 449 { 450 if ((ctxt == NULL) || (ctxt->instate == XML_PARSER_EOF) || 451 (ctxt->input == NULL)) 452 return; 453 454 if (ctxt->charset == XML_CHAR_ENCODING_UTF8) { 455 if ((*ctxt->input->cur == 0) && 456 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0) && 457 (ctxt->instate != XML_PARSER_COMMENT)) { 458 /* 459 * If we are at the end of the current entity and 460 * the context allows it, we pop consumed entities 461 * automatically. 462 * the auto closing should be blocked in other cases 463 */ 464 xmlPopInput(ctxt); 465 } else { 466 const unsigned char *cur; 467 unsigned char c; 468 469 /* 470 * 2.11 End-of-Line Handling 471 * the literal two-character sequence "#xD#xA" or a standalone 472 * literal #xD, an XML processor must pass to the application 473 * the single character #xA. 474 */ 475 if (*(ctxt->input->cur) == '\n') { 476 ctxt->input->line++; ctxt->input->col = 1; 477 } else 478 ctxt->input->col++; 479 480 /* 481 * We are supposed to handle UTF8, check it's valid 482 * From rfc2044: encoding of the Unicode values on UTF-8: 483 * 484 * UCS-4 range (hex.) UTF-8 octet sequence (binary) 485 * 0000 0000-0000 007F 0xxxxxxx 486 * 0000 0080-0000 07FF 110xxxxx 10xxxxxx 487 * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx 488 * 489 * Check for the 0x110000 limit too 490 */ 491 cur = ctxt->input->cur; 492 493 c = *cur; 494 if (c & 0x80) { 495 if (c == 0xC0) 496 goto encoding_error; 497 if (cur[1] == 0) 498 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 499 if ((cur[1] & 0xc0) != 0x80) 500 goto encoding_error; 501 if ((c & 0xe0) == 0xe0) { 502 unsigned int val; 503 504 if (cur[2] == 0) 505 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 506 if ((cur[2] & 0xc0) != 0x80) 507 goto encoding_error; 508 if ((c & 0xf0) == 0xf0) { 509 if (cur[3] == 0) 510 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 511 if (((c & 0xf8) != 0xf0) || 512 ((cur[3] & 0xc0) != 0x80)) 513 goto encoding_error; 514 /* 4-byte code */ 515 ctxt->input->cur += 4; 516 val = (cur[0] & 0x7) << 18; 517 val |= (cur[1] & 0x3f) << 12; 518 val |= (cur[2] & 0x3f) << 6; 519 val |= cur[3] & 0x3f; 520 } else { 521 /* 3-byte code */ 522 ctxt->input->cur += 3; 523 val = (cur[0] & 0xf) << 12; 524 val |= (cur[1] & 0x3f) << 6; 525 val |= cur[2] & 0x3f; 526 } 527 if (((val > 0xd7ff) && (val < 0xe000)) || 528 ((val > 0xfffd) && (val < 0x10000)) || 529 (val >= 0x110000)) { 530 xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR, 531 "Char 0x%X out of allowed range\n", 532 val); 533 } 534 } else 535 /* 2-byte code */ 536 ctxt->input->cur += 2; 537 } else 538 /* 1-byte code */ 539 ctxt->input->cur++; 540 541 ctxt->nbChars++; 542 if (*ctxt->input->cur == 0) 543 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 544 } 545 } else { 546 /* 547 * Assume it's a fixed length encoding (1) with 548 * a compatible encoding for the ASCII set, since 549 * XML constructs only use < 128 chars 550 */ 551 552 if (*(ctxt->input->cur) == '\n') { 553 ctxt->input->line++; ctxt->input->col = 1; 554 } else 555 ctxt->input->col++; 556 ctxt->input->cur++; 557 ctxt->nbChars++; 558 if (*ctxt->input->cur == 0) 559 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 560 } 561 if ((*ctxt->input->cur == '%') && (!ctxt->html)) 562 xmlParserHandlePEReference(ctxt); 563 if ((*ctxt->input->cur == 0) && 564 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) 565 xmlPopInput(ctxt); 566 return; 567 encoding_error: 568 /* 569 * If we detect an UTF8 error that probably mean that the 570 * input encoding didn't get properly advertised in the 571 * declaration header. Report the error and switch the encoding 572 * to ISO-Latin-1 (if you don't like this policy, just declare the 573 * encoding !) 574 */ 575 if ((ctxt == NULL) || (ctxt->input == NULL) || 576 (ctxt->input->end - ctxt->input->cur < 4)) { 577 __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR, 578 "Input is not proper UTF-8, indicate encoding !\n", 579 NULL, NULL); 580 } else { 581 char buffer[150]; 582 583 snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n", 584 ctxt->input->cur[0], ctxt->input->cur[1], 585 ctxt->input->cur[2], ctxt->input->cur[3]); 586 __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR, 587 "Input is not proper UTF-8, indicate encoding !\n%s", 588 BAD_CAST buffer, NULL); 589 } 590 ctxt->charset = XML_CHAR_ENCODING_8859_1; 591 ctxt->input->cur++; 592 return; 593 } 594 595 /** 596 * xmlCurrentChar: 597 * @ctxt: the XML parser context 598 * @len: pointer to the length of the char read 599 * 600 * The current char value, if using UTF-8 this may actually span multiple 601 * bytes in the input buffer. Implement the end of line normalization: 602 * 2.11 End-of-Line Handling 603 * Wherever an external parsed entity or the literal entity value 604 * of an internal parsed entity contains either the literal two-character 605 * sequence "#xD#xA" or a standalone literal #xD, an XML processor 606 * must pass to the application the single character #xA. 607 * This behavior can conveniently be produced by normalizing all 608 * line breaks to #xA on input, before parsing.) 609 * 610 * Returns the current char value and its length 611 */ 612 613 int 614 xmlCurrentChar(xmlParserCtxtPtr ctxt, int *len) { 615 if ((ctxt == NULL) || (len == NULL) || (ctxt->input == NULL)) return(0); 616 if (ctxt->instate == XML_PARSER_EOF) 617 return(0); 618 619 if ((*ctxt->input->cur >= 0x20) && (*ctxt->input->cur <= 0x7F)) { 620 *len = 1; 621 return((int) *ctxt->input->cur); 622 } 623 if (ctxt->charset == XML_CHAR_ENCODING_UTF8) { 624 /* 625 * We are supposed to handle UTF8, check it's valid 626 * From rfc2044: encoding of the Unicode values on UTF-8: 627 * 628 * UCS-4 range (hex.) UTF-8 octet sequence (binary) 629 * 0000 0000-0000 007F 0xxxxxxx 630 * 0000 0080-0000 07FF 110xxxxx 10xxxxxx 631 * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx 632 * 633 * Check for the 0x110000 limit too 634 */ 635 const unsigned char *cur = ctxt->input->cur; 636 unsigned char c; 637 unsigned int val; 638 639 c = *cur; 640 if (c & 0x80) { 641 if (((c & 0x40) == 0) || (c == 0xC0)) 642 goto encoding_error; 643 if (cur[1] == 0) 644 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 645 if ((cur[1] & 0xc0) != 0x80) 646 goto encoding_error; 647 if ((c & 0xe0) == 0xe0) { 648 if (cur[2] == 0) 649 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 650 if ((cur[2] & 0xc0) != 0x80) 651 goto encoding_error; 652 if ((c & 0xf0) == 0xf0) { 653 if (cur[3] == 0) 654 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 655 if (((c & 0xf8) != 0xf0) || 656 ((cur[3] & 0xc0) != 0x80)) 657 goto encoding_error; 658 /* 4-byte code */ 659 *len = 4; 660 val = (cur[0] & 0x7) << 18; 661 val |= (cur[1] & 0x3f) << 12; 662 val |= (cur[2] & 0x3f) << 6; 663 val |= cur[3] & 0x3f; 664 if (val < 0x10000) 665 goto encoding_error; 666 } else { 667 /* 3-byte code */ 668 *len = 3; 669 val = (cur[0] & 0xf) << 12; 670 val |= (cur[1] & 0x3f) << 6; 671 val |= cur[2] & 0x3f; 672 if (val < 0x800) 673 goto encoding_error; 674 } 675 } else { 676 /* 2-byte code */ 677 *len = 2; 678 val = (cur[0] & 0x1f) << 6; 679 val |= cur[1] & 0x3f; 680 if (val < 0x80) 681 goto encoding_error; 682 } 683 if (!IS_CHAR(val)) { 684 xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR, 685 "Char 0x%X out of allowed range\n", val); 686 } 687 return(val); 688 } else { 689 /* 1-byte code */ 690 *len = 1; 691 if (*ctxt->input->cur == 0) 692 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 693 if ((*ctxt->input->cur == 0) && 694 (ctxt->input->end > ctxt->input->cur)) { 695 xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR, 696 "Char 0x0 out of allowed range\n", 0); 697 } 698 if (*ctxt->input->cur == 0xD) { 699 if (ctxt->input->cur[1] == 0xA) { 700 ctxt->nbChars++; 701 ctxt->input->cur++; 702 } 703 return(0xA); 704 } 705 return((int) *ctxt->input->cur); 706 } 707 } 708 /* 709 * Assume it's a fixed length encoding (1) with 710 * a compatible encoding for the ASCII set, since 711 * XML constructs only use < 128 chars 712 */ 713 *len = 1; 714 if (*ctxt->input->cur == 0xD) { 715 if (ctxt->input->cur[1] == 0xA) { 716 ctxt->nbChars++; 717 ctxt->input->cur++; 718 } 719 return(0xA); 720 } 721 return((int) *ctxt->input->cur); 722 encoding_error: 723 /* 724 * An encoding problem may arise from a truncated input buffer 725 * splitting a character in the middle. In that case do not raise 726 * an error but return 0 to endicate an end of stream problem 727 */ 728 if (ctxt->input->end - ctxt->input->cur < 4) { 729 *len = 0; 730 return(0); 731 } 732 733 /* 734 * If we detect an UTF8 error that probably mean that the 735 * input encoding didn't get properly advertised in the 736 * declaration header. Report the error and switch the encoding 737 * to ISO-Latin-1 (if you don't like this policy, just declare the 738 * encoding !) 739 */ 740 { 741 char buffer[150]; 742 743 snprintf(&buffer[0], 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n", 744 ctxt->input->cur[0], ctxt->input->cur[1], 745 ctxt->input->cur[2], ctxt->input->cur[3]); 746 __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR, 747 "Input is not proper UTF-8, indicate encoding !\n%s", 748 BAD_CAST buffer, NULL); 749 } 750 ctxt->charset = XML_CHAR_ENCODING_8859_1; 751 *len = 1; 752 return((int) *ctxt->input->cur); 753 } 754 755 /** 756 * xmlStringCurrentChar: 757 * @ctxt: the XML parser context 758 * @cur: pointer to the beginning of the char 759 * @len: pointer to the length of the char read 760 * 761 * The current char value, if using UTF-8 this may actually span multiple 762 * bytes in the input buffer. 763 * 764 * Returns the current char value and its length 765 */ 766 767 int 768 xmlStringCurrentChar(xmlParserCtxtPtr ctxt, const xmlChar * cur, int *len) 769 { 770 if ((len == NULL) || (cur == NULL)) return(0); 771 if ((ctxt == NULL) || (ctxt->charset == XML_CHAR_ENCODING_UTF8)) { 772 /* 773 * We are supposed to handle UTF8, check it's valid 774 * From rfc2044: encoding of the Unicode values on UTF-8: 775 * 776 * UCS-4 range (hex.) UTF-8 octet sequence (binary) 777 * 0000 0000-0000 007F 0xxxxxxx 778 * 0000 0080-0000 07FF 110xxxxx 10xxxxxx 779 * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx 780 * 781 * Check for the 0x110000 limit too 782 */ 783 unsigned char c; 784 unsigned int val; 785 786 c = *cur; 787 if (c & 0x80) { 788 if ((cur[1] & 0xc0) != 0x80) 789 goto encoding_error; 790 if ((c & 0xe0) == 0xe0) { 791 792 if ((cur[2] & 0xc0) != 0x80) 793 goto encoding_error; 794 if ((c & 0xf0) == 0xf0) { 795 if (((c & 0xf8) != 0xf0) || ((cur[3] & 0xc0) != 0x80)) 796 goto encoding_error; 797 /* 4-byte code */ 798 *len = 4; 799 val = (cur[0] & 0x7) << 18; 800 val |= (cur[1] & 0x3f) << 12; 801 val |= (cur[2] & 0x3f) << 6; 802 val |= cur[3] & 0x3f; 803 } else { 804 /* 3-byte code */ 805 *len = 3; 806 val = (cur[0] & 0xf) << 12; 807 val |= (cur[1] & 0x3f) << 6; 808 val |= cur[2] & 0x3f; 809 } 810 } else { 811 /* 2-byte code */ 812 *len = 2; 813 val = (cur[0] & 0x1f) << 6; 814 val |= cur[1] & 0x3f; 815 } 816 if (!IS_CHAR(val)) { 817 xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR, 818 "Char 0x%X out of allowed range\n", val); 819 } 820 return (val); 821 } else { 822 /* 1-byte code */ 823 *len = 1; 824 return ((int) *cur); 825 } 826 } 827 /* 828 * Assume it's a fixed length encoding (1) with 829 * a compatible encoding for the ASCII set, since 830 * XML constructs only use < 128 chars 831 */ 832 *len = 1; 833 return ((int) *cur); 834 encoding_error: 835 836 /* 837 * An encoding problem may arise from a truncated input buffer 838 * splitting a character in the middle. In that case do not raise 839 * an error but return 0 to endicate an end of stream problem 840 */ 841 if ((ctxt == NULL) || (ctxt->input == NULL) || 842 (ctxt->input->end - ctxt->input->cur < 4)) { 843 *len = 0; 844 return(0); 845 } 846 /* 847 * If we detect an UTF8 error that probably mean that the 848 * input encoding didn't get properly advertised in the 849 * declaration header. Report the error and switch the encoding 850 * to ISO-Latin-1 (if you don't like this policy, just declare the 851 * encoding !) 852 */ 853 { 854 char buffer[150]; 855 856 snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n", 857 ctxt->input->cur[0], ctxt->input->cur[1], 858 ctxt->input->cur[2], ctxt->input->cur[3]); 859 __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR, 860 "Input is not proper UTF-8, indicate encoding !\n%s", 861 BAD_CAST buffer, NULL); 862 } 863 *len = 1; 864 return ((int) *cur); 865 } 866 867 /** 868 * xmlCopyCharMultiByte: 869 * @out: pointer to an array of xmlChar 870 * @val: the char value 871 * 872 * append the char value in the array 873 * 874 * Returns the number of xmlChar written 875 */ 876 int 877 xmlCopyCharMultiByte(xmlChar *out, int val) { 878 if (out == NULL) return(0); 879 /* 880 * We are supposed to handle UTF8, check it's valid 881 * From rfc2044: encoding of the Unicode values on UTF-8: 882 * 883 * UCS-4 range (hex.) UTF-8 octet sequence (binary) 884 * 0000 0000-0000 007F 0xxxxxxx 885 * 0000 0080-0000 07FF 110xxxxx 10xxxxxx 886 * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx 887 */ 888 if (val >= 0x80) { 889 xmlChar *savedout = out; 890 int bits; 891 if (val < 0x800) { *out++= (val >> 6) | 0xC0; bits= 0; } 892 else if (val < 0x10000) { *out++= (val >> 12) | 0xE0; bits= 6;} 893 else if (val < 0x110000) { *out++= (val >> 18) | 0xF0; bits= 12; } 894 else { 895 xmlErrEncodingInt(NULL, XML_ERR_INVALID_CHAR, 896 "Internal error, xmlCopyCharMultiByte 0x%X out of bound\n", 897 val); 898 return(0); 899 } 900 for ( ; bits >= 0; bits-= 6) 901 *out++= ((val >> bits) & 0x3F) | 0x80 ; 902 return (out - savedout); 903 } 904 *out = (xmlChar) val; 905 return 1; 906 } 907 908 /** 909 * xmlCopyChar: 910 * @len: Ignored, compatibility 911 * @out: pointer to an array of xmlChar 912 * @val: the char value 913 * 914 * append the char value in the array 915 * 916 * Returns the number of xmlChar written 917 */ 918 919 int 920 xmlCopyChar(int len ATTRIBUTE_UNUSED, xmlChar *out, int val) { 921 if (out == NULL) return(0); 922 /* the len parameter is ignored */ 923 if (val >= 0x80) { 924 return(xmlCopyCharMultiByte (out, val)); 925 } 926 *out = (xmlChar) val; 927 return 1; 928 } 929 930 /************************************************************************ 931 * * 932 * Commodity functions to switch encodings * 933 * * 934 ************************************************************************/ 935 936 /** 937 * xmlSwitchEncoding: 938 * @ctxt: the parser context 939 * @enc: the encoding value (number) 940 * 941 * change the input functions when discovering the character encoding 942 * of a given entity. 943 * 944 * Returns 0 in case of success, -1 otherwise 945 */ 946 int 947 xmlSwitchEncoding(xmlParserCtxtPtr ctxt, xmlCharEncoding enc) 948 { 949 xmlCharEncodingHandlerPtr handler; 950 951 if (ctxt == NULL) return(-1); 952 switch (enc) { 953 case XML_CHAR_ENCODING_ERROR: 954 __xmlErrEncoding(ctxt, XML_ERR_UNKNOWN_ENCODING, 955 "encoding unknown\n", NULL, NULL); 956 return(-1); 957 case XML_CHAR_ENCODING_NONE: 958 /* let's assume it's UTF-8 without the XML decl */ 959 ctxt->charset = XML_CHAR_ENCODING_UTF8; 960 return(0); 961 case XML_CHAR_ENCODING_UTF8: 962 /* default encoding, no conversion should be needed */ 963 ctxt->charset = XML_CHAR_ENCODING_UTF8; 964 965 /* 966 * Errata on XML-1.0 June 20 2001 967 * Specific handling of the Byte Order Mark for 968 * UTF-8 969 */ 970 if ((ctxt->input != NULL) && 971 (ctxt->input->cur[0] == 0xEF) && 972 (ctxt->input->cur[1] == 0xBB) && 973 (ctxt->input->cur[2] == 0xBF)) { 974 ctxt->input->cur += 3; 975 } 976 return(0); 977 case XML_CHAR_ENCODING_UTF16LE: 978 case XML_CHAR_ENCODING_UTF16BE: 979 /*The raw input characters are encoded 980 *in UTF-16. As we expect this function 981 *to be called after xmlCharEncInFunc, we expect 982 *ctxt->input->cur to contain UTF-8 encoded characters. 983 *So the raw UTF16 Byte Order Mark 984 *has also been converted into 985 *an UTF-8 BOM. Let's skip that BOM. 986 */ 987 if ((ctxt->input != NULL) && (ctxt->input->cur != NULL) && 988 (ctxt->input->cur[0] == 0xEF) && 989 (ctxt->input->cur[1] == 0xBB) && 990 (ctxt->input->cur[2] == 0xBF)) { 991 ctxt->input->cur += 3; 992 } 993 break ; 994 default: 995 break; 996 } 997 handler = xmlGetCharEncodingHandler(enc); 998 if (handler == NULL) { 999 /* 1000 * Default handlers. 1001 */ 1002 switch (enc) { 1003 case XML_CHAR_ENCODING_ASCII: 1004 /* default encoding, no conversion should be needed */ 1005 ctxt->charset = XML_CHAR_ENCODING_UTF8; 1006 return(0); 1007 case XML_CHAR_ENCODING_UTF16LE: 1008 break; 1009 case XML_CHAR_ENCODING_UTF16BE: 1010 break; 1011 case XML_CHAR_ENCODING_UCS4LE: 1012 __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 1013 "encoding not supported %s\n", 1014 BAD_CAST "USC4 little endian", NULL); 1015 break; 1016 case XML_CHAR_ENCODING_UCS4BE: 1017 __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 1018 "encoding not supported %s\n", 1019 BAD_CAST "USC4 big endian", NULL); 1020 break; 1021 case XML_CHAR_ENCODING_EBCDIC: 1022 __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 1023 "encoding not supported %s\n", 1024 BAD_CAST "EBCDIC", NULL); 1025 break; 1026 case XML_CHAR_ENCODING_UCS4_2143: 1027 __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 1028 "encoding not supported %s\n", 1029 BAD_CAST "UCS4 2143", NULL); 1030 break; 1031 case XML_CHAR_ENCODING_UCS4_3412: 1032 __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 1033 "encoding not supported %s\n", 1034 BAD_CAST "UCS4 3412", NULL); 1035 break; 1036 case XML_CHAR_ENCODING_UCS2: 1037 __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 1038 "encoding not supported %s\n", 1039 BAD_CAST "UCS2", NULL); 1040 break; 1041 case XML_CHAR_ENCODING_8859_1: 1042 case XML_CHAR_ENCODING_8859_2: 1043 case XML_CHAR_ENCODING_8859_3: 1044 case XML_CHAR_ENCODING_8859_4: 1045 case XML_CHAR_ENCODING_8859_5: 1046 case XML_CHAR_ENCODING_8859_6: 1047 case XML_CHAR_ENCODING_8859_7: 1048 case XML_CHAR_ENCODING_8859_8: 1049 case XML_CHAR_ENCODING_8859_9: 1050 /* 1051 * We used to keep the internal content in the 1052 * document encoding however this turns being unmaintainable 1053 * So xmlGetCharEncodingHandler() will return non-null 1054 * values for this now. 1055 */ 1056 if ((ctxt->inputNr == 1) && 1057 (ctxt->encoding == NULL) && 1058 (ctxt->input != NULL) && 1059 (ctxt->input->encoding != NULL)) { 1060 ctxt->encoding = xmlStrdup(ctxt->input->encoding); 1061 } 1062 ctxt->charset = enc; 1063 return(0); 1064 case XML_CHAR_ENCODING_2022_JP: 1065 __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 1066 "encoding not supported %s\n", 1067 BAD_CAST "ISO-2022-JP", NULL); 1068 break; 1069 case XML_CHAR_ENCODING_SHIFT_JIS: 1070 __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 1071 "encoding not supported %s\n", 1072 BAD_CAST "Shift_JIS", NULL); 1073 break; 1074 case XML_CHAR_ENCODING_EUC_JP: 1075 __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 1076 "encoding not supported %s\n", 1077 BAD_CAST "EUC-JP", NULL); 1078 break; 1079 default: 1080 break; 1081 } 1082 } 1083 if (handler == NULL) 1084 return(-1); 1085 ctxt->charset = XML_CHAR_ENCODING_UTF8; 1086 return(xmlSwitchToEncoding(ctxt, handler)); 1087 } 1088 1089 /** 1090 * xmlSwitchInputEncoding: 1091 * @ctxt: the parser context 1092 * @input: the input stream 1093 * @handler: the encoding handler 1094 * 1095 * change the input functions when discovering the character encoding 1096 * of a given entity. 1097 * 1098 * Returns 0 in case of success, -1 otherwise 1099 */ 1100 int 1101 xmlSwitchInputEncoding(xmlParserCtxtPtr ctxt, xmlParserInputPtr input, 1102 xmlCharEncodingHandlerPtr handler) 1103 { 1104 int nbchars; 1105 1106 if (handler == NULL) 1107 return (-1); 1108 if (input == NULL) 1109 return (-1); 1110 if (input->buf != NULL) { 1111 if (input->buf->encoder != NULL) { 1112 /* 1113 * Check in case the auto encoding detetection triggered 1114 * in already. 1115 */ 1116 if (input->buf->encoder == handler) 1117 return (0); 1118 1119 /* 1120 * "UTF-16" can be used for both LE and BE 1121 if ((!xmlStrncmp(BAD_CAST input->buf->encoder->name, 1122 BAD_CAST "UTF-16", 6)) && 1123 (!xmlStrncmp(BAD_CAST handler->name, 1124 BAD_CAST "UTF-16", 6))) { 1125 return(0); 1126 } 1127 */ 1128 1129 /* 1130 * Note: this is a bit dangerous, but that's what it 1131 * takes to use nearly compatible signature for different 1132 * encodings. 1133 */ 1134 xmlCharEncCloseFunc(input->buf->encoder); 1135 input->buf->encoder = handler; 1136 return (0); 1137 } 1138 input->buf->encoder = handler; 1139 1140 /* 1141 * Is there already some content down the pipe to convert ? 1142 */ 1143 if ((input->buf->buffer != NULL) && (input->buf->buffer->use > 0)) { 1144 int processed; 1145 unsigned int use; 1146 1147 /* 1148 * Specific handling of the Byte Order Mark for 1149 * UTF-16 1150 */ 1151 if ((handler->name != NULL) && 1152 (!strcmp(handler->name, "UTF-16LE") || 1153 !strcmp(handler->name, "UTF-16")) && 1154 (input->cur[0] == 0xFF) && (input->cur[1] == 0xFE)) { 1155 input->cur += 2; 1156 } 1157 if ((handler->name != NULL) && 1158 (!strcmp(handler->name, "UTF-16BE")) && 1159 (input->cur[0] == 0xFE) && (input->cur[1] == 0xFF)) { 1160 input->cur += 2; 1161 } 1162 /* 1163 * Errata on XML-1.0 June 20 2001 1164 * Specific handling of the Byte Order Mark for 1165 * UTF-8 1166 */ 1167 if ((handler->name != NULL) && 1168 (!strcmp(handler->name, "UTF-8")) && 1169 (input->cur[0] == 0xEF) && 1170 (input->cur[1] == 0xBB) && (input->cur[2] == 0xBF)) { 1171 input->cur += 3; 1172 } 1173 1174 /* 1175 * Shrink the current input buffer. 1176 * Move it as the raw buffer and create a new input buffer 1177 */ 1178 processed = input->cur - input->base; 1179 xmlBufferShrink(input->buf->buffer, processed); 1180 input->buf->raw = input->buf->buffer; 1181 input->buf->buffer = xmlBufferCreate(); 1182 input->buf->rawconsumed = processed; 1183 use = input->buf->raw->use; 1184 1185 if (ctxt->html) { 1186 /* 1187 * convert as much as possible of the buffer 1188 */ 1189 nbchars = xmlCharEncInFunc(input->buf->encoder, 1190 input->buf->buffer, 1191 input->buf->raw); 1192 } else { 1193 /* 1194 * convert just enough to get 1195 * '<?xml version="1.0" encoding="xxx"?>' 1196 * parsed with the autodetected encoding 1197 * into the parser reading buffer. 1198 */ 1199 nbchars = xmlCharEncFirstLine(input->buf->encoder, 1200 input->buf->buffer, 1201 input->buf->raw); 1202 } 1203 if (nbchars < 0) { 1204 xmlErrInternal(ctxt, 1205 "switching encoding: encoder error\n", 1206 NULL); 1207 return (-1); 1208 } 1209 input->buf->rawconsumed += use - input->buf->raw->use; 1210 input->base = input->cur = input->buf->buffer->content; 1211 input->end = &input->base[input->buf->buffer->use]; 1212 1213 } 1214 return (0); 1215 } else if (input->length == 0) { 1216 /* 1217 * When parsing a static memory array one must know the 1218 * size to be able to convert the buffer. 1219 */ 1220 xmlErrInternal(ctxt, "switching encoding : no input\n", NULL); 1221 return (-1); 1222 } 1223 return (0); 1224 } 1225 1226 /** 1227 * xmlSwitchToEncoding: 1228 * @ctxt: the parser context 1229 * @handler: the encoding handler 1230 * 1231 * change the input functions when discovering the character encoding 1232 * of a given entity. 1233 * 1234 * Returns 0 in case of success, -1 otherwise 1235 */ 1236 int 1237 xmlSwitchToEncoding(xmlParserCtxtPtr ctxt, xmlCharEncodingHandlerPtr handler) 1238 { 1239 int ret = 0; 1240 1241 if (handler != NULL) { 1242 if (ctxt->input != NULL) { 1243 ret = xmlSwitchInputEncoding(ctxt, ctxt->input, handler); 1244 } else { 1245 xmlErrInternal(ctxt, "xmlSwitchToEncoding : no input\n", 1246 NULL); 1247 return(-1); 1248 } 1249 /* 1250 * The parsing is now done in UTF8 natively 1251 */ 1252 ctxt->charset = XML_CHAR_ENCODING_UTF8; 1253 } else 1254 return(-1); 1255 return(ret); 1256 } 1257 1258 /************************************************************************ 1259 * * 1260 * Commodity functions to handle entities processing * 1261 * * 1262 ************************************************************************/ 1263 1264 /** 1265 * xmlFreeInputStream: 1266 * @input: an xmlParserInputPtr 1267 * 1268 * Free up an input stream. 1269 */ 1270 void 1271 xmlFreeInputStream(xmlParserInputPtr input) { 1272 if (input == NULL) return; 1273 1274 if (input->filename != NULL) xmlFree((char *) input->filename); 1275 if (input->directory != NULL) xmlFree((char *) input->directory); 1276 if (input->encoding != NULL) xmlFree((char *) input->encoding); 1277 if (input->version != NULL) xmlFree((char *) input->version); 1278 if ((input->free != NULL) && (input->base != NULL)) 1279 input->free((xmlChar *) input->base); 1280 if (input->buf != NULL) 1281 xmlFreeParserInputBuffer(input->buf); 1282 xmlFree(input); 1283 } 1284 1285 /** 1286 * xmlNewInputStream: 1287 * @ctxt: an XML parser context 1288 * 1289 * Create a new input stream structure 1290 * Returns the new input stream or NULL 1291 */ 1292 xmlParserInputPtr 1293 xmlNewInputStream(xmlParserCtxtPtr ctxt) { 1294 xmlParserInputPtr input; 1295 static int id = 0; 1296 1297 input = (xmlParserInputPtr) xmlMalloc(sizeof(xmlParserInput)); 1298 if (input == NULL) { 1299 xmlErrMemory(ctxt, "couldn't allocate a new input stream\n"); 1300 return(NULL); 1301 } 1302 memset(input, 0, sizeof(xmlParserInput)); 1303 input->line = 1; 1304 input->col = 1; 1305 input->standalone = -1; 1306 /* 1307 * we don't care about thread reentrancy unicity for a single 1308 * parser context (and hence thread) is sufficient. 1309 */ 1310 input->id = id++; 1311 return(input); 1312 } 1313 1314 /** 1315 * xmlNewIOInputStream: 1316 * @ctxt: an XML parser context 1317 * @input: an I/O Input 1318 * @enc: the charset encoding if known 1319 * 1320 * Create a new input stream structure encapsulating the @input into 1321 * a stream suitable for the parser. 1322 * 1323 * Returns the new input stream or NULL 1324 */ 1325 xmlParserInputPtr 1326 xmlNewIOInputStream(xmlParserCtxtPtr ctxt, xmlParserInputBufferPtr input, 1327 xmlCharEncoding enc) { 1328 xmlParserInputPtr inputStream; 1329 1330 if (input == NULL) return(NULL); 1331 if (xmlParserDebugEntities) 1332 xmlGenericError(xmlGenericErrorContext, "new input from I/O\n"); 1333 inputStream = xmlNewInputStream(ctxt); 1334 if (inputStream == NULL) { 1335 return(NULL); 1336 } 1337 inputStream->filename = NULL; 1338 inputStream->buf = input; 1339 inputStream->base = inputStream->buf->buffer->content; 1340 inputStream->cur = inputStream->buf->buffer->content; 1341 inputStream->end = &inputStream->base[inputStream->buf->buffer->use]; 1342 if (enc != XML_CHAR_ENCODING_NONE) { 1343 xmlSwitchEncoding(ctxt, enc); 1344 } 1345 1346 return(inputStream); 1347 } 1348 1349 /** 1350 * xmlNewEntityInputStream: 1351 * @ctxt: an XML parser context 1352 * @entity: an Entity pointer 1353 * 1354 * Create a new input stream based on an xmlEntityPtr 1355 * 1356 * Returns the new input stream or NULL 1357 */ 1358 xmlParserInputPtr 1359 xmlNewEntityInputStream(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) { 1360 xmlParserInputPtr input; 1361 1362 if (entity == NULL) { 1363 xmlErrInternal(ctxt, "xmlNewEntityInputStream entity = NULL\n", 1364 NULL); 1365 return(NULL); 1366 } 1367 if (xmlParserDebugEntities) 1368 xmlGenericError(xmlGenericErrorContext, 1369 "new input from entity: %s\n", entity->name); 1370 if (entity->content == NULL) { 1371 switch (entity->etype) { 1372 case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY: 1373 xmlErrInternal(ctxt, "Cannot parse entity %s\n", 1374 entity->name); 1375 break; 1376 case XML_EXTERNAL_GENERAL_PARSED_ENTITY: 1377 case XML_EXTERNAL_PARAMETER_ENTITY: 1378 return(xmlLoadExternalEntity((char *) entity->URI, 1379 (char *) entity->ExternalID, ctxt)); 1380 case XML_INTERNAL_GENERAL_ENTITY: 1381 xmlErrInternal(ctxt, 1382 "Internal entity %s without content !\n", 1383 entity->name); 1384 break; 1385 case XML_INTERNAL_PARAMETER_ENTITY: 1386 xmlErrInternal(ctxt, 1387 "Internal parameter entity %s without content !\n", 1388 entity->name); 1389 break; 1390 case XML_INTERNAL_PREDEFINED_ENTITY: 1391 xmlErrInternal(ctxt, 1392 "Predefined entity %s without content !\n", 1393 entity->name); 1394 break; 1395 } 1396 return(NULL); 1397 } 1398 input = xmlNewInputStream(ctxt); 1399 if (input == NULL) { 1400 return(NULL); 1401 } 1402 if (entity->URI != NULL) 1403 input->filename = (char *) xmlStrdup((xmlChar *) entity->URI); 1404 input->base = entity->content; 1405 input->cur = entity->content; 1406 input->length = entity->length; 1407 input->end = &entity->content[input->length]; 1408 return(input); 1409 } 1410 1411 /** 1412 * xmlNewStringInputStream: 1413 * @ctxt: an XML parser context 1414 * @buffer: an memory buffer 1415 * 1416 * Create a new input stream based on a memory buffer. 1417 * Returns the new input stream 1418 */ 1419 xmlParserInputPtr 1420 xmlNewStringInputStream(xmlParserCtxtPtr ctxt, const xmlChar *buffer) { 1421 xmlParserInputPtr input; 1422 1423 if (buffer == NULL) { 1424 xmlErrInternal(ctxt, "xmlNewStringInputStream string = NULL\n", 1425 NULL); 1426 return(NULL); 1427 } 1428 if (xmlParserDebugEntities) 1429 xmlGenericError(xmlGenericErrorContext, 1430 "new fixed input: %.30s\n", buffer); 1431 input = xmlNewInputStream(ctxt); 1432 if (input == NULL) { 1433 xmlErrMemory(ctxt, "couldn't allocate a new input stream\n"); 1434 return(NULL); 1435 } 1436 input->base = buffer; 1437 input->cur = buffer; 1438 input->length = xmlStrlen(buffer); 1439 input->end = &buffer[input->length]; 1440 return(input); 1441 } 1442 1443 /** 1444 * xmlNewInputFromFile: 1445 * @ctxt: an XML parser context 1446 * @filename: the filename to use as entity 1447 * 1448 * Create a new input stream based on a file or an URL. 1449 * 1450 * Returns the new input stream or NULL in case of error 1451 */ 1452 xmlParserInputPtr 1453 xmlNewInputFromFile(xmlParserCtxtPtr ctxt, const char *filename) { 1454 xmlParserInputBufferPtr buf; 1455 xmlParserInputPtr inputStream; 1456 char *directory = NULL; 1457 xmlChar *URI = NULL; 1458 1459 if (xmlParserDebugEntities) 1460 xmlGenericError(xmlGenericErrorContext, 1461 "new input from file: %s\n", filename); 1462 if (ctxt == NULL) return(NULL); 1463 buf = xmlParserInputBufferCreateFilename(filename, XML_CHAR_ENCODING_NONE); 1464 if (buf == NULL) { 1465 if (filename == NULL) 1466 __xmlLoaderErr(ctxt, 1467 "failed to load external entity: NULL filename \n", 1468 NULL); 1469 else 1470 __xmlLoaderErr(ctxt, "failed to load external entity \"%s\"\n", 1471 (const char *) filename); 1472 return(NULL); 1473 } 1474 1475 inputStream = xmlNewInputStream(ctxt); 1476 if (inputStream == NULL) 1477 return(NULL); 1478 1479 inputStream->buf = buf; 1480 inputStream = xmlCheckHTTPInput(ctxt, inputStream); 1481 if (inputStream == NULL) 1482 return(NULL); 1483 1484 if (inputStream->filename == NULL) 1485 URI = xmlStrdup((xmlChar *) filename); 1486 else 1487 URI = xmlStrdup((xmlChar *) inputStream->filename); 1488 directory = xmlParserGetDirectory((const char *) URI); 1489 if (inputStream->filename != NULL) xmlFree((char *)inputStream->filename); 1490 inputStream->filename = (char *) xmlCanonicPath((const xmlChar *) URI); 1491 if (URI != NULL) xmlFree((char *) URI); 1492 inputStream->directory = directory; 1493 1494 inputStream->base = inputStream->buf->buffer->content; 1495 inputStream->cur = inputStream->buf->buffer->content; 1496 inputStream->end = &inputStream->base[inputStream->buf->buffer->use]; 1497 if ((ctxt->directory == NULL) && (directory != NULL)) 1498 ctxt->directory = (char *) xmlStrdup((const xmlChar *) directory); 1499 return(inputStream); 1500 } 1501 1502 /************************************************************************ 1503 * * 1504 * Commodity functions to handle parser contexts * 1505 * * 1506 ************************************************************************/ 1507 1508 /** 1509 * xmlInitParserCtxt: 1510 * @ctxt: an XML parser context 1511 * 1512 * Initialize a parser context 1513 * 1514 * Returns 0 in case of success and -1 in case of error 1515 */ 1516 1517 int 1518 xmlInitParserCtxt(xmlParserCtxtPtr ctxt) 1519 { 1520 xmlParserInputPtr input; 1521 1522 if(ctxt==NULL) { 1523 xmlErrInternal(NULL, "Got NULL parser context\n", NULL); 1524 return(-1); 1525 } 1526 1527 xmlDefaultSAXHandlerInit(); 1528 1529 if (ctxt->dict == NULL) 1530 ctxt->dict = xmlDictCreate(); 1531 if (ctxt->dict == NULL) { 1532 xmlErrMemory(NULL, "cannot initialize parser context\n"); 1533 return(-1); 1534 } 1535 if (ctxt->sax == NULL) 1536 ctxt->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler)); 1537 if (ctxt->sax == NULL) { 1538 xmlErrMemory(NULL, "cannot initialize parser context\n"); 1539 return(-1); 1540 } 1541 else 1542 xmlSAXVersion(ctxt->sax, 2); 1543 1544 ctxt->maxatts = 0; 1545 ctxt->atts = NULL; 1546 /* Allocate the Input stack */ 1547 if (ctxt->inputTab == NULL) { 1548 ctxt->inputTab = (xmlParserInputPtr *) 1549 xmlMalloc(5 * sizeof(xmlParserInputPtr)); 1550 ctxt->inputMax = 5; 1551 } 1552 if (ctxt->inputTab == NULL) { 1553 xmlErrMemory(NULL, "cannot initialize parser context\n"); 1554 ctxt->inputNr = 0; 1555 ctxt->inputMax = 0; 1556 ctxt->input = NULL; 1557 return(-1); 1558 } 1559 while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */ 1560 xmlFreeInputStream(input); 1561 } 1562 ctxt->inputNr = 0; 1563 ctxt->input = NULL; 1564 1565 ctxt->version = NULL; 1566 ctxt->encoding = NULL; 1567 ctxt->standalone = -1; 1568 ctxt->hasExternalSubset = 0; 1569 ctxt->hasPErefs = 0; 1570 ctxt->html = 0; 1571 ctxt->external = 0; 1572 ctxt->instate = XML_PARSER_START; 1573 ctxt->token = 0; 1574 ctxt->directory = NULL; 1575 1576 /* Allocate the Node stack */ 1577 if (ctxt->nodeTab == NULL) { 1578 ctxt->nodeTab = (xmlNodePtr *) xmlMalloc(10 * sizeof(xmlNodePtr)); 1579 ctxt->nodeMax = 10; 1580 } 1581 if (ctxt->nodeTab == NULL) { 1582 xmlErrMemory(NULL, "cannot initialize parser context\n"); 1583 ctxt->nodeNr = 0; 1584 ctxt->nodeMax = 0; 1585 ctxt->node = NULL; 1586 ctxt->inputNr = 0; 1587 ctxt->inputMax = 0; 1588 ctxt->input = NULL; 1589 return(-1); 1590 } 1591 ctxt->nodeNr = 0; 1592 ctxt->node = NULL; 1593 1594 /* Allocate the Name stack */ 1595 if (ctxt->nameTab == NULL) { 1596 ctxt->nameTab = (const xmlChar **) xmlMalloc(10 * sizeof(xmlChar *)); 1597 ctxt->nameMax = 10; 1598 } 1599 if (ctxt->nameTab == NULL) { 1600 xmlErrMemory(NULL, "cannot initialize parser context\n"); 1601 ctxt->nodeNr = 0; 1602 ctxt->nodeMax = 0; 1603 ctxt->node = NULL; 1604 ctxt->inputNr = 0; 1605 ctxt->inputMax = 0; 1606 ctxt->input = NULL; 1607 ctxt->nameNr = 0; 1608 ctxt->nameMax = 0; 1609 ctxt->name = NULL; 1610 return(-1); 1611 } 1612 ctxt->nameNr = 0; 1613 ctxt->name = NULL; 1614 1615 /* Allocate the space stack */ 1616 if (ctxt->spaceTab == NULL) { 1617 ctxt->spaceTab = (int *) xmlMalloc(10 * sizeof(int)); 1618 ctxt->spaceMax = 10; 1619 } 1620 if (ctxt->spaceTab == NULL) { 1621 xmlErrMemory(NULL, "cannot initialize parser context\n"); 1622 ctxt->nodeNr = 0; 1623 ctxt->nodeMax = 0; 1624 ctxt->node = NULL; 1625 ctxt->inputNr = 0; 1626 ctxt->inputMax = 0; 1627 ctxt->input = NULL; 1628 ctxt->nameNr = 0; 1629 ctxt->nameMax = 0; 1630 ctxt->name = NULL; 1631 ctxt->spaceNr = 0; 1632 ctxt->spaceMax = 0; 1633 ctxt->space = NULL; 1634 return(-1); 1635 } 1636 ctxt->spaceNr = 1; 1637 ctxt->spaceMax = 10; 1638 ctxt->spaceTab[0] = -1; 1639 ctxt->space = &ctxt->spaceTab[0]; 1640 ctxt->userData = ctxt; 1641 ctxt->myDoc = NULL; 1642 ctxt->wellFormed = 1; 1643 ctxt->nsWellFormed = 1; 1644 ctxt->valid = 1; 1645 ctxt->loadsubset = xmlLoadExtDtdDefaultValue; 1646 ctxt->validate = xmlDoValidityCheckingDefaultValue; 1647 ctxt->pedantic = xmlPedanticParserDefaultValue; 1648 ctxt->linenumbers = xmlLineNumbersDefaultValue; 1649 ctxt->keepBlanks = xmlKeepBlanksDefaultValue; 1650 if (ctxt->keepBlanks == 0) 1651 ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace; 1652 1653 ctxt->vctxt.finishDtd = XML_CTXT_FINISH_DTD_0; 1654 ctxt->vctxt.userData = ctxt; 1655 ctxt->vctxt.error = xmlParserValidityError; 1656 ctxt->vctxt.warning = xmlParserValidityWarning; 1657 if (ctxt->validate) { 1658 if (xmlGetWarningsDefaultValue == 0) 1659 ctxt->vctxt.warning = NULL; 1660 else 1661 ctxt->vctxt.warning = xmlParserValidityWarning; 1662 ctxt->vctxt.nodeMax = 0; 1663 } 1664 ctxt->replaceEntities = xmlSubstituteEntitiesDefaultValue; 1665 ctxt->record_info = 0; 1666 ctxt->nbChars = 0; 1667 ctxt->checkIndex = 0; 1668 ctxt->inSubset = 0; 1669 ctxt->errNo = XML_ERR_OK; 1670 ctxt->depth = 0; 1671 ctxt->charset = XML_CHAR_ENCODING_UTF8; 1672 ctxt->catalogs = NULL; 1673 ctxt->nbentities = 0; 1674 xmlInitNodeInfoSeq(&ctxt->node_seq); 1675 return(0); 1676 } 1677 1678 /** 1679 * xmlFreeParserCtxt: 1680 * @ctxt: an XML parser context 1681 * 1682 * Free all the memory used by a parser context. However the parsed 1683 * document in ctxt->myDoc is not freed. 1684 */ 1685 1686 void 1687 xmlFreeParserCtxt(xmlParserCtxtPtr ctxt) 1688 { 1689 xmlParserInputPtr input; 1690 1691 if (ctxt == NULL) return; 1692 1693 while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */ 1694 xmlFreeInputStream(input); 1695 } 1696 if (ctxt->spaceTab != NULL) xmlFree(ctxt->spaceTab); 1697 if (ctxt->nameTab != NULL) xmlFree((xmlChar * *)ctxt->nameTab); 1698 if (ctxt->nodeTab != NULL) xmlFree(ctxt->nodeTab); 1699 if (ctxt->inputTab != NULL) xmlFree(ctxt->inputTab); 1700 if (ctxt->version != NULL) xmlFree((char *) ctxt->version); 1701 if (ctxt->encoding != NULL) xmlFree((char *) ctxt->encoding); 1702 if (ctxt->extSubURI != NULL) xmlFree((char *) ctxt->extSubURI); 1703 if (ctxt->extSubSystem != NULL) xmlFree((char *) ctxt->extSubSystem); 1704 #ifdef LIBXML_SAX1_ENABLED 1705 if ((ctxt->sax != NULL) && 1706 (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)) 1707 #else 1708 if (ctxt->sax != NULL) 1709 #endif /* LIBXML_SAX1_ENABLED */ 1710 xmlFree(ctxt->sax); 1711 if (ctxt->directory != NULL) xmlFree((char *) ctxt->directory); 1712 if (ctxt->vctxt.nodeTab != NULL) xmlFree(ctxt->vctxt.nodeTab); 1713 if (ctxt->atts != NULL) xmlFree((xmlChar * *)ctxt->atts); 1714 if (ctxt->dict != NULL) xmlDictFree(ctxt->dict); 1715 if (ctxt->nsTab != NULL) xmlFree((char *) ctxt->nsTab); 1716 if (ctxt->pushTab != NULL) xmlFree(ctxt->pushTab); 1717 if (ctxt->attallocs != NULL) xmlFree(ctxt->attallocs); 1718 if (ctxt->attsDefault != NULL) 1719 xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree); 1720 if (ctxt->attsSpecial != NULL) 1721 xmlHashFree(ctxt->attsSpecial, NULL); 1722 if (ctxt->freeElems != NULL) { 1723 xmlNodePtr cur, next; 1724 1725 cur = ctxt->freeElems; 1726 while (cur != NULL) { 1727 next = cur->next; 1728 xmlFree(cur); 1729 cur = next; 1730 } 1731 } 1732 if (ctxt->freeAttrs != NULL) { 1733 xmlAttrPtr cur, next; 1734 1735 cur = ctxt->freeAttrs; 1736 while (cur != NULL) { 1737 next = cur->next; 1738 xmlFree(cur); 1739 cur = next; 1740 } 1741 } 1742 /* 1743 * cleanup the error strings 1744 */ 1745 if (ctxt->lastError.message != NULL) 1746 xmlFree(ctxt->lastError.message); 1747 if (ctxt->lastError.file != NULL) 1748 xmlFree(ctxt->lastError.file); 1749 if (ctxt->lastError.str1 != NULL) 1750 xmlFree(ctxt->lastError.str1); 1751 if (ctxt->lastError.str2 != NULL) 1752 xmlFree(ctxt->lastError.str2); 1753 if (ctxt->lastError.str3 != NULL) 1754 xmlFree(ctxt->lastError.str3); 1755 1756 #ifdef LIBXML_CATALOG_ENABLED 1757 if (ctxt->catalogs != NULL) 1758 xmlCatalogFreeLocal(ctxt->catalogs); 1759 #endif 1760 xmlFree(ctxt); 1761 } 1762 1763 /** 1764 * xmlNewParserCtxt: 1765 * 1766 * Allocate and initialize a new parser context. 1767 * 1768 * Returns the xmlParserCtxtPtr or NULL 1769 */ 1770 1771 xmlParserCtxtPtr 1772 xmlNewParserCtxt(void) 1773 { 1774 xmlParserCtxtPtr ctxt; 1775 1776 ctxt = (xmlParserCtxtPtr) xmlMalloc(sizeof(xmlParserCtxt)); 1777 if (ctxt == NULL) { 1778 xmlErrMemory(NULL, "cannot allocate parser context\n"); 1779 return(NULL); 1780 } 1781 memset(ctxt, 0, sizeof(xmlParserCtxt)); 1782 if (xmlInitParserCtxt(ctxt) < 0) { 1783 xmlFreeParserCtxt(ctxt); 1784 return(NULL); 1785 } 1786 return(ctxt); 1787 } 1788 1789 /************************************************************************ 1790 * * 1791 * Handling of node informations * 1792 * * 1793 ************************************************************************/ 1794 1795 /** 1796 * xmlClearParserCtxt: 1797 * @ctxt: an XML parser context 1798 * 1799 * Clear (release owned resources) and reinitialize a parser context 1800 */ 1801 1802 void 1803 xmlClearParserCtxt(xmlParserCtxtPtr ctxt) 1804 { 1805 if (ctxt==NULL) 1806 return; 1807 xmlClearNodeInfoSeq(&ctxt->node_seq); 1808 xmlCtxtReset(ctxt); 1809 } 1810 1811 1812 /** 1813 * xmlParserFindNodeInfo: 1814 * @ctx: an XML parser context 1815 * @node: an XML node within the tree 1816 * 1817 * Find the parser node info struct for a given node 1818 * 1819 * Returns an xmlParserNodeInfo block pointer or NULL 1820 */ 1821 const xmlParserNodeInfo * 1822 xmlParserFindNodeInfo(const xmlParserCtxtPtr ctx, const xmlNodePtr node) 1823 { 1824 unsigned long pos; 1825 1826 if ((ctx == NULL) || (node == NULL)) 1827 return (NULL); 1828 /* Find position where node should be at */ 1829 pos = xmlParserFindNodeInfoIndex(&ctx->node_seq, node); 1830 if (pos < ctx->node_seq.length 1831 && ctx->node_seq.buffer[pos].node == node) 1832 return &ctx->node_seq.buffer[pos]; 1833 else 1834 return NULL; 1835 } 1836 1837 1838 /** 1839 * xmlInitNodeInfoSeq: 1840 * @seq: a node info sequence pointer 1841 * 1842 * -- Initialize (set to initial state) node info sequence 1843 */ 1844 void 1845 xmlInitNodeInfoSeq(xmlParserNodeInfoSeqPtr seq) 1846 { 1847 if (seq == NULL) 1848 return; 1849 seq->length = 0; 1850 seq->maximum = 0; 1851 seq->buffer = NULL; 1852 } 1853 1854 /** 1855 * xmlClearNodeInfoSeq: 1856 * @seq: a node info sequence pointer 1857 * 1858 * -- Clear (release memory and reinitialize) node 1859 * info sequence 1860 */ 1861 void 1862 xmlClearNodeInfoSeq(xmlParserNodeInfoSeqPtr seq) 1863 { 1864 if (seq == NULL) 1865 return; 1866 if (seq->buffer != NULL) 1867 xmlFree(seq->buffer); 1868 xmlInitNodeInfoSeq(seq); 1869 } 1870 1871 /** 1872 * xmlParserFindNodeInfoIndex: 1873 * @seq: a node info sequence pointer 1874 * @node: an XML node pointer 1875 * 1876 * 1877 * xmlParserFindNodeInfoIndex : Find the index that the info record for 1878 * the given node is or should be at in a sorted sequence 1879 * 1880 * Returns a long indicating the position of the record 1881 */ 1882 unsigned long 1883 xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq, 1884 const xmlNodePtr node) 1885 { 1886 unsigned long upper, lower, middle; 1887 int found = 0; 1888 1889 if ((seq == NULL) || (node == NULL)) 1890 return ((unsigned long) -1); 1891 1892 /* Do a binary search for the key */ 1893 lower = 1; 1894 upper = seq->length; 1895 middle = 0; 1896 while (lower <= upper && !found) { 1897 middle = lower + (upper - lower) / 2; 1898 if (node == seq->buffer[middle - 1].node) 1899 found = 1; 1900 else if (node < seq->buffer[middle - 1].node) 1901 upper = middle - 1; 1902 else 1903 lower = middle + 1; 1904 } 1905 1906 /* Return position */ 1907 if (middle == 0 || seq->buffer[middle - 1].node < node) 1908 return middle; 1909 else 1910 return middle - 1; 1911 } 1912 1913 1914 /** 1915 * xmlParserAddNodeInfo: 1916 * @ctxt: an XML parser context 1917 * @info: a node info sequence pointer 1918 * 1919 * Insert node info record into the sorted sequence 1920 */ 1921 void 1922 xmlParserAddNodeInfo(xmlParserCtxtPtr ctxt, 1923 const xmlParserNodeInfoPtr info) 1924 { 1925 unsigned long pos; 1926 1927 if ((ctxt == NULL) || (info == NULL)) return; 1928 1929 /* Find pos and check to see if node is already in the sequence */ 1930 pos = xmlParserFindNodeInfoIndex(&ctxt->node_seq, (xmlNodePtr) 1931 info->node); 1932 1933 if ((pos < ctxt->node_seq.length) && 1934 (ctxt->node_seq.buffer != NULL) && 1935 (ctxt->node_seq.buffer[pos].node == info->node)) { 1936 ctxt->node_seq.buffer[pos] = *info; 1937 } 1938 1939 /* Otherwise, we need to add new node to buffer */ 1940 else { 1941 if (ctxt->node_seq.length + 1 > ctxt->node_seq.maximum) { 1942 xmlParserNodeInfo *tmp_buffer; 1943 unsigned int byte_size; 1944 1945 if (ctxt->node_seq.maximum == 0) 1946 ctxt->node_seq.maximum = 2; 1947 byte_size = (sizeof(*ctxt->node_seq.buffer) * 1948 (2 * ctxt->node_seq.maximum)); 1949 1950 if (ctxt->node_seq.buffer == NULL) 1951 tmp_buffer = (xmlParserNodeInfo *) xmlMalloc(byte_size); 1952 else 1953 tmp_buffer = 1954 (xmlParserNodeInfo *) xmlRealloc(ctxt->node_seq.buffer, 1955 byte_size); 1956 1957 if (tmp_buffer == NULL) { 1958 xmlErrMemory(ctxt, "failed to allocate buffer\n"); 1959 return; 1960 } 1961 ctxt->node_seq.buffer = tmp_buffer; 1962 ctxt->node_seq.maximum *= 2; 1963 } 1964 1965 /* If position is not at end, move elements out of the way */ 1966 if (pos != ctxt->node_seq.length) { 1967 unsigned long i; 1968 1969 for (i = ctxt->node_seq.length; i > pos; i--) 1970 ctxt->node_seq.buffer[i] = ctxt->node_seq.buffer[i - 1]; 1971 } 1972 1973 /* Copy element and increase length */ 1974 ctxt->node_seq.buffer[pos] = *info; 1975 ctxt->node_seq.length++; 1976 } 1977 } 1978 1979 /************************************************************************ 1980 * * 1981 * Defaults settings * 1982 * * 1983 ************************************************************************/ 1984 /** 1985 * xmlPedanticParserDefault: 1986 * @val: int 0 or 1 1987 * 1988 * Set and return the previous value for enabling pedantic warnings. 1989 * 1990 * Returns the last value for 0 for no substitution, 1 for substitution. 1991 */ 1992 1993 int 1994 xmlPedanticParserDefault(int val) { 1995 int old = xmlPedanticParserDefaultValue; 1996 1997 xmlPedanticParserDefaultValue = val; 1998 return(old); 1999 } 2000 2001 /** 2002 * xmlLineNumbersDefault: 2003 * @val: int 0 or 1 2004 * 2005 * Set and return the previous value for enabling line numbers in elements 2006 * contents. This may break on old application and is turned off by default. 2007 * 2008 * Returns the last value for 0 for no substitution, 1 for substitution. 2009 */ 2010 2011 int 2012 xmlLineNumbersDefault(int val) { 2013 int old = xmlLineNumbersDefaultValue; 2014 2015 xmlLineNumbersDefaultValue = val; 2016 return(old); 2017 } 2018 2019 /** 2020 * xmlSubstituteEntitiesDefault: 2021 * @val: int 0 or 1 2022 * 2023 * Set and return the previous value for default entity support. 2024 * Initially the parser always keep entity references instead of substituting 2025 * entity values in the output. This function has to be used to change the 2026 * default parser behavior 2027 * SAX::substituteEntities() has to be used for changing that on a file by 2028 * file basis. 2029 * 2030 * Returns the last value for 0 for no substitution, 1 for substitution. 2031 */ 2032 2033 int 2034 xmlSubstituteEntitiesDefault(int val) { 2035 int old = xmlSubstituteEntitiesDefaultValue; 2036 2037 xmlSubstituteEntitiesDefaultValue = val; 2038 return(old); 2039 } 2040 2041 /** 2042 * xmlKeepBlanksDefault: 2043 * @val: int 0 or 1 2044 * 2045 * Set and return the previous value for default blanks text nodes support. 2046 * The 1.x version of the parser used an heuristic to try to detect 2047 * ignorable white spaces. As a result the SAX callback was generating 2048 * xmlSAX2IgnorableWhitespace() callbacks instead of characters() one, and when 2049 * using the DOM output text nodes containing those blanks were not generated. 2050 * The 2.x and later version will switch to the XML standard way and 2051 * ignorableWhitespace() are only generated when running the parser in 2052 * validating mode and when the current element doesn't allow CDATA or 2053 * mixed content. 2054 * This function is provided as a way to force the standard behavior 2055 * on 1.X libs and to switch back to the old mode for compatibility when 2056 * running 1.X client code on 2.X . Upgrade of 1.X code should be done 2057 * by using xmlIsBlankNode() commodity function to detect the "empty" 2058 * nodes generated. 2059 * This value also affect autogeneration of indentation when saving code 2060 * if blanks sections are kept, indentation is not generated. 2061 * 2062 * Returns the last value for 0 for no substitution, 1 for substitution. 2063 */ 2064 2065 int 2066 xmlKeepBlanksDefault(int val) { 2067 int old = xmlKeepBlanksDefaultValue; 2068 2069 xmlKeepBlanksDefaultValue = val; 2070 xmlIndentTreeOutput = !val; 2071 return(old); 2072 } 2073 2074 #define bottom_parserInternals 2075 #include "elfgcchack.h" 2076
