testSAX.c
1 /* 2 * testSAX.c : a small tester program for parsing using the SAX API. 3 * 4 * See Copyright for the status of this software. 5 * 6 * daniel@veillard.com 7 */ 8 9 #include "libxml.h" 10 11 #ifdef HAVE_SYS_TIME_H 12 #include <sys/time.h> 13 #endif 14 #ifdef HAVE_SYS_TIMEB_H 15 #include <sys/timeb.h> 16 #endif 17 #ifdef HAVE_TIME_H 18 #include <time.h> 19 #endif 20 21 #ifdef LIBXML_SAX1_ENABLED 22 #include <string.h> 23 #include <stdarg.h> 24 25 #ifdef HAVE_SYS_TYPES_H 26 #include <sys/types.h> 27 #endif 28 #ifdef HAVE_SYS_STAT_H 29 #include <sys/stat.h> 30 #endif 31 #ifdef HAVE_FCNTL_H 32 #include <fcntl.h> 33 #endif 34 #ifdef HAVE_UNISTD_H 35 #include <unistd.h> 36 #endif 37 #ifdef HAVE_STDLIB_H 38 #include <stdlib.h> 39 #endif 40 #ifdef HAVE_STRING_H 41 #include <string.h> 42 #endif 43 44 45 #include <libxml/globals.h> 46 #include <libxml/xmlerror.h> 47 #include <libxml/parser.h> 48 #include <libxml/parserInternals.h> /* only for xmlNewInputFromFile() */ 49 #include <libxml/tree.h> 50 #include <libxml/debugXML.h> 51 #include <libxml/xmlmemory.h> 52 53 static int debug = 0; 54 static int copy = 0; 55 static int recovery = 0; 56 static int push = 0; 57 static int speed = 0; 58 static int noent = 0; 59 static int quiet = 0; 60 static int nonull = 0; 61 static int sax2 = 0; 62 static int repeat = 0; 63 static int callbacks = 0; 64 static int timing = 0; 65 66 /* 67 * Timing routines. 68 */ 69 /* 70 * Internal timing routines to remove the necessity to have unix-specific 71 * function calls 72 */ 73 74 #ifndef HAVE_GETTIMEOFDAY 75 #ifdef HAVE_SYS_TIMEB_H 76 #ifdef HAVE_SYS_TIME_H 77 #ifdef HAVE_FTIME 78 79 static int 80 my_gettimeofday(struct timeval *tvp, void *tzp) 81 { 82 struct timeb timebuffer; 83 84 ftime(&timebuffer); 85 if (tvp) { 86 tvp->tv_sec = timebuffer.time; 87 tvp->tv_usec = timebuffer.millitm * 1000L; 88 } 89 return (0); 90 } 91 #define HAVE_GETTIMEOFDAY 1 92 #define gettimeofday my_gettimeofday 93 94 #endif /* HAVE_FTIME */ 95 #endif /* HAVE_SYS_TIME_H */ 96 #endif /* HAVE_SYS_TIMEB_H */ 97 #endif /* !HAVE_GETTIMEOFDAY */ 98 99 #if defined(HAVE_GETTIMEOFDAY) 100 static struct timeval begin, end; 101 102 /* 103 * startTimer: call where you want to start timing 104 */ 105 static void 106 startTimer(void) 107 { 108 gettimeofday(&begin, NULL); 109 } 110 111 /* 112 * endTimer: call where you want to stop timing and to print out a 113 * message about the timing performed; format is a printf 114 * type argument 115 */ 116 static void XMLCDECL 117 endTimer(const char *fmt, ...) 118 { 119 long msec; 120 va_list ap; 121 122 gettimeofday(&end, NULL); 123 msec = end.tv_sec - begin.tv_sec; 124 msec *= 1000; 125 msec += (end.tv_usec - begin.tv_usec) / 1000; 126 127 #ifndef HAVE_STDARG_H 128 #error "endTimer required stdarg functions" 129 #endif 130 va_start(ap, fmt); 131 vfprintf(stderr, fmt, ap); 132 va_end(ap); 133 134 fprintf(stderr, " took %ld ms\n", msec); 135 } 136 #elif defined(HAVE_TIME_H) 137 /* 138 * No gettimeofday function, so we have to make do with calling clock. 139 * This is obviously less accurate, but there's little we can do about 140 * that. 141 */ 142 #ifndef CLOCKS_PER_SEC 143 #define CLOCKS_PER_SEC 100 144 #endif 145 146 static clock_t begin, end; 147 static void 148 startTimer(void) 149 { 150 begin = clock(); 151 } 152 static void XMLCDECL 153 endTimer(const char *fmt, ...) 154 { 155 long msec; 156 va_list ap; 157 158 end = clock(); 159 msec = ((end - begin) * 1000) / CLOCKS_PER_SEC; 160 161 #ifndef HAVE_STDARG_H 162 #error "endTimer required stdarg functions" 163 #endif 164 va_start(ap, fmt); 165 vfprintf(stderr, fmt, ap); 166 va_end(ap); 167 fprintf(stderr, " took %ld ms\n", msec); 168 } 169 #else 170 171 /* 172 * We don't have a gettimeofday or time.h, so we just don't do timing 173 */ 174 static void 175 startTimer(void) 176 { 177 /* 178 * Do nothing 179 */ 180 } 181 static void XMLCDECL 182 endTimer(char *format, ...) 183 { 184 /* 185 * We cannot do anything because we don't have a timing function 186 */ 187 #ifdef HAVE_STDARG_H 188 va_start(ap, format); 189 vfprintf(stderr, format, ap); 190 va_end(ap); 191 fprintf(stderr, " was not timed\n", msec); 192 #else 193 /* We don't have gettimeofday, time or stdarg.h, what crazy world is 194 * this ?! 195 */ 196 #endif 197 } 198 #endif 199 200 /* 201 * empty SAX block 202 */ 203 static xmlSAXHandler emptySAXHandlerStruct = { 204 NULL, /* internalSubset */ 205 NULL, /* isStandalone */ 206 NULL, /* hasInternalSubset */ 207 NULL, /* hasExternalSubset */ 208 NULL, /* resolveEntity */ 209 NULL, /* getEntity */ 210 NULL, /* entityDecl */ 211 NULL, /* notationDecl */ 212 NULL, /* attributeDecl */ 213 NULL, /* elementDecl */ 214 NULL, /* unparsedEntityDecl */ 215 NULL, /* setDocumentLocator */ 216 NULL, /* startDocument */ 217 NULL, /* endDocument */ 218 NULL, /* startElement */ 219 NULL, /* endElement */ 220 NULL, /* reference */ 221 NULL, /* characters */ 222 NULL, /* ignorableWhitespace */ 223 NULL, /* processingInstruction */ 224 NULL, /* comment */ 225 NULL, /* xmlParserWarning */ 226 NULL, /* xmlParserError */ 227 NULL, /* xmlParserError */ 228 NULL, /* getParameterEntity */ 229 NULL, /* cdataBlock; */ 230 NULL, /* externalSubset; */ 231 1, 232 NULL, 233 NULL, /* startElementNs */ 234 NULL, /* endElementNs */ 235 NULL /* xmlStructuredErrorFunc */ 236 }; 237 238 static xmlSAXHandlerPtr emptySAXHandler = &emptySAXHandlerStruct; 239 extern xmlSAXHandlerPtr debugSAXHandler; 240 241 /************************************************************************ 242 * * 243 * Debug Handlers * 244 * * 245 ************************************************************************/ 246 247 /** 248 * isStandaloneDebug: 249 * @ctxt: An XML parser context 250 * 251 * Is this document tagged standalone ? 252 * 253 * Returns 1 if true 254 */ 255 static int 256 isStandaloneDebug(void *ctx ATTRIBUTE_UNUSED) 257 { 258 callbacks++; 259 if (quiet) 260 return(0); 261 fprintf(stdout, "SAX.isStandalone()\n"); 262 return(0); 263 } 264 265 /** 266 * hasInternalSubsetDebug: 267 * @ctxt: An XML parser context 268 * 269 * Does this document has an internal subset 270 * 271 * Returns 1 if true 272 */ 273 static int 274 hasInternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED) 275 { 276 callbacks++; 277 if (quiet) 278 return(0); 279 fprintf(stdout, "SAX.hasInternalSubset()\n"); 280 return(0); 281 } 282 283 /** 284 * hasExternalSubsetDebug: 285 * @ctxt: An XML parser context 286 * 287 * Does this document has an external subset 288 * 289 * Returns 1 if true 290 */ 291 static int 292 hasExternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED) 293 { 294 callbacks++; 295 if (quiet) 296 return(0); 297 fprintf(stdout, "SAX.hasExternalSubset()\n"); 298 return(0); 299 } 300 301 /** 302 * internalSubsetDebug: 303 * @ctxt: An XML parser context 304 * 305 * Does this document has an internal subset 306 */ 307 static void 308 internalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, 309 const xmlChar *ExternalID, const xmlChar *SystemID) 310 { 311 callbacks++; 312 if (quiet) 313 return; 314 fprintf(stdout, "SAX.internalSubset(%s,", name); 315 if (ExternalID == NULL) 316 fprintf(stdout, " ,"); 317 else 318 fprintf(stdout, " %s,", ExternalID); 319 if (SystemID == NULL) 320 fprintf(stdout, " )\n"); 321 else 322 fprintf(stdout, " %s)\n", SystemID); 323 } 324 325 /** 326 * externalSubsetDebug: 327 * @ctxt: An XML parser context 328 * 329 * Does this document has an external subset 330 */ 331 static void 332 externalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, 333 const xmlChar *ExternalID, const xmlChar *SystemID) 334 { 335 callbacks++; 336 if (quiet) 337 return; 338 fprintf(stdout, "SAX.externalSubset(%s,", name); 339 if (ExternalID == NULL) 340 fprintf(stdout, " ,"); 341 else 342 fprintf(stdout, " %s,", ExternalID); 343 if (SystemID == NULL) 344 fprintf(stdout, " )\n"); 345 else 346 fprintf(stdout, " %s)\n", SystemID); 347 } 348 349 /** 350 * resolveEntityDebug: 351 * @ctxt: An XML parser context 352 * @publicId: The public ID of the entity 353 * @systemId: The system ID of the entity 354 * 355 * Special entity resolver, better left to the parser, it has 356 * more context than the application layer. 357 * The default behaviour is to NOT resolve the entities, in that case 358 * the ENTITY_REF nodes are built in the structure (and the parameter 359 * values). 360 * 361 * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour. 362 */ 363 static xmlParserInputPtr 364 resolveEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *publicId, const xmlChar *systemId) 365 { 366 callbacks++; 367 if (quiet) 368 return(NULL); 369 /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */ 370 371 372 fprintf(stdout, "SAX.resolveEntity("); 373 if (publicId != NULL) 374 fprintf(stdout, "%s", (char *)publicId); 375 else 376 fprintf(stdout, " "); 377 if (systemId != NULL) 378 fprintf(stdout, ", %s)\n", (char *)systemId); 379 else 380 fprintf(stdout, ", )\n"); 381 /********* 382 if (systemId != NULL) { 383 return(xmlNewInputFromFile(ctxt, (char *) systemId)); 384 } 385 *********/ 386 return(NULL); 387 } 388 389 /** 390 * getEntityDebug: 391 * @ctxt: An XML parser context 392 * @name: The entity name 393 * 394 * Get an entity by name 395 * 396 * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour. 397 */ 398 static xmlEntityPtr 399 getEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name) 400 { 401 callbacks++; 402 if (quiet) 403 return(NULL); 404 fprintf(stdout, "SAX.getEntity(%s)\n", name); 405 return(NULL); 406 } 407 408 /** 409 * getParameterEntityDebug: 410 * @ctxt: An XML parser context 411 * @name: The entity name 412 * 413 * Get a parameter entity by name 414 * 415 * Returns the xmlParserInputPtr 416 */ 417 static xmlEntityPtr 418 getParameterEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name) 419 { 420 callbacks++; 421 if (quiet) 422 return(NULL); 423 fprintf(stdout, "SAX.getParameterEntity(%s)\n", name); 424 return(NULL); 425 } 426 427 428 /** 429 * entityDeclDebug: 430 * @ctxt: An XML parser context 431 * @name: the entity name 432 * @type: the entity type 433 * @publicId: The public ID of the entity 434 * @systemId: The system ID of the entity 435 * @content: the entity value (without processing). 436 * 437 * An entity definition has been parsed 438 */ 439 static void 440 entityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type, 441 const xmlChar *publicId, const xmlChar *systemId, xmlChar *content) 442 { 443 const xmlChar *nullstr = BAD_CAST "(null)"; 444 /* not all libraries handle printing null pointers nicely */ 445 if (publicId == NULL) 446 publicId = nullstr; 447 if (systemId == NULL) 448 systemId = nullstr; 449 if (content == NULL) 450 content = (xmlChar *)nullstr; 451 callbacks++; 452 if (quiet) 453 return; 454 fprintf(stdout, "SAX.entityDecl(%s, %d, %s, %s, %s)\n", 455 name, type, publicId, systemId, content); 456 } 457 458 /** 459 * attributeDeclDebug: 460 * @ctxt: An XML parser context 461 * @name: the attribute name 462 * @type: the attribute type 463 * 464 * An attribute definition has been parsed 465 */ 466 static void 467 attributeDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar * elem, 468 const xmlChar * name, int type, int def, 469 const xmlChar * defaultValue, xmlEnumerationPtr tree) 470 { 471 callbacks++; 472 if (quiet) 473 return; 474 if (defaultValue == NULL) 475 fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, NULL, ...)\n", 476 elem, name, type, def); 477 else 478 fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, %s, ...)\n", 479 elem, name, type, def, defaultValue); 480 xmlFreeEnumeration(tree); 481 } 482 483 /** 484 * elementDeclDebug: 485 * @ctxt: An XML parser context 486 * @name: the element name 487 * @type: the element type 488 * @content: the element value (without processing). 489 * 490 * An element definition has been parsed 491 */ 492 static void 493 elementDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type, 494 xmlElementContentPtr content ATTRIBUTE_UNUSED) 495 { 496 callbacks++; 497 if (quiet) 498 return; 499 fprintf(stdout, "SAX.elementDecl(%s, %d, ...)\n", 500 name, type); 501 } 502 503 /** 504 * notationDeclDebug: 505 * @ctxt: An XML parser context 506 * @name: The name of the notation 507 * @publicId: The public ID of the entity 508 * @systemId: The system ID of the entity 509 * 510 * What to do when a notation declaration has been parsed. 511 */ 512 static void 513 notationDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, 514 const xmlChar *publicId, const xmlChar *systemId) 515 { 516 callbacks++; 517 if (quiet) 518 return; 519 fprintf(stdout, "SAX.notationDecl(%s, %s, %s)\n", 520 (char *) name, (char *) publicId, (char *) systemId); 521 } 522 523 /** 524 * unparsedEntityDeclDebug: 525 * @ctxt: An XML parser context 526 * @name: The name of the entity 527 * @publicId: The public ID of the entity 528 * @systemId: The system ID of the entity 529 * @notationName: the name of the notation 530 * 531 * What to do when an unparsed entity declaration is parsed 532 */ 533 static void 534 unparsedEntityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, 535 const xmlChar *publicId, const xmlChar *systemId, 536 const xmlChar *notationName) 537 { 538 const xmlChar *nullstr = BAD_CAST "(null)"; 539 540 if (publicId == NULL) 541 publicId = nullstr; 542 if (systemId == NULL) 543 systemId = nullstr; 544 if (notationName == NULL) 545 notationName = nullstr; 546 callbacks++; 547 if (quiet) 548 return; 549 fprintf(stdout, "SAX.unparsedEntityDecl(%s, %s, %s, %s)\n", 550 (char *) name, (char *) publicId, (char *) systemId, 551 (char *) notationName); 552 } 553 554 /** 555 * setDocumentLocatorDebug: 556 * @ctxt: An XML parser context 557 * @loc: A SAX Locator 558 * 559 * Receive the document locator at startup, actually xmlDefaultSAXLocator 560 * Everything is available on the context, so this is useless in our case. 561 */ 562 static void 563 setDocumentLocatorDebug(void *ctx ATTRIBUTE_UNUSED, xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED) 564 { 565 callbacks++; 566 if (quiet) 567 return; 568 fprintf(stdout, "SAX.setDocumentLocator()\n"); 569 } 570 571 /** 572 * startDocumentDebug: 573 * @ctxt: An XML parser context 574 * 575 * called when the document start being processed. 576 */ 577 static void 578 startDocumentDebug(void *ctx ATTRIBUTE_UNUSED) 579 { 580 callbacks++; 581 if (quiet) 582 return; 583 fprintf(stdout, "SAX.startDocument()\n"); 584 } 585 586 /** 587 * endDocumentDebug: 588 * @ctxt: An XML parser context 589 * 590 * called when the document end has been detected. 591 */ 592 static void 593 endDocumentDebug(void *ctx ATTRIBUTE_UNUSED) 594 { 595 callbacks++; 596 if (quiet) 597 return; 598 fprintf(stdout, "SAX.endDocument()\n"); 599 } 600 601 /** 602 * startElementDebug: 603 * @ctxt: An XML parser context 604 * @name: The element name 605 * 606 * called when an opening tag has been processed. 607 */ 608 static void 609 startElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, const xmlChar **atts) 610 { 611 int i; 612 613 callbacks++; 614 if (quiet) 615 return; 616 fprintf(stdout, "SAX.startElement(%s", (char *) name); 617 if (atts != NULL) { 618 for (i = 0;(atts[i] != NULL);i++) { 619 fprintf(stdout, ", %s='", atts[i++]); 620 if (atts[i] != NULL) 621 fprintf(stdout, "%s'", atts[i]); 622 } 623 } 624 fprintf(stdout, ")\n"); 625 } 626 627 /** 628 * endElementDebug: 629 * @ctxt: An XML parser context 630 * @name: The element name 631 * 632 * called when the end of an element has been detected. 633 */ 634 static void 635 endElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name) 636 { 637 callbacks++; 638 if (quiet) 639 return; 640 fprintf(stdout, "SAX.endElement(%s)\n", (char *) name); 641 } 642 643 /** 644 * charactersDebug: 645 * @ctxt: An XML parser context 646 * @ch: a xmlChar string 647 * @len: the number of xmlChar 648 * 649 * receiving some chars from the parser. 650 * Question: how much at a time ??? 651 */ 652 static void 653 charactersDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len) 654 { 655 char output[40]; 656 int i; 657 658 callbacks++; 659 if (quiet) 660 return; 661 for (i = 0;(i<len) && (i < 30);i++) 662 output[i] = ch[i]; 663 output[i] = 0; 664 665 fprintf(stdout, "SAX.characters(%s, %d)\n", output, len); 666 } 667 668 /** 669 * referenceDebug: 670 * @ctxt: An XML parser context 671 * @name: The entity name 672 * 673 * called when an entity reference is detected. 674 */ 675 static void 676 referenceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name) 677 { 678 callbacks++; 679 if (quiet) 680 return; 681 fprintf(stdout, "SAX.reference(%s)\n", name); 682 } 683 684 /** 685 * ignorableWhitespaceDebug: 686 * @ctxt: An XML parser context 687 * @ch: a xmlChar string 688 * @start: the first char in the string 689 * @len: the number of xmlChar 690 * 691 * receiving some ignorable whitespaces from the parser. 692 * Question: how much at a time ??? 693 */ 694 static void 695 ignorableWhitespaceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len) 696 { 697 char output[40]; 698 int i; 699 700 callbacks++; 701 if (quiet) 702 return; 703 for (i = 0;(i<len) && (i < 30);i++) 704 output[i] = ch[i]; 705 output[i] = 0; 706 fprintf(stdout, "SAX.ignorableWhitespace(%s, %d)\n", output, len); 707 } 708 709 /** 710 * processingInstructionDebug: 711 * @ctxt: An XML parser context 712 * @target: the target name 713 * @data: the PI data's 714 * @len: the number of xmlChar 715 * 716 * A processing instruction has been parsed. 717 */ 718 static void 719 processingInstructionDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *target, 720 const xmlChar *data) 721 { 722 callbacks++; 723 if (quiet) 724 return; 725 if (data != NULL) 726 fprintf(stdout, "SAX.processingInstruction(%s, %s)\n", 727 (char *) target, (char *) data); 728 else 729 fprintf(stdout, "SAX.processingInstruction(%s, NULL)\n", 730 (char *) target); 731 } 732 733 /** 734 * cdataBlockDebug: 735 * @ctx: the user data (XML parser context) 736 * @value: The pcdata content 737 * @len: the block length 738 * 739 * called when a pcdata block has been parsed 740 */ 741 static void 742 cdataBlockDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value, int len) 743 { 744 callbacks++; 745 if (quiet) 746 return; 747 fprintf(stdout, "SAX.pcdata(%.20s, %d)\n", 748 (char *) value, len); 749 } 750 751 /** 752 * commentDebug: 753 * @ctxt: An XML parser context 754 * @value: the comment content 755 * 756 * A comment has been parsed. 757 */ 758 static void 759 commentDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value) 760 { 761 callbacks++; 762 if (quiet) 763 return; 764 fprintf(stdout, "SAX.comment(%s)\n", value); 765 } 766 767 /** 768 * warningDebug: 769 * @ctxt: An XML parser context 770 * @msg: the message to display/transmit 771 * @...: extra parameters for the message display 772 * 773 * Display and format a warning messages, gives file, line, position and 774 * extra parameters. 775 */ 776 static void XMLCDECL 777 warningDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) 778 { 779 va_list args; 780 781 callbacks++; 782 if (quiet) 783 return; 784 va_start(args, msg); 785 fprintf(stdout, "SAX.warning: "); 786 vfprintf(stdout, msg, args); 787 va_end(args); 788 } 789 790 /** 791 * errorDebug: 792 * @ctxt: An XML parser context 793 * @msg: the message to display/transmit 794 * @...: extra parameters for the message display 795 * 796 * Display and format a error messages, gives file, line, position and 797 * extra parameters. 798 */ 799 static void XMLCDECL 800 errorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) 801 { 802 va_list args; 803 804 callbacks++; 805 if (quiet) 806 return; 807 va_start(args, msg); 808 fprintf(stdout, "SAX.error: "); 809 vfprintf(stdout, msg, args); 810 va_end(args); 811 } 812 813 /** 814 * fatalErrorDebug: 815 * @ctxt: An XML parser context 816 * @msg: the message to display/transmit 817 * @...: extra parameters for the message display 818 * 819 * Display and format a fatalError messages, gives file, line, position and 820 * extra parameters. 821 */ 822 static void XMLCDECL 823 fatalErrorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) 824 { 825 va_list args; 826 827 callbacks++; 828 if (quiet) 829 return; 830 va_start(args, msg); 831 fprintf(stdout, "SAX.fatalError: "); 832 vfprintf(stdout, msg, args); 833 va_end(args); 834 } 835 836 static xmlSAXHandler debugSAXHandlerStruct = { 837 internalSubsetDebug, 838 isStandaloneDebug, 839 hasInternalSubsetDebug, 840 hasExternalSubsetDebug, 841 resolveEntityDebug, 842 getEntityDebug, 843 entityDeclDebug, 844 notationDeclDebug, 845 attributeDeclDebug, 846 elementDeclDebug, 847 unparsedEntityDeclDebug, 848 setDocumentLocatorDebug, 849 startDocumentDebug, 850 endDocumentDebug, 851 startElementDebug, 852 endElementDebug, 853 referenceDebug, 854 charactersDebug, 855 ignorableWhitespaceDebug, 856 processingInstructionDebug, 857 commentDebug, 858 warningDebug, 859 errorDebug, 860 fatalErrorDebug, 861 getParameterEntityDebug, 862 cdataBlockDebug, 863 externalSubsetDebug, 864 1, 865 NULL, 866 NULL, 867 NULL, 868 NULL 869 }; 870 871 xmlSAXHandlerPtr debugSAXHandler = &debugSAXHandlerStruct; 872 873 /* 874 * SAX2 specific callbacks 875 */ 876 /** 877 * startElementNsDebug: 878 * @ctxt: An XML parser context 879 * @name: The element name 880 * 881 * called when an opening tag has been processed. 882 */ 883 static void 884 startElementNsDebug(void *ctx ATTRIBUTE_UNUSED, 885 const xmlChar *localname, 886 const xmlChar *prefix, 887 const xmlChar *URI, 888 int nb_namespaces, 889 const xmlChar **namespaces, 890 int nb_attributes, 891 int nb_defaulted, 892 const xmlChar **attributes) 893 { 894 int i; 895 896 callbacks++; 897 if (quiet) 898 return; 899 fprintf(stdout, "SAX.startElementNs(%s", (char *) localname); 900 if (prefix == NULL) 901 fprintf(stdout, ", NULL"); 902 else 903 fprintf(stdout, ", %s", (char *) prefix); 904 if (URI == NULL) 905 fprintf(stdout, ", NULL"); 906 else 907 fprintf(stdout, ", '%s'", (char *) URI); 908 fprintf(stdout, ", %d", nb_namespaces); 909 910 if (namespaces != NULL) { 911 for (i = 0;i < nb_namespaces * 2;i++) { 912 fprintf(stdout, ", xmlns"); 913 if (namespaces[i] != NULL) 914 fprintf(stdout, ":%s", namespaces[i]); 915 i++; 916 fprintf(stdout, "='%s'", namespaces[i]); 917 } 918 } 919 fprintf(stdout, ", %d, %d", nb_attributes, nb_defaulted); 920 if (attributes != NULL) { 921 for (i = 0;i < nb_attributes * 5;i += 5) { 922 if (attributes[i + 1] != NULL) 923 fprintf(stdout, ", %s:%s='", attributes[i + 1], attributes[i]); 924 else 925 fprintf(stdout, ", %s='", attributes[i]); 926 fprintf(stdout, "%.4s...', %d", attributes[i + 3], 927 (int)(attributes[i + 4] - attributes[i + 3])); 928 } 929 } 930 fprintf(stdout, ")\n"); 931 } 932 933 /** 934 * endElementDebug: 935 * @ctxt: An XML parser context 936 * @name: The element name 937 * 938 * called when the end of an element has been detected. 939 */ 940 static void 941 endElementNsDebug(void *ctx ATTRIBUTE_UNUSED, 942 const xmlChar *localname, 943 const xmlChar *prefix, 944 const xmlChar *URI) 945 { 946 callbacks++; 947 if (quiet) 948 return; 949 fprintf(stdout, "SAX.endElementNs(%s", (char *) localname); 950 if (prefix == NULL) 951 fprintf(stdout, ", NULL"); 952 else 953 fprintf(stdout, ", %s", (char *) prefix); 954 if (URI == NULL) 955 fprintf(stdout, ", NULL)\n"); 956 else 957 fprintf(stdout, ", '%s')\n", (char *) URI); 958 } 959 960 static xmlSAXHandler debugSAX2HandlerStruct = { 961 internalSubsetDebug, 962 isStandaloneDebug, 963 hasInternalSubsetDebug, 964 hasExternalSubsetDebug, 965 resolveEntityDebug, 966 getEntityDebug, 967 entityDeclDebug, 968 notationDeclDebug, 969 attributeDeclDebug, 970 elementDeclDebug, 971 unparsedEntityDeclDebug, 972 setDocumentLocatorDebug, 973 startDocumentDebug, 974 endDocumentDebug, 975 NULL, 976 NULL, 977 referenceDebug, 978 charactersDebug, 979 ignorableWhitespaceDebug, 980 processingInstructionDebug, 981 commentDebug, 982 warningDebug, 983 errorDebug, 984 fatalErrorDebug, 985 getParameterEntityDebug, 986 cdataBlockDebug, 987 externalSubsetDebug, 988 XML_SAX2_MAGIC, 989 NULL, 990 startElementNsDebug, 991 endElementNsDebug, 992 NULL 993 }; 994 995 static xmlSAXHandlerPtr debugSAX2Handler = &debugSAX2HandlerStruct; 996 997 /************************************************************************ 998 * * 999 * Debug * 1000 * * 1001 ************************************************************************/ 1002 1003 static void 1004 parseAndPrintFile(char *filename) { 1005 int res; 1006 1007 #ifdef LIBXML_PUSH_ENABLED 1008 if (push) { 1009 FILE *f; 1010 1011 if ((!quiet) && (!nonull)) { 1012 /* 1013 * Empty callbacks for checking 1014 */ 1015 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__) 1016 f = fopen(filename, "rb"); 1017 #else 1018 f = fopen(filename, "r"); 1019 #endif 1020 if (f != NULL) { 1021 int ret; 1022 char chars[10]; 1023 xmlParserCtxtPtr ctxt; 1024 1025 ret = fread(chars, 1, 4, f); 1026 if (ret > 0) { 1027 ctxt = xmlCreatePushParserCtxt(emptySAXHandler, NULL, 1028 chars, ret, filename); 1029 while ((ret = fread(chars, 1, 3, f)) > 0) { 1030 xmlParseChunk(ctxt, chars, ret, 0); 1031 } 1032 xmlParseChunk(ctxt, chars, 0, 1); 1033 xmlFreeParserCtxt(ctxt); 1034 } 1035 fclose(f); 1036 } else { 1037 xmlGenericError(xmlGenericErrorContext, 1038 "Cannot read file %s\n", filename); 1039 } 1040 } 1041 /* 1042 * Debug callback 1043 */ 1044 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__) 1045 f = fopen(filename, "rb"); 1046 #else 1047 f = fopen(filename, "r"); 1048 #endif 1049 if (f != NULL) { 1050 int ret; 1051 char chars[10]; 1052 xmlParserCtxtPtr ctxt; 1053 1054 ret = fread(chars, 1, 4, f); 1055 if (ret > 0) { 1056 if (sax2) 1057 ctxt = xmlCreatePushParserCtxt(debugSAX2Handler, NULL, 1058 chars, ret, filename); 1059 else 1060 ctxt = xmlCreatePushParserCtxt(debugSAXHandler, NULL, 1061 chars, ret, filename); 1062 while ((ret = fread(chars, 1, 3, f)) > 0) { 1063 xmlParseChunk(ctxt, chars, ret, 0); 1064 } 1065 ret = xmlParseChunk(ctxt, chars, 0, 1); 1066 xmlFreeParserCtxt(ctxt); 1067 if (ret != 0) { 1068 fprintf(stdout, 1069 "xmlSAXUserParseFile returned error %d\n", ret); 1070 } 1071 } 1072 fclose(f); 1073 } 1074 } else { 1075 #endif /* LIBXML_PUSH_ENABLED */ 1076 if (!speed) { 1077 /* 1078 * Empty callbacks for checking 1079 */ 1080 if ((!quiet) && (!nonull)) { 1081 res = xmlSAXUserParseFile(emptySAXHandler, NULL, filename); 1082 if (res != 0) { 1083 fprintf(stdout, "xmlSAXUserParseFile returned error %d\n", res); 1084 } 1085 } 1086 1087 /* 1088 * Debug callback 1089 */ 1090 callbacks = 0; 1091 if (repeat) { 1092 int i; 1093 for (i = 0;i < 99;i++) { 1094 if (sax2) 1095 res = xmlSAXUserParseFile(debugSAX2Handler, NULL, 1096 filename); 1097 else 1098 res = xmlSAXUserParseFile(debugSAXHandler, NULL, 1099 filename); 1100 } 1101 } 1102 if (sax2) 1103 res = xmlSAXUserParseFile(debugSAX2Handler, NULL, filename); 1104 else 1105 res = xmlSAXUserParseFile(debugSAXHandler, NULL, filename); 1106 if (res != 0) { 1107 fprintf(stdout, "xmlSAXUserParseFile returned error %d\n", res); 1108 } 1109 if (quiet) 1110 fprintf(stdout, "%d callbacks generated\n", callbacks); 1111 } else { 1112 /* 1113 * test 100x the SAX parse 1114 */ 1115 int i; 1116 1117 for (i = 0; i<100;i++) 1118 res = xmlSAXUserParseFile(emptySAXHandler, NULL, filename); 1119 if (res != 0) { 1120 fprintf(stdout, "xmlSAXUserParseFile returned error %d\n", res); 1121 } 1122 } 1123 #ifdef LIBXML_PUSH_ENABLED 1124 } 1125 #endif 1126 } 1127 1128 1129 int main(int argc, char **argv) { 1130 int i; 1131 int files = 0; 1132 1133 LIBXML_TEST_VERSION /* be safe, plus calls xmlInitParser */ 1134 1135 for (i = 1; i < argc ; i++) { 1136 if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug"))) 1137 debug++; 1138 else if ((!strcmp(argv[i], "-copy")) || (!strcmp(argv[i], "--copy"))) 1139 copy++; 1140 else if ((!strcmp(argv[i], "-recover")) || 1141 (!strcmp(argv[i], "--recover"))) 1142 recovery++; 1143 else if ((!strcmp(argv[i], "-push")) || 1144 (!strcmp(argv[i], "--push"))) 1145 #ifdef LIBXML_PUSH_ENABLED 1146 push++; 1147 #else 1148 fprintf(stderr,"'push' not enabled in library - ignoring\n"); 1149 #endif /* LIBXML_PUSH_ENABLED */ 1150 else if ((!strcmp(argv[i], "-speed")) || 1151 (!strcmp(argv[i], "--speed"))) 1152 speed++; 1153 else if ((!strcmp(argv[i], "-timing")) || 1154 (!strcmp(argv[i], "--timing"))) { 1155 nonull++; 1156 timing++; 1157 quiet++; 1158 } else if ((!strcmp(argv[i], "-repeat")) || 1159 (!strcmp(argv[i], "--repeat"))) { 1160 repeat++; 1161 quiet++; 1162 } else if ((!strcmp(argv[i], "-noent")) || 1163 (!strcmp(argv[i], "--noent"))) 1164 noent++; 1165 else if ((!strcmp(argv[i], "-quiet")) || 1166 (!strcmp(argv[i], "--quiet"))) 1167 quiet++; 1168 else if ((!strcmp(argv[i], "-sax2")) || 1169 (!strcmp(argv[i], "--sax2"))) 1170 sax2++; 1171 else if ((!strcmp(argv[i], "-nonull")) || 1172 (!strcmp(argv[i], "--nonull"))) 1173 nonull++; 1174 } 1175 if (noent != 0) xmlSubstituteEntitiesDefault(1); 1176 for (i = 1; i < argc ; i++) { 1177 if (argv[i][0] != '-') { 1178 if (timing) { 1179 startTimer(); 1180 } 1181 parseAndPrintFile(argv[i]); 1182 if (timing) { 1183 endTimer("Parsing"); 1184 } 1185 files ++; 1186 } 1187 } 1188 xmlCleanupParser(); 1189 xmlMemoryDump(); 1190 1191 return(0); 1192 } 1193 #else 1194 int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) { 1195 printf("%s : SAX1 parsing support not compiled in\n", argv[0]); 1196 return(0); 1197 } 1198 #endif /* LIBXML_SAX1_ENABLED */