Annotation of embedaddon/libxml2/testHTML.c, revision 1.1
1.1 ! misho 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
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to testHTML.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2