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 cur = ctxt->input->cur; 500 } 501 if ((cur[1] & 0xc0) != 0x80) 502 goto encoding_error; 503 if ((c & 0xe0) == 0xe0) { 504 unsigned int val; 505 506 if (cur[2] == 0) { 507 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 508 cur = ctxt->input->cur; 509 } 510 if ((cur[2] & 0xc0) != 0x80) 511 goto encoding_error; 512 if ((c & 0xf0) == 0xf0) { 513 if (cur[3] == 0) { 514 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 515 cur = ctxt->input->cur; 516 } 517 if (((c & 0xf8) != 0xf0) || 518 ((cur[3] & 0xc0) != 0x80)) 519 goto encoding_error; 520 /* 4-byte code */ 521 ctxt->input->cur += 4; 522 val = (cur[0] & 0x7) << 18; 523 val |= (cur[1] & 0x3f) << 12; 524 val |= (cur[2] & 0x3f) << 6; 525 val |= cur[3] & 0x3f; 526 } else { 527 /* 3-byte code */ 528 ctxt->input->cur += 3; 529 val = (cur[0] & 0xf) << 12; 530 val |= (cur[1] & 0x3f) << 6; 531 val |= cur[2] & 0x3f; 532 } 533 if (((val > 0xd7ff) && (val < 0xe000)) || 534 ((val > 0xfffd) && (val < 0x10000)) || 535 (val >= 0x110000)) { 536 xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR, 537 "Char 0x%X out of allowed range\n", 538 val); 539 } 540 } else 541 /* 2-byte code */ 542 ctxt->input->cur += 2; 543 } else 544 /* 1-byte code */ 545 ctxt->input->cur++; 546 547 ctxt->nbChars++; 548 if (*ctxt->input->cur == 0) 549 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 550 } 551 } else { 552 /* 553 * Assume it's a fixed length encoding (1) with 554 * a compatible encoding for the ASCII set, since 555 * XML constructs only use < 128 chars 556 */ 557 558 if (*(ctxt->input->cur) == '\n') { 559 ctxt->input->line++; ctxt->input->col = 1; 560 } else 561 ctxt->input->col++; 562 ctxt->input->cur++; 563 ctxt->nbChars++; 564 if (*ctxt->input->cur == 0) 565 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 566 } 567 if ((*ctxt->input->cur == '%') && (!ctxt->html)) 568 xmlParserHandlePEReference(ctxt); 569 if ((*ctxt->input->cur == 0) && 570 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) 571 xmlPopInput(ctxt); 572 return; 573 encoding_error: 574 /* 575 * If we detect an UTF8 error that probably mean that the 576 * input encoding didn't get properly advertised in the 577 * declaration header. Report the error and switch the encoding 578 * to ISO-Latin-1 (if you don't like this policy, just declare the 579 * encoding !) 580 */ 581 if ((ctxt == NULL) || (ctxt->input == NULL) || 582 (ctxt->input->end - ctxt->input->cur < 4)) { 583 __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR, 584 "Input is not proper UTF-8, indicate encoding !\n", 585 NULL, NULL); 586 } else { 587 char buffer[150]; 588 589 snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n", 590 ctxt->input->cur[0], ctxt->input->cur[1], 591 ctxt->input->cur[2], ctxt->input->cur[3]); 592 __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR, 593 "Input is not proper UTF-8, indicate encoding !\n%s", 594 BAD_CAST buffer, NULL); 595 } 596 ctxt->charset = XML_CHAR_ENCODING_8859_1; 597 ctxt->input->cur++; 598 return; 599 } 600 601 /** 602 * xmlCurrentChar: 603 * @ctxt: the XML parser context 604 * @len: pointer to the length of the char read 605 * 606 * The current char value, if using UTF-8 this may actually span multiple 607 * bytes in the input buffer. Implement the end of line normalization: 608 * 2.11 End-of-Line Handling 609 * Wherever an external parsed entity or the literal entity value 610 * of an internal parsed entity contains either the literal two-character 611 * sequence "#xD#xA" or a standalone literal #xD, an XML processor 612 * must pass to the application the single character #xA. 613 * This behavior can conveniently be produced by normalizing all 614 * line breaks to #xA on input, before parsing.) 615 * 616 * Returns the current char value and its length 617 */ 618 619 int 620 xmlCurrentChar(xmlParserCtxtPtr ctxt, int *len) { 621 if ((ctxt == NULL) || (len == NULL) || (ctxt->input == NULL)) return(0); 622 if (ctxt->instate == XML_PARSER_EOF) 623 return(0); 624 625 if ((*ctxt->input->cur >= 0x20) && (*ctxt->input->cur <= 0x7F)) { 626 *len = 1; 627 return((int) *ctxt->input->cur); 628 } 629 if (ctxt->charset == XML_CHAR_ENCODING_UTF8) { 630 /* 631 * We are supposed to handle UTF8, check it's valid 632 * From rfc2044: encoding of the Unicode values on UTF-8: 633 * 634 * UCS-4 range (hex.) UTF-8 octet sequence (binary) 635 * 0000 0000-0000 007F 0xxxxxxx 636 * 0000 0080-0000 07FF 110xxxxx 10xxxxxx 637 * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx 638 * 639 * Check for the 0x110000 limit too 640 */ 641 const unsigned char *cur = ctxt->input->cur; 642 unsigned char c; 643 unsigned int val; 644 645 c = *cur; 646 if (c & 0x80) { 647 if (((c & 0x40) == 0) || (c == 0xC0)) 648 goto encoding_error; 649 if (cur[1] == 0) { 650 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 651 cur = ctxt->input->cur; 652 } 653 if ((cur[1] & 0xc0) != 0x80) 654 goto encoding_error; 655 if ((c & 0xe0) == 0xe0) { 656 if (cur[2] == 0) { 657 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 658 cur = ctxt->input->cur; 659 } 660 if ((cur[2] & 0xc0) != 0x80) 661 goto encoding_error; 662 if ((c & 0xf0) == 0xf0) { 663 if (cur[3] == 0) { 664 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 665 cur = ctxt->input->cur; 666 } 667 if (((c & 0xf8) != 0xf0) || 668 ((cur[3] & 0xc0) != 0x80)) 669 goto encoding_error; 670 /* 4-byte code */ 671 *len = 4; 672 val = (cur[0] & 0x7) << 18; 673 val |= (cur[1] & 0x3f) << 12; 674 val |= (cur[2] & 0x3f) << 6; 675 val |= cur[3] & 0x3f; 676 if (val < 0x10000) 677 goto encoding_error; 678 } else { 679 /* 3-byte code */ 680 *len = 3; 681 val = (cur[0] & 0xf) << 12; 682 val |= (cur[1] & 0x3f) << 6; 683 val |= cur[2] & 0x3f; 684 if (val < 0x800) 685 goto encoding_error; 686 } 687 } else { 688 /* 2-byte code */ 689 *len = 2; 690 val = (cur[0] & 0x1f) << 6; 691 val |= cur[1] & 0x3f; 692 if (val < 0x80) 693 goto encoding_error; 694 } 695 if (!IS_CHAR(val)) { 696 xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR, 697 "Char 0x%X out of allowed range\n", val); 698 } 699 return(val); 700 } else { 701 /* 1-byte code */ 702 *len = 1; 703 if (*ctxt->input->cur == 0) 704 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 705 if ((*ctxt->input->cur == 0) && 706 (ctxt->input->end > ctxt->input->cur)) { 707 xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR, 708 "Char 0x0 out of allowed range\n", 0); 709 } 710 if (*ctxt->input->cur == 0xD) { 711 if (ctxt->input->cur[1] == 0xA) { 712 ctxt->nbChars++; 713 ctxt->input->cur++; 714 } 715 return(0xA); 716 } 717 return((int) *ctxt->input->cur); 718 } 719 } 720 /* 721 * Assume it's a fixed length encoding (1) with 722 * a compatible encoding for the ASCII set, since 723 * XML constructs only use < 128 chars 724 */ 725 *len = 1; 726 if (*ctxt->input->cur == 0xD) { 727 if (ctxt->input->cur[1] == 0xA) { 728 ctxt->nbChars++; 729 ctxt->input->cur++; 730 } 731 return(0xA); 732 } 733 return((int) *ctxt->input->cur); 734 encoding_error: 735 /* 736 * An encoding problem may arise from a truncated input buffer 737 * splitting a character in the middle. In that case do not raise 738 * an error but return 0 to endicate an end of stream problem 739 */ 740 if (ctxt->input->end - ctxt->input->cur < 4) { 741 *len = 0; 742 return(0); 743 } 744 745 /* 746 * If we detect an UTF8 error that probably mean that the 747 * input encoding didn't get properly advertised in the 748 * declaration header. Report the error and switch the encoding 749 * to ISO-Latin-1 (if you don't like this policy, just declare the 750 * encoding !) 751 */ 752 { 753 char buffer[150]; 754 755 snprintf(&buffer[0], 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n", 756 ctxt->input->cur[0], ctxt->input->cur[1], 757 ctxt->input->cur[2], ctxt->input->cur[3]); 758 __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR, 759 "Input is not proper UTF-8, indicate encoding !\n%s", 760 BAD_CAST buffer, NULL); 761 } 762 ctxt->charset = XML_CHAR_ENCODING_8859_1; 763 *len = 1; 764 return((int) *ctxt->input->cur); 765 } 766 767 /** 768 * xmlStringCurrentChar: 769 * @ctxt: the XML parser context 770 * @cur: pointer to the beginning of the char 771 * @len: pointer to the length of the char read 772 * 773 * The current char value, if using UTF-8 this may actually span multiple 774 * bytes in the input buffer. 775 * 776 * Returns the current char value and its length 777 */ 778 779 int 780 xmlStringCurrentChar(xmlParserCtxtPtr ctxt, const xmlChar * cur, int *len) 781 { 782 if ((len == NULL) || (cur == NULL)) return(0); 783 if ((ctxt == NULL) || (ctxt->charset == XML_CHAR_ENCODING_UTF8)) { 784 /* 785 * We are supposed to handle UTF8, check it's valid 786 * From rfc2044: encoding of the Unicode values on UTF-8: 787 * 788 * UCS-4 range (hex.) UTF-8 octet sequence (binary) 789 * 0000 0000-0000 007F 0xxxxxxx 790 * 0000 0080-0000 07FF 110xxxxx 10xxxxxx 791 * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx 792 * 793 * Check for the 0x110000 limit too 794 */ 795 unsigned char c; 796 unsigned int val; 797 798 c = *cur; 799 if (c & 0x80) { 800 if ((cur[1] & 0xc0) != 0x80) 801 goto encoding_error; 802 if ((c & 0xe0) == 0xe0) { 803 804 if ((cur[2] & 0xc0) != 0x80) 805 goto encoding_error; 806 if ((c & 0xf0) == 0xf0) { 807 if (((c & 0xf8) != 0xf0) || ((cur[3] & 0xc0) != 0x80)) 808 goto encoding_error; 809 /* 4-byte code */ 810 *len = 4; 811 val = (cur[0] & 0x7) << 18; 812 val |= (cur[1] & 0x3f) << 12; 813 val |= (cur[2] & 0x3f) << 6; 814 val |= cur[3] & 0x3f; 815 } else { 816 /* 3-byte code */ 817 *len = 3; 818 val = (cur[0] & 0xf) << 12; 819 val |= (cur[1] & 0x3f) << 6; 820 val |= cur[2] & 0x3f; 821 } 822 } else { 823 /* 2-byte code */ 824 *len = 2; 825 val = (cur[0] & 0x1f) << 6; 826 val |= cur[1] & 0x3f; 827 } 828 if (!IS_CHAR(val)) { 829 xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR, 830 "Char 0x%X out of allowed range\n", val); 831 } 832 return (val); 833 } else { 834 /* 1-byte code */ 835 *len = 1; 836 return ((int) *cur); 837 } 838 } 839 /* 840 * Assume it's a fixed length encoding (1) with 841 * a compatible encoding for the ASCII set, since 842 * XML constructs only use < 128 chars 843 */ 844 *len = 1; 845 return ((int) *cur); 846 encoding_error: 847 848 /* 849 * An encoding problem may arise from a truncated input buffer 850 * splitting a character in the middle. In that case do not raise 851 * an error but return 0 to endicate an end of stream problem 852 */ 853 if ((ctxt == NULL) || (ctxt->input == NULL) || 854 (ctxt->input->end - ctxt->input->cur < 4)) { 855 *len = 0; 856 return(0); 857 } 858 /* 859 * If we detect an UTF8 error that probably mean that the 860 * input encoding didn't get properly advertised in the 861 * declaration header. Report the error and switch the encoding 862 * to ISO-Latin-1 (if you don't like this policy, just declare the 863 * encoding !) 864 */ 865 { 866 char buffer[150]; 867 868 snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n", 869 ctxt->input->cur[0], ctxt->input->cur[1], 870 ctxt->input->cur[2], ctxt->input->cur[3]); 871 __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR, 872 "Input is not proper UTF-8, indicate encoding !\n%s", 873 BAD_CAST buffer, NULL); 874 } 875 *len = 1; 876 return ((int) *cur); 877 } 878 879 /** 880 * xmlCopyCharMultiByte: 881 * @out: pointer to an array of xmlChar 882 * @val: the char value 883 * 884 * append the char value in the array 885 * 886 * Returns the number of xmlChar written 887 */ 888 int 889 xmlCopyCharMultiByte(xmlChar *out, int val) { 890 if (out == NULL) return(0); 891 /* 892 * We are supposed to handle UTF8, check it's valid 893 * From rfc2044: encoding of the Unicode values on UTF-8: 894 * 895 * UCS-4 range (hex.) UTF-8 octet sequence (binary) 896 * 0000 0000-0000 007F 0xxxxxxx 897 * 0000 0080-0000 07FF 110xxxxx 10xxxxxx 898 * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx 899 */ 900 if (val >= 0x80) { 901 xmlChar *savedout = out; 902 int bits; 903 if (val < 0x800) { *out++= (val >> 6) | 0xC0; bits= 0; } 904 else if (val < 0x10000) { *out++= (val >> 12) | 0xE0; bits= 6;} 905 else if (val < 0x110000) { *out++= (val >> 18) | 0xF0; bits= 12; } 906 else { 907 xmlErrEncodingInt(NULL, XML_ERR_INVALID_CHAR, 908 "Internal error, xmlCopyCharMultiByte 0x%X out of bound\n", 909 val); 910 return(0); 911 } 912 for ( ; bits >= 0; bits-= 6) 913 *out++= ((val >> bits) & 0x3F) | 0x80 ; 914 return (out - savedout); 915 } 916 *out = (xmlChar) val; 917 return 1; 918 } 919 920 /** 921 * xmlCopyChar: 922 * @len: Ignored, compatibility 923 * @out: pointer to an array of xmlChar 924 * @val: the char value 925 * 926 * append the char value in the array 927 * 928 * Returns the number of xmlChar written 929 */ 930 931 int 932 xmlCopyChar(int len ATTRIBUTE_UNUSED, xmlChar *out, int val) { 933 if (out == NULL) return(0); 934 /* the len parameter is ignored */ 935 if (val >= 0x80) { 936 return(xmlCopyCharMultiByte (out, val)); 937 } 938 *out = (xmlChar) val; 939 return 1; 940 } 941 942 /************************************************************************ 943 * * 944 * Commodity functions to switch encodings * 945 * * 946 ************************************************************************/ 947 948 /* defined in encoding.c, not public */ 949 int 950 xmlCharEncFirstLineInt(xmlCharEncodingHandler *handler, xmlBufferPtr out, 951 xmlBufferPtr in, int len); 952 953 static int 954 xmlSwitchToEncodingInt(xmlParserCtxtPtr ctxt, 955 xmlCharEncodingHandlerPtr handler, int len); 956 static int 957 xmlSwitchInputEncodingInt(xmlParserCtxtPtr ctxt, xmlParserInputPtr input, 958 xmlCharEncodingHandlerPtr handler, int len); 959 /** 960 * xmlSwitchEncoding: 961 * @ctxt: the parser context 962 * @enc: the encoding value (number) 963 * 964 * change the input functions when discovering the character encoding 965 * of a given entity. 966 * 967 * Returns 0 in case of success, -1 otherwise 968 */ 969 int 970 xmlSwitchEncoding(xmlParserCtxtPtr ctxt, xmlCharEncoding enc) 971 { 972 xmlCharEncodingHandlerPtr handler; 973 int len = -1; 974 975 if (ctxt == NULL) return(-1); 976 switch (enc) { 977 case XML_CHAR_ENCODING_ERROR: 978 __xmlErrEncoding(ctxt, XML_ERR_UNKNOWN_ENCODING, 979 "encoding unknown\n", NULL, NULL); 980 return(-1); 981 case XML_CHAR_ENCODING_NONE: 982 /* let's assume it's UTF-8 without the XML decl */ 983 ctxt->charset = XML_CHAR_ENCODING_UTF8; 984 return(0); 985 case XML_CHAR_ENCODING_UTF8: 986 /* default encoding, no conversion should be needed */ 987 ctxt->charset = XML_CHAR_ENCODING_UTF8; 988 989 /* 990 * Errata on XML-1.0 June 20 2001 991 * Specific handling of the Byte Order Mark for 992 * UTF-8 993 */ 994 if ((ctxt->input != NULL) && 995 (ctxt->input->cur[0] == 0xEF) && 996 (ctxt->input->cur[1] == 0xBB) && 997 (ctxt->input->cur[2] == 0xBF)) { 998 ctxt->input->cur += 3; 999 } 1000 return(0); 1001 case XML_CHAR_ENCODING_UTF16LE: 1002 case XML_CHAR_ENCODING_UTF16BE: 1003 /*The raw input characters are encoded 1004 *in UTF-16. As we expect this function 1005 *to be called after xmlCharEncInFunc, we expect 1006 *ctxt->input->cur to contain UTF-8 encoded characters. 1007 *So the raw UTF16 Byte Order Mark 1008 *has also been converted into 1009 *an UTF-8 BOM. Let's skip that BOM. 1010 */ 1011 if ((ctxt->input != NULL) && (ctxt->input->cur != NULL) && 1012 (ctxt->input->cur[0] == 0xEF) && 1013 (ctxt->input->cur[1] == 0xBB) && 1014 (ctxt->input->cur[2] == 0xBF)) { 1015 ctxt->input->cur += 3; 1016 } 1017 len = 90; 1018 break; 1019 case XML_CHAR_ENCODING_UCS2: 1020 len = 90; 1021 break; 1022 case XML_CHAR_ENCODING_UCS4BE: 1023 case XML_CHAR_ENCODING_UCS4LE: 1024 case XML_CHAR_ENCODING_UCS4_2143: 1025 case XML_CHAR_ENCODING_UCS4_3412: 1026 len = 180; 1027 break; 1028 case XML_CHAR_ENCODING_EBCDIC: 1029 case XML_CHAR_ENCODING_8859_1: 1030 case XML_CHAR_ENCODING_8859_2: 1031 case XML_CHAR_ENCODING_8859_3: 1032 case XML_CHAR_ENCODING_8859_4: 1033 case XML_CHAR_ENCODING_8859_5: 1034 case XML_CHAR_ENCODING_8859_6: 1035 case XML_CHAR_ENCODING_8859_7: 1036 case XML_CHAR_ENCODING_8859_8: 1037 case XML_CHAR_ENCODING_8859_9: 1038 case XML_CHAR_ENCODING_ASCII: 1039 case XML_CHAR_ENCODING_2022_JP: 1040 case XML_CHAR_ENCODING_SHIFT_JIS: 1041 case XML_CHAR_ENCODING_EUC_JP: 1042 len = 45; 1043 break; 1044 } 1045 handler = xmlGetCharEncodingHandler(enc); 1046 if (handler == NULL) { 1047 /* 1048 * Default handlers. 1049 */ 1050 switch (enc) { 1051 case XML_CHAR_ENCODING_ASCII: 1052 /* default encoding, no conversion should be needed */ 1053 ctxt->charset = XML_CHAR_ENCODING_UTF8; 1054 return(0); 1055 case XML_CHAR_ENCODING_UTF16LE: 1056 break; 1057 case XML_CHAR_ENCODING_UTF16BE: 1058 break; 1059 case XML_CHAR_ENCODING_UCS4LE: 1060 __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 1061 "encoding not supported %s\n", 1062 BAD_CAST "USC4 little endian", NULL); 1063 break; 1064 case XML_CHAR_ENCODING_UCS4BE: 1065 __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 1066 "encoding not supported %s\n", 1067 BAD_CAST "USC4 big endian", NULL); 1068 break; 1069 case XML_CHAR_ENCODING_EBCDIC: 1070 __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 1071 "encoding not supported %s\n", 1072 BAD_CAST "EBCDIC", NULL); 1073 break; 1074 case XML_CHAR_ENCODING_UCS4_2143: 1075 __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 1076 "encoding not supported %s\n", 1077 BAD_CAST "UCS4 2143", NULL); 1078 break; 1079 case XML_CHAR_ENCODING_UCS4_3412: 1080 __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 1081 "encoding not supported %s\n", 1082 BAD_CAST "UCS4 3412", NULL); 1083 break; 1084 case XML_CHAR_ENCODING_UCS2: 1085 __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 1086 "encoding not supported %s\n", 1087 BAD_CAST "UCS2", NULL); 1088 break; 1089 case XML_CHAR_ENCODING_8859_1: 1090 case XML_CHAR_ENCODING_8859_2: 1091 case XML_CHAR_ENCODING_8859_3: 1092 case XML_CHAR_ENCODING_8859_4: 1093 case XML_CHAR_ENCODING_8859_5: 1094 case XML_CHAR_ENCODING_8859_6: 1095 case XML_CHAR_ENCODING_8859_7: 1096 case XML_CHAR_ENCODING_8859_8: 1097 case XML_CHAR_ENCODING_8859_9: 1098 /* 1099 * We used to keep the internal content in the 1100 * document encoding however this turns being unmaintainable 1101 * So xmlGetCharEncodingHandler() will return non-null 1102 * values for this now. 1103 */ 1104 if ((ctxt->inputNr == 1) && 1105 (ctxt->encoding == NULL) && 1106 (ctxt->input != NULL) && 1107 (ctxt->input->encoding != NULL)) { 1108 ctxt->encoding = xmlStrdup(ctxt->input->encoding); 1109 } 1110 ctxt->charset = enc; 1111 return(0); 1112 case XML_CHAR_ENCODING_2022_JP: 1113 __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 1114 "encoding not supported %s\n", 1115 BAD_CAST "ISO-2022-JP", NULL); 1116 break; 1117 case XML_CHAR_ENCODING_SHIFT_JIS: 1118 __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 1119 "encoding not supported %s\n", 1120 BAD_CAST "Shift_JIS", NULL); 1121 break; 1122 case XML_CHAR_ENCODING_EUC_JP: 1123 __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 1124 "encoding not supported %s\n", 1125 BAD_CAST "EUC-JP", NULL); 1126 break; 1127 default: 1128 break; 1129 } 1130 } 1131 if (handler == NULL) 1132 return(-1); 1133 ctxt->charset = XML_CHAR_ENCODING_UTF8; 1134 return(xmlSwitchToEncodingInt(ctxt, handler, len)); 1135 } 1136 1137 /** 1138 * xmlSwitchInputEncoding: 1139 * @ctxt: the parser context 1140 * @input: the input stream 1141 * @handler: the encoding handler 1142 * @len: the number of bytes to convert for the first line or -1 1143 * 1144 * change the input functions when discovering the character encoding 1145 * of a given entity. 1146 * 1147 * Returns 0 in case of success, -1 otherwise 1148 */ 1149 static int 1150 xmlSwitchInputEncodingInt(xmlParserCtxtPtr ctxt, xmlParserInputPtr input, 1151 xmlCharEncodingHandlerPtr handler, int len) 1152 { 1153 int nbchars; 1154 1155 if (handler == NULL) 1156 return (-1); 1157 if (input == NULL) 1158 return (-1); 1159 if (input->buf != NULL) { 1160 if (input->buf->encoder != NULL) { 1161 /* 1162 * Check in case the auto encoding detetection triggered 1163 * in already. 1164 */ 1165 if (input->buf->encoder == handler) 1166 return (0); 1167 1168 /* 1169 * "UTF-16" can be used for both LE and BE 1170 if ((!xmlStrncmp(BAD_CAST input->buf->encoder->name, 1171 BAD_CAST "UTF-16", 6)) && 1172 (!xmlStrncmp(BAD_CAST handler->name, 1173 BAD_CAST "UTF-16", 6))) { 1174 return(0); 1175 } 1176 */ 1177 1178 /* 1179 * Note: this is a bit dangerous, but that's what it 1180 * takes to use nearly compatible signature for different 1181 * encodings. 1182 */ 1183 xmlCharEncCloseFunc(input->buf->encoder); 1184 input->buf->encoder = handler; 1185 return (0); 1186 } 1187 input->buf->encoder = handler; 1188 1189 /* 1190 * Is there already some content down the pipe to convert ? 1191 */ 1192 if ((input->buf->buffer != NULL) && (input->buf->buffer->use > 0)) { 1193 int processed; 1194 unsigned int use; 1195 1196 /* 1197 * Specific handling of the Byte Order Mark for 1198 * UTF-16 1199 */ 1200 if ((handler->name != NULL) && 1201 (!strcmp(handler->name, "UTF-16LE") || 1202 !strcmp(handler->name, "UTF-16")) && 1203 (input->cur[0] == 0xFF) && (input->cur[1] == 0xFE)) { 1204 input->cur += 2; 1205 } 1206 if ((handler->name != NULL) && 1207 (!strcmp(handler->name, "UTF-16BE")) && 1208 (input->cur[0] == 0xFE) && (input->cur[1] == 0xFF)) { 1209 input->cur += 2; 1210 } 1211 /* 1212 * Errata on XML-1.0 June 20 2001 1213 * Specific handling of the Byte Order Mark for 1214 * UTF-8 1215 */ 1216 if ((handler->name != NULL) && 1217 (!strcmp(handler->name, "UTF-8")) && 1218 (input->cur[0] == 0xEF) && 1219 (input->cur[1] == 0xBB) && (input->cur[2] == 0xBF)) { 1220 input->cur += 3; 1221 } 1222 1223 /* 1224 * Shrink the current input buffer. 1225 * Move it as the raw buffer and create a new input buffer 1226 */ 1227 processed = input->cur - input->base; 1228 xmlBufferShrink(input->buf->buffer, processed); 1229 input->buf->raw = input->buf->buffer; 1230 input->buf->buffer = xmlBufferCreate(); 1231 input->buf->rawconsumed = processed; 1232 use = input->buf->raw->use; 1233 1234 if (ctxt->html) { 1235 /* 1236 * convert as much as possible of the buffer 1237 */ 1238 nbchars = xmlCharEncInFunc(input->buf->encoder, 1239 input->buf->buffer, 1240 input->buf->raw); 1241 } else { 1242 /* 1243 * convert just enough to get 1244 * '<?xml version="1.0" encoding="xxx"?>' 1245 * parsed with the autodetected encoding 1246 * into the parser reading buffer. 1247 */ 1248 nbchars = xmlCharEncFirstLineInt(input->buf->encoder, 1249 input->buf->buffer, 1250 input->buf->raw, 1251 len); 1252 } 1253 if (nbchars < 0) { 1254 xmlErrInternal(ctxt, 1255 "switching encoding: encoder error\n", 1256 NULL); 1257 return (-1); 1258 } 1259 input->buf->rawconsumed += use - input->buf->raw->use; 1260 input->base = input->cur = input->buf->buffer->content; 1261 input->end = &input->base[input->buf->buffer->use]; 1262 1263 } 1264 return (0); 1265 } else if (input->length == 0) { 1266 /* 1267 * When parsing a static memory array one must know the 1268 * size to be able to convert the buffer. 1269 */ 1270 xmlErrInternal(ctxt, "switching encoding : no input\n", NULL); 1271 return (-1); 1272 } 1273 return (0); 1274 } 1275 1276 /** 1277 * xmlSwitchInputEncoding: 1278 * @ctxt: the parser context 1279 * @input: the input stream 1280 * @handler: the encoding handler 1281 * 1282 * change the input functions when discovering the character encoding 1283 * of a given entity. 1284 * 1285 * Returns 0 in case of success, -1 otherwise 1286 */ 1287 int 1288 xmlSwitchInputEncoding(xmlParserCtxtPtr ctxt, xmlParserInputPtr input, 1289 xmlCharEncodingHandlerPtr handler) { 1290 return(xmlSwitchInputEncodingInt(ctxt, input, handler, -1)); 1291 } 1292 1293 /** 1294 * xmlSwitchToEncodingInt: 1295 * @ctxt: the parser context 1296 * @handler: the encoding handler 1297 * @len: the lenght to convert or -1 1298 * 1299 * change the input functions when discovering the character encoding 1300 * of a given entity, and convert only @len bytes of the output, this 1301 * is needed on auto detect to allows any declared encoding later to 1302 * convert the actual content after the xmlDecl 1303 * 1304 * Returns 0 in case of success, -1 otherwise 1305 */ 1306 static int 1307 xmlSwitchToEncodingInt(xmlParserCtxtPtr ctxt, 1308 xmlCharEncodingHandlerPtr handler, int len) { 1309 int ret = 0; 1310 1311 if (handler != NULL) { 1312 if (ctxt->input != NULL) { 1313 ret = xmlSwitchInputEncodingInt(ctxt, ctxt->input, handler, len); 1314 } else { 1315 xmlErrInternal(ctxt, "xmlSwitchToEncoding : no input\n", 1316 NULL); 1317 return(-1); 1318 } 1319 /* 1320 * The parsing is now done in UTF8 natively 1321 */ 1322 ctxt->charset = XML_CHAR_ENCODING_UTF8; 1323 } else 1324 return(-1); 1325 return(ret); 1326 } 1327 1328 /** 1329 * xmlSwitchToEncoding: 1330 * @ctxt: the parser context 1331 * @handler: the encoding handler 1332 * 1333 * change the input functions when discovering the character encoding 1334 * of a given entity. 1335 * 1336 * Returns 0 in case of success, -1 otherwise 1337 */ 1338 int 1339 xmlSwitchToEncoding(xmlParserCtxtPtr ctxt, xmlCharEncodingHandlerPtr handler) 1340 { 1341 return (xmlSwitchToEncodingInt(ctxt, handler, -1)); 1342 } 1343 1344 /************************************************************************ 1345 * * 1346 * Commodity functions to handle entities processing * 1347 * * 1348 ************************************************************************/ 1349 1350 /** 1351 * xmlFreeInputStream: 1352 * @input: an xmlParserInputPtr 1353 * 1354 * Free up an input stream. 1355 */ 1356 void 1357 xmlFreeInputStream(xmlParserInputPtr input) { 1358 if (input == NULL) return; 1359 1360 if (input->filename != NULL) xmlFree((char *) input->filename); 1361 if (input->directory != NULL) xmlFree((char *) input->directory); 1362 if (input->encoding != NULL) xmlFree((char *) input->encoding); 1363 if (input->version != NULL) xmlFree((char *) input->version); 1364 if ((input->free != NULL) && (input->base != NULL)) 1365 input->free((xmlChar *) input->base); 1366 if (input->buf != NULL) 1367 xmlFreeParserInputBuffer(input->buf); 1368 xmlFree(input); 1369 } 1370 1371 /** 1372 * xmlNewInputStream: 1373 * @ctxt: an XML parser context 1374 * 1375 * Create a new input stream structure 1376 * Returns the new input stream or NULL 1377 */ 1378 xmlParserInputPtr 1379 xmlNewInputStream(xmlParserCtxtPtr ctxt) { 1380 xmlParserInputPtr input; 1381 static int id = 0; 1382 1383 input = (xmlParserInputPtr) xmlMalloc(sizeof(xmlParserInput)); 1384 if (input == NULL) { 1385 xmlErrMemory(ctxt, "couldn't allocate a new input stream\n"); 1386 return(NULL); 1387 } 1388 memset(input, 0, sizeof(xmlParserInput)); 1389 input->line = 1; 1390 input->col = 1; 1391 input->standalone = -1; 1392 /* 1393 * we don't care about thread reentrancy unicity for a single 1394 * parser context (and hence thread) is sufficient. 1395 */ 1396 input->id = id++; 1397 return(input); 1398 } 1399 1400 /** 1401 * xmlNewIOInputStream: 1402 * @ctxt: an XML parser context 1403 * @input: an I/O Input 1404 * @enc: the charset encoding if known 1405 * 1406 * Create a new input stream structure encapsulating the @input into 1407 * a stream suitable for the parser. 1408 * 1409 * Returns the new input stream or NULL 1410 */ 1411 xmlParserInputPtr 1412 xmlNewIOInputStream(xmlParserCtxtPtr ctxt, xmlParserInputBufferPtr input, 1413 xmlCharEncoding enc) { 1414 xmlParserInputPtr inputStream; 1415 1416 if (input == NULL) return(NULL); 1417 if (xmlParserDebugEntities) 1418 xmlGenericError(xmlGenericErrorContext, "new input from I/O\n"); 1419 inputStream = xmlNewInputStream(ctxt); 1420 if (inputStream == NULL) { 1421 return(NULL); 1422 } 1423 inputStream->filename = NULL; 1424 inputStream->buf = input; 1425 inputStream->base = inputStream->buf->buffer->content; 1426 inputStream->cur = inputStream->buf->buffer->content; 1427 inputStream->end = &inputStream->base[inputStream->buf->buffer->use]; 1428 if (enc != XML_CHAR_ENCODING_NONE) { 1429 xmlSwitchEncoding(ctxt, enc); 1430 } 1431 1432 return(inputStream); 1433 } 1434 1435 /** 1436 * xmlNewEntityInputStream: 1437 * @ctxt: an XML parser context 1438 * @entity: an Entity pointer 1439 * 1440 * Create a new input stream based on an xmlEntityPtr 1441 * 1442 * Returns the new input stream or NULL 1443 */ 1444 xmlParserInputPtr 1445 xmlNewEntityInputStream(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) { 1446 xmlParserInputPtr input; 1447 1448 if (entity == NULL) { 1449 xmlErrInternal(ctxt, "xmlNewEntityInputStream entity = NULL\n", 1450 NULL); 1451 return(NULL); 1452 } 1453 if (xmlParserDebugEntities) 1454 xmlGenericError(xmlGenericErrorContext, 1455 "new input from entity: %s\n", entity->name); 1456 if (entity->content == NULL) { 1457 switch (entity->etype) { 1458 case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY: 1459 xmlErrInternal(ctxt, "Cannot parse entity %s\n", 1460 entity->name); 1461 break; 1462 case XML_EXTERNAL_GENERAL_PARSED_ENTITY: 1463 case XML_EXTERNAL_PARAMETER_ENTITY: 1464 return(xmlLoadExternalEntity((char *) entity->URI, 1465 (char *) entity->ExternalID, ctxt)); 1466 case XML_INTERNAL_GENERAL_ENTITY: 1467 xmlErrInternal(ctxt, 1468 "Internal entity %s without content !\n", 1469 entity->name); 1470 break; 1471 case XML_INTERNAL_PARAMETER_ENTITY: 1472 xmlErrInternal(ctxt, 1473 "Internal parameter entity %s without content !\n", 1474 entity->name); 1475 break; 1476 case XML_INTERNAL_PREDEFINED_ENTITY: 1477 xmlErrInternal(ctxt, 1478 "Predefined entity %s without content !\n", 1479 entity->name); 1480 break; 1481 } 1482 return(NULL); 1483 } 1484 input = xmlNewInputStream(ctxt); 1485 if (input == NULL) { 1486 return(NULL); 1487 } 1488 if (entity->URI != NULL) 1489 input->filename = (char *) xmlStrdup((xmlChar *) entity->URI); 1490 input->base = entity->content; 1491 input->cur = entity->content; 1492 input->length = entity->length; 1493 input->end = &entity->content[input->length]; 1494 return(input); 1495 } 1496 1497 /** 1498 * xmlNewStringInputStream: 1499 * @ctxt: an XML parser context 1500 * @buffer: an memory buffer 1501 * 1502 * Create a new input stream based on a memory buffer. 1503 * Returns the new input stream 1504 */ 1505 xmlParserInputPtr 1506 xmlNewStringInputStream(xmlParserCtxtPtr ctxt, const xmlChar *buffer) { 1507 xmlParserInputPtr input; 1508 1509 if (buffer == NULL) { 1510 xmlErrInternal(ctxt, "xmlNewStringInputStream string = NULL\n", 1511 NULL); 1512 return(NULL); 1513 } 1514 if (xmlParserDebugEntities) 1515 xmlGenericError(xmlGenericErrorContext, 1516 "new fixed input: %.30s\n", buffer); 1517 input = xmlNewInputStream(ctxt); 1518 if (input == NULL) { 1519 xmlErrMemory(ctxt, "couldn't allocate a new input stream\n"); 1520 return(NULL); 1521 } 1522 input->base = buffer; 1523 input->cur = buffer; 1524 input->length = xmlStrlen(buffer); 1525 input->end = &buffer[input->length]; 1526 return(input); 1527 } 1528 1529 /** 1530 * xmlNewInputFromFile: 1531 * @ctxt: an XML parser context 1532 * @filename: the filename to use as entity 1533 * 1534 * Create a new input stream based on a file or an URL. 1535 * 1536 * Returns the new input stream or NULL in case of error 1537 */ 1538 xmlParserInputPtr 1539 xmlNewInputFromFile(xmlParserCtxtPtr ctxt, const char *filename) { 1540 xmlParserInputBufferPtr buf; 1541 xmlParserInputPtr inputStream; 1542 char *directory = NULL; 1543 xmlChar *URI = NULL; 1544 1545 if (xmlParserDebugEntities) 1546 xmlGenericError(xmlGenericErrorContext, 1547 "new input from file: %s\n", filename); 1548 if (ctxt == NULL) return(NULL); 1549 buf = xmlParserInputBufferCreateFilename(filename, XML_CHAR_ENCODING_NONE); 1550 if (buf == NULL) { 1551 if (filename == NULL) 1552 __xmlLoaderErr(ctxt, 1553 "failed to load external entity: NULL filename \n", 1554 NULL); 1555 else 1556 __xmlLoaderErr(ctxt, "failed to load external entity \"%s\"\n", 1557 (const char *) filename); 1558 return(NULL); 1559 } 1560 1561 inputStream = xmlNewInputStream(ctxt); 1562 if (inputStream == NULL) 1563 return(NULL); 1564 1565 inputStream->buf = buf; 1566 inputStream = xmlCheckHTTPInput(ctxt, inputStream); 1567 if (inputStream == NULL) 1568 return(NULL); 1569 1570 if (inputStream->filename == NULL) 1571 URI = xmlStrdup((xmlChar *) filename); 1572 else 1573 URI = xmlStrdup((xmlChar *) inputStream->filename); 1574 directory = xmlParserGetDirectory((const char *) URI); 1575 if (inputStream->filename != NULL) xmlFree((char *)inputStream->filename); 1576 inputStream->filename = (char *) xmlCanonicPath((const xmlChar *) URI); 1577 if (URI != NULL) xmlFree((char *) URI); 1578 inputStream->directory = directory; 1579 1580 inputStream->base = inputStream->buf->buffer->content; 1581 inputStream->cur = inputStream->buf->buffer->content; 1582 inputStream->end = &inputStream->base[inputStream->buf->buffer->use]; 1583 if ((ctxt->directory == NULL) && (directory != NULL)) 1584 ctxt->directory = (char *) xmlStrdup((const xmlChar *) directory); 1585 return(inputStream); 1586 } 1587 1588 /************************************************************************ 1589 * * 1590 * Commodity functions to handle parser contexts * 1591 * * 1592 ************************************************************************/ 1593 1594 /** 1595 * xmlInitParserCtxt: 1596 * @ctxt: an XML parser context 1597 * 1598 * Initialize a parser context 1599 * 1600 * Returns 0 in case of success and -1 in case of error 1601 */ 1602 1603 int 1604 xmlInitParserCtxt(xmlParserCtxtPtr ctxt) 1605 { 1606 xmlParserInputPtr input; 1607 1608 if(ctxt==NULL) { 1609 xmlErrInternal(NULL, "Got NULL parser context\n", NULL); 1610 return(-1); 1611 } 1612 1613 xmlDefaultSAXHandlerInit(); 1614 1615 if (ctxt->dict == NULL) 1616 ctxt->dict = xmlDictCreate(); 1617 if (ctxt->dict == NULL) { 1618 xmlErrMemory(NULL, "cannot initialize parser context\n"); 1619 return(-1); 1620 } 1621 if (ctxt->sax == NULL) 1622 ctxt->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler)); 1623 if (ctxt->sax == NULL) { 1624 xmlErrMemory(NULL, "cannot initialize parser context\n"); 1625 return(-1); 1626 } 1627 else 1628 xmlSAXVersion(ctxt->sax, 2); 1629 1630 ctxt->maxatts = 0; 1631 ctxt->atts = NULL; 1632 /* Allocate the Input stack */ 1633 if (ctxt->inputTab == NULL) { 1634 ctxt->inputTab = (xmlParserInputPtr *) 1635 xmlMalloc(5 * sizeof(xmlParserInputPtr)); 1636 ctxt->inputMax = 5; 1637 } 1638 if (ctxt->inputTab == NULL) { 1639 xmlErrMemory(NULL, "cannot initialize parser context\n"); 1640 ctxt->inputNr = 0; 1641 ctxt->inputMax = 0; 1642 ctxt->input = NULL; 1643 return(-1); 1644 } 1645 while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */ 1646 xmlFreeInputStream(input); 1647 } 1648 ctxt->inputNr = 0; 1649 ctxt->input = NULL; 1650 1651 ctxt->version = NULL; 1652 ctxt->encoding = NULL; 1653 ctxt->standalone = -1; 1654 ctxt->hasExternalSubset = 0; 1655 ctxt->hasPErefs = 0; 1656 ctxt->html = 0; 1657 ctxt->external = 0; 1658 ctxt->instate = XML_PARSER_START; 1659 ctxt->token = 0; 1660 ctxt->directory = NULL; 1661 1662 /* Allocate the Node stack */ 1663 if (ctxt->nodeTab == NULL) { 1664 ctxt->nodeTab = (xmlNodePtr *) xmlMalloc(10 * sizeof(xmlNodePtr)); 1665 ctxt->nodeMax = 10; 1666 } 1667 if (ctxt->nodeTab == NULL) { 1668 xmlErrMemory(NULL, "cannot initialize parser context\n"); 1669 ctxt->nodeNr = 0; 1670 ctxt->nodeMax = 0; 1671 ctxt->node = NULL; 1672 ctxt->inputNr = 0; 1673 ctxt->inputMax = 0; 1674 ctxt->input = NULL; 1675 return(-1); 1676 } 1677 ctxt->nodeNr = 0; 1678 ctxt->node = NULL; 1679 1680 /* Allocate the Name stack */ 1681 if (ctxt->nameTab == NULL) { 1682 ctxt->nameTab = (const xmlChar **) xmlMalloc(10 * sizeof(xmlChar *)); 1683 ctxt->nameMax = 10; 1684 } 1685 if (ctxt->nameTab == NULL) { 1686 xmlErrMemory(NULL, "cannot initialize parser context\n"); 1687 ctxt->nodeNr = 0; 1688 ctxt->nodeMax = 0; 1689 ctxt->node = NULL; 1690 ctxt->inputNr = 0; 1691 ctxt->inputMax = 0; 1692 ctxt->input = NULL; 1693 ctxt->nameNr = 0; 1694 ctxt->nameMax = 0; 1695 ctxt->name = NULL; 1696 return(-1); 1697 } 1698 ctxt->nameNr = 0; 1699 ctxt->name = NULL; 1700 1701 /* Allocate the space stack */ 1702 if (ctxt->spaceTab == NULL) { 1703 ctxt->spaceTab = (int *) xmlMalloc(10 * sizeof(int)); 1704 ctxt->spaceMax = 10; 1705 } 1706 if (ctxt->spaceTab == NULL) { 1707 xmlErrMemory(NULL, "cannot initialize parser context\n"); 1708 ctxt->nodeNr = 0; 1709 ctxt->nodeMax = 0; 1710 ctxt->node = NULL; 1711 ctxt->inputNr = 0; 1712 ctxt->inputMax = 0; 1713 ctxt->input = NULL; 1714 ctxt->nameNr = 0; 1715 ctxt->nameMax = 0; 1716 ctxt->name = NULL; 1717 ctxt->spaceNr = 0; 1718 ctxt->spaceMax = 0; 1719 ctxt->space = NULL; 1720 return(-1); 1721 } 1722 ctxt->spaceNr = 1; 1723 ctxt->spaceMax = 10; 1724 ctxt->spaceTab[0] = -1; 1725 ctxt->space = &ctxt->spaceTab[0]; 1726 ctxt->userData = ctxt; 1727 ctxt->myDoc = NULL; 1728 ctxt->wellFormed = 1; 1729 ctxt->nsWellFormed = 1; 1730 ctxt->valid = 1; 1731 ctxt->loadsubset = xmlLoadExtDtdDefaultValue; 1732 ctxt->validate = xmlDoValidityCheckingDefaultValue; 1733 ctxt->pedantic = xmlPedanticParserDefaultValue; 1734 ctxt->linenumbers = xmlLineNumbersDefaultValue; 1735 ctxt->keepBlanks = xmlKeepBlanksDefaultValue; 1736 if (ctxt->keepBlanks == 0) 1737 ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace; 1738 1739 ctxt->vctxt.finishDtd = XML_CTXT_FINISH_DTD_0; 1740 ctxt->vctxt.userData = ctxt; 1741 ctxt->vctxt.error = xmlParserValidityError; 1742 ctxt->vctxt.warning = xmlParserValidityWarning; 1743 if (ctxt->validate) { 1744 if (xmlGetWarningsDefaultValue == 0) 1745 ctxt->vctxt.warning = NULL; 1746 else 1747 ctxt->vctxt.warning = xmlParserValidityWarning; 1748 ctxt->vctxt.nodeMax = 0; 1749 } 1750 ctxt->replaceEntities = xmlSubstituteEntitiesDefaultValue; 1751 ctxt->record_info = 0; 1752 ctxt->nbChars = 0; 1753 ctxt->checkIndex = 0; 1754 ctxt->inSubset = 0; 1755 ctxt->errNo = XML_ERR_OK; 1756 ctxt->depth = 0; 1757 ctxt->charset = XML_CHAR_ENCODING_UTF8; 1758 ctxt->catalogs = NULL; 1759 ctxt->nbentities = 0; 1760 xmlInitNodeInfoSeq(&ctxt->node_seq); 1761 return(0); 1762 } 1763 1764 /** 1765 * xmlFreeParserCtxt: 1766 * @ctxt: an XML parser context 1767 * 1768 * Free all the memory used by a parser context. However the parsed 1769 * document in ctxt->myDoc is not freed. 1770 */ 1771 1772 void 1773 xmlFreeParserCtxt(xmlParserCtxtPtr ctxt) 1774 { 1775 xmlParserInputPtr input; 1776 1777 if (ctxt == NULL) return; 1778 1779 while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */ 1780 xmlFreeInputStream(input); 1781 } 1782 if (ctxt->spaceTab != NULL) xmlFree(ctxt->spaceTab); 1783 if (ctxt->nameTab != NULL) xmlFree((xmlChar * *)ctxt->nameTab); 1784 if (ctxt->nodeTab != NULL) xmlFree(ctxt->nodeTab); 1785 if (ctxt->nodeInfoTab != NULL) xmlFree(ctxt->nodeInfoTab); 1786 if (ctxt->inputTab != NULL) xmlFree(ctxt->inputTab); 1787 if (ctxt->version != NULL) xmlFree((char *) ctxt->version); 1788 if (ctxt->encoding != NULL) xmlFree((char *) ctxt->encoding); 1789 if (ctxt->extSubURI != NULL) xmlFree((char *) ctxt->extSubURI); 1790 if (ctxt->extSubSystem != NULL) xmlFree((char *) ctxt->extSubSystem); 1791 #ifdef LIBXML_SAX1_ENABLED 1792 if ((ctxt->sax != NULL) && 1793 (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)) 1794 #else 1795 if (ctxt->sax != NULL) 1796 #endif /* LIBXML_SAX1_ENABLED */ 1797 xmlFree(ctxt->sax); 1798 if (ctxt->directory != NULL) xmlFree((char *) ctxt->directory); 1799 if (ctxt->vctxt.nodeTab != NULL) xmlFree(ctxt->vctxt.nodeTab); 1800 if (ctxt->atts != NULL) xmlFree((xmlChar * *)ctxt->atts); 1801 if (ctxt->dict != NULL) xmlDictFree(ctxt->dict); 1802 if (ctxt->nsTab != NULL) xmlFree((char *) ctxt->nsTab); 1803 if (ctxt->pushTab != NULL) xmlFree(ctxt->pushTab); 1804 if (ctxt->attallocs != NULL) xmlFree(ctxt->attallocs); 1805 if (ctxt->attsDefault != NULL) 1806 xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree); 1807 if (ctxt->attsSpecial != NULL) 1808 xmlHashFree(ctxt->attsSpecial, NULL); 1809 if (ctxt->freeElems != NULL) { 1810 xmlNodePtr cur, next; 1811 1812 cur = ctxt->freeElems; 1813 while (cur != NULL) { 1814 next = cur->next; 1815 xmlFree(cur); 1816 cur = next; 1817 } 1818 } 1819 if (ctxt->freeAttrs != NULL) { 1820 xmlAttrPtr cur, next; 1821 1822 cur = ctxt->freeAttrs; 1823 while (cur != NULL) { 1824 next = cur->next; 1825 xmlFree(cur); 1826 cur = next; 1827 } 1828 } 1829 /* 1830 * cleanup the error strings 1831 */ 1832 if (ctxt->lastError.message != NULL) 1833 xmlFree(ctxt->lastError.message); 1834 if (ctxt->lastError.file != NULL) 1835 xmlFree(ctxt->lastError.file); 1836 if (ctxt->lastError.str1 != NULL) 1837 xmlFree(ctxt->lastError.str1); 1838 if (ctxt->lastError.str2 != NULL) 1839 xmlFree(ctxt->lastError.str2); 1840 if (ctxt->lastError.str3 != NULL) 1841 xmlFree(ctxt->lastError.str3); 1842 1843 #ifdef LIBXML_CATALOG_ENABLED 1844 if (ctxt->catalogs != NULL) 1845 xmlCatalogFreeLocal(ctxt->catalogs); 1846 #endif 1847 xmlFree(ctxt); 1848 } 1849 1850 /** 1851 * xmlNewParserCtxt: 1852 * 1853 * Allocate and initialize a new parser context. 1854 * 1855 * Returns the xmlParserCtxtPtr or NULL 1856 */ 1857 1858 xmlParserCtxtPtr 1859 xmlNewParserCtxt(void) 1860 { 1861 xmlParserCtxtPtr ctxt; 1862 1863 ctxt = (xmlParserCtxtPtr) xmlMalloc(sizeof(xmlParserCtxt)); 1864 if (ctxt == NULL) { 1865 xmlErrMemory(NULL, "cannot allocate parser context\n"); 1866 return(NULL); 1867 } 1868 memset(ctxt, 0, sizeof(xmlParserCtxt)); 1869 if (xmlInitParserCtxt(ctxt) < 0) { 1870 xmlFreeParserCtxt(ctxt); 1871 return(NULL); 1872 } 1873 return(ctxt); 1874 } 1875 1876 /************************************************************************ 1877 * * 1878 * Handling of node informations * 1879 * * 1880 ************************************************************************/ 1881 1882 /** 1883 * xmlClearParserCtxt: 1884 * @ctxt: an XML parser context 1885 * 1886 * Clear (release owned resources) and reinitialize a parser context 1887 */ 1888 1889 void 1890 xmlClearParserCtxt(xmlParserCtxtPtr ctxt) 1891 { 1892 if (ctxt==NULL) 1893 return; 1894 xmlClearNodeInfoSeq(&ctxt->node_seq); 1895 xmlCtxtReset(ctxt); 1896 } 1897 1898 1899 /** 1900 * xmlParserFindNodeInfo: 1901 * @ctx: an XML parser context 1902 * @node: an XML node within the tree 1903 * 1904 * Find the parser node info struct for a given node 1905 * 1906 * Returns an xmlParserNodeInfo block pointer or NULL 1907 */ 1908 const xmlParserNodeInfo * 1909 xmlParserFindNodeInfo(const xmlParserCtxtPtr ctx, const xmlNodePtr node) 1910 { 1911 unsigned long pos; 1912 1913 if ((ctx == NULL) || (node == NULL)) 1914 return (NULL); 1915 /* Find position where node should be at */ 1916 pos = xmlParserFindNodeInfoIndex(&ctx->node_seq, node); 1917 if (pos < ctx->node_seq.length 1918 && ctx->node_seq.buffer[pos].node == node) 1919 return &ctx->node_seq.buffer[pos]; 1920 else 1921 return NULL; 1922 } 1923 1924 1925 /** 1926 * xmlInitNodeInfoSeq: 1927 * @seq: a node info sequence pointer 1928 * 1929 * -- Initialize (set to initial state) node info sequence 1930 */ 1931 void 1932 xmlInitNodeInfoSeq(xmlParserNodeInfoSeqPtr seq) 1933 { 1934 if (seq == NULL) 1935 return; 1936 seq->length = 0; 1937 seq->maximum = 0; 1938 seq->buffer = NULL; 1939 } 1940 1941 /** 1942 * xmlClearNodeInfoSeq: 1943 * @seq: a node info sequence pointer 1944 * 1945 * -- Clear (release memory and reinitialize) node 1946 * info sequence 1947 */ 1948 void 1949 xmlClearNodeInfoSeq(xmlParserNodeInfoSeqPtr seq) 1950 { 1951 if (seq == NULL) 1952 return; 1953 if (seq->buffer != NULL) 1954 xmlFree(seq->buffer); 1955 xmlInitNodeInfoSeq(seq); 1956 } 1957 1958 /** 1959 * xmlParserFindNodeInfoIndex: 1960 * @seq: a node info sequence pointer 1961 * @node: an XML node pointer 1962 * 1963 * 1964 * xmlParserFindNodeInfoIndex : Find the index that the info record for 1965 * the given node is or should be at in a sorted sequence 1966 * 1967 * Returns a long indicating the position of the record 1968 */ 1969 unsigned long 1970 xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq, 1971 const xmlNodePtr node) 1972 { 1973 unsigned long upper, lower, middle; 1974 int found = 0; 1975 1976 if ((seq == NULL) || (node == NULL)) 1977 return ((unsigned long) -1); 1978 1979 /* Do a binary search for the key */ 1980 lower = 1; 1981 upper = seq->length; 1982 middle = 0; 1983 while (lower <= upper && !found) { 1984 middle = lower + (upper - lower) / 2; 1985 if (node == seq->buffer[middle - 1].node) 1986 found = 1; 1987 else if (node < seq->buffer[middle - 1].node) 1988 upper = middle - 1; 1989 else 1990 lower = middle + 1; 1991 } 1992 1993 /* Return position */ 1994 if (middle == 0 || seq->buffer[middle - 1].node < node) 1995 return middle; 1996 else 1997 return middle - 1; 1998 } 1999 2000 2001 /** 2002 * xmlParserAddNodeInfo: 2003 * @ctxt: an XML parser context 2004 * @info: a node info sequence pointer 2005 * 2006 * Insert node info record into the sorted sequence 2007 */ 2008 void 2009 xmlParserAddNodeInfo(xmlParserCtxtPtr ctxt, 2010 const xmlParserNodeInfoPtr info) 2011 { 2012 unsigned long pos; 2013 2014 if ((ctxt == NULL) || (info == NULL)) return; 2015 2016 /* Find pos and check to see if node is already in the sequence */ 2017 pos = xmlParserFindNodeInfoIndex(&ctxt->node_seq, (xmlNodePtr) 2018 info->node); 2019 2020 if ((pos < ctxt->node_seq.length) && 2021 (ctxt->node_seq.buffer != NULL) && 2022 (ctxt->node_seq.buffer[pos].node == info->node)) { 2023 ctxt->node_seq.buffer[pos] = *info; 2024 } 2025 2026 /* Otherwise, we need to add new node to buffer */ 2027 else { 2028 if (ctxt->node_seq.length + 1 > ctxt->node_seq.maximum) { 2029 xmlParserNodeInfo *tmp_buffer; 2030 unsigned int byte_size; 2031 2032 if (ctxt->node_seq.maximum == 0) 2033 ctxt->node_seq.maximum = 2; 2034 byte_size = (sizeof(*ctxt->node_seq.buffer) * 2035 (2 * ctxt->node_seq.maximum)); 2036 2037 if (ctxt->node_seq.buffer == NULL) 2038 tmp_buffer = (xmlParserNodeInfo *) xmlMalloc(byte_size); 2039 else 2040 tmp_buffer = 2041 (xmlParserNodeInfo *) xmlRealloc(ctxt->node_seq.buffer, 2042 byte_size); 2043 2044 if (tmp_buffer == NULL) { 2045 xmlErrMemory(ctxt, "failed to allocate buffer\n"); 2046 return; 2047 } 2048 ctxt->node_seq.buffer = tmp_buffer; 2049 ctxt->node_seq.maximum *= 2; 2050 } 2051 2052 /* If position is not at end, move elements out of the way */ 2053 if (pos != ctxt->node_seq.length) { 2054 unsigned long i; 2055 2056 for (i = ctxt->node_seq.length; i > pos; i--) 2057 ctxt->node_seq.buffer[i] = ctxt->node_seq.buffer[i - 1]; 2058 } 2059 2060 /* Copy element and increase length */ 2061 ctxt->node_seq.buffer[pos] = *info; 2062 ctxt->node_seq.length++; 2063 } 2064 } 2065 2066 /************************************************************************ 2067 * * 2068 * Defaults settings * 2069 * * 2070 ************************************************************************/ 2071 /** 2072 * xmlPedanticParserDefault: 2073 * @val: int 0 or 1 2074 * 2075 * Set and return the previous value for enabling pedantic warnings. 2076 * 2077 * Returns the last value for 0 for no substitution, 1 for substitution. 2078 */ 2079 2080 int 2081 xmlPedanticParserDefault(int val) { 2082 int old = xmlPedanticParserDefaultValue; 2083 2084 xmlPedanticParserDefaultValue = val; 2085 return(old); 2086 } 2087 2088 /** 2089 * xmlLineNumbersDefault: 2090 * @val: int 0 or 1 2091 * 2092 * Set and return the previous value for enabling line numbers in elements 2093 * contents. This may break on old application and is turned off by default. 2094 * 2095 * Returns the last value for 0 for no substitution, 1 for substitution. 2096 */ 2097 2098 int 2099 xmlLineNumbersDefault(int val) { 2100 int old = xmlLineNumbersDefaultValue; 2101 2102 xmlLineNumbersDefaultValue = val; 2103 return(old); 2104 } 2105 2106 /** 2107 * xmlSubstituteEntitiesDefault: 2108 * @val: int 0 or 1 2109 * 2110 * Set and return the previous value for default entity support. 2111 * Initially the parser always keep entity references instead of substituting 2112 * entity values in the output. This function has to be used to change the 2113 * default parser behavior 2114 * SAX::substituteEntities() has to be used for changing that on a file by 2115 * file basis. 2116 * 2117 * Returns the last value for 0 for no substitution, 1 for substitution. 2118 */ 2119 2120 int 2121 xmlSubstituteEntitiesDefault(int val) { 2122 int old = xmlSubstituteEntitiesDefaultValue; 2123 2124 xmlSubstituteEntitiesDefaultValue = val; 2125 return(old); 2126 } 2127 2128 /** 2129 * xmlKeepBlanksDefault: 2130 * @val: int 0 or 1 2131 * 2132 * Set and return the previous value for default blanks text nodes support. 2133 * The 1.x version of the parser used an heuristic to try to detect 2134 * ignorable white spaces. As a result the SAX callback was generating 2135 * xmlSAX2IgnorableWhitespace() callbacks instead of characters() one, and when 2136 * using the DOM output text nodes containing those blanks were not generated. 2137 * The 2.x and later version will switch to the XML standard way and 2138 * ignorableWhitespace() are only generated when running the parser in 2139 * validating mode and when the current element doesn't allow CDATA or 2140 * mixed content. 2141 * This function is provided as a way to force the standard behavior 2142 * on 1.X libs and to switch back to the old mode for compatibility when 2143 * running 1.X client code on 2.X . Upgrade of 1.X code should be done 2144 * by using xmlIsBlankNode() commodity function to detect the "empty" 2145 * nodes generated. 2146 * This value also affect autogeneration of indentation when saving code 2147 * if blanks sections are kept, indentation is not generated. 2148 * 2149 * Returns the last value for 0 for no substitution, 1 for substitution. 2150 */ 2151 2152 int 2153 xmlKeepBlanksDefault(int val) { 2154 int old = xmlKeepBlanksDefaultValue; 2155 2156 xmlKeepBlanksDefaultValue = val; 2157 if (!val) xmlIndentTreeOutput = 1; 2158 return(old); 2159 } 2160 2161 #define bottom_parserInternals 2162 #include "elfgcchack.h" 2163
