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