testHTML.c

   1 /*
   2  * testHTML.c : a small tester program for HTML input.
   3  *
   4  * See Copyright for the status of this software.
   5  *
   6  * daniel@veillard.com
   7  */
   8
   9 #include "libxml.h"
  10
  11 #ifdef LIBXML_HTML_ENABLED
  12
  13 #include <string.h>
  14 #include <stdarg.h>
  15
  16
  17 #ifdef HAVE_SYS_TYPES_H
  18 #include <sys/types.h>
  19 #endif
  20 #ifdef HAVE_SYS_STAT_H
  21 #include <sys/stat.h>
  22 #endif
  23 #ifdef HAVE_FCNTL_H
  24 #include <fcntl.h>
  25 #endif
  26 #ifdef HAVE_UNISTD_H
  27 #include <unistd.h>
  28 #endif
  29 #ifdef HAVE_STDLIB_H
  30 #include <stdlib.h>
  31 #endif
  32
  33 #include <libxml/xmlmemory.h>
  34 #include <libxml/HTMLparser.h>
  35 #include <libxml/HTMLtree.h>
  36 #include <libxml/debugXML.h>
  37 #include <libxml/xmlerror.h>
  38 #include <libxml/globals.h>
  39
  40 #ifdef LIBXML_DEBUG_ENABLED
  41 static int debug = 0;
  42 #endif
  43 static int copy = 0;
  44 static int sax = 0;
  45 static int repeat = 0;
  46 static int noout = 0;
  47 #ifdef LIBXML_PUSH_ENABLED
  48 static int push = 0;
  49 #endif /* LIBXML_PUSH_ENABLED */
  50 static char *encoding = NULL;
  51 static int options = 0;
  52
  53 static xmlSAXHandler emptySAXHandlerStruct = {
  54     NULL, /* internalSubset */
  55     NULL, /* isStandalone */
  56     NULL, /* hasInternalSubset */
  57     NULL, /* hasExternalSubset */
  58     NULL, /* resolveEntity */
  59     NULL, /* getEntity */
  60     NULL, /* entityDecl */
  61     NULL, /* notationDecl */
  62     NULL, /* attributeDecl */
  63     NULL, /* elementDecl */
  64     NULL, /* unparsedEntityDecl */
  65     NULL, /* setDocumentLocator */
  66     NULL, /* startDocument */
  67     NULL, /* endDocument */
  68     NULL, /* startElement */
  69     NULL, /* endElement */
  70     NULL, /* reference */
  71     NULL, /* characters */
  72     NULL, /* ignorableWhitespace */
  73     NULL, /* processingInstruction */
  74     NULL, /* comment */
  75     NULL, /* xmlParserWarning */
  76     NULL, /* xmlParserError */
  77     NULL, /* xmlParserError */
  78     NULL, /* getParameterEntity */
  79     NULL, /* cdataBlock */
  80     NULL, /* externalSubset */
  81     1,    /* initialized */
  82     NULL, /* private */
  83     NULL, /* startElementNsSAX2Func */
  84     NULL, /* endElementNsSAX2Func */
  85     NULL  /* xmlStructuredErrorFunc */
  86 };
  87
  88 static xmlSAXHandlerPtr emptySAXHandler = &emptySAXHandlerStruct;
  89 extern xmlSAXHandlerPtr debugSAXHandler;
  90
  91 /************************************************************************
  92  *                                                                      *
  93  *                              Debug Handlers                          *
  94  *                                                                      *
  95  ************************************************************************/
  96
  97 /**
  98  * isStandaloneDebug:
  99  * @ctxt:  An XML parser context
 100  *
 101  * Is this document tagged standalone ?
 102  *
 103  * Returns 1 if true
 104  */
 105 static int
 106 isStandaloneDebug(void *ctx ATTRIBUTE_UNUSED)
 107 {
 108     fprintf(stdout, "SAX.isStandalone()\n");
 109     return(0);
 110 }
 111
 112 /**
 113  * hasInternalSubsetDebug:
 114  * @ctxt:  An XML parser context
 115  *
 116  * Does this document has an internal subset
 117  *
 118  * Returns 1 if true
 119  */
 120 static int
 121 hasInternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
 122 {
 123     fprintf(stdout, "SAX.hasInternalSubset()\n");
 124     return(0);
 125 }
 126
 127 /**
 128  * hasExternalSubsetDebug:
 129  * @ctxt:  An XML parser context
 130  *
 131  * Does this document has an external subset
 132  *
 133  * Returns 1 if true
 134  */
 135 static int
 136 hasExternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
 137 {
 138     fprintf(stdout, "SAX.hasExternalSubset()\n");
 139     return(0);
 140 }
 141
 142 /**
 143  * hasInternalSubsetDebug:
 144  * @ctxt:  An XML parser context
 145  *
 146  * Does this document has an internal subset
 147  */
 148 static void
 149 internalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
 150                const xmlChar *ExternalID, const xmlChar *SystemID)
 151 {
 152     fprintf(stdout, "SAX.internalSubset(%s,", name);
 153     if (ExternalID == NULL)
 154         fprintf(stdout, " ,");
 155     else
 156         fprintf(stdout, " %s,", ExternalID);
 157     if (SystemID == NULL)
 158         fprintf(stdout, " )\n");
 159     else
 160         fprintf(stdout, " %s)\n", SystemID);
 161 }
 162
 163 /**
 164  * resolveEntityDebug:
 165  * @ctxt:  An XML parser context
 166  * @publicId: The public ID of the entity
 167  * @systemId: The system ID of the entity
 168  *
 169  * Special entity resolver, better left to the parser, it has
 170  * more context than the application layer.
 171  * The default behaviour is to NOT resolve the entities, in that case
 172  * the ENTITY_REF nodes are built in the structure (and the parameter
 173  * values).
 174  *
 175  * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
 176  */
 177 static xmlParserInputPtr
 178 resolveEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *publicId, const xmlChar *systemId)
 179 {
 180     /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
 181
 182
 183     fprintf(stdout, "SAX.resolveEntity(");
 184     if (publicId != NULL)
 185         fprintf(stdout, "%s", (char *)publicId);
 186     else
 187         fprintf(stdout, " ");
 188     if (systemId != NULL)
 189         fprintf(stdout, ", %s)\n", (char *)systemId);
 190     else
 191         fprintf(stdout, ", )\n");
 192 /*********
 193     if (systemId != NULL) {
 194         return(xmlNewInputFromFile(ctxt, (char *) systemId));
 195     }
 196  *********/
 197     return(NULL);
 198 }
 199
 200 /**
 201  * getEntityDebug:
 202  * @ctxt:  An XML parser context
 203  * @name: The entity name
 204  *
 205  * Get an entity by name
 206  *
 207  * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
 208  */
 209 static xmlEntityPtr
 210 getEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
 211 {
 212     fprintf(stdout, "SAX.getEntity(%s)\n", name);
 213     return(NULL);
 214 }
 215
 216 /**
 217  * getParameterEntityDebug:
 218  * @ctxt:  An XML parser context
 219  * @name: The entity name
 220  *
 221  * Get a parameter entity by name
 222  *
 223  * Returns the xmlParserInputPtr
 224  */
 225 static xmlEntityPtr
 226 getParameterEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
 227 {
 228     fprintf(stdout, "SAX.getParameterEntity(%s)\n", name);
 229     return(NULL);
 230 }
 231
 232
 233 /**
 234  * entityDeclDebug:
 235  * @ctxt:  An XML parser context
 236  * @name:  the entity name
 237  * @type:  the entity type
 238  * @publicId: The public ID of the entity
 239  * @systemId: The system ID of the entity
 240  * @content: the entity value (without processing).
 241  *
 242  * An entity definition has been parsed
 243  */
 244 static void
 245 entityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
 246           const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
 247 {
 248     fprintf(stdout, "SAX.entityDecl(%s, %d, %s, %s, %s)\n",
 249             name, type, publicId, systemId, content);
 250 }
 251
 252 /**
 253  * attributeDeclDebug:
 254  * @ctxt:  An XML parser context
 255  * @name:  the attribute name
 256  * @type:  the attribute type
 257  *
 258  * An attribute definition has been parsed
 259  */
 260 static void
 261 attributeDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *elem, const xmlChar *name,
 262               int type, int def, const xmlChar *defaultValue,
 263               xmlEnumerationPtr tree ATTRIBUTE_UNUSED)
 264 {
 265     fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, %s, ...)\n",
 266             elem, name, type, def, defaultValue);
 267 }
 268
 269 /**
 270  * elementDeclDebug:
 271  * @ctxt:  An XML parser context
 272  * @name:  the element name
 273  * @type:  the element type
 274  * @content: the element value (without processing).
 275  *
 276  * An element definition has been parsed
 277  */
 278 static void
 279 elementDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
 280             xmlElementContentPtr content ATTRIBUTE_UNUSED)
 281 {
 282     fprintf(stdout, "SAX.elementDecl(%s, %d, ...)\n",
 283             name, type);
 284 }
 285
 286 /**
 287  * notationDeclDebug:
 288  * @ctxt:  An XML parser context
 289  * @name: The name of the notation
 290  * @publicId: The public ID of the entity
 291  * @systemId: The system ID of the entity
 292  *
 293  * What to do when a notation declaration has been parsed.
 294  */
 295 static void
 296 notationDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
 297              const xmlChar *publicId, const xmlChar *systemId)
 298 {
 299     fprintf(stdout, "SAX.notationDecl(%s, %s, %s)\n",
 300             (char *) name, (char *) publicId, (char *) systemId);
 301 }
 302
 303 /**
 304  * unparsedEntityDeclDebug:
 305  * @ctxt:  An XML parser context
 306  * @name: The name of the entity
 307  * @publicId: The public ID of the entity
 308  * @systemId: The system ID of the entity
 309  * @notationName: the name of the notation
 310  *
 311  * What to do when an unparsed entity declaration is parsed
 312  */
 313 static void
 314 unparsedEntityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
 315                    const xmlChar *publicId, const xmlChar *systemId,
 316                    const xmlChar *notationName)
 317 {
 318     fprintf(stdout, "SAX.unparsedEntityDecl(%s, %s, %s, %s)\n",
 319             (char *) name, (char *) publicId, (char *) systemId,
 320             (char *) notationName);
 321 }
 322
 323 /**
 324  * setDocumentLocatorDebug:
 325  * @ctxt:  An XML parser context
 326  * @loc: A SAX Locator
 327  *
 328  * Receive the document locator at startup, actually xmlDefaultSAXLocator
 329  * Everything is available on the context, so this is useless in our case.
 330  */
 331 static void
 332 setDocumentLocatorDebug(void *ctx ATTRIBUTE_UNUSED, xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
 333 {
 334     fprintf(stdout, "SAX.setDocumentLocator()\n");
 335 }
 336
 337 /**
 338  * startDocumentDebug:
 339  * @ctxt:  An XML parser context
 340  *
 341  * called when the document start being processed.
 342  */
 343 static void
 344 startDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
 345 {
 346     fprintf(stdout, "SAX.startDocument()\n");
 347 }
 348
 349 /**
 350  * endDocumentDebug:
 351  * @ctxt:  An XML parser context
 352  *
 353  * called when the document end has been detected.
 354  */
 355 static void
 356 endDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
 357 {
 358     fprintf(stdout, "SAX.endDocument()\n");
 359 }
 360
 361 /**
 362  * startElementDebug:
 363  * @ctxt:  An XML parser context
 364  * @name:  The element name
 365  *
 366  * called when an opening tag has been processed.
 367  */
 368 static void
 369 startElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, const xmlChar **atts)
 370 {
 371     int i;
 372
 373     fprintf(stdout, "SAX.startElement(%s", (char *) name);
 374     if (atts != NULL) {
 375         for (i = 0;(atts[i] != NULL);i++) {
 376             fprintf(stdout, ", %s", atts[i++]);
 377             if (atts[i] != NULL) {
 378                 unsigned char output[40];
 379                 const unsigned char *att = atts[i];
 380                 int outlen, attlen;
 381                 fprintf(stdout, "='");
 382                 while ((attlen = strlen((char*)att)) > 0) {
 383                     outlen = sizeof output - 1;
 384                     htmlEncodeEntities(output, &outlen, att, &attlen, '\'');
 385                     output[outlen] = 0;
 386                     fprintf(stdout, "%s", (char *) output);
 387                     att += attlen;
 388                 }
 389                 fprintf(stdout, "'");
 390             }
 391         }
 392     }
 393     fprintf(stdout, ")\n");
 394 }
 395
 396 /**
 397  * endElementDebug:
 398  * @ctxt:  An XML parser context
 399  * @name:  The element name
 400  *
 401  * called when the end of an element has been detected.
 402  */
 403 static void
 404 endElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
 405 {
 406     fprintf(stdout, "SAX.endElement(%s)\n", (char *) name);
 407 }
 408
 409 /**
 410  * charactersDebug:
 411  * @ctxt:  An XML parser context
 412  * @ch:  a xmlChar string
 413  * @len: the number of xmlChar
 414  *
 415  * receiving some chars from the parser.
 416  * Question: how much at a time ???
 417  */
 418 static void
 419 charactersDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
 420 {
 421     unsigned char output[40];
 422     int inlen = len, outlen = 30;
 423
 424     htmlEncodeEntities(output, &outlen, ch, &inlen, 0);
 425     output[outlen] = 0;
 426
 427     fprintf(stdout, "SAX.characters(%s, %d)\n", output, len);
 428 }
 429
 430 /**
 431  * cdataDebug:
 432  * @ctxt:  An XML parser context
 433  * @ch:  a xmlChar string
 434  * @len: the number of xmlChar
 435  *
 436  * receiving some cdata chars from the parser.
 437  * Question: how much at a time ???
 438  */
 439 static void
 440 cdataDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
 441 {
 442     unsigned char output[40];
 443     int inlen = len, outlen = 30;
 444
 445     htmlEncodeEntities(output, &outlen, ch, &inlen, 0);
 446     output[outlen] = 0;
 447
 448     fprintf(stdout, "SAX.cdata(%s, %d)\n", output, len);
 449 }
 450
 451 /**
 452  * referenceDebug:
 453  * @ctxt:  An XML parser context
 454  * @name:  The entity name
 455  *
 456  * called when an entity reference is detected.
 457  */
 458 static void
 459 referenceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
 460 {
 461     fprintf(stdout, "SAX.reference(%s)\n", name);
 462 }
 463
 464 /**
 465  * ignorableWhitespaceDebug:
 466  * @ctxt:  An XML parser context
 467  * @ch:  a xmlChar string
 468  * @start: the first char in the string
 469  * @len: the number of xmlChar
 470  *
 471  * receiving some ignorable whitespaces from the parser.
 472  * Question: how much at a time ???
 473  */
 474 static void
 475 ignorableWhitespaceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
 476 {
 477     char output[40];
 478     int i;
 479
 480     for (i = 0;(i<len) && (i < 30);i++)
 481         output[i] = ch[i];
 482     output[i] = 0;
 483
 484     fprintf(stdout, "SAX.ignorableWhitespace(%s, %d)\n", output, len);
 485 }
 486
 487 /**
 488  * processingInstructionDebug:
 489  * @ctxt:  An XML parser context
 490  * @target:  the target name
 491  * @data: the PI data's
 492  * @len: the number of xmlChar
 493  *
 494  * A processing instruction has been parsed.
 495  */
 496 static void
 497 processingInstructionDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *target,
 498                       const xmlChar *data)
 499 {
 500     fprintf(stdout, "SAX.processingInstruction(%s, %s)\n",
 501             (char *) target, (char *) data);
 502 }
 503
 504 /**
 505  * commentDebug:
 506  * @ctxt:  An XML parser context
 507  * @value:  the comment content
 508  *
 509  * A comment has been parsed.
 510  */
 511 static void
 512 commentDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value)
 513 {
 514     fprintf(stdout, "SAX.comment(%s)\n", value);
 515 }
 516
 517 /**
 518  * warningDebug:
 519  * @ctxt:  An XML parser context
 520  * @msg:  the message to display/transmit
 521  * @...:  extra parameters for the message display
 522  *
 523  * Display and format a warning messages, gives file, line, position and
 524  * extra parameters.
 525  */
 526 static void XMLCDECL
 527 warningDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
 528 {
 529     va_list args;
 530
 531     va_start(args, msg);
 532     fprintf(stdout, "SAX.warning: ");
 533     vfprintf(stdout, msg, args);
 534     va_end(args);
 535 }
 536
 537 /**
 538  * errorDebug:
 539  * @ctxt:  An XML parser context
 540  * @msg:  the message to display/transmit
 541  * @...:  extra parameters for the message display
 542  *
 543  * Display and format a error messages, gives file, line, position and
 544  * extra parameters.
 545  */
 546 static void XMLCDECL
 547 errorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
 548 {
 549     va_list args;
 550
 551     va_start(args, msg);
 552     fprintf(stdout, "SAX.error: ");
 553     vfprintf(stdout, msg, args);
 554     va_end(args);
 555 }
 556
 557 /**
 558  * fatalErrorDebug:
 559  * @ctxt:  An XML parser context
 560  * @msg:  the message to display/transmit
 561  * @...:  extra parameters for the message display
 562  *
 563  * Display and format a fatalError messages, gives file, line, position and
 564  * extra parameters.
 565  */
 566 static void XMLCDECL
 567 fatalErrorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
 568 {
 569     va_list args;
 570
 571     va_start(args, msg);
 572     fprintf(stdout, "SAX.fatalError: ");
 573     vfprintf(stdout, msg, args);
 574     va_end(args);
 575 }
 576
 577 static xmlSAXHandler debugSAXHandlerStruct = {
 578     internalSubsetDebug,
 579     isStandaloneDebug,
 580     hasInternalSubsetDebug,
 581     hasExternalSubsetDebug,
 582     resolveEntityDebug,
 583     getEntityDebug,
 584     entityDeclDebug,
 585     notationDeclDebug,
 586     attributeDeclDebug,
 587     elementDeclDebug,
 588     unparsedEntityDeclDebug,
 589     setDocumentLocatorDebug,
 590     startDocumentDebug,
 591     endDocumentDebug,
 592     startElementDebug,
 593     endElementDebug,
 594     referenceDebug,
 595     charactersDebug,
 596     ignorableWhitespaceDebug,
 597     processingInstructionDebug,
 598     commentDebug,
 599     warningDebug,
 600     errorDebug,
 601     fatalErrorDebug,
 602     getParameterEntityDebug,
 603     cdataDebug,
 604     NULL,
 605     1,
 606     NULL,
 607     NULL,
 608     NULL,
 609     NULL
 610 };
 611
 612 xmlSAXHandlerPtr debugSAXHandler = &debugSAXHandlerStruct;
 613 /************************************************************************
 614  *                                                                      *
 615  *                              Debug                                   *
 616  *                                                                      *
 617  ************************************************************************/
 618
 619 static void
 620 parseSAXFile(char *filename) {
 621     htmlDocPtr doc = NULL;
 622
 623     /*
 624      * Empty callbacks for checking
 625      */
 626 #ifdef LIBXML_PUSH_ENABLED
 627     if (push) {
 628         FILE *f;
 629
 630 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
 631         f = fopen(filename, "rb");
 632 #else
 633         f = fopen(filename, "r");
 634 #endif
 635         if (f != NULL) {
 636             int res, size = 3;
 637             char chars[4096];
 638             htmlParserCtxtPtr ctxt;
 639
 640             /* if (repeat) */
 641                 size = 4096;
 642             res = fread(chars, 1, 4, f);
 643             if (res > 0) {
 644                 ctxt = htmlCreatePushParserCtxt(emptySAXHandler, NULL,
 645                             chars, res, filename, XML_CHAR_ENCODING_NONE);
 646                 while ((res = fread(chars, 1, size, f)) > 0) {
 647                     htmlParseChunk(ctxt, chars, res, 0);
 648                 }
 649                 htmlParseChunk(ctxt, chars, 0, 1);
 650                 doc = ctxt->myDoc;
 651                 htmlFreeParserCtxt(ctxt);
 652             }
 653             if (doc != NULL) {
 654                 fprintf(stdout, "htmlSAXParseFile returned non-NULL\n");
 655                 xmlFreeDoc(doc);
 656             }
 657             fclose(f);
 658         }
 659         if (!noout) {
 660 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
 661                 f = fopen(filename, "rb");
 662 #else
 663                 f = fopen(filename, "r");
 664 #endif
 665             if (f != NULL) {
 666                 int res, size = 3;
 667                 char chars[4096];
 668                 htmlParserCtxtPtr ctxt;
 669
 670                 /* if (repeat) */
 671                     size = 4096;
 672                 res = fread(chars, 1, 4, f);
 673                 if (res > 0) {
 674                     ctxt = htmlCreatePushParserCtxt(debugSAXHandler, NULL,
 675                                 chars, res, filename, XML_CHAR_ENCODING_NONE);
 676                     while ((res = fread(chars, 1, size, f)) > 0) {
 677                         htmlParseChunk(ctxt, chars, res, 0);
 678                     }
 679                     htmlParseChunk(ctxt, chars, 0, 1);
 680                     doc = ctxt->myDoc;
 681                     htmlFreeParserCtxt(ctxt);
 682                 }
 683                 if (doc != NULL) {
 684                     fprintf(stdout, "htmlSAXParseFile returned non-NULL\n");
 685                     xmlFreeDoc(doc);
 686                 }
 687                 fclose(f);
 688             }
 689         }
 690     } else {
 691 #endif /* LIBXML_PUSH_ENABLED */
 692         doc = htmlSAXParseFile(filename, NULL, emptySAXHandler, NULL);
 693         if (doc != NULL) {
 694             fprintf(stdout, "htmlSAXParseFile returned non-NULL\n");
 695             xmlFreeDoc(doc);
 696         }
 697
 698         if (!noout) {
 699             /*
 700              * Debug callback
 701              */
 702             doc = htmlSAXParseFile(filename, NULL, debugSAXHandler, NULL);
 703             if (doc != NULL) {
 704                 fprintf(stdout, "htmlSAXParseFile returned non-NULL\n");
 705                 xmlFreeDoc(doc);
 706             }
 707         }
 708 #ifdef LIBXML_PUSH_ENABLED
 709     }
 710 #endif /* LIBXML_PUSH_ENABLED */
 711 }
 712
 713 static void
 714 parseAndPrintFile(char *filename) {
 715     htmlDocPtr doc = NULL;
 716
 717     /*
 718      * build an HTML tree from a string;
 719      */
 720 #ifdef LIBXML_PUSH_ENABLED
 721     if (push) {
 722         FILE *f;
 723
 724 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
 725         f = fopen(filename, "rb");
 726 #else
 727         f = fopen(filename, "r");
 728 #endif
 729         if (f != NULL) {
 730             int res, size = 3;
 731             char chars[4096];
 732             htmlParserCtxtPtr ctxt;
 733
 734             /* if (repeat) */
 735                 size = 4096;
 736             res = fread(chars, 1, 4, f);
 737             if (res > 0) {
 738                 ctxt = htmlCreatePushParserCtxt(NULL, NULL,
 739                             chars, res, filename, XML_CHAR_ENCODING_NONE);
 740                 while ((res = fread(chars, 1, size, f)) > 0) {
 741                     htmlParseChunk(ctxt, chars, res, 0);
 742                 }
 743                 htmlParseChunk(ctxt, chars, 0, 1);
 744                 doc = ctxt->myDoc;
 745                 htmlFreeParserCtxt(ctxt);
 746             }
 747             fclose(f);
 748         }
 749     } else {
 750         doc = htmlReadFile(filename, NULL, options);
 751     }
 752 #else
 753         doc = htmlReadFile(filename,NULL,options);
 754 #endif
 755     if (doc == NULL) {
 756         xmlGenericError(xmlGenericErrorContext,
 757                 "Could not parse %s\n", filename);
 758     }
 759
 760 #ifdef LIBXML_TREE_ENABLED
 761     /*
 762      * test intermediate copy if needed.
 763      */
 764     if (copy) {
 765         htmlDocPtr tmp;
 766
 767         tmp = doc;
 768         doc = xmlCopyDoc(doc, 1);
 769         xmlFreeDoc(tmp);
 770     }
 771 #endif
 772
 773 #ifdef LIBXML_OUTPUT_ENABLED
 774     /*
 775      * print it.
 776      */
 777     if (!noout) {
 778 #ifdef LIBXML_DEBUG_ENABLED
 779         if (!debug) {
 780             if (encoding)
 781                 htmlSaveFileEnc("-", doc, encoding);
 782             else
 783                 htmlDocDump(stdout, doc);
 784         } else
 785             xmlDebugDumpDocument(stdout, doc);
 786 #else
 787         if (encoding)
 788             htmlSaveFileEnc("-", doc, encoding);
 789         else
 790             htmlDocDump(stdout, doc);
 791 #endif
 792     }
 793 #endif /* LIBXML_OUTPUT_ENABLED */
 794
 795     /*
 796      * free it.
 797      */
 798     xmlFreeDoc(doc);
 799 }
 800
 801 int main(int argc, char **argv) {
 802     int i, count;
 803     int files = 0;
 804
 805     for (i = 1; i < argc ; i++) {
 806 #ifdef LIBXML_DEBUG_ENABLED
 807         if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
 808             debug++;
 809         else
 810 #endif
 811             if ((!strcmp(argv[i], "-copy")) || (!strcmp(argv[i], "--copy")))
 812             copy++;
 813 #ifdef LIBXML_PUSH_ENABLED
 814         else if ((!strcmp(argv[i], "-push")) || (!strcmp(argv[i], "--push")))
 815             push++;
 816 #endif /* LIBXML_PUSH_ENABLED */
 817         else if ((!strcmp(argv[i], "-sax")) || (!strcmp(argv[i], "--sax")))
 818             sax++;
 819         else if ((!strcmp(argv[i], "-noout")) || (!strcmp(argv[i], "--noout")))
 820             noout++;
 821         else if ((!strcmp(argv[i], "-repeat")) ||
 822                  (!strcmp(argv[i], "--repeat")))
 823             repeat++;
 824         else if ((!strcmp(argv[i], "-encode")) ||
 825                  (!strcmp(argv[i], "--encode"))) {
 826             i++;
 827             encoding = argv[i];
 828         }
 829     }
 830     for (i = 1; i < argc ; i++) {
 831         if ((!strcmp(argv[i], "-encode")) ||
 832                  (!strcmp(argv[i], "--encode"))) {
 833             i++;
 834             continue;
 835         }
 836         if (argv[i][0] != '-') {
 837             if (repeat) {
 838                 for (count = 0;count < 100 * repeat;count++) {
 839                     if (sax)
 840                         parseSAXFile(argv[i]);
 841                     else
 842                         parseAndPrintFile(argv[i]);
 843                 }
 844             } else {
 845                 if (sax)
 846                     parseSAXFile(argv[i]);
 847                 else
 848                     parseAndPrintFile(argv[i]);
 849             }
 850             files ++;
 851         }
 852     }
 853     if (files == 0) {
 854         printf("Usage : %s [--debug] [--copy] [--copy] HTMLfiles ...\n",
 855                argv[0]);
 856         printf("\tParse the HTML files and output the result of the parsing\n");
 857 #ifdef LIBXML_DEBUG_ENABLED
 858         printf("\t--debug : dump a debug tree of the in-memory document\n");
 859 #endif
 860         printf("\t--copy : used to test the internal copy implementation\n");
 861         printf("\t--sax : debug the sequence of SAX callbacks\n");
 862         printf("\t--repeat : parse the file 100 times, for timing\n");
 863         printf("\t--noout : do not print the result\n");
 864 #ifdef LIBXML_PUSH_ENABLED
 865         printf("\t--push : use the push mode parser\n");
 866 #endif /* LIBXML_PUSH_ENABLED */
 867         printf("\t--encode encoding : output in the given encoding\n");
 868     }
 869     xmlCleanupParser();
 870     xmlMemoryDump();
 871
 872     return(0);
 873 }
 874 #else /* !LIBXML_HTML_ENABLED */
 875 #include <stdio.h>
 876 int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
 877     printf("%s : HTML support not compiled in\n", argv[0]);
 878     return(0);
 879 }
 880 #endif