Annotation of embedaddon/libxml2/xmllint.c, revision 1.1
1.1 ! misho 1: /*
! 2: * xmllint.c : a small tester program for XML input.
! 3: *
! 4: * See Copyright for the status of this software.
! 5: *
! 6: * daniel@veillard.com
! 7: */
! 8:
! 9: #include "libxml.h"
! 10:
! 11: #include <string.h>
! 12: #include <stdarg.h>
! 13: #include <assert.h>
! 14:
! 15: #if defined (_WIN32) && !defined(__CYGWIN__)
! 16: #if defined (_MSC_VER) || defined(__BORLANDC__)
! 17: #include <winsock2.h>
! 18: #pragma comment(lib, "ws2_32.lib")
! 19: #define gettimeofday(p1,p2)
! 20: #endif /* _MSC_VER */
! 21: #endif /* _WIN32 */
! 22:
! 23: #ifdef HAVE_SYS_TIME_H
! 24: #include <sys/time.h>
! 25: #endif
! 26: #ifdef HAVE_TIME_H
! 27: #include <time.h>
! 28: #endif
! 29:
! 30: #ifdef __MINGW32__
! 31: #define _WINSOCKAPI_
! 32: #include <wsockcompat.h>
! 33: #include <winsock2.h>
! 34: #undef XML_SOCKLEN_T
! 35: #define XML_SOCKLEN_T unsigned int
! 36: #endif
! 37:
! 38: #ifdef HAVE_SYS_TIMEB_H
! 39: #include <sys/timeb.h>
! 40: #endif
! 41:
! 42: #ifdef HAVE_SYS_TYPES_H
! 43: #include <sys/types.h>
! 44: #endif
! 45: #ifdef HAVE_SYS_STAT_H
! 46: #include <sys/stat.h>
! 47: #endif
! 48: #ifdef HAVE_FCNTL_H
! 49: #include <fcntl.h>
! 50: #endif
! 51: #ifdef HAVE_UNISTD_H
! 52: #include <unistd.h>
! 53: #endif
! 54: #ifdef HAVE_SYS_MMAN_H
! 55: #include <sys/mman.h>
! 56: /* seems needed for Solaris */
! 57: #ifndef MAP_FAILED
! 58: #define MAP_FAILED ((void *) -1)
! 59: #endif
! 60: #endif
! 61: #ifdef HAVE_STDLIB_H
! 62: #include <stdlib.h>
! 63: #endif
! 64: #ifdef HAVE_LIBREADLINE
! 65: #include <readline/readline.h>
! 66: #ifdef HAVE_LIBHISTORY
! 67: #include <readline/history.h>
! 68: #endif
! 69: #endif
! 70:
! 71: #include <libxml/xmlmemory.h>
! 72: #include <libxml/parser.h>
! 73: #include <libxml/parserInternals.h>
! 74: #include <libxml/HTMLparser.h>
! 75: #include <libxml/HTMLtree.h>
! 76: #include <libxml/tree.h>
! 77: #include <libxml/xpath.h>
! 78: #include <libxml/debugXML.h>
! 79: #include <libxml/xmlerror.h>
! 80: #ifdef LIBXML_XINCLUDE_ENABLED
! 81: #include <libxml/xinclude.h>
! 82: #endif
! 83: #ifdef LIBXML_CATALOG_ENABLED
! 84: #include <libxml/catalog.h>
! 85: #endif
! 86: #include <libxml/globals.h>
! 87: #include <libxml/xmlreader.h>
! 88: #ifdef LIBXML_SCHEMATRON_ENABLED
! 89: #include <libxml/schematron.h>
! 90: #endif
! 91: #ifdef LIBXML_SCHEMAS_ENABLED
! 92: #include <libxml/relaxng.h>
! 93: #include <libxml/xmlschemas.h>
! 94: #endif
! 95: #ifdef LIBXML_PATTERN_ENABLED
! 96: #include <libxml/pattern.h>
! 97: #endif
! 98: #ifdef LIBXML_C14N_ENABLED
! 99: #include <libxml/c14n.h>
! 100: #endif
! 101: #ifdef LIBXML_OUTPUT_ENABLED
! 102: #include <libxml/xmlsave.h>
! 103: #endif
! 104:
! 105: #ifndef XML_XML_DEFAULT_CATALOG
! 106: #define XML_XML_DEFAULT_CATALOG "file:///etc/xml/catalog"
! 107: #endif
! 108:
! 109: typedef enum {
! 110: XMLLINT_RETURN_OK = 0, /* No error */
! 111: XMLLINT_ERR_UNCLASS = 1, /* Unclassified */
! 112: XMLLINT_ERR_DTD = 2, /* Error in DTD */
! 113: XMLLINT_ERR_VALID = 3, /* Validation error */
! 114: XMLLINT_ERR_RDFILE = 4, /* CtxtReadFile error */
! 115: XMLLINT_ERR_SCHEMACOMP = 5, /* Schema compilation */
! 116: XMLLINT_ERR_OUT = 6, /* Error writing output */
! 117: XMLLINT_ERR_SCHEMAPAT = 7, /* Error in schema pattern */
! 118: XMLLINT_ERR_RDREGIS = 8, /* Error in Reader registration */
! 119: XMLLINT_ERR_MEM = 9, /* Out of memory error */
! 120: XMLLINT_ERR_XPATH = 10 /* XPath evaluation error */
! 121: } xmllintReturnCode;
! 122: #ifdef LIBXML_DEBUG_ENABLED
! 123: static int shell = 0;
! 124: static int debugent = 0;
! 125: #endif
! 126: static int debug = 0;
! 127: static int maxmem = 0;
! 128: #ifdef LIBXML_TREE_ENABLED
! 129: static int copy = 0;
! 130: #endif /* LIBXML_TREE_ENABLED */
! 131: static int recovery = 0;
! 132: static int noent = 0;
! 133: static int noblanks = 0;
! 134: static int noout = 0;
! 135: static int nowrap = 0;
! 136: #ifdef LIBXML_OUTPUT_ENABLED
! 137: static int format = 0;
! 138: static const char *output = NULL;
! 139: static int compress = 0;
! 140: static int oldout = 0;
! 141: #endif /* LIBXML_OUTPUT_ENABLED */
! 142: #ifdef LIBXML_VALID_ENABLED
! 143: static int valid = 0;
! 144: static int postvalid = 0;
! 145: static char * dtdvalid = NULL;
! 146: static char * dtdvalidfpi = NULL;
! 147: #endif
! 148: #ifdef LIBXML_SCHEMAS_ENABLED
! 149: static char * relaxng = NULL;
! 150: static xmlRelaxNGPtr relaxngschemas = NULL;
! 151: static char * schema = NULL;
! 152: static xmlSchemaPtr wxschemas = NULL;
! 153: #endif
! 154: #ifdef LIBXML_SCHEMATRON_ENABLED
! 155: static char * schematron = NULL;
! 156: static xmlSchematronPtr wxschematron = NULL;
! 157: #endif
! 158: static int repeat = 0;
! 159: static int insert = 0;
! 160: #if defined(LIBXML_HTML_ENABLED) || defined(LIBXML_VALID_ENABLED)
! 161: static int html = 0;
! 162: static int xmlout = 0;
! 163: #endif
! 164: static int htmlout = 0;
! 165: #if defined(LIBXML_HTML_ENABLED)
! 166: static int nodefdtd = 0;
! 167: #endif
! 168: #ifdef LIBXML_PUSH_ENABLED
! 169: static int push = 0;
! 170: #endif /* LIBXML_PUSH_ENABLED */
! 171: #ifdef HAVE_SYS_MMAN_H
! 172: static int memory = 0;
! 173: #endif
! 174: static int testIO = 0;
! 175: static char *encoding = NULL;
! 176: #ifdef LIBXML_XINCLUDE_ENABLED
! 177: static int xinclude = 0;
! 178: #endif
! 179: static int dtdattrs = 0;
! 180: static int loaddtd = 0;
! 181: static xmllintReturnCode progresult = XMLLINT_RETURN_OK;
! 182: static int timing = 0;
! 183: static int generate = 0;
! 184: static int dropdtd = 0;
! 185: #ifdef LIBXML_CATALOG_ENABLED
! 186: static int catalogs = 0;
! 187: static int nocatalogs = 0;
! 188: #endif
! 189: #ifdef LIBXML_C14N_ENABLED
! 190: static int canonical = 0;
! 191: static int canonical_11 = 0;
! 192: static int exc_canonical = 0;
! 193: #endif
! 194: #ifdef LIBXML_READER_ENABLED
! 195: static int stream = 0;
! 196: static int walker = 0;
! 197: #endif /* LIBXML_READER_ENABLED */
! 198: static int chkregister = 0;
! 199: static int nbregister = 0;
! 200: #ifdef LIBXML_SAX1_ENABLED
! 201: static int sax1 = 0;
! 202: #endif /* LIBXML_SAX1_ENABLED */
! 203: #ifdef LIBXML_PATTERN_ENABLED
! 204: static const char *pattern = NULL;
! 205: static xmlPatternPtr patternc = NULL;
! 206: static xmlStreamCtxtPtr patstream = NULL;
! 207: #endif
! 208: #ifdef LIBXML_XPATH_ENABLED
! 209: static const char *xpathquery = NULL;
! 210: #endif
! 211: static int options = XML_PARSE_COMPACT;
! 212: static int sax = 0;
! 213: static int oldxml10 = 0;
! 214:
! 215: /************************************************************************
! 216: * *
! 217: * Entity loading control and customization. *
! 218: * *
! 219: ************************************************************************/
! 220: #define MAX_PATHS 64
! 221: #ifdef _WIN32
! 222: # define PATH_SEPARATOR ';'
! 223: #else
! 224: # define PATH_SEPARATOR ':'
! 225: #endif
! 226: static xmlChar *paths[MAX_PATHS + 1];
! 227: static int nbpaths = 0;
! 228: static int load_trace = 0;
! 229:
! 230: static
! 231: void parsePath(const xmlChar *path) {
! 232: const xmlChar *cur;
! 233:
! 234: if (path == NULL)
! 235: return;
! 236: while (*path != 0) {
! 237: if (nbpaths >= MAX_PATHS) {
! 238: fprintf(stderr, "MAX_PATHS reached: too many paths\n");
! 239: return;
! 240: }
! 241: cur = path;
! 242: while ((*cur == ' ') || (*cur == PATH_SEPARATOR))
! 243: cur++;
! 244: path = cur;
! 245: while ((*cur != 0) && (*cur != ' ') && (*cur != PATH_SEPARATOR))
! 246: cur++;
! 247: if (cur != path) {
! 248: paths[nbpaths] = xmlStrndup(path, cur - path);
! 249: if (paths[nbpaths] != NULL)
! 250: nbpaths++;
! 251: path = cur;
! 252: }
! 253: }
! 254: }
! 255:
! 256: static xmlExternalEntityLoader defaultEntityLoader = NULL;
! 257:
! 258: static xmlParserInputPtr
! 259: xmllintExternalEntityLoader(const char *URL, const char *ID,
! 260: xmlParserCtxtPtr ctxt) {
! 261: xmlParserInputPtr ret;
! 262: warningSAXFunc warning = NULL;
! 263: errorSAXFunc err = NULL;
! 264:
! 265: int i;
! 266: const char *lastsegment = URL;
! 267: const char *iter = URL;
! 268:
! 269: if ((nbpaths > 0) && (iter != NULL)) {
! 270: while (*iter != 0) {
! 271: if (*iter == '/')
! 272: lastsegment = iter + 1;
! 273: iter++;
! 274: }
! 275: }
! 276:
! 277: if ((ctxt != NULL) && (ctxt->sax != NULL)) {
! 278: warning = ctxt->sax->warning;
! 279: err = ctxt->sax->error;
! 280: ctxt->sax->warning = NULL;
! 281: ctxt->sax->error = NULL;
! 282: }
! 283:
! 284: if (defaultEntityLoader != NULL) {
! 285: ret = defaultEntityLoader(URL, ID, ctxt);
! 286: if (ret != NULL) {
! 287: if (warning != NULL)
! 288: ctxt->sax->warning = warning;
! 289: if (err != NULL)
! 290: ctxt->sax->error = err;
! 291: if (load_trace) {
! 292: fprintf \
! 293: (stderr,
! 294: "Loaded URL=\"%s\" ID=\"%s\"\n",
! 295: URL ? URL : "(null)",
! 296: ID ? ID : "(null)");
! 297: }
! 298: return(ret);
! 299: }
! 300: }
! 301: for (i = 0;i < nbpaths;i++) {
! 302: xmlChar *newURL;
! 303:
! 304: newURL = xmlStrdup((const xmlChar *) paths[i]);
! 305: newURL = xmlStrcat(newURL, (const xmlChar *) "/");
! 306: newURL = xmlStrcat(newURL, (const xmlChar *) lastsegment);
! 307: if (newURL != NULL) {
! 308: ret = defaultEntityLoader((const char *)newURL, ID, ctxt);
! 309: if (ret != NULL) {
! 310: if (warning != NULL)
! 311: ctxt->sax->warning = warning;
! 312: if (err != NULL)
! 313: ctxt->sax->error = err;
! 314: if (load_trace) {
! 315: fprintf \
! 316: (stderr,
! 317: "Loaded URL=\"%s\" ID=\"%s\"\n",
! 318: newURL,
! 319: ID ? ID : "(null)");
! 320: }
! 321: xmlFree(newURL);
! 322: return(ret);
! 323: }
! 324: xmlFree(newURL);
! 325: }
! 326: }
! 327: if (err != NULL)
! 328: ctxt->sax->error = err;
! 329: if (warning != NULL) {
! 330: ctxt->sax->warning = warning;
! 331: if (URL != NULL)
! 332: warning(ctxt, "failed to load external entity \"%s\"\n", URL);
! 333: else if (ID != NULL)
! 334: warning(ctxt, "failed to load external entity \"%s\"\n", ID);
! 335: }
! 336: return(NULL);
! 337: }
! 338: /************************************************************************
! 339: * *
! 340: * Memory allocation consumption debugging *
! 341: * *
! 342: ************************************************************************/
! 343:
! 344: static void
! 345: OOM(void)
! 346: {
! 347: fprintf(stderr, "Ran out of memory needs > %d bytes\n", maxmem);
! 348: progresult = XMLLINT_ERR_MEM;
! 349: }
! 350:
! 351: static void
! 352: myFreeFunc(void *mem)
! 353: {
! 354: xmlMemFree(mem);
! 355: }
! 356: static void *
! 357: myMallocFunc(size_t size)
! 358: {
! 359: void *ret;
! 360:
! 361: ret = xmlMemMalloc(size);
! 362: if (ret != NULL) {
! 363: if (xmlMemUsed() > maxmem) {
! 364: OOM();
! 365: xmlMemFree(ret);
! 366: return (NULL);
! 367: }
! 368: }
! 369: return (ret);
! 370: }
! 371: static void *
! 372: myReallocFunc(void *mem, size_t size)
! 373: {
! 374: void *ret;
! 375:
! 376: ret = xmlMemRealloc(mem, size);
! 377: if (ret != NULL) {
! 378: if (xmlMemUsed() > maxmem) {
! 379: OOM();
! 380: xmlMemFree(ret);
! 381: return (NULL);
! 382: }
! 383: }
! 384: return (ret);
! 385: }
! 386: static char *
! 387: myStrdupFunc(const char *str)
! 388: {
! 389: char *ret;
! 390:
! 391: ret = xmlMemoryStrdup(str);
! 392: if (ret != NULL) {
! 393: if (xmlMemUsed() > maxmem) {
! 394: OOM();
! 395: xmlFree(ret);
! 396: return (NULL);
! 397: }
! 398: }
! 399: return (ret);
! 400: }
! 401: /************************************************************************
! 402: * *
! 403: * Internal timing routines to remove the necessity to have *
! 404: * unix-specific function calls. *
! 405: * *
! 406: ************************************************************************/
! 407:
! 408: #ifndef HAVE_GETTIMEOFDAY
! 409: #ifdef HAVE_SYS_TIMEB_H
! 410: #ifdef HAVE_SYS_TIME_H
! 411: #ifdef HAVE_FTIME
! 412:
! 413: static int
! 414: my_gettimeofday(struct timeval *tvp, void *tzp)
! 415: {
! 416: struct timeb timebuffer;
! 417:
! 418: ftime(&timebuffer);
! 419: if (tvp) {
! 420: tvp->tv_sec = timebuffer.time;
! 421: tvp->tv_usec = timebuffer.millitm * 1000L;
! 422: }
! 423: return (0);
! 424: }
! 425: #define HAVE_GETTIMEOFDAY 1
! 426: #define gettimeofday my_gettimeofday
! 427:
! 428: #endif /* HAVE_FTIME */
! 429: #endif /* HAVE_SYS_TIME_H */
! 430: #endif /* HAVE_SYS_TIMEB_H */
! 431: #endif /* !HAVE_GETTIMEOFDAY */
! 432:
! 433: #if defined(HAVE_GETTIMEOFDAY)
! 434: static struct timeval begin, end;
! 435:
! 436: /*
! 437: * startTimer: call where you want to start timing
! 438: */
! 439: static void
! 440: startTimer(void)
! 441: {
! 442: gettimeofday(&begin, NULL);
! 443: }
! 444:
! 445: /*
! 446: * endTimer: call where you want to stop timing and to print out a
! 447: * message about the timing performed; format is a printf
! 448: * type argument
! 449: */
! 450: static void XMLCDECL
! 451: endTimer(const char *fmt, ...)
! 452: {
! 453: long msec;
! 454: va_list ap;
! 455:
! 456: gettimeofday(&end, NULL);
! 457: msec = end.tv_sec - begin.tv_sec;
! 458: msec *= 1000;
! 459: msec += (end.tv_usec - begin.tv_usec) / 1000;
! 460:
! 461: #ifndef HAVE_STDARG_H
! 462: #error "endTimer required stdarg functions"
! 463: #endif
! 464: va_start(ap, fmt);
! 465: vfprintf(stderr, fmt, ap);
! 466: va_end(ap);
! 467:
! 468: fprintf(stderr, " took %ld ms\n", msec);
! 469: }
! 470: #elif defined(HAVE_TIME_H)
! 471: /*
! 472: * No gettimeofday function, so we have to make do with calling clock.
! 473: * This is obviously less accurate, but there's little we can do about
! 474: * that.
! 475: */
! 476: #ifndef CLOCKS_PER_SEC
! 477: #define CLOCKS_PER_SEC 100
! 478: #endif
! 479:
! 480: static clock_t begin, end;
! 481: static void
! 482: startTimer(void)
! 483: {
! 484: begin = clock();
! 485: }
! 486: static void XMLCDECL
! 487: endTimer(const char *fmt, ...)
! 488: {
! 489: long msec;
! 490: va_list ap;
! 491:
! 492: end = clock();
! 493: msec = ((end - begin) * 1000) / CLOCKS_PER_SEC;
! 494:
! 495: #ifndef HAVE_STDARG_H
! 496: #error "endTimer required stdarg functions"
! 497: #endif
! 498: va_start(ap, fmt);
! 499: vfprintf(stderr, fmt, ap);
! 500: va_end(ap);
! 501: fprintf(stderr, " took %ld ms\n", msec);
! 502: }
! 503: #else
! 504:
! 505: /*
! 506: * We don't have a gettimeofday or time.h, so we just don't do timing
! 507: */
! 508: static void
! 509: startTimer(void)
! 510: {
! 511: /*
! 512: * Do nothing
! 513: */
! 514: }
! 515: static void XMLCDECL
! 516: endTimer(char *format, ...)
! 517: {
! 518: /*
! 519: * We cannot do anything because we don't have a timing function
! 520: */
! 521: #ifdef HAVE_STDARG_H
! 522: va_start(ap, format);
! 523: vfprintf(stderr, format, ap);
! 524: va_end(ap);
! 525: fprintf(stderr, " was not timed\n", msec);
! 526: #else
! 527: /* We don't have gettimeofday, time or stdarg.h, what crazy world is
! 528: * this ?!
! 529: */
! 530: #endif
! 531: }
! 532: #endif
! 533: /************************************************************************
! 534: * *
! 535: * HTML ouput *
! 536: * *
! 537: ************************************************************************/
! 538: static char buffer[50000];
! 539:
! 540: static void
! 541: xmlHTMLEncodeSend(void) {
! 542: char *result;
! 543:
! 544: result = (char *) xmlEncodeEntitiesReentrant(NULL, BAD_CAST buffer);
! 545: if (result) {
! 546: xmlGenericError(xmlGenericErrorContext, "%s", result);
! 547: xmlFree(result);
! 548: }
! 549: buffer[0] = 0;
! 550: }
! 551:
! 552: /**
! 553: * xmlHTMLPrintFileInfo:
! 554: * @input: an xmlParserInputPtr input
! 555: *
! 556: * Displays the associated file and line informations for the current input
! 557: */
! 558:
! 559: static void
! 560: xmlHTMLPrintFileInfo(xmlParserInputPtr input) {
! 561: int len;
! 562: xmlGenericError(xmlGenericErrorContext, "<p>");
! 563:
! 564: len = strlen(buffer);
! 565: if (input != NULL) {
! 566: if (input->filename) {
! 567: snprintf(&buffer[len], sizeof(buffer) - len, "%s:%d: ", input->filename,
! 568: input->line);
! 569: } else {
! 570: snprintf(&buffer[len], sizeof(buffer) - len, "Entity: line %d: ", input->line);
! 571: }
! 572: }
! 573: xmlHTMLEncodeSend();
! 574: }
! 575:
! 576: /**
! 577: * xmlHTMLPrintFileContext:
! 578: * @input: an xmlParserInputPtr input
! 579: *
! 580: * Displays current context within the input content for error tracking
! 581: */
! 582:
! 583: static void
! 584: xmlHTMLPrintFileContext(xmlParserInputPtr input) {
! 585: const xmlChar *cur, *base;
! 586: int len;
! 587: int n;
! 588:
! 589: if (input == NULL) return;
! 590: xmlGenericError(xmlGenericErrorContext, "<pre>\n");
! 591: cur = input->cur;
! 592: base = input->base;
! 593: while ((cur > base) && ((*cur == '\n') || (*cur == '\r'))) {
! 594: cur--;
! 595: }
! 596: n = 0;
! 597: while ((n++ < 80) && (cur > base) && (*cur != '\n') && (*cur != '\r'))
! 598: cur--;
! 599: if ((*cur == '\n') || (*cur == '\r')) cur++;
! 600: base = cur;
! 601: n = 0;
! 602: while ((*cur != 0) && (*cur != '\n') && (*cur != '\r') && (n < 79)) {
! 603: len = strlen(buffer);
! 604: snprintf(&buffer[len], sizeof(buffer) - len, "%c",
! 605: (unsigned char) *cur++);
! 606: n++;
! 607: }
! 608: len = strlen(buffer);
! 609: snprintf(&buffer[len], sizeof(buffer) - len, "\n");
! 610: cur = input->cur;
! 611: while ((*cur == '\n') || (*cur == '\r'))
! 612: cur--;
! 613: n = 0;
! 614: while ((cur != base) && (n++ < 80)) {
! 615: len = strlen(buffer);
! 616: snprintf(&buffer[len], sizeof(buffer) - len, " ");
! 617: base++;
! 618: }
! 619: len = strlen(buffer);
! 620: snprintf(&buffer[len], sizeof(buffer) - len, "^\n");
! 621: xmlHTMLEncodeSend();
! 622: xmlGenericError(xmlGenericErrorContext, "</pre>");
! 623: }
! 624:
! 625: /**
! 626: * xmlHTMLError:
! 627: * @ctx: an XML parser context
! 628: * @msg: the message to display/transmit
! 629: * @...: extra parameters for the message display
! 630: *
! 631: * Display and format an error messages, gives file, line, position and
! 632: * extra parameters.
! 633: */
! 634: static void XMLCDECL
! 635: xmlHTMLError(void *ctx, const char *msg, ...)
! 636: {
! 637: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
! 638: xmlParserInputPtr input;
! 639: va_list args;
! 640: int len;
! 641:
! 642: buffer[0] = 0;
! 643: input = ctxt->input;
! 644: if ((input != NULL) && (input->filename == NULL) && (ctxt->inputNr > 1)) {
! 645: input = ctxt->inputTab[ctxt->inputNr - 2];
! 646: }
! 647:
! 648: xmlHTMLPrintFileInfo(input);
! 649:
! 650: xmlGenericError(xmlGenericErrorContext, "<b>error</b>: ");
! 651: va_start(args, msg);
! 652: len = strlen(buffer);
! 653: vsnprintf(&buffer[len], sizeof(buffer) - len, msg, args);
! 654: va_end(args);
! 655: xmlHTMLEncodeSend();
! 656: xmlGenericError(xmlGenericErrorContext, "</p>\n");
! 657:
! 658: xmlHTMLPrintFileContext(input);
! 659: xmlHTMLEncodeSend();
! 660: }
! 661:
! 662: /**
! 663: * xmlHTMLWarning:
! 664: * @ctx: an XML parser context
! 665: * @msg: the message to display/transmit
! 666: * @...: extra parameters for the message display
! 667: *
! 668: * Display and format a warning messages, gives file, line, position and
! 669: * extra parameters.
! 670: */
! 671: static void XMLCDECL
! 672: xmlHTMLWarning(void *ctx, const char *msg, ...)
! 673: {
! 674: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
! 675: xmlParserInputPtr input;
! 676: va_list args;
! 677: int len;
! 678:
! 679: buffer[0] = 0;
! 680: input = ctxt->input;
! 681: if ((input != NULL) && (input->filename == NULL) && (ctxt->inputNr > 1)) {
! 682: input = ctxt->inputTab[ctxt->inputNr - 2];
! 683: }
! 684:
! 685:
! 686: xmlHTMLPrintFileInfo(input);
! 687:
! 688: xmlGenericError(xmlGenericErrorContext, "<b>warning</b>: ");
! 689: va_start(args, msg);
! 690: len = strlen(buffer);
! 691: vsnprintf(&buffer[len], sizeof(buffer) - len, msg, args);
! 692: va_end(args);
! 693: xmlHTMLEncodeSend();
! 694: xmlGenericError(xmlGenericErrorContext, "</p>\n");
! 695:
! 696: xmlHTMLPrintFileContext(input);
! 697: xmlHTMLEncodeSend();
! 698: }
! 699:
! 700: /**
! 701: * xmlHTMLValidityError:
! 702: * @ctx: an XML parser context
! 703: * @msg: the message to display/transmit
! 704: * @...: extra parameters for the message display
! 705: *
! 706: * Display and format an validity error messages, gives file,
! 707: * line, position and extra parameters.
! 708: */
! 709: static void XMLCDECL
! 710: xmlHTMLValidityError(void *ctx, const char *msg, ...)
! 711: {
! 712: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
! 713: xmlParserInputPtr input;
! 714: va_list args;
! 715: int len;
! 716:
! 717: buffer[0] = 0;
! 718: input = ctxt->input;
! 719: if ((input->filename == NULL) && (ctxt->inputNr > 1))
! 720: input = ctxt->inputTab[ctxt->inputNr - 2];
! 721:
! 722: xmlHTMLPrintFileInfo(input);
! 723:
! 724: xmlGenericError(xmlGenericErrorContext, "<b>validity error</b>: ");
! 725: len = strlen(buffer);
! 726: va_start(args, msg);
! 727: vsnprintf(&buffer[len], sizeof(buffer) - len, msg, args);
! 728: va_end(args);
! 729: xmlHTMLEncodeSend();
! 730: xmlGenericError(xmlGenericErrorContext, "</p>\n");
! 731:
! 732: xmlHTMLPrintFileContext(input);
! 733: xmlHTMLEncodeSend();
! 734: progresult = XMLLINT_ERR_VALID;
! 735: }
! 736:
! 737: /**
! 738: * xmlHTMLValidityWarning:
! 739: * @ctx: an XML parser context
! 740: * @msg: the message to display/transmit
! 741: * @...: extra parameters for the message display
! 742: *
! 743: * Display and format a validity warning messages, gives file, line,
! 744: * position and extra parameters.
! 745: */
! 746: static void XMLCDECL
! 747: xmlHTMLValidityWarning(void *ctx, const char *msg, ...)
! 748: {
! 749: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
! 750: xmlParserInputPtr input;
! 751: va_list args;
! 752: int len;
! 753:
! 754: buffer[0] = 0;
! 755: input = ctxt->input;
! 756: if ((input->filename == NULL) && (ctxt->inputNr > 1))
! 757: input = ctxt->inputTab[ctxt->inputNr - 2];
! 758:
! 759: xmlHTMLPrintFileInfo(input);
! 760:
! 761: xmlGenericError(xmlGenericErrorContext, "<b>validity warning</b>: ");
! 762: va_start(args, msg);
! 763: len = strlen(buffer);
! 764: vsnprintf(&buffer[len], sizeof(buffer) - len, msg, args);
! 765: va_end(args);
! 766: xmlHTMLEncodeSend();
! 767: xmlGenericError(xmlGenericErrorContext, "</p>\n");
! 768:
! 769: xmlHTMLPrintFileContext(input);
! 770: xmlHTMLEncodeSend();
! 771: }
! 772:
! 773: /************************************************************************
! 774: * *
! 775: * Shell Interface *
! 776: * *
! 777: ************************************************************************/
! 778: #ifdef LIBXML_DEBUG_ENABLED
! 779: #ifdef LIBXML_XPATH_ENABLED
! 780: /**
! 781: * xmlShellReadline:
! 782: * @prompt: the prompt value
! 783: *
! 784: * Read a string
! 785: *
! 786: * Returns a pointer to it or NULL on EOF the caller is expected to
! 787: * free the returned string.
! 788: */
! 789: static char *
! 790: xmlShellReadline(char *prompt) {
! 791: #ifdef HAVE_LIBREADLINE
! 792: char *line_read;
! 793:
! 794: /* Get a line from the user. */
! 795: line_read = readline (prompt);
! 796:
! 797: /* If the line has any text in it, save it on the history. */
! 798: if (line_read && *line_read)
! 799: add_history (line_read);
! 800:
! 801: return (line_read);
! 802: #else
! 803: char line_read[501];
! 804: char *ret;
! 805: int len;
! 806:
! 807: if (prompt != NULL)
! 808: fprintf(stdout, "%s", prompt);
! 809: if (!fgets(line_read, 500, stdin))
! 810: return(NULL);
! 811: line_read[500] = 0;
! 812: len = strlen(line_read);
! 813: ret = (char *) malloc(len + 1);
! 814: if (ret != NULL) {
! 815: memcpy (ret, line_read, len + 1);
! 816: }
! 817: return(ret);
! 818: #endif
! 819: }
! 820: #endif /* LIBXML_XPATH_ENABLED */
! 821: #endif /* LIBXML_DEBUG_ENABLED */
! 822:
! 823: /************************************************************************
! 824: * *
! 825: * I/O Interfaces *
! 826: * *
! 827: ************************************************************************/
! 828:
! 829: static int myRead(FILE *f, char * buf, int len) {
! 830: return(fread(buf, 1, len, f));
! 831: }
! 832: static void myClose(FILE *f) {
! 833: if (f != stdin) {
! 834: fclose(f);
! 835: }
! 836: }
! 837:
! 838: /************************************************************************
! 839: * *
! 840: * SAX based tests *
! 841: * *
! 842: ************************************************************************/
! 843:
! 844: /*
! 845: * empty SAX block
! 846: */
! 847: static xmlSAXHandler emptySAXHandlerStruct = {
! 848: NULL, /* internalSubset */
! 849: NULL, /* isStandalone */
! 850: NULL, /* hasInternalSubset */
! 851: NULL, /* hasExternalSubset */
! 852: NULL, /* resolveEntity */
! 853: NULL, /* getEntity */
! 854: NULL, /* entityDecl */
! 855: NULL, /* notationDecl */
! 856: NULL, /* attributeDecl */
! 857: NULL, /* elementDecl */
! 858: NULL, /* unparsedEntityDecl */
! 859: NULL, /* setDocumentLocator */
! 860: NULL, /* startDocument */
! 861: NULL, /* endDocument */
! 862: NULL, /* startElement */
! 863: NULL, /* endElement */
! 864: NULL, /* reference */
! 865: NULL, /* characters */
! 866: NULL, /* ignorableWhitespace */
! 867: NULL, /* processingInstruction */
! 868: NULL, /* comment */
! 869: NULL, /* xmlParserWarning */
! 870: NULL, /* xmlParserError */
! 871: NULL, /* xmlParserError */
! 872: NULL, /* getParameterEntity */
! 873: NULL, /* cdataBlock; */
! 874: NULL, /* externalSubset; */
! 875: XML_SAX2_MAGIC,
! 876: NULL,
! 877: NULL, /* startElementNs */
! 878: NULL, /* endElementNs */
! 879: NULL /* xmlStructuredErrorFunc */
! 880: };
! 881:
! 882: static xmlSAXHandlerPtr emptySAXHandler = &emptySAXHandlerStruct;
! 883: extern xmlSAXHandlerPtr debugSAXHandler;
! 884: static int callbacks;
! 885:
! 886: /**
! 887: * isStandaloneDebug:
! 888: * @ctxt: An XML parser context
! 889: *
! 890: * Is this document tagged standalone ?
! 891: *
! 892: * Returns 1 if true
! 893: */
! 894: static int
! 895: isStandaloneDebug(void *ctx ATTRIBUTE_UNUSED)
! 896: {
! 897: callbacks++;
! 898: if (noout)
! 899: return(0);
! 900: fprintf(stdout, "SAX.isStandalone()\n");
! 901: return(0);
! 902: }
! 903:
! 904: /**
! 905: * hasInternalSubsetDebug:
! 906: * @ctxt: An XML parser context
! 907: *
! 908: * Does this document has an internal subset
! 909: *
! 910: * Returns 1 if true
! 911: */
! 912: static int
! 913: hasInternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
! 914: {
! 915: callbacks++;
! 916: if (noout)
! 917: return(0);
! 918: fprintf(stdout, "SAX.hasInternalSubset()\n");
! 919: return(0);
! 920: }
! 921:
! 922: /**
! 923: * hasExternalSubsetDebug:
! 924: * @ctxt: An XML parser context
! 925: *
! 926: * Does this document has an external subset
! 927: *
! 928: * Returns 1 if true
! 929: */
! 930: static int
! 931: hasExternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
! 932: {
! 933: callbacks++;
! 934: if (noout)
! 935: return(0);
! 936: fprintf(stdout, "SAX.hasExternalSubset()\n");
! 937: return(0);
! 938: }
! 939:
! 940: /**
! 941: * internalSubsetDebug:
! 942: * @ctxt: An XML parser context
! 943: *
! 944: * Does this document has an internal subset
! 945: */
! 946: static void
! 947: internalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
! 948: const xmlChar *ExternalID, const xmlChar *SystemID)
! 949: {
! 950: callbacks++;
! 951: if (noout)
! 952: return;
! 953: fprintf(stdout, "SAX.internalSubset(%s,", name);
! 954: if (ExternalID == NULL)
! 955: fprintf(stdout, " ,");
! 956: else
! 957: fprintf(stdout, " %s,", ExternalID);
! 958: if (SystemID == NULL)
! 959: fprintf(stdout, " )\n");
! 960: else
! 961: fprintf(stdout, " %s)\n", SystemID);
! 962: }
! 963:
! 964: /**
! 965: * externalSubsetDebug:
! 966: * @ctxt: An XML parser context
! 967: *
! 968: * Does this document has an external subset
! 969: */
! 970: static void
! 971: externalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
! 972: const xmlChar *ExternalID, const xmlChar *SystemID)
! 973: {
! 974: callbacks++;
! 975: if (noout)
! 976: return;
! 977: fprintf(stdout, "SAX.externalSubset(%s,", name);
! 978: if (ExternalID == NULL)
! 979: fprintf(stdout, " ,");
! 980: else
! 981: fprintf(stdout, " %s,", ExternalID);
! 982: if (SystemID == NULL)
! 983: fprintf(stdout, " )\n");
! 984: else
! 985: fprintf(stdout, " %s)\n", SystemID);
! 986: }
! 987:
! 988: /**
! 989: * resolveEntityDebug:
! 990: * @ctxt: An XML parser context
! 991: * @publicId: The public ID of the entity
! 992: * @systemId: The system ID of the entity
! 993: *
! 994: * Special entity resolver, better left to the parser, it has
! 995: * more context than the application layer.
! 996: * The default behaviour is to NOT resolve the entities, in that case
! 997: * the ENTITY_REF nodes are built in the structure (and the parameter
! 998: * values).
! 999: *
! 1000: * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
! 1001: */
! 1002: static xmlParserInputPtr
! 1003: resolveEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *publicId, const xmlChar *systemId)
! 1004: {
! 1005: callbacks++;
! 1006: if (noout)
! 1007: return(NULL);
! 1008: /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
! 1009:
! 1010:
! 1011: fprintf(stdout, "SAX.resolveEntity(");
! 1012: if (publicId != NULL)
! 1013: fprintf(stdout, "%s", (char *)publicId);
! 1014: else
! 1015: fprintf(stdout, " ");
! 1016: if (systemId != NULL)
! 1017: fprintf(stdout, ", %s)\n", (char *)systemId);
! 1018: else
! 1019: fprintf(stdout, ", )\n");
! 1020: return(NULL);
! 1021: }
! 1022:
! 1023: /**
! 1024: * getEntityDebug:
! 1025: * @ctxt: An XML parser context
! 1026: * @name: The entity name
! 1027: *
! 1028: * Get an entity by name
! 1029: *
! 1030: * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
! 1031: */
! 1032: static xmlEntityPtr
! 1033: getEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
! 1034: {
! 1035: callbacks++;
! 1036: if (noout)
! 1037: return(NULL);
! 1038: fprintf(stdout, "SAX.getEntity(%s)\n", name);
! 1039: return(NULL);
! 1040: }
! 1041:
! 1042: /**
! 1043: * getParameterEntityDebug:
! 1044: * @ctxt: An XML parser context
! 1045: * @name: The entity name
! 1046: *
! 1047: * Get a parameter entity by name
! 1048: *
! 1049: * Returns the xmlParserInputPtr
! 1050: */
! 1051: static xmlEntityPtr
! 1052: getParameterEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
! 1053: {
! 1054: callbacks++;
! 1055: if (noout)
! 1056: return(NULL);
! 1057: fprintf(stdout, "SAX.getParameterEntity(%s)\n", name);
! 1058: return(NULL);
! 1059: }
! 1060:
! 1061:
! 1062: /**
! 1063: * entityDeclDebug:
! 1064: * @ctxt: An XML parser context
! 1065: * @name: the entity name
! 1066: * @type: the entity type
! 1067: * @publicId: The public ID of the entity
! 1068: * @systemId: The system ID of the entity
! 1069: * @content: the entity value (without processing).
! 1070: *
! 1071: * An entity definition has been parsed
! 1072: */
! 1073: static void
! 1074: entityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
! 1075: const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
! 1076: {
! 1077: const xmlChar *nullstr = BAD_CAST "(null)";
! 1078: /* not all libraries handle printing null pointers nicely */
! 1079: if (publicId == NULL)
! 1080: publicId = nullstr;
! 1081: if (systemId == NULL)
! 1082: systemId = nullstr;
! 1083: if (content == NULL)
! 1084: content = (xmlChar *)nullstr;
! 1085: callbacks++;
! 1086: if (noout)
! 1087: return;
! 1088: fprintf(stdout, "SAX.entityDecl(%s, %d, %s, %s, %s)\n",
! 1089: name, type, publicId, systemId, content);
! 1090: }
! 1091:
! 1092: /**
! 1093: * attributeDeclDebug:
! 1094: * @ctxt: An XML parser context
! 1095: * @name: the attribute name
! 1096: * @type: the attribute type
! 1097: *
! 1098: * An attribute definition has been parsed
! 1099: */
! 1100: static void
! 1101: attributeDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar * elem,
! 1102: const xmlChar * name, int type, int def,
! 1103: const xmlChar * defaultValue, xmlEnumerationPtr tree)
! 1104: {
! 1105: callbacks++;
! 1106: if (noout)
! 1107: return;
! 1108: if (defaultValue == NULL)
! 1109: fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, NULL, ...)\n",
! 1110: elem, name, type, def);
! 1111: else
! 1112: fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, %s, ...)\n",
! 1113: elem, name, type, def, defaultValue);
! 1114: xmlFreeEnumeration(tree);
! 1115: }
! 1116:
! 1117: /**
! 1118: * elementDeclDebug:
! 1119: * @ctxt: An XML parser context
! 1120: * @name: the element name
! 1121: * @type: the element type
! 1122: * @content: the element value (without processing).
! 1123: *
! 1124: * An element definition has been parsed
! 1125: */
! 1126: static void
! 1127: elementDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
! 1128: xmlElementContentPtr content ATTRIBUTE_UNUSED)
! 1129: {
! 1130: callbacks++;
! 1131: if (noout)
! 1132: return;
! 1133: fprintf(stdout, "SAX.elementDecl(%s, %d, ...)\n",
! 1134: name, type);
! 1135: }
! 1136:
! 1137: /**
! 1138: * notationDeclDebug:
! 1139: * @ctxt: An XML parser context
! 1140: * @name: The name of the notation
! 1141: * @publicId: The public ID of the entity
! 1142: * @systemId: The system ID of the entity
! 1143: *
! 1144: * What to do when a notation declaration has been parsed.
! 1145: */
! 1146: static void
! 1147: notationDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
! 1148: const xmlChar *publicId, const xmlChar *systemId)
! 1149: {
! 1150: callbacks++;
! 1151: if (noout)
! 1152: return;
! 1153: fprintf(stdout, "SAX.notationDecl(%s, %s, %s)\n",
! 1154: (char *) name, (char *) publicId, (char *) systemId);
! 1155: }
! 1156:
! 1157: /**
! 1158: * unparsedEntityDeclDebug:
! 1159: * @ctxt: An XML parser context
! 1160: * @name: The name of the entity
! 1161: * @publicId: The public ID of the entity
! 1162: * @systemId: The system ID of the entity
! 1163: * @notationName: the name of the notation
! 1164: *
! 1165: * What to do when an unparsed entity declaration is parsed
! 1166: */
! 1167: static void
! 1168: unparsedEntityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
! 1169: const xmlChar *publicId, const xmlChar *systemId,
! 1170: const xmlChar *notationName)
! 1171: {
! 1172: const xmlChar *nullstr = BAD_CAST "(null)";
! 1173:
! 1174: if (publicId == NULL)
! 1175: publicId = nullstr;
! 1176: if (systemId == NULL)
! 1177: systemId = nullstr;
! 1178: if (notationName == NULL)
! 1179: notationName = nullstr;
! 1180: callbacks++;
! 1181: if (noout)
! 1182: return;
! 1183: fprintf(stdout, "SAX.unparsedEntityDecl(%s, %s, %s, %s)\n",
! 1184: (char *) name, (char *) publicId, (char *) systemId,
! 1185: (char *) notationName);
! 1186: }
! 1187:
! 1188: /**
! 1189: * setDocumentLocatorDebug:
! 1190: * @ctxt: An XML parser context
! 1191: * @loc: A SAX Locator
! 1192: *
! 1193: * Receive the document locator at startup, actually xmlDefaultSAXLocator
! 1194: * Everything is available on the context, so this is useless in our case.
! 1195: */
! 1196: static void
! 1197: setDocumentLocatorDebug(void *ctx ATTRIBUTE_UNUSED, xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
! 1198: {
! 1199: callbacks++;
! 1200: if (noout)
! 1201: return;
! 1202: fprintf(stdout, "SAX.setDocumentLocator()\n");
! 1203: }
! 1204:
! 1205: /**
! 1206: * startDocumentDebug:
! 1207: * @ctxt: An XML parser context
! 1208: *
! 1209: * called when the document start being processed.
! 1210: */
! 1211: static void
! 1212: startDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
! 1213: {
! 1214: callbacks++;
! 1215: if (noout)
! 1216: return;
! 1217: fprintf(stdout, "SAX.startDocument()\n");
! 1218: }
! 1219:
! 1220: /**
! 1221: * endDocumentDebug:
! 1222: * @ctxt: An XML parser context
! 1223: *
! 1224: * called when the document end has been detected.
! 1225: */
! 1226: static void
! 1227: endDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
! 1228: {
! 1229: callbacks++;
! 1230: if (noout)
! 1231: return;
! 1232: fprintf(stdout, "SAX.endDocument()\n");
! 1233: }
! 1234:
! 1235: /**
! 1236: * startElementDebug:
! 1237: * @ctxt: An XML parser context
! 1238: * @name: The element name
! 1239: *
! 1240: * called when an opening tag has been processed.
! 1241: */
! 1242: static void
! 1243: startElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, const xmlChar **atts)
! 1244: {
! 1245: int i;
! 1246:
! 1247: callbacks++;
! 1248: if (noout)
! 1249: return;
! 1250: fprintf(stdout, "SAX.startElement(%s", (char *) name);
! 1251: if (atts != NULL) {
! 1252: for (i = 0;(atts[i] != NULL);i++) {
! 1253: fprintf(stdout, ", %s='", atts[i++]);
! 1254: if (atts[i] != NULL)
! 1255: fprintf(stdout, "%s'", atts[i]);
! 1256: }
! 1257: }
! 1258: fprintf(stdout, ")\n");
! 1259: }
! 1260:
! 1261: /**
! 1262: * endElementDebug:
! 1263: * @ctxt: An XML parser context
! 1264: * @name: The element name
! 1265: *
! 1266: * called when the end of an element has been detected.
! 1267: */
! 1268: static void
! 1269: endElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
! 1270: {
! 1271: callbacks++;
! 1272: if (noout)
! 1273: return;
! 1274: fprintf(stdout, "SAX.endElement(%s)\n", (char *) name);
! 1275: }
! 1276:
! 1277: /**
! 1278: * charactersDebug:
! 1279: * @ctxt: An XML parser context
! 1280: * @ch: a xmlChar string
! 1281: * @len: the number of xmlChar
! 1282: *
! 1283: * receiving some chars from the parser.
! 1284: * Question: how much at a time ???
! 1285: */
! 1286: static void
! 1287: charactersDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
! 1288: {
! 1289: char out[40];
! 1290: int i;
! 1291:
! 1292: callbacks++;
! 1293: if (noout)
! 1294: return;
! 1295: for (i = 0;(i<len) && (i < 30);i++)
! 1296: out[i] = ch[i];
! 1297: out[i] = 0;
! 1298:
! 1299: fprintf(stdout, "SAX.characters(%s, %d)\n", out, len);
! 1300: }
! 1301:
! 1302: /**
! 1303: * referenceDebug:
! 1304: * @ctxt: An XML parser context
! 1305: * @name: The entity name
! 1306: *
! 1307: * called when an entity reference is detected.
! 1308: */
! 1309: static void
! 1310: referenceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
! 1311: {
! 1312: callbacks++;
! 1313: if (noout)
! 1314: return;
! 1315: fprintf(stdout, "SAX.reference(%s)\n", name);
! 1316: }
! 1317:
! 1318: /**
! 1319: * ignorableWhitespaceDebug:
! 1320: * @ctxt: An XML parser context
! 1321: * @ch: a xmlChar string
! 1322: * @start: the first char in the string
! 1323: * @len: the number of xmlChar
! 1324: *
! 1325: * receiving some ignorable whitespaces from the parser.
! 1326: * Question: how much at a time ???
! 1327: */
! 1328: static void
! 1329: ignorableWhitespaceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
! 1330: {
! 1331: char out[40];
! 1332: int i;
! 1333:
! 1334: callbacks++;
! 1335: if (noout)
! 1336: return;
! 1337: for (i = 0;(i<len) && (i < 30);i++)
! 1338: out[i] = ch[i];
! 1339: out[i] = 0;
! 1340: fprintf(stdout, "SAX.ignorableWhitespace(%s, %d)\n", out, len);
! 1341: }
! 1342:
! 1343: /**
! 1344: * processingInstructionDebug:
! 1345: * @ctxt: An XML parser context
! 1346: * @target: the target name
! 1347: * @data: the PI data's
! 1348: * @len: the number of xmlChar
! 1349: *
! 1350: * A processing instruction has been parsed.
! 1351: */
! 1352: static void
! 1353: processingInstructionDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *target,
! 1354: const xmlChar *data)
! 1355: {
! 1356: callbacks++;
! 1357: if (noout)
! 1358: return;
! 1359: if (data != NULL)
! 1360: fprintf(stdout, "SAX.processingInstruction(%s, %s)\n",
! 1361: (char *) target, (char *) data);
! 1362: else
! 1363: fprintf(stdout, "SAX.processingInstruction(%s, NULL)\n",
! 1364: (char *) target);
! 1365: }
! 1366:
! 1367: /**
! 1368: * cdataBlockDebug:
! 1369: * @ctx: the user data (XML parser context)
! 1370: * @value: The pcdata content
! 1371: * @len: the block length
! 1372: *
! 1373: * called when a pcdata block has been parsed
! 1374: */
! 1375: static void
! 1376: cdataBlockDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value, int len)
! 1377: {
! 1378: callbacks++;
! 1379: if (noout)
! 1380: return;
! 1381: fprintf(stdout, "SAX.pcdata(%.20s, %d)\n",
! 1382: (char *) value, len);
! 1383: }
! 1384:
! 1385: /**
! 1386: * commentDebug:
! 1387: * @ctxt: An XML parser context
! 1388: * @value: the comment content
! 1389: *
! 1390: * A comment has been parsed.
! 1391: */
! 1392: static void
! 1393: commentDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value)
! 1394: {
! 1395: callbacks++;
! 1396: if (noout)
! 1397: return;
! 1398: fprintf(stdout, "SAX.comment(%s)\n", value);
! 1399: }
! 1400:
! 1401: /**
! 1402: * warningDebug:
! 1403: * @ctxt: An XML parser context
! 1404: * @msg: the message to display/transmit
! 1405: * @...: extra parameters for the message display
! 1406: *
! 1407: * Display and format a warning messages, gives file, line, position and
! 1408: * extra parameters.
! 1409: */
! 1410: static void XMLCDECL
! 1411: warningDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
! 1412: {
! 1413: va_list args;
! 1414:
! 1415: callbacks++;
! 1416: if (noout)
! 1417: return;
! 1418: va_start(args, msg);
! 1419: fprintf(stdout, "SAX.warning: ");
! 1420: vfprintf(stdout, msg, args);
! 1421: va_end(args);
! 1422: }
! 1423:
! 1424: /**
! 1425: * errorDebug:
! 1426: * @ctxt: An XML parser context
! 1427: * @msg: the message to display/transmit
! 1428: * @...: extra parameters for the message display
! 1429: *
! 1430: * Display and format a error messages, gives file, line, position and
! 1431: * extra parameters.
! 1432: */
! 1433: static void XMLCDECL
! 1434: errorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
! 1435: {
! 1436: va_list args;
! 1437:
! 1438: callbacks++;
! 1439: if (noout)
! 1440: return;
! 1441: va_start(args, msg);
! 1442: fprintf(stdout, "SAX.error: ");
! 1443: vfprintf(stdout, msg, args);
! 1444: va_end(args);
! 1445: }
! 1446:
! 1447: /**
! 1448: * fatalErrorDebug:
! 1449: * @ctxt: An XML parser context
! 1450: * @msg: the message to display/transmit
! 1451: * @...: extra parameters for the message display
! 1452: *
! 1453: * Display and format a fatalError messages, gives file, line, position and
! 1454: * extra parameters.
! 1455: */
! 1456: static void XMLCDECL
! 1457: fatalErrorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
! 1458: {
! 1459: va_list args;
! 1460:
! 1461: callbacks++;
! 1462: if (noout)
! 1463: return;
! 1464: va_start(args, msg);
! 1465: fprintf(stdout, "SAX.fatalError: ");
! 1466: vfprintf(stdout, msg, args);
! 1467: va_end(args);
! 1468: }
! 1469:
! 1470: static xmlSAXHandler debugSAXHandlerStruct = {
! 1471: internalSubsetDebug,
! 1472: isStandaloneDebug,
! 1473: hasInternalSubsetDebug,
! 1474: hasExternalSubsetDebug,
! 1475: resolveEntityDebug,
! 1476: getEntityDebug,
! 1477: entityDeclDebug,
! 1478: notationDeclDebug,
! 1479: attributeDeclDebug,
! 1480: elementDeclDebug,
! 1481: unparsedEntityDeclDebug,
! 1482: setDocumentLocatorDebug,
! 1483: startDocumentDebug,
! 1484: endDocumentDebug,
! 1485: startElementDebug,
! 1486: endElementDebug,
! 1487: referenceDebug,
! 1488: charactersDebug,
! 1489: ignorableWhitespaceDebug,
! 1490: processingInstructionDebug,
! 1491: commentDebug,
! 1492: warningDebug,
! 1493: errorDebug,
! 1494: fatalErrorDebug,
! 1495: getParameterEntityDebug,
! 1496: cdataBlockDebug,
! 1497: externalSubsetDebug,
! 1498: 1,
! 1499: NULL,
! 1500: NULL,
! 1501: NULL,
! 1502: NULL
! 1503: };
! 1504:
! 1505: xmlSAXHandlerPtr debugSAXHandler = &debugSAXHandlerStruct;
! 1506:
! 1507: /*
! 1508: * SAX2 specific callbacks
! 1509: */
! 1510: /**
! 1511: * startElementNsDebug:
! 1512: * @ctxt: An XML parser context
! 1513: * @name: The element name
! 1514: *
! 1515: * called when an opening tag has been processed.
! 1516: */
! 1517: static void
! 1518: startElementNsDebug(void *ctx ATTRIBUTE_UNUSED,
! 1519: const xmlChar *localname,
! 1520: const xmlChar *prefix,
! 1521: const xmlChar *URI,
! 1522: int nb_namespaces,
! 1523: const xmlChar **namespaces,
! 1524: int nb_attributes,
! 1525: int nb_defaulted,
! 1526: const xmlChar **attributes)
! 1527: {
! 1528: int i;
! 1529:
! 1530: callbacks++;
! 1531: if (noout)
! 1532: return;
! 1533: fprintf(stdout, "SAX.startElementNs(%s", (char *) localname);
! 1534: if (prefix == NULL)
! 1535: fprintf(stdout, ", NULL");
! 1536: else
! 1537: fprintf(stdout, ", %s", (char *) prefix);
! 1538: if (URI == NULL)
! 1539: fprintf(stdout, ", NULL");
! 1540: else
! 1541: fprintf(stdout, ", '%s'", (char *) URI);
! 1542: fprintf(stdout, ", %d", nb_namespaces);
! 1543:
! 1544: if (namespaces != NULL) {
! 1545: for (i = 0;i < nb_namespaces * 2;i++) {
! 1546: fprintf(stdout, ", xmlns");
! 1547: if (namespaces[i] != NULL)
! 1548: fprintf(stdout, ":%s", namespaces[i]);
! 1549: i++;
! 1550: fprintf(stdout, "='%s'", namespaces[i]);
! 1551: }
! 1552: }
! 1553: fprintf(stdout, ", %d, %d", nb_attributes, nb_defaulted);
! 1554: if (attributes != NULL) {
! 1555: for (i = 0;i < nb_attributes * 5;i += 5) {
! 1556: if (attributes[i + 1] != NULL)
! 1557: fprintf(stdout, ", %s:%s='", attributes[i + 1], attributes[i]);
! 1558: else
! 1559: fprintf(stdout, ", %s='", attributes[i]);
! 1560: fprintf(stdout, "%.4s...', %d", attributes[i + 3],
! 1561: (int)(attributes[i + 4] - attributes[i + 3]));
! 1562: }
! 1563: }
! 1564: fprintf(stdout, ")\n");
! 1565: }
! 1566:
! 1567: /**
! 1568: * endElementDebug:
! 1569: * @ctxt: An XML parser context
! 1570: * @name: The element name
! 1571: *
! 1572: * called when the end of an element has been detected.
! 1573: */
! 1574: static void
! 1575: endElementNsDebug(void *ctx ATTRIBUTE_UNUSED,
! 1576: const xmlChar *localname,
! 1577: const xmlChar *prefix,
! 1578: const xmlChar *URI)
! 1579: {
! 1580: callbacks++;
! 1581: if (noout)
! 1582: return;
! 1583: fprintf(stdout, "SAX.endElementNs(%s", (char *) localname);
! 1584: if (prefix == NULL)
! 1585: fprintf(stdout, ", NULL");
! 1586: else
! 1587: fprintf(stdout, ", %s", (char *) prefix);
! 1588: if (URI == NULL)
! 1589: fprintf(stdout, ", NULL)\n");
! 1590: else
! 1591: fprintf(stdout, ", '%s')\n", (char *) URI);
! 1592: }
! 1593:
! 1594: static xmlSAXHandler debugSAX2HandlerStruct = {
! 1595: internalSubsetDebug,
! 1596: isStandaloneDebug,
! 1597: hasInternalSubsetDebug,
! 1598: hasExternalSubsetDebug,
! 1599: resolveEntityDebug,
! 1600: getEntityDebug,
! 1601: entityDeclDebug,
! 1602: notationDeclDebug,
! 1603: attributeDeclDebug,
! 1604: elementDeclDebug,
! 1605: unparsedEntityDeclDebug,
! 1606: setDocumentLocatorDebug,
! 1607: startDocumentDebug,
! 1608: endDocumentDebug,
! 1609: NULL,
! 1610: NULL,
! 1611: referenceDebug,
! 1612: charactersDebug,
! 1613: ignorableWhitespaceDebug,
! 1614: processingInstructionDebug,
! 1615: commentDebug,
! 1616: warningDebug,
! 1617: errorDebug,
! 1618: fatalErrorDebug,
! 1619: getParameterEntityDebug,
! 1620: cdataBlockDebug,
! 1621: externalSubsetDebug,
! 1622: XML_SAX2_MAGIC,
! 1623: NULL,
! 1624: startElementNsDebug,
! 1625: endElementNsDebug,
! 1626: NULL
! 1627: };
! 1628:
! 1629: static xmlSAXHandlerPtr debugSAX2Handler = &debugSAX2HandlerStruct;
! 1630:
! 1631: static void
! 1632: testSAX(const char *filename) {
! 1633: xmlSAXHandlerPtr handler;
! 1634: const char *user_data = "user_data"; /* mostly for debugging */
! 1635: xmlParserInputBufferPtr buf = NULL;
! 1636: xmlParserInputPtr inputStream;
! 1637: xmlParserCtxtPtr ctxt = NULL;
! 1638: xmlSAXHandlerPtr old_sax = NULL;
! 1639:
! 1640: callbacks = 0;
! 1641:
! 1642: if (noout) {
! 1643: handler = emptySAXHandler;
! 1644: #ifdef LIBXML_SAX1_ENABLED
! 1645: } else if (sax1) {
! 1646: handler = debugSAXHandler;
! 1647: #endif
! 1648: } else {
! 1649: handler = debugSAX2Handler;
! 1650: }
! 1651:
! 1652: /*
! 1653: * it's not the simplest code but the most generic in term of I/O
! 1654: */
! 1655: buf = xmlParserInputBufferCreateFilename(filename, XML_CHAR_ENCODING_NONE);
! 1656: if (buf == NULL) {
! 1657: goto error;
! 1658: }
! 1659:
! 1660: #ifdef LIBXML_SCHEMAS_ENABLED
! 1661: if (wxschemas != NULL) {
! 1662: int ret;
! 1663: xmlSchemaValidCtxtPtr vctxt;
! 1664:
! 1665: vctxt = xmlSchemaNewValidCtxt(wxschemas);
! 1666: xmlSchemaSetValidErrors(vctxt,
! 1667: (xmlSchemaValidityErrorFunc) fprintf,
! 1668: (xmlSchemaValidityWarningFunc) fprintf,
! 1669: stderr);
! 1670:
! 1671: ret = xmlSchemaValidateStream(vctxt, buf, 0, handler,
! 1672: (void *)user_data);
! 1673: if (repeat == 0) {
! 1674: if (ret == 0) {
! 1675: fprintf(stderr, "%s validates\n", filename);
! 1676: } else if (ret > 0) {
! 1677: fprintf(stderr, "%s fails to validate\n", filename);
! 1678: progresult = XMLLINT_ERR_VALID;
! 1679: } else {
! 1680: fprintf(stderr, "%s validation generated an internal error\n",
! 1681: filename);
! 1682: progresult = XMLLINT_ERR_VALID;
! 1683: }
! 1684: }
! 1685: xmlSchemaFreeValidCtxt(vctxt);
! 1686: } else
! 1687: #endif
! 1688: {
! 1689: /*
! 1690: * Create the parser context amd hook the input
! 1691: */
! 1692: ctxt = xmlNewParserCtxt();
! 1693: if (ctxt == NULL) {
! 1694: xmlFreeParserInputBuffer(buf);
! 1695: goto error;
! 1696: }
! 1697: old_sax = ctxt->sax;
! 1698: ctxt->sax = handler;
! 1699: ctxt->userData = (void *) user_data;
! 1700: inputStream = xmlNewIOInputStream(ctxt, buf, XML_CHAR_ENCODING_NONE);
! 1701: if (inputStream == NULL) {
! 1702: xmlFreeParserInputBuffer(buf);
! 1703: goto error;
! 1704: }
! 1705: inputPush(ctxt, inputStream);
! 1706:
! 1707: /* do the parsing */
! 1708: xmlParseDocument(ctxt);
! 1709:
! 1710: if (ctxt->myDoc != NULL) {
! 1711: fprintf(stderr, "SAX generated a doc !\n");
! 1712: xmlFreeDoc(ctxt->myDoc);
! 1713: ctxt->myDoc = NULL;
! 1714: }
! 1715: }
! 1716:
! 1717: error:
! 1718: if (ctxt != NULL) {
! 1719: ctxt->sax = old_sax;
! 1720: xmlFreeParserCtxt(ctxt);
! 1721: }
! 1722: }
! 1723:
! 1724: /************************************************************************
! 1725: * *
! 1726: * Stream Test processing *
! 1727: * *
! 1728: ************************************************************************/
! 1729: #ifdef LIBXML_READER_ENABLED
! 1730: static void processNode(xmlTextReaderPtr reader) {
! 1731: const xmlChar *name, *value;
! 1732: int type, empty;
! 1733:
! 1734: type = xmlTextReaderNodeType(reader);
! 1735: empty = xmlTextReaderIsEmptyElement(reader);
! 1736:
! 1737: if (debug) {
! 1738: name = xmlTextReaderConstName(reader);
! 1739: if (name == NULL)
! 1740: name = BAD_CAST "--";
! 1741:
! 1742: value = xmlTextReaderConstValue(reader);
! 1743:
! 1744:
! 1745: printf("%d %d %s %d %d",
! 1746: xmlTextReaderDepth(reader),
! 1747: type,
! 1748: name,
! 1749: empty,
! 1750: xmlTextReaderHasValue(reader));
! 1751: if (value == NULL)
! 1752: printf("\n");
! 1753: else {
! 1754: printf(" %s\n", value);
! 1755: }
! 1756: }
! 1757: #ifdef LIBXML_PATTERN_ENABLED
! 1758: if (patternc) {
! 1759: xmlChar *path = NULL;
! 1760: int match = -1;
! 1761:
! 1762: if (type == XML_READER_TYPE_ELEMENT) {
! 1763: /* do the check only on element start */
! 1764: match = xmlPatternMatch(patternc, xmlTextReaderCurrentNode(reader));
! 1765:
! 1766: if (match) {
! 1767: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
! 1768: path = xmlGetNodePath(xmlTextReaderCurrentNode(reader));
! 1769: printf("Node %s matches pattern %s\n", path, pattern);
! 1770: #else
! 1771: printf("Node %s matches pattern %s\n",
! 1772: xmlTextReaderConstName(reader), pattern);
! 1773: #endif
! 1774: }
! 1775: }
! 1776: if (patstream != NULL) {
! 1777: int ret;
! 1778:
! 1779: if (type == XML_READER_TYPE_ELEMENT) {
! 1780: ret = xmlStreamPush(patstream,
! 1781: xmlTextReaderConstLocalName(reader),
! 1782: xmlTextReaderConstNamespaceUri(reader));
! 1783: if (ret < 0) {
! 1784: fprintf(stderr, "xmlStreamPush() failure\n");
! 1785: xmlFreeStreamCtxt(patstream);
! 1786: patstream = NULL;
! 1787: } else if (ret != match) {
! 1788: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
! 1789: if (path == NULL) {
! 1790: path = xmlGetNodePath(
! 1791: xmlTextReaderCurrentNode(reader));
! 1792: }
! 1793: #endif
! 1794: fprintf(stderr,
! 1795: "xmlPatternMatch and xmlStreamPush disagree\n");
! 1796: if (path != NULL)
! 1797: fprintf(stderr, " pattern %s node %s\n",
! 1798: pattern, path);
! 1799: else
! 1800: fprintf(stderr, " pattern %s node %s\n",
! 1801: pattern, xmlTextReaderConstName(reader));
! 1802: }
! 1803:
! 1804: }
! 1805: if ((type == XML_READER_TYPE_END_ELEMENT) ||
! 1806: ((type == XML_READER_TYPE_ELEMENT) && (empty))) {
! 1807: ret = xmlStreamPop(patstream);
! 1808: if (ret < 0) {
! 1809: fprintf(stderr, "xmlStreamPop() failure\n");
! 1810: xmlFreeStreamCtxt(patstream);
! 1811: patstream = NULL;
! 1812: }
! 1813: }
! 1814: }
! 1815: if (path != NULL)
! 1816: xmlFree(path);
! 1817: }
! 1818: #endif
! 1819: }
! 1820:
! 1821: static void streamFile(char *filename) {
! 1822: xmlTextReaderPtr reader;
! 1823: int ret;
! 1824: #ifdef HAVE_SYS_MMAN_H
! 1825: int fd = -1;
! 1826: struct stat info;
! 1827: const char *base = NULL;
! 1828: xmlParserInputBufferPtr input = NULL;
! 1829:
! 1830: if (memory) {
! 1831: if (stat(filename, &info) < 0)
! 1832: return;
! 1833: if ((fd = open(filename, O_RDONLY)) < 0)
! 1834: return;
! 1835: base = mmap(NULL, info.st_size, PROT_READ, MAP_SHARED, fd, 0) ;
! 1836: if (base == (void *) MAP_FAILED)
! 1837: return;
! 1838:
! 1839: reader = xmlReaderForMemory(base, info.st_size, filename,
! 1840: NULL, options);
! 1841: } else
! 1842: #endif
! 1843: reader = xmlReaderForFile(filename, NULL, options);
! 1844: #ifdef LIBXML_PATTERN_ENABLED
! 1845: if (pattern != NULL) {
! 1846: patternc = xmlPatterncompile((const xmlChar *) pattern, NULL, 0, NULL);
! 1847: if (patternc == NULL) {
! 1848: xmlGenericError(xmlGenericErrorContext,
! 1849: "Pattern %s failed to compile\n", pattern);
! 1850: progresult = XMLLINT_ERR_SCHEMAPAT;
! 1851: pattern = NULL;
! 1852: }
! 1853: }
! 1854: if (patternc != NULL) {
! 1855: patstream = xmlPatternGetStreamCtxt(patternc);
! 1856: if (patstream != NULL) {
! 1857: ret = xmlStreamPush(patstream, NULL, NULL);
! 1858: if (ret < 0) {
! 1859: fprintf(stderr, "xmlStreamPush() failure\n");
! 1860: xmlFreeStreamCtxt(patstream);
! 1861: patstream = NULL;
! 1862: }
! 1863: }
! 1864: }
! 1865: #endif
! 1866:
! 1867:
! 1868: if (reader != NULL) {
! 1869: #ifdef LIBXML_VALID_ENABLED
! 1870: if (valid)
! 1871: xmlTextReaderSetParserProp(reader, XML_PARSER_VALIDATE, 1);
! 1872: else
! 1873: #endif /* LIBXML_VALID_ENABLED */
! 1874: xmlTextReaderSetParserProp(reader, XML_PARSER_LOADDTD, 1);
! 1875: #ifdef LIBXML_SCHEMAS_ENABLED
! 1876: if (relaxng != NULL) {
! 1877: if ((timing) && (!repeat)) {
! 1878: startTimer();
! 1879: }
! 1880: ret = xmlTextReaderRelaxNGValidate(reader, relaxng);
! 1881: if (ret < 0) {
! 1882: xmlGenericError(xmlGenericErrorContext,
! 1883: "Relax-NG schema %s failed to compile\n", relaxng);
! 1884: progresult = XMLLINT_ERR_SCHEMACOMP;
! 1885: relaxng = NULL;
! 1886: }
! 1887: if ((timing) && (!repeat)) {
! 1888: endTimer("Compiling the schemas");
! 1889: }
! 1890: }
! 1891: if (schema != NULL) {
! 1892: if ((timing) && (!repeat)) {
! 1893: startTimer();
! 1894: }
! 1895: ret = xmlTextReaderSchemaValidate(reader, schema);
! 1896: if (ret < 0) {
! 1897: xmlGenericError(xmlGenericErrorContext,
! 1898: "XSD schema %s failed to compile\n", schema);
! 1899: progresult = XMLLINT_ERR_SCHEMACOMP;
! 1900: schema = NULL;
! 1901: }
! 1902: if ((timing) && (!repeat)) {
! 1903: endTimer("Compiling the schemas");
! 1904: }
! 1905: }
! 1906: #endif
! 1907:
! 1908: /*
! 1909: * Process all nodes in sequence
! 1910: */
! 1911: if ((timing) && (!repeat)) {
! 1912: startTimer();
! 1913: }
! 1914: ret = xmlTextReaderRead(reader);
! 1915: while (ret == 1) {
! 1916: if ((debug)
! 1917: #ifdef LIBXML_PATTERN_ENABLED
! 1918: || (patternc)
! 1919: #endif
! 1920: )
! 1921: processNode(reader);
! 1922: ret = xmlTextReaderRead(reader);
! 1923: }
! 1924: if ((timing) && (!repeat)) {
! 1925: #ifdef LIBXML_SCHEMAS_ENABLED
! 1926: if (relaxng != NULL)
! 1927: endTimer("Parsing and validating");
! 1928: else
! 1929: #endif
! 1930: #ifdef LIBXML_VALID_ENABLED
! 1931: if (valid)
! 1932: endTimer("Parsing and validating");
! 1933: else
! 1934: #endif
! 1935: endTimer("Parsing");
! 1936: }
! 1937:
! 1938: #ifdef LIBXML_VALID_ENABLED
! 1939: if (valid) {
! 1940: if (xmlTextReaderIsValid(reader) != 1) {
! 1941: xmlGenericError(xmlGenericErrorContext,
! 1942: "Document %s does not validate\n", filename);
! 1943: progresult = XMLLINT_ERR_VALID;
! 1944: }
! 1945: }
! 1946: #endif /* LIBXML_VALID_ENABLED */
! 1947: #ifdef LIBXML_SCHEMAS_ENABLED
! 1948: if ((relaxng != NULL) || (schema != NULL)) {
! 1949: if (xmlTextReaderIsValid(reader) != 1) {
! 1950: fprintf(stderr, "%s fails to validate\n", filename);
! 1951: progresult = XMLLINT_ERR_VALID;
! 1952: } else {
! 1953: fprintf(stderr, "%s validates\n", filename);
! 1954: }
! 1955: }
! 1956: #endif
! 1957: /*
! 1958: * Done, cleanup and status
! 1959: */
! 1960: xmlFreeTextReader(reader);
! 1961: if (ret != 0) {
! 1962: fprintf(stderr, "%s : failed to parse\n", filename);
! 1963: progresult = XMLLINT_ERR_UNCLASS;
! 1964: }
! 1965: } else {
! 1966: fprintf(stderr, "Unable to open %s\n", filename);
! 1967: progresult = XMLLINT_ERR_UNCLASS;
! 1968: }
! 1969: #ifdef LIBXML_PATTERN_ENABLED
! 1970: if (patstream != NULL) {
! 1971: xmlFreeStreamCtxt(patstream);
! 1972: patstream = NULL;
! 1973: }
! 1974: #endif
! 1975: #ifdef HAVE_SYS_MMAN_H
! 1976: if (memory) {
! 1977: xmlFreeParserInputBuffer(input);
! 1978: munmap((char *) base, info.st_size);
! 1979: close(fd);
! 1980: }
! 1981: #endif
! 1982: }
! 1983:
! 1984: static void walkDoc(xmlDocPtr doc) {
! 1985: xmlTextReaderPtr reader;
! 1986: int ret;
! 1987:
! 1988: #ifdef LIBXML_PATTERN_ENABLED
! 1989: xmlNodePtr root;
! 1990: const xmlChar *namespaces[22];
! 1991: int i;
! 1992: xmlNsPtr ns;
! 1993:
! 1994: root = xmlDocGetRootElement(doc);
! 1995: for (ns = root->nsDef, i = 0;ns != NULL && i < 20;ns=ns->next) {
! 1996: namespaces[i++] = ns->href;
! 1997: namespaces[i++] = ns->prefix;
! 1998: }
! 1999: namespaces[i++] = NULL;
! 2000: namespaces[i] = NULL;
! 2001:
! 2002: if (pattern != NULL) {
! 2003: patternc = xmlPatterncompile((const xmlChar *) pattern, doc->dict,
! 2004: 0, &namespaces[0]);
! 2005: if (patternc == NULL) {
! 2006: xmlGenericError(xmlGenericErrorContext,
! 2007: "Pattern %s failed to compile\n", pattern);
! 2008: progresult = XMLLINT_ERR_SCHEMAPAT;
! 2009: pattern = NULL;
! 2010: }
! 2011: }
! 2012: if (patternc != NULL) {
! 2013: patstream = xmlPatternGetStreamCtxt(patternc);
! 2014: if (patstream != NULL) {
! 2015: ret = xmlStreamPush(patstream, NULL, NULL);
! 2016: if (ret < 0) {
! 2017: fprintf(stderr, "xmlStreamPush() failure\n");
! 2018: xmlFreeStreamCtxt(patstream);
! 2019: patstream = NULL;
! 2020: }
! 2021: }
! 2022: }
! 2023: #endif /* LIBXML_PATTERN_ENABLED */
! 2024: reader = xmlReaderWalker(doc);
! 2025: if (reader != NULL) {
! 2026: if ((timing) && (!repeat)) {
! 2027: startTimer();
! 2028: }
! 2029: ret = xmlTextReaderRead(reader);
! 2030: while (ret == 1) {
! 2031: if ((debug)
! 2032: #ifdef LIBXML_PATTERN_ENABLED
! 2033: || (patternc)
! 2034: #endif
! 2035: )
! 2036: processNode(reader);
! 2037: ret = xmlTextReaderRead(reader);
! 2038: }
! 2039: if ((timing) && (!repeat)) {
! 2040: endTimer("walking through the doc");
! 2041: }
! 2042: xmlFreeTextReader(reader);
! 2043: if (ret != 0) {
! 2044: fprintf(stderr, "failed to walk through the doc\n");
! 2045: progresult = XMLLINT_ERR_UNCLASS;
! 2046: }
! 2047: } else {
! 2048: fprintf(stderr, "Failed to crate a reader from the document\n");
! 2049: progresult = XMLLINT_ERR_UNCLASS;
! 2050: }
! 2051: #ifdef LIBXML_PATTERN_ENABLED
! 2052: if (patstream != NULL) {
! 2053: xmlFreeStreamCtxt(patstream);
! 2054: patstream = NULL;
! 2055: }
! 2056: #endif
! 2057: }
! 2058: #endif /* LIBXML_READER_ENABLED */
! 2059:
! 2060: #ifdef LIBXML_XPATH_ENABLED
! 2061: /************************************************************************
! 2062: * *
! 2063: * XPath Query *
! 2064: * *
! 2065: ************************************************************************/
! 2066:
! 2067: static void doXPathDump(xmlXPathObjectPtr cur) {
! 2068: switch(cur->type) {
! 2069: case XPATH_NODESET: {
! 2070: int i;
! 2071: xmlNodePtr node;
! 2072: #ifdef LIBXML_OUTPUT_ENABLED
! 2073: xmlSaveCtxtPtr ctxt;
! 2074:
! 2075: if (cur->nodesetval->nodeNr <= 0) {
! 2076: fprintf(stderr, "XPath set is empty\n");
! 2077: progresult = XMLLINT_ERR_XPATH;
! 2078: break;
! 2079: }
! 2080: ctxt = xmlSaveToFd(1, NULL, 0);
! 2081: if (ctxt == NULL) {
! 2082: fprintf(stderr, "Out of memory for XPath\n");
! 2083: progresult = XMLLINT_ERR_MEM;
! 2084: return;
! 2085: }
! 2086: for (i = 0;i < cur->nodesetval->nodeNr;i++) {
! 2087: node = cur->nodesetval->nodeTab[i];
! 2088: xmlSaveTree(ctxt, node);
! 2089: }
! 2090: xmlSaveClose(ctxt);
! 2091: #else
! 2092: printf("xpath returned %d nodes\n", cur->nodesetval->nodeNr);
! 2093: #endif
! 2094: break;
! 2095: }
! 2096: case XPATH_BOOLEAN:
! 2097: if (cur->boolval) printf("true");
! 2098: else printf("false");
! 2099: break;
! 2100: case XPATH_NUMBER:
! 2101: switch (xmlXPathIsInf(cur->floatval)) {
! 2102: case 1:
! 2103: printf("Infinity");
! 2104: break;
! 2105: case -1:
! 2106: printf("-Infinity");
! 2107: break;
! 2108: default:
! 2109: if (xmlXPathIsNaN(cur->floatval)) {
! 2110: printf("NaN");
! 2111: } else {
! 2112: printf("%0g", cur->floatval);
! 2113: }
! 2114: }
! 2115: break;
! 2116: case XPATH_STRING:
! 2117: printf("%s", (const char *) cur->stringval);
! 2118: break;
! 2119: case XPATH_UNDEFINED:
! 2120: fprintf(stderr, "XPath Object is uninitialized\n");
! 2121: progresult = XMLLINT_ERR_XPATH;
! 2122: break;
! 2123: default:
! 2124: fprintf(stderr, "XPath object of unexpected type\n");
! 2125: progresult = XMLLINT_ERR_XPATH;
! 2126: break;
! 2127: }
! 2128: }
! 2129:
! 2130: static void doXPathQuery(xmlDocPtr doc, const char *query) {
! 2131: xmlXPathContextPtr ctxt;
! 2132: xmlXPathObjectPtr res;
! 2133:
! 2134: ctxt = xmlXPathNewContext(doc);
! 2135: if (ctxt == NULL) {
! 2136: fprintf(stderr, "Out of memory for XPath\n");
! 2137: progresult = XMLLINT_ERR_MEM;
! 2138: return;
! 2139: }
! 2140: ctxt->node = xmlDocGetRootElement(doc);
! 2141: res = xmlXPathEval(BAD_CAST query, ctxt);
! 2142: xmlXPathFreeContext(ctxt);
! 2143:
! 2144: if (res == NULL) {
! 2145: fprintf(stderr, "XPath evaluation failure\n");
! 2146: progresult = XMLLINT_ERR_XPATH;
! 2147: return;
! 2148: }
! 2149: doXPathDump(res);
! 2150: xmlXPathFreeObject(res);
! 2151: }
! 2152: #endif /* LIBXML_XPATH_ENABLED */
! 2153:
! 2154: /************************************************************************
! 2155: * *
! 2156: * Tree Test processing *
! 2157: * *
! 2158: ************************************************************************/
! 2159: static void parseAndPrintFile(char *filename, xmlParserCtxtPtr rectxt) {
! 2160: xmlDocPtr doc = NULL;
! 2161: #ifdef LIBXML_TREE_ENABLED
! 2162: xmlDocPtr tmp;
! 2163: #endif /* LIBXML_TREE_ENABLED */
! 2164:
! 2165: if ((timing) && (!repeat))
! 2166: startTimer();
! 2167:
! 2168:
! 2169: #ifdef LIBXML_TREE_ENABLED
! 2170: if (filename == NULL) {
! 2171: if (generate) {
! 2172: xmlNodePtr n;
! 2173:
! 2174: doc = xmlNewDoc(BAD_CAST "1.0");
! 2175: n = xmlNewDocNode(doc, NULL, BAD_CAST "info", NULL);
! 2176: xmlNodeSetContent(n, BAD_CAST "abc");
! 2177: xmlDocSetRootElement(doc, n);
! 2178: }
! 2179: }
! 2180: #endif /* LIBXML_TREE_ENABLED */
! 2181: #ifdef LIBXML_HTML_ENABLED
! 2182: #ifdef LIBXML_PUSH_ENABLED
! 2183: else if ((html) && (push)) {
! 2184: FILE *f;
! 2185:
! 2186: #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
! 2187: f = fopen(filename, "rb");
! 2188: #else
! 2189: f = fopen(filename, "r");
! 2190: #endif
! 2191: if (f != NULL) {
! 2192: int res, size = 3;
! 2193: char chars[4096];
! 2194: htmlParserCtxtPtr ctxt;
! 2195:
! 2196: /* if (repeat) */
! 2197: size = 4096;
! 2198: res = fread(chars, 1, 4, f);
! 2199: if (res > 0) {
! 2200: ctxt = htmlCreatePushParserCtxt(NULL, NULL,
! 2201: chars, res, filename, XML_CHAR_ENCODING_NONE);
! 2202: while ((res = fread(chars, 1, size, f)) > 0) {
! 2203: htmlParseChunk(ctxt, chars, res, 0);
! 2204: }
! 2205: htmlParseChunk(ctxt, chars, 0, 1);
! 2206: doc = ctxt->myDoc;
! 2207: htmlFreeParserCtxt(ctxt);
! 2208: }
! 2209: fclose(f);
! 2210: }
! 2211: }
! 2212: #endif /* LIBXML_PUSH_ENABLED */
! 2213: #ifdef HAVE_SYS_MMAN_H
! 2214: else if ((html) && (memory)) {
! 2215: int fd;
! 2216: struct stat info;
! 2217: const char *base;
! 2218: if (stat(filename, &info) < 0)
! 2219: return;
! 2220: if ((fd = open(filename, O_RDONLY)) < 0)
! 2221: return;
! 2222: base = mmap(NULL, info.st_size, PROT_READ, MAP_SHARED, fd, 0) ;
! 2223: if (base == (void *) MAP_FAILED)
! 2224: return;
! 2225:
! 2226: doc = htmlReadMemory((char *) base, info.st_size, filename,
! 2227: NULL, options);
! 2228:
! 2229: munmap((char *) base, info.st_size);
! 2230: close(fd);
! 2231: }
! 2232: #endif
! 2233: else if (html) {
! 2234: doc = htmlReadFile(filename, NULL, options);
! 2235: }
! 2236: #endif /* LIBXML_HTML_ENABLED */
! 2237: else {
! 2238: #ifdef LIBXML_PUSH_ENABLED
! 2239: /*
! 2240: * build an XML tree from a string;
! 2241: */
! 2242: if (push) {
! 2243: FILE *f;
! 2244:
! 2245: /* '-' Usually means stdin -<sven@zen.org> */
! 2246: if ((filename[0] == '-') && (filename[1] == 0)) {
! 2247: f = stdin;
! 2248: } else {
! 2249: #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
! 2250: f = fopen(filename, "rb");
! 2251: #else
! 2252: f = fopen(filename, "r");
! 2253: #endif
! 2254: }
! 2255: if (f != NULL) {
! 2256: int ret;
! 2257: int res, size = 1024;
! 2258: char chars[1024];
! 2259: xmlParserCtxtPtr ctxt;
! 2260:
! 2261: /* if (repeat) size = 1024; */
! 2262: res = fread(chars, 1, 4, f);
! 2263: if (res > 0) {
! 2264: ctxt = xmlCreatePushParserCtxt(NULL, NULL,
! 2265: chars, res, filename);
! 2266: xmlCtxtUseOptions(ctxt, options);
! 2267: while ((res = fread(chars, 1, size, f)) > 0) {
! 2268: xmlParseChunk(ctxt, chars, res, 0);
! 2269: }
! 2270: xmlParseChunk(ctxt, chars, 0, 1);
! 2271: doc = ctxt->myDoc;
! 2272: ret = ctxt->wellFormed;
! 2273: xmlFreeParserCtxt(ctxt);
! 2274: if (!ret) {
! 2275: xmlFreeDoc(doc);
! 2276: doc = NULL;
! 2277: }
! 2278: }
! 2279: if (f != stdin)
! 2280: fclose(f);
! 2281: }
! 2282: } else
! 2283: #endif /* LIBXML_PUSH_ENABLED */
! 2284: if (testIO) {
! 2285: if ((filename[0] == '-') && (filename[1] == 0)) {
! 2286: doc = xmlReadFd(0, NULL, NULL, options);
! 2287: } else {
! 2288: FILE *f;
! 2289:
! 2290: #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
! 2291: f = fopen(filename, "rb");
! 2292: #else
! 2293: f = fopen(filename, "r");
! 2294: #endif
! 2295: if (f != NULL) {
! 2296: if (rectxt == NULL)
! 2297: doc = xmlReadIO((xmlInputReadCallback) myRead,
! 2298: (xmlInputCloseCallback) myClose, f,
! 2299: filename, NULL, options);
! 2300: else
! 2301: doc = xmlCtxtReadIO(rectxt,
! 2302: (xmlInputReadCallback) myRead,
! 2303: (xmlInputCloseCallback) myClose, f,
! 2304: filename, NULL, options);
! 2305: } else
! 2306: doc = NULL;
! 2307: }
! 2308: } else if (htmlout) {
! 2309: xmlParserCtxtPtr ctxt;
! 2310:
! 2311: if (rectxt == NULL)
! 2312: ctxt = xmlNewParserCtxt();
! 2313: else
! 2314: ctxt = rectxt;
! 2315: if (ctxt == NULL) {
! 2316: doc = NULL;
! 2317: } else {
! 2318: ctxt->sax->error = xmlHTMLError;
! 2319: ctxt->sax->warning = xmlHTMLWarning;
! 2320: ctxt->vctxt.error = xmlHTMLValidityError;
! 2321: ctxt->vctxt.warning = xmlHTMLValidityWarning;
! 2322:
! 2323: doc = xmlCtxtReadFile(ctxt, filename, NULL, options);
! 2324:
! 2325: if (rectxt == NULL)
! 2326: xmlFreeParserCtxt(ctxt);
! 2327: }
! 2328: #ifdef HAVE_SYS_MMAN_H
! 2329: } else if (memory) {
! 2330: int fd;
! 2331: struct stat info;
! 2332: const char *base;
! 2333: if (stat(filename, &info) < 0)
! 2334: return;
! 2335: if ((fd = open(filename, O_RDONLY)) < 0)
! 2336: return;
! 2337: base = mmap(NULL, info.st_size, PROT_READ, MAP_SHARED, fd, 0) ;
! 2338: if (base == (void *) MAP_FAILED)
! 2339: return;
! 2340:
! 2341: if (rectxt == NULL)
! 2342: doc = xmlReadMemory((char *) base, info.st_size,
! 2343: filename, NULL, options);
! 2344: else
! 2345: doc = xmlCtxtReadMemory(rectxt, (char *) base, info.st_size,
! 2346: filename, NULL, options);
! 2347:
! 2348: munmap((char *) base, info.st_size);
! 2349: close(fd);
! 2350: #endif
! 2351: #ifdef LIBXML_VALID_ENABLED
! 2352: } else if (valid) {
! 2353: xmlParserCtxtPtr ctxt = NULL;
! 2354:
! 2355: if (rectxt == NULL)
! 2356: ctxt = xmlNewParserCtxt();
! 2357: else
! 2358: ctxt = rectxt;
! 2359: if (ctxt == NULL) {
! 2360: doc = NULL;
! 2361: } else {
! 2362: doc = xmlCtxtReadFile(ctxt, filename, NULL, options);
! 2363:
! 2364: if (ctxt->valid == 0)
! 2365: progresult = XMLLINT_ERR_RDFILE;
! 2366: if (rectxt == NULL)
! 2367: xmlFreeParserCtxt(ctxt);
! 2368: }
! 2369: #endif /* LIBXML_VALID_ENABLED */
! 2370: } else {
! 2371: if (rectxt != NULL)
! 2372: doc = xmlCtxtReadFile(rectxt, filename, NULL, options);
! 2373: else {
! 2374: #ifdef LIBXML_SAX1_ENABLED
! 2375: if (sax1)
! 2376: doc = xmlParseFile(filename);
! 2377: else
! 2378: #endif /* LIBXML_SAX1_ENABLED */
! 2379: doc = xmlReadFile(filename, NULL, options);
! 2380: }
! 2381: }
! 2382: }
! 2383:
! 2384: /*
! 2385: * If we don't have a document we might as well give up. Do we
! 2386: * want an error message here? <sven@zen.org> */
! 2387: if (doc == NULL) {
! 2388: progresult = XMLLINT_ERR_UNCLASS;
! 2389: return;
! 2390: }
! 2391:
! 2392: if ((timing) && (!repeat)) {
! 2393: endTimer("Parsing");
! 2394: }
! 2395:
! 2396: /*
! 2397: * Remove DOCTYPE nodes
! 2398: */
! 2399: if (dropdtd) {
! 2400: xmlDtdPtr dtd;
! 2401:
! 2402: dtd = xmlGetIntSubset(doc);
! 2403: if (dtd != NULL) {
! 2404: xmlUnlinkNode((xmlNodePtr)dtd);
! 2405: xmlFreeDtd(dtd);
! 2406: }
! 2407: }
! 2408:
! 2409: #ifdef LIBXML_XINCLUDE_ENABLED
! 2410: if (xinclude) {
! 2411: if ((timing) && (!repeat)) {
! 2412: startTimer();
! 2413: }
! 2414: if (xmlXIncludeProcessFlags(doc, options) < 0)
! 2415: progresult = XMLLINT_ERR_UNCLASS;
! 2416: if ((timing) && (!repeat)) {
! 2417: endTimer("Xinclude processing");
! 2418: }
! 2419: }
! 2420: #endif
! 2421:
! 2422: #ifdef LIBXML_XPATH_ENABLED
! 2423: if (xpathquery != NULL) {
! 2424: doXPathQuery(doc, xpathquery);
! 2425: }
! 2426: #endif
! 2427:
! 2428: #ifdef LIBXML_DEBUG_ENABLED
! 2429: #ifdef LIBXML_XPATH_ENABLED
! 2430: /*
! 2431: * shell interaction
! 2432: */
! 2433: if (shell) {
! 2434: xmlXPathOrderDocElems(doc);
! 2435: xmlShell(doc, filename, xmlShellReadline, stdout);
! 2436: }
! 2437: #endif
! 2438: #endif
! 2439:
! 2440: #ifdef LIBXML_TREE_ENABLED
! 2441: /*
! 2442: * test intermediate copy if needed.
! 2443: */
! 2444: if (copy) {
! 2445: tmp = doc;
! 2446: if (timing) {
! 2447: startTimer();
! 2448: }
! 2449: doc = xmlCopyDoc(doc, 1);
! 2450: if (timing) {
! 2451: endTimer("Copying");
! 2452: }
! 2453: if (timing) {
! 2454: startTimer();
! 2455: }
! 2456: xmlFreeDoc(tmp);
! 2457: if (timing) {
! 2458: endTimer("Freeing original");
! 2459: }
! 2460: }
! 2461: #endif /* LIBXML_TREE_ENABLED */
! 2462:
! 2463: #ifdef LIBXML_VALID_ENABLED
! 2464: if ((insert) && (!html)) {
! 2465: const xmlChar* list[256];
! 2466: int nb, i;
! 2467: xmlNodePtr node;
! 2468:
! 2469: if (doc->children != NULL) {
! 2470: node = doc->children;
! 2471: while ((node != NULL) && (node->last == NULL)) node = node->next;
! 2472: if (node != NULL) {
! 2473: nb = xmlValidGetValidElements(node->last, NULL, list, 256);
! 2474: if (nb < 0) {
! 2475: fprintf(stderr, "could not get valid list of elements\n");
! 2476: } else if (nb == 0) {
! 2477: fprintf(stderr, "No element can be inserted under root\n");
! 2478: } else {
! 2479: fprintf(stderr, "%d element types can be inserted under root:\n",
! 2480: nb);
! 2481: for (i = 0;i < nb;i++) {
! 2482: fprintf(stderr, "%s\n", (char *) list[i]);
! 2483: }
! 2484: }
! 2485: }
! 2486: }
! 2487: }else
! 2488: #endif /* LIBXML_VALID_ENABLED */
! 2489: #ifdef LIBXML_READER_ENABLED
! 2490: if (walker) {
! 2491: walkDoc(doc);
! 2492: }
! 2493: #endif /* LIBXML_READER_ENABLED */
! 2494: #ifdef LIBXML_OUTPUT_ENABLED
! 2495: if (noout == 0) {
! 2496: int ret;
! 2497:
! 2498: /*
! 2499: * print it.
! 2500: */
! 2501: #ifdef LIBXML_DEBUG_ENABLED
! 2502: if (!debug) {
! 2503: #endif
! 2504: if ((timing) && (!repeat)) {
! 2505: startTimer();
! 2506: }
! 2507: #ifdef LIBXML_HTML_ENABLED
! 2508: if ((html) && (!xmlout)) {
! 2509: if (compress) {
! 2510: htmlSaveFile(output ? output : "-", doc);
! 2511: }
! 2512: else if (encoding != NULL) {
! 2513: if (format == 1) {
! 2514: htmlSaveFileFormat(output ? output : "-", doc, encoding, 1);
! 2515: }
! 2516: else {
! 2517: htmlSaveFileFormat(output ? output : "-", doc, encoding, 0);
! 2518: }
! 2519: }
! 2520: else if (format == 1) {
! 2521: htmlSaveFileFormat(output ? output : "-", doc, NULL, 1);
! 2522: }
! 2523: else {
! 2524: FILE *out;
! 2525: if (output == NULL)
! 2526: out = stdout;
! 2527: else {
! 2528: out = fopen(output,"wb");
! 2529: }
! 2530: if (out != NULL) {
! 2531: if (htmlDocDump(out, doc) < 0)
! 2532: progresult = XMLLINT_ERR_OUT;
! 2533:
! 2534: if (output != NULL)
! 2535: fclose(out);
! 2536: } else {
! 2537: fprintf(stderr, "failed to open %s\n", output);
! 2538: progresult = XMLLINT_ERR_OUT;
! 2539: }
! 2540: }
! 2541: if ((timing) && (!repeat)) {
! 2542: endTimer("Saving");
! 2543: }
! 2544: } else
! 2545: #endif
! 2546: #ifdef LIBXML_C14N_ENABLED
! 2547: if (canonical) {
! 2548: xmlChar *result = NULL;
! 2549: int size;
! 2550:
! 2551: size = xmlC14NDocDumpMemory(doc, NULL, XML_C14N_1_0, NULL, 1, &result);
! 2552: if (size >= 0) {
! 2553: write(1, result, size);
! 2554: xmlFree(result);
! 2555: } else {
! 2556: fprintf(stderr, "Failed to canonicalize\n");
! 2557: progresult = XMLLINT_ERR_OUT;
! 2558: }
! 2559: } else if (canonical) {
! 2560: xmlChar *result = NULL;
! 2561: int size;
! 2562:
! 2563: size = xmlC14NDocDumpMemory(doc, NULL, XML_C14N_1_1, NULL, 1, &result);
! 2564: if (size >= 0) {
! 2565: write(1, result, size);
! 2566: xmlFree(result);
! 2567: } else {
! 2568: fprintf(stderr, "Failed to canonicalize\n");
! 2569: progresult = XMLLINT_ERR_OUT;
! 2570: }
! 2571: } else
! 2572: if (exc_canonical) {
! 2573: xmlChar *result = NULL;
! 2574: int size;
! 2575:
! 2576: size = xmlC14NDocDumpMemory(doc, NULL, XML_C14N_EXCLUSIVE_1_0, NULL, 1, &result);
! 2577: if (size >= 0) {
! 2578: write(1, result, size);
! 2579: xmlFree(result);
! 2580: } else {
! 2581: fprintf(stderr, "Failed to canonicalize\n");
! 2582: progresult = XMLLINT_ERR_OUT;
! 2583: }
! 2584: } else
! 2585: #endif
! 2586: #ifdef HAVE_SYS_MMAN_H
! 2587: if (memory) {
! 2588: xmlChar *result;
! 2589: int len;
! 2590:
! 2591: if (encoding != NULL) {
! 2592: if (format == 1) {
! 2593: xmlDocDumpFormatMemoryEnc(doc, &result, &len, encoding, 1);
! 2594: } else {
! 2595: xmlDocDumpMemoryEnc(doc, &result, &len, encoding);
! 2596: }
! 2597: } else {
! 2598: if (format == 1)
! 2599: xmlDocDumpFormatMemory(doc, &result, &len, 1);
! 2600: else
! 2601: xmlDocDumpMemory(doc, &result, &len);
! 2602: }
! 2603: if (result == NULL) {
! 2604: fprintf(stderr, "Failed to save\n");
! 2605: progresult = XMLLINT_ERR_OUT;
! 2606: } else {
! 2607: write(1, result, len);
! 2608: xmlFree(result);
! 2609: }
! 2610:
! 2611: } else
! 2612: #endif /* HAVE_SYS_MMAN_H */
! 2613: if (compress) {
! 2614: xmlSaveFile(output ? output : "-", doc);
! 2615: } else if (oldout) {
! 2616: if (encoding != NULL) {
! 2617: if (format == 1) {
! 2618: ret = xmlSaveFormatFileEnc(output ? output : "-", doc,
! 2619: encoding, 1);
! 2620: }
! 2621: else {
! 2622: ret = xmlSaveFileEnc(output ? output : "-", doc,
! 2623: encoding);
! 2624: }
! 2625: if (ret < 0) {
! 2626: fprintf(stderr, "failed save to %s\n",
! 2627: output ? output : "-");
! 2628: progresult = XMLLINT_ERR_OUT;
! 2629: }
! 2630: } else if (format == 1) {
! 2631: ret = xmlSaveFormatFile(output ? output : "-", doc, 1);
! 2632: if (ret < 0) {
! 2633: fprintf(stderr, "failed save to %s\n",
! 2634: output ? output : "-");
! 2635: progresult = XMLLINT_ERR_OUT;
! 2636: }
! 2637: } else {
! 2638: FILE *out;
! 2639: if (output == NULL)
! 2640: out = stdout;
! 2641: else {
! 2642: out = fopen(output,"wb");
! 2643: }
! 2644: if (out != NULL) {
! 2645: if (xmlDocDump(out, doc) < 0)
! 2646: progresult = XMLLINT_ERR_OUT;
! 2647:
! 2648: if (output != NULL)
! 2649: fclose(out);
! 2650: } else {
! 2651: fprintf(stderr, "failed to open %s\n", output);
! 2652: progresult = XMLLINT_ERR_OUT;
! 2653: }
! 2654: }
! 2655: } else {
! 2656: xmlSaveCtxtPtr ctxt;
! 2657: int saveOpts = 0;
! 2658:
! 2659: if (format == 1)
! 2660: saveOpts |= XML_SAVE_FORMAT;
! 2661: else if (format == 2)
! 2662: saveOpts |= XML_SAVE_WSNONSIG;
! 2663:
! 2664: #if defined(LIBXML_HTML_ENABLED) || defined(LIBXML_VALID_ENABLED)
! 2665: if (xmlout)
! 2666: saveOpts |= XML_SAVE_AS_XML;
! 2667: #endif
! 2668:
! 2669: if (output == NULL)
! 2670: ctxt = xmlSaveToFd(1, encoding, saveOpts);
! 2671: else
! 2672: ctxt = xmlSaveToFilename(output, encoding, saveOpts);
! 2673:
! 2674: if (ctxt != NULL) {
! 2675: if (xmlSaveDoc(ctxt, doc) < 0) {
! 2676: fprintf(stderr, "failed save to %s\n",
! 2677: output ? output : "-");
! 2678: progresult = XMLLINT_ERR_OUT;
! 2679: }
! 2680: xmlSaveClose(ctxt);
! 2681: } else {
! 2682: progresult = XMLLINT_ERR_OUT;
! 2683: }
! 2684: }
! 2685: if ((timing) && (!repeat)) {
! 2686: endTimer("Saving");
! 2687: }
! 2688: #ifdef LIBXML_DEBUG_ENABLED
! 2689: } else {
! 2690: FILE *out;
! 2691: if (output == NULL)
! 2692: out = stdout;
! 2693: else {
! 2694: out = fopen(output,"wb");
! 2695: }
! 2696: if (out != NULL) {
! 2697: xmlDebugDumpDocument(out, doc);
! 2698:
! 2699: if (output != NULL)
! 2700: fclose(out);
! 2701: } else {
! 2702: fprintf(stderr, "failed to open %s\n", output);
! 2703: progresult = XMLLINT_ERR_OUT;
! 2704: }
! 2705: }
! 2706: #endif
! 2707: }
! 2708: #endif /* LIBXML_OUTPUT_ENABLED */
! 2709:
! 2710: #ifdef LIBXML_VALID_ENABLED
! 2711: /*
! 2712: * A posteriori validation test
! 2713: */
! 2714: if ((dtdvalid != NULL) || (dtdvalidfpi != NULL)) {
! 2715: xmlDtdPtr dtd;
! 2716:
! 2717: if ((timing) && (!repeat)) {
! 2718: startTimer();
! 2719: }
! 2720: if (dtdvalid != NULL)
! 2721: dtd = xmlParseDTD(NULL, (const xmlChar *)dtdvalid);
! 2722: else
! 2723: dtd = xmlParseDTD((const xmlChar *)dtdvalidfpi, NULL);
! 2724: if ((timing) && (!repeat)) {
! 2725: endTimer("Parsing DTD");
! 2726: }
! 2727: if (dtd == NULL) {
! 2728: if (dtdvalid != NULL)
! 2729: xmlGenericError(xmlGenericErrorContext,
! 2730: "Could not parse DTD %s\n", dtdvalid);
! 2731: else
! 2732: xmlGenericError(xmlGenericErrorContext,
! 2733: "Could not parse DTD %s\n", dtdvalidfpi);
! 2734: progresult = XMLLINT_ERR_DTD;
! 2735: } else {
! 2736: xmlValidCtxtPtr cvp;
! 2737:
! 2738: if ((cvp = xmlNewValidCtxt()) == NULL) {
! 2739: xmlGenericError(xmlGenericErrorContext,
! 2740: "Couldn't allocate validation context\n");
! 2741: exit(-1);
! 2742: }
! 2743: cvp->userData = (void *) stderr;
! 2744: cvp->error = (xmlValidityErrorFunc) fprintf;
! 2745: cvp->warning = (xmlValidityWarningFunc) fprintf;
! 2746:
! 2747: if ((timing) && (!repeat)) {
! 2748: startTimer();
! 2749: }
! 2750: if (!xmlValidateDtd(cvp, doc, dtd)) {
! 2751: if (dtdvalid != NULL)
! 2752: xmlGenericError(xmlGenericErrorContext,
! 2753: "Document %s does not validate against %s\n",
! 2754: filename, dtdvalid);
! 2755: else
! 2756: xmlGenericError(xmlGenericErrorContext,
! 2757: "Document %s does not validate against %s\n",
! 2758: filename, dtdvalidfpi);
! 2759: progresult = XMLLINT_ERR_VALID;
! 2760: }
! 2761: if ((timing) && (!repeat)) {
! 2762: endTimer("Validating against DTD");
! 2763: }
! 2764: xmlFreeValidCtxt(cvp);
! 2765: xmlFreeDtd(dtd);
! 2766: }
! 2767: } else if (postvalid) {
! 2768: xmlValidCtxtPtr cvp;
! 2769:
! 2770: if ((cvp = xmlNewValidCtxt()) == NULL) {
! 2771: xmlGenericError(xmlGenericErrorContext,
! 2772: "Couldn't allocate validation context\n");
! 2773: exit(-1);
! 2774: }
! 2775:
! 2776: if ((timing) && (!repeat)) {
! 2777: startTimer();
! 2778: }
! 2779: cvp->userData = (void *) stderr;
! 2780: cvp->error = (xmlValidityErrorFunc) fprintf;
! 2781: cvp->warning = (xmlValidityWarningFunc) fprintf;
! 2782: if (!xmlValidateDocument(cvp, doc)) {
! 2783: xmlGenericError(xmlGenericErrorContext,
! 2784: "Document %s does not validate\n", filename);
! 2785: progresult = XMLLINT_ERR_VALID;
! 2786: }
! 2787: if ((timing) && (!repeat)) {
! 2788: endTimer("Validating");
! 2789: }
! 2790: xmlFreeValidCtxt(cvp);
! 2791: }
! 2792: #endif /* LIBXML_VALID_ENABLED */
! 2793: #ifdef LIBXML_SCHEMATRON_ENABLED
! 2794: if (wxschematron != NULL) {
! 2795: xmlSchematronValidCtxtPtr ctxt;
! 2796: int ret;
! 2797: int flag;
! 2798:
! 2799: if ((timing) && (!repeat)) {
! 2800: startTimer();
! 2801: }
! 2802:
! 2803: if (debug)
! 2804: flag = XML_SCHEMATRON_OUT_XML;
! 2805: else
! 2806: flag = XML_SCHEMATRON_OUT_TEXT;
! 2807: if (noout)
! 2808: flag |= XML_SCHEMATRON_OUT_QUIET;
! 2809: ctxt = xmlSchematronNewValidCtxt(wxschematron, flag);
! 2810: #if 0
! 2811: xmlSchematronSetValidErrors(ctxt,
! 2812: (xmlSchematronValidityErrorFunc) fprintf,
! 2813: (xmlSchematronValidityWarningFunc) fprintf,
! 2814: stderr);
! 2815: #endif
! 2816: ret = xmlSchematronValidateDoc(ctxt, doc);
! 2817: if (ret == 0) {
! 2818: fprintf(stderr, "%s validates\n", filename);
! 2819: } else if (ret > 0) {
! 2820: fprintf(stderr, "%s fails to validate\n", filename);
! 2821: progresult = XMLLINT_ERR_VALID;
! 2822: } else {
! 2823: fprintf(stderr, "%s validation generated an internal error\n",
! 2824: filename);
! 2825: progresult = XMLLINT_ERR_VALID;
! 2826: }
! 2827: xmlSchematronFreeValidCtxt(ctxt);
! 2828: if ((timing) && (!repeat)) {
! 2829: endTimer("Validating");
! 2830: }
! 2831: }
! 2832: #endif
! 2833: #ifdef LIBXML_SCHEMAS_ENABLED
! 2834: if (relaxngschemas != NULL) {
! 2835: xmlRelaxNGValidCtxtPtr ctxt;
! 2836: int ret;
! 2837:
! 2838: if ((timing) && (!repeat)) {
! 2839: startTimer();
! 2840: }
! 2841:
! 2842: ctxt = xmlRelaxNGNewValidCtxt(relaxngschemas);
! 2843: xmlRelaxNGSetValidErrors(ctxt,
! 2844: (xmlRelaxNGValidityErrorFunc) fprintf,
! 2845: (xmlRelaxNGValidityWarningFunc) fprintf,
! 2846: stderr);
! 2847: ret = xmlRelaxNGValidateDoc(ctxt, doc);
! 2848: if (ret == 0) {
! 2849: fprintf(stderr, "%s validates\n", filename);
! 2850: } else if (ret > 0) {
! 2851: fprintf(stderr, "%s fails to validate\n", filename);
! 2852: progresult = XMLLINT_ERR_VALID;
! 2853: } else {
! 2854: fprintf(stderr, "%s validation generated an internal error\n",
! 2855: filename);
! 2856: progresult = XMLLINT_ERR_VALID;
! 2857: }
! 2858: xmlRelaxNGFreeValidCtxt(ctxt);
! 2859: if ((timing) && (!repeat)) {
! 2860: endTimer("Validating");
! 2861: }
! 2862: } else if (wxschemas != NULL) {
! 2863: xmlSchemaValidCtxtPtr ctxt;
! 2864: int ret;
! 2865:
! 2866: if ((timing) && (!repeat)) {
! 2867: startTimer();
! 2868: }
! 2869:
! 2870: ctxt = xmlSchemaNewValidCtxt(wxschemas);
! 2871: xmlSchemaSetValidErrors(ctxt,
! 2872: (xmlSchemaValidityErrorFunc) fprintf,
! 2873: (xmlSchemaValidityWarningFunc) fprintf,
! 2874: stderr);
! 2875: ret = xmlSchemaValidateDoc(ctxt, doc);
! 2876: if (ret == 0) {
! 2877: fprintf(stderr, "%s validates\n", filename);
! 2878: } else if (ret > 0) {
! 2879: fprintf(stderr, "%s fails to validate\n", filename);
! 2880: progresult = XMLLINT_ERR_VALID;
! 2881: } else {
! 2882: fprintf(stderr, "%s validation generated an internal error\n",
! 2883: filename);
! 2884: progresult = XMLLINT_ERR_VALID;
! 2885: }
! 2886: xmlSchemaFreeValidCtxt(ctxt);
! 2887: if ((timing) && (!repeat)) {
! 2888: endTimer("Validating");
! 2889: }
! 2890: }
! 2891: #endif
! 2892:
! 2893: #ifdef LIBXML_DEBUG_ENABLED
! 2894: #if defined(LIBXML_HTML_ENABLED) || defined(LIBXML_VALID_ENABLED)
! 2895: if ((debugent) && (!html))
! 2896: xmlDebugDumpEntities(stderr, doc);
! 2897: #endif
! 2898: #endif
! 2899:
! 2900: /*
! 2901: * free it.
! 2902: */
! 2903: if ((timing) && (!repeat)) {
! 2904: startTimer();
! 2905: }
! 2906: xmlFreeDoc(doc);
! 2907: if ((timing) && (!repeat)) {
! 2908: endTimer("Freeing");
! 2909: }
! 2910: }
! 2911:
! 2912: /************************************************************************
! 2913: * *
! 2914: * Usage and Main *
! 2915: * *
! 2916: ************************************************************************/
! 2917:
! 2918: static void showVersion(const char *name) {
! 2919: fprintf(stderr, "%s: using libxml version %s\n", name, xmlParserVersion);
! 2920: fprintf(stderr, " compiled with: ");
! 2921: if (xmlHasFeature(XML_WITH_THREAD)) fprintf(stderr, "Threads ");
! 2922: if (xmlHasFeature(XML_WITH_TREE)) fprintf(stderr, "Tree ");
! 2923: if (xmlHasFeature(XML_WITH_OUTPUT)) fprintf(stderr, "Output ");
! 2924: if (xmlHasFeature(XML_WITH_PUSH)) fprintf(stderr, "Push ");
! 2925: if (xmlHasFeature(XML_WITH_READER)) fprintf(stderr, "Reader ");
! 2926: if (xmlHasFeature(XML_WITH_PATTERN)) fprintf(stderr, "Patterns ");
! 2927: if (xmlHasFeature(XML_WITH_WRITER)) fprintf(stderr, "Writer ");
! 2928: if (xmlHasFeature(XML_WITH_SAX1)) fprintf(stderr, "SAXv1 ");
! 2929: if (xmlHasFeature(XML_WITH_FTP)) fprintf(stderr, "FTP ");
! 2930: if (xmlHasFeature(XML_WITH_HTTP)) fprintf(stderr, "HTTP ");
! 2931: if (xmlHasFeature(XML_WITH_VALID)) fprintf(stderr, "DTDValid ");
! 2932: if (xmlHasFeature(XML_WITH_HTML)) fprintf(stderr, "HTML ");
! 2933: if (xmlHasFeature(XML_WITH_LEGACY)) fprintf(stderr, "Legacy ");
! 2934: if (xmlHasFeature(XML_WITH_C14N)) fprintf(stderr, "C14N ");
! 2935: if (xmlHasFeature(XML_WITH_CATALOG)) fprintf(stderr, "Catalog ");
! 2936: if (xmlHasFeature(XML_WITH_XPATH)) fprintf(stderr, "XPath ");
! 2937: if (xmlHasFeature(XML_WITH_XPTR)) fprintf(stderr, "XPointer ");
! 2938: if (xmlHasFeature(XML_WITH_XINCLUDE)) fprintf(stderr, "XInclude ");
! 2939: if (xmlHasFeature(XML_WITH_ICONV)) fprintf(stderr, "Iconv ");
! 2940: if (xmlHasFeature(XML_WITH_ISO8859X)) fprintf(stderr, "ISO8859X ");
! 2941: if (xmlHasFeature(XML_WITH_UNICODE)) fprintf(stderr, "Unicode ");
! 2942: if (xmlHasFeature(XML_WITH_REGEXP)) fprintf(stderr, "Regexps ");
! 2943: if (xmlHasFeature(XML_WITH_AUTOMATA)) fprintf(stderr, "Automata ");
! 2944: if (xmlHasFeature(XML_WITH_EXPR)) fprintf(stderr, "Expr ");
! 2945: if (xmlHasFeature(XML_WITH_SCHEMAS)) fprintf(stderr, "Schemas ");
! 2946: if (xmlHasFeature(XML_WITH_SCHEMATRON)) fprintf(stderr, "Schematron ");
! 2947: if (xmlHasFeature(XML_WITH_MODULES)) fprintf(stderr, "Modules ");
! 2948: if (xmlHasFeature(XML_WITH_DEBUG)) fprintf(stderr, "Debug ");
! 2949: if (xmlHasFeature(XML_WITH_DEBUG_MEM)) fprintf(stderr, "MemDebug ");
! 2950: if (xmlHasFeature(XML_WITH_DEBUG_RUN)) fprintf(stderr, "RunDebug ");
! 2951: if (xmlHasFeature(XML_WITH_ZLIB)) fprintf(stderr, "Zlib ");
! 2952: fprintf(stderr, "\n");
! 2953: }
! 2954:
! 2955: static void usage(const char *name) {
! 2956: printf("Usage : %s [options] XMLfiles ...\n", name);
! 2957: #ifdef LIBXML_OUTPUT_ENABLED
! 2958: printf("\tParse the XML files and output the result of the parsing\n");
! 2959: #else
! 2960: printf("\tParse the XML files\n");
! 2961: #endif /* LIBXML_OUTPUT_ENABLED */
! 2962: printf("\t--version : display the version of the XML library used\n");
! 2963: #ifdef LIBXML_DEBUG_ENABLED
! 2964: printf("\t--debug : dump a debug tree of the in-memory document\n");
! 2965: printf("\t--shell : run a navigating shell\n");
! 2966: printf("\t--debugent : debug the entities defined in the document\n");
! 2967: #else
! 2968: #ifdef LIBXML_READER_ENABLED
! 2969: printf("\t--debug : dump the nodes content when using --stream\n");
! 2970: #endif /* LIBXML_READER_ENABLED */
! 2971: #endif
! 2972: #ifdef LIBXML_TREE_ENABLED
! 2973: printf("\t--copy : used to test the internal copy implementation\n");
! 2974: #endif /* LIBXML_TREE_ENABLED */
! 2975: printf("\t--recover : output what was parsable on broken XML documents\n");
! 2976: printf("\t--huge : remove any internal arbitrary parser limits\n");
! 2977: printf("\t--noent : substitute entity references by their value\n");
! 2978: printf("\t--noout : don't output the result tree\n");
! 2979: printf("\t--path 'paths': provide a set of paths for resources\n");
! 2980: printf("\t--load-trace : print trace of all external entites loaded\n");
! 2981: printf("\t--nonet : refuse to fetch DTDs or entities over network\n");
! 2982: printf("\t--nocompact : do not generate compact text nodes\n");
! 2983: printf("\t--htmlout : output results as HTML\n");
! 2984: printf("\t--nowrap : do not put HTML doc wrapper\n");
! 2985: #ifdef LIBXML_VALID_ENABLED
! 2986: printf("\t--valid : validate the document in addition to std well-formed check\n");
! 2987: printf("\t--postvalid : do a posteriori validation, i.e after parsing\n");
! 2988: printf("\t--dtdvalid URL : do a posteriori validation against a given DTD\n");
! 2989: printf("\t--dtdvalidfpi FPI : same but name the DTD with a Public Identifier\n");
! 2990: #endif /* LIBXML_VALID_ENABLED */
! 2991: printf("\t--timing : print some timings\n");
! 2992: printf("\t--output file or -o file: save to a given file\n");
! 2993: printf("\t--repeat : repeat 100 times, for timing or profiling\n");
! 2994: printf("\t--insert : ad-hoc test for valid insertions\n");
! 2995: #ifdef LIBXML_OUTPUT_ENABLED
! 2996: #ifdef HAVE_ZLIB_H
! 2997: printf("\t--compress : turn on gzip compression of output\n");
! 2998: #endif
! 2999: #endif /* LIBXML_OUTPUT_ENABLED */
! 3000: #ifdef LIBXML_HTML_ENABLED
! 3001: printf("\t--html : use the HTML parser\n");
! 3002: printf("\t--xmlout : force to use the XML serializer when using --html\n");
! 3003: printf("\t--nodefdtd : do not default HTML doctype\n");
! 3004: #endif
! 3005: #ifdef LIBXML_PUSH_ENABLED
! 3006: printf("\t--push : use the push mode of the parser\n");
! 3007: #endif /* LIBXML_PUSH_ENABLED */
! 3008: #ifdef HAVE_SYS_MMAN_H
! 3009: printf("\t--memory : parse from memory\n");
! 3010: #endif
! 3011: printf("\t--maxmem nbbytes : limits memory allocation to nbbytes bytes\n");
! 3012: printf("\t--nowarning : do not emit warnings from parser/validator\n");
! 3013: printf("\t--noblanks : drop (ignorable?) blanks spaces\n");
! 3014: printf("\t--nocdata : replace cdata section with text nodes\n");
! 3015: #ifdef LIBXML_OUTPUT_ENABLED
! 3016: printf("\t--format : reformat/reindent the input\n");
! 3017: printf("\t--encode encoding : output in the given encoding\n");
! 3018: printf("\t--dropdtd : remove the DOCTYPE of the input docs\n");
! 3019: printf("\t--pretty STYLE : pretty-print in a particular style\n");
! 3020: printf("\t 0 Do not pretty print\n");
! 3021: printf("\t 1 Format the XML content, as --format\n");
! 3022: printf("\t 2 Add whitespace inside tags, preserving content\n");
! 3023: #endif /* LIBXML_OUTPUT_ENABLED */
! 3024: printf("\t--c14n : save in W3C canonical format v1.0 (with comments)\n");
! 3025: printf("\t--c14n11 : save in W3C canonical format v1.1 (with comments)\n");
! 3026: printf("\t--exc-c14n : save in W3C exclusive canonical format (with comments)\n");
! 3027: #ifdef LIBXML_C14N_ENABLED
! 3028: #endif /* LIBXML_C14N_ENABLED */
! 3029: printf("\t--nsclean : remove redundant namespace declarations\n");
! 3030: printf("\t--testIO : test user I/O support\n");
! 3031: #ifdef LIBXML_CATALOG_ENABLED
! 3032: printf("\t--catalogs : use SGML catalogs from $SGML_CATALOG_FILES\n");
! 3033: printf("\t otherwise XML Catalogs starting from \n");
! 3034: printf("\t %s are activated by default\n", XML_XML_DEFAULT_CATALOG);
! 3035: printf("\t--nocatalogs: deactivate all catalogs\n");
! 3036: #endif
! 3037: printf("\t--auto : generate a small doc on the fly\n");
! 3038: #ifdef LIBXML_XINCLUDE_ENABLED
! 3039: printf("\t--xinclude : do XInclude processing\n");
! 3040: printf("\t--noxincludenode : same but do not generate XInclude nodes\n");
! 3041: printf("\t--nofixup-base-uris : do not fixup xml:base uris\n");
! 3042: #endif
! 3043: printf("\t--loaddtd : fetch external DTD\n");
! 3044: printf("\t--dtdattr : loaddtd + populate the tree with inherited attributes \n");
! 3045: #ifdef LIBXML_READER_ENABLED
! 3046: printf("\t--stream : use the streaming interface to process very large files\n");
! 3047: printf("\t--walker : create a reader and walk though the resulting doc\n");
! 3048: #endif /* LIBXML_READER_ENABLED */
! 3049: #ifdef LIBXML_PATTERN_ENABLED
! 3050: printf("\t--pattern pattern_value : test the pattern support\n");
! 3051: #endif
! 3052: printf("\t--chkregister : verify the node registration code\n");
! 3053: #ifdef LIBXML_SCHEMAS_ENABLED
! 3054: printf("\t--relaxng schema : do RelaxNG validation against the schema\n");
! 3055: printf("\t--schema schema : do validation against the WXS schema\n");
! 3056: #endif
! 3057: #ifdef LIBXML_SCHEMATRON_ENABLED
! 3058: printf("\t--schematron schema : do validation against a schematron\n");
! 3059: #endif
! 3060: #ifdef LIBXML_SAX1_ENABLED
! 3061: printf("\t--sax1: use the old SAX1 interfaces for processing\n");
! 3062: #endif
! 3063: printf("\t--sax: do not build a tree but work just at the SAX level\n");
! 3064: printf("\t--oldxml10: use XML-1.0 parsing rules before the 5th edition\n");
! 3065: #ifdef LIBXML_XPATH_ENABLED
! 3066: printf("\t--xpath expr: evaluate the XPath expression, inply --noout\n");
! 3067: #endif
! 3068:
! 3069: printf("\nLibxml project home page: http://xmlsoft.org/\n");
! 3070: printf("To report bugs or get some help check: http://xmlsoft.org/bugs.html\n");
! 3071: }
! 3072:
! 3073: static void registerNode(xmlNodePtr node)
! 3074: {
! 3075: node->_private = malloc(sizeof(long));
! 3076: *(long*)node->_private = (long) 0x81726354;
! 3077: nbregister++;
! 3078: }
! 3079:
! 3080: static void deregisterNode(xmlNodePtr node)
! 3081: {
! 3082: assert(node->_private != NULL);
! 3083: assert(*(long*)node->_private == (long) 0x81726354);
! 3084: free(node->_private);
! 3085: nbregister--;
! 3086: }
! 3087:
! 3088: int
! 3089: main(int argc, char **argv) {
! 3090: int i, acount;
! 3091: int files = 0;
! 3092: int version = 0;
! 3093: const char* indent;
! 3094:
! 3095: if (argc <= 1) {
! 3096: usage(argv[0]);
! 3097: return(1);
! 3098: }
! 3099: LIBXML_TEST_VERSION
! 3100: for (i = 1; i < argc ; i++) {
! 3101: if (!strcmp(argv[i], "-"))
! 3102: break;
! 3103:
! 3104: if (argv[i][0] != '-')
! 3105: continue;
! 3106: if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
! 3107: debug++;
! 3108: else
! 3109: #ifdef LIBXML_DEBUG_ENABLED
! 3110: if ((!strcmp(argv[i], "-shell")) ||
! 3111: (!strcmp(argv[i], "--shell"))) {
! 3112: shell++;
! 3113: noout = 1;
! 3114: } else
! 3115: #endif
! 3116: #ifdef LIBXML_TREE_ENABLED
! 3117: if ((!strcmp(argv[i], "-copy")) || (!strcmp(argv[i], "--copy")))
! 3118: copy++;
! 3119: else
! 3120: #endif /* LIBXML_TREE_ENABLED */
! 3121: if ((!strcmp(argv[i], "-recover")) ||
! 3122: (!strcmp(argv[i], "--recover"))) {
! 3123: recovery++;
! 3124: options |= XML_PARSE_RECOVER;
! 3125: } else if ((!strcmp(argv[i], "-huge")) ||
! 3126: (!strcmp(argv[i], "--huge"))) {
! 3127: options |= XML_PARSE_HUGE;
! 3128: } else if ((!strcmp(argv[i], "-noent")) ||
! 3129: (!strcmp(argv[i], "--noent"))) {
! 3130: noent++;
! 3131: options |= XML_PARSE_NOENT;
! 3132: } else if ((!strcmp(argv[i], "-nsclean")) ||
! 3133: (!strcmp(argv[i], "--nsclean"))) {
! 3134: options |= XML_PARSE_NSCLEAN;
! 3135: } else if ((!strcmp(argv[i], "-nocdata")) ||
! 3136: (!strcmp(argv[i], "--nocdata"))) {
! 3137: options |= XML_PARSE_NOCDATA;
! 3138: } else if ((!strcmp(argv[i], "-nodict")) ||
! 3139: (!strcmp(argv[i], "--nodict"))) {
! 3140: options |= XML_PARSE_NODICT;
! 3141: } else if ((!strcmp(argv[i], "-version")) ||
! 3142: (!strcmp(argv[i], "--version"))) {
! 3143: showVersion(argv[0]);
! 3144: version = 1;
! 3145: } else if ((!strcmp(argv[i], "-noout")) ||
! 3146: (!strcmp(argv[i], "--noout")))
! 3147: noout++;
! 3148: #ifdef LIBXML_OUTPUT_ENABLED
! 3149: else if ((!strcmp(argv[i], "-o")) ||
! 3150: (!strcmp(argv[i], "-output")) ||
! 3151: (!strcmp(argv[i], "--output"))) {
! 3152: i++;
! 3153: output = argv[i];
! 3154: }
! 3155: #endif /* LIBXML_OUTPUT_ENABLED */
! 3156: else if ((!strcmp(argv[i], "-htmlout")) ||
! 3157: (!strcmp(argv[i], "--htmlout")))
! 3158: htmlout++;
! 3159: else if ((!strcmp(argv[i], "-nowrap")) ||
! 3160: (!strcmp(argv[i], "--nowrap")))
! 3161: nowrap++;
! 3162: #ifdef LIBXML_HTML_ENABLED
! 3163: else if ((!strcmp(argv[i], "-html")) ||
! 3164: (!strcmp(argv[i], "--html"))) {
! 3165: html++;
! 3166: }
! 3167: else if ((!strcmp(argv[i], "-xmlout")) ||
! 3168: (!strcmp(argv[i], "--xmlout"))) {
! 3169: xmlout++;
! 3170: } else if ((!strcmp(argv[i], "-nodefdtd")) ||
! 3171: (!strcmp(argv[i], "--nodefdtd"))) {
! 3172: nodefdtd++;
! 3173: options |= HTML_PARSE_NODEFDTD;
! 3174: }
! 3175: #endif /* LIBXML_HTML_ENABLED */
! 3176: else if ((!strcmp(argv[i], "-loaddtd")) ||
! 3177: (!strcmp(argv[i], "--loaddtd"))) {
! 3178: loaddtd++;
! 3179: options |= XML_PARSE_DTDLOAD;
! 3180: } else if ((!strcmp(argv[i], "-dtdattr")) ||
! 3181: (!strcmp(argv[i], "--dtdattr"))) {
! 3182: loaddtd++;
! 3183: dtdattrs++;
! 3184: options |= XML_PARSE_DTDATTR;
! 3185: }
! 3186: #ifdef LIBXML_VALID_ENABLED
! 3187: else if ((!strcmp(argv[i], "-valid")) ||
! 3188: (!strcmp(argv[i], "--valid"))) {
! 3189: valid++;
! 3190: options |= XML_PARSE_DTDVALID;
! 3191: } else if ((!strcmp(argv[i], "-postvalid")) ||
! 3192: (!strcmp(argv[i], "--postvalid"))) {
! 3193: postvalid++;
! 3194: loaddtd++;
! 3195: options |= XML_PARSE_DTDLOAD;
! 3196: } else if ((!strcmp(argv[i], "-dtdvalid")) ||
! 3197: (!strcmp(argv[i], "--dtdvalid"))) {
! 3198: i++;
! 3199: dtdvalid = argv[i];
! 3200: loaddtd++;
! 3201: options |= XML_PARSE_DTDLOAD;
! 3202: } else if ((!strcmp(argv[i], "-dtdvalidfpi")) ||
! 3203: (!strcmp(argv[i], "--dtdvalidfpi"))) {
! 3204: i++;
! 3205: dtdvalidfpi = argv[i];
! 3206: loaddtd++;
! 3207: options |= XML_PARSE_DTDLOAD;
! 3208: }
! 3209: #endif /* LIBXML_VALID_ENABLED */
! 3210: else if ((!strcmp(argv[i], "-dropdtd")) ||
! 3211: (!strcmp(argv[i], "--dropdtd")))
! 3212: dropdtd++;
! 3213: else if ((!strcmp(argv[i], "-insert")) ||
! 3214: (!strcmp(argv[i], "--insert")))
! 3215: insert++;
! 3216: else if ((!strcmp(argv[i], "-timing")) ||
! 3217: (!strcmp(argv[i], "--timing")))
! 3218: timing++;
! 3219: else if ((!strcmp(argv[i], "-auto")) ||
! 3220: (!strcmp(argv[i], "--auto")))
! 3221: generate++;
! 3222: else if ((!strcmp(argv[i], "-repeat")) ||
! 3223: (!strcmp(argv[i], "--repeat"))) {
! 3224: if (repeat)
! 3225: repeat *= 10;
! 3226: else
! 3227: repeat = 100;
! 3228: }
! 3229: #ifdef LIBXML_PUSH_ENABLED
! 3230: else if ((!strcmp(argv[i], "-push")) ||
! 3231: (!strcmp(argv[i], "--push")))
! 3232: push++;
! 3233: #endif /* LIBXML_PUSH_ENABLED */
! 3234: #ifdef HAVE_SYS_MMAN_H
! 3235: else if ((!strcmp(argv[i], "-memory")) ||
! 3236: (!strcmp(argv[i], "--memory")))
! 3237: memory++;
! 3238: #endif
! 3239: else if ((!strcmp(argv[i], "-testIO")) ||
! 3240: (!strcmp(argv[i], "--testIO")))
! 3241: testIO++;
! 3242: #ifdef LIBXML_XINCLUDE_ENABLED
! 3243: else if ((!strcmp(argv[i], "-xinclude")) ||
! 3244: (!strcmp(argv[i], "--xinclude"))) {
! 3245: xinclude++;
! 3246: options |= XML_PARSE_XINCLUDE;
! 3247: }
! 3248: else if ((!strcmp(argv[i], "-noxincludenode")) ||
! 3249: (!strcmp(argv[i], "--noxincludenode"))) {
! 3250: xinclude++;
! 3251: options |= XML_PARSE_XINCLUDE;
! 3252: options |= XML_PARSE_NOXINCNODE;
! 3253: }
! 3254: else if ((!strcmp(argv[i], "-nofixup-base-uris")) ||
! 3255: (!strcmp(argv[i], "--nofixup-base-uris"))) {
! 3256: xinclude++;
! 3257: options |= XML_PARSE_XINCLUDE;
! 3258: options |= XML_PARSE_NOBASEFIX;
! 3259: }
! 3260: #endif
! 3261: #ifdef LIBXML_OUTPUT_ENABLED
! 3262: #ifdef HAVE_ZLIB_H
! 3263: else if ((!strcmp(argv[i], "-compress")) ||
! 3264: (!strcmp(argv[i], "--compress"))) {
! 3265: compress++;
! 3266: xmlSetCompressMode(9);
! 3267: }
! 3268: #endif
! 3269: #endif /* LIBXML_OUTPUT_ENABLED */
! 3270: else if ((!strcmp(argv[i], "-nowarning")) ||
! 3271: (!strcmp(argv[i], "--nowarning"))) {
! 3272: xmlGetWarningsDefaultValue = 0;
! 3273: xmlPedanticParserDefault(0);
! 3274: options |= XML_PARSE_NOWARNING;
! 3275: }
! 3276: else if ((!strcmp(argv[i], "-pedantic")) ||
! 3277: (!strcmp(argv[i], "--pedantic"))) {
! 3278: xmlGetWarningsDefaultValue = 1;
! 3279: xmlPedanticParserDefault(1);
! 3280: options |= XML_PARSE_PEDANTIC;
! 3281: }
! 3282: #ifdef LIBXML_DEBUG_ENABLED
! 3283: else if ((!strcmp(argv[i], "-debugent")) ||
! 3284: (!strcmp(argv[i], "--debugent"))) {
! 3285: debugent++;
! 3286: xmlParserDebugEntities = 1;
! 3287: }
! 3288: #endif
! 3289: #ifdef LIBXML_C14N_ENABLED
! 3290: else if ((!strcmp(argv[i], "-c14n")) ||
! 3291: (!strcmp(argv[i], "--c14n"))) {
! 3292: canonical++;
! 3293: options |= XML_PARSE_NOENT | XML_PARSE_DTDATTR | XML_PARSE_DTDLOAD;
! 3294: }
! 3295: else if ((!strcmp(argv[i], "-c14n11")) ||
! 3296: (!strcmp(argv[i], "--c14n11"))) {
! 3297: canonical_11++;
! 3298: options |= XML_PARSE_NOENT | XML_PARSE_DTDATTR | XML_PARSE_DTDLOAD;
! 3299: }
! 3300: else if ((!strcmp(argv[i], "-exc-c14n")) ||
! 3301: (!strcmp(argv[i], "--exc-c14n"))) {
! 3302: exc_canonical++;
! 3303: options |= XML_PARSE_NOENT | XML_PARSE_DTDATTR | XML_PARSE_DTDLOAD;
! 3304: }
! 3305: #endif
! 3306: #ifdef LIBXML_CATALOG_ENABLED
! 3307: else if ((!strcmp(argv[i], "-catalogs")) ||
! 3308: (!strcmp(argv[i], "--catalogs"))) {
! 3309: catalogs++;
! 3310: } else if ((!strcmp(argv[i], "-nocatalogs")) ||
! 3311: (!strcmp(argv[i], "--nocatalogs"))) {
! 3312: nocatalogs++;
! 3313: }
! 3314: #endif
! 3315: else if ((!strcmp(argv[i], "-encode")) ||
! 3316: (!strcmp(argv[i], "--encode"))) {
! 3317: i++;
! 3318: encoding = argv[i];
! 3319: /*
! 3320: * OK it's for testing purposes
! 3321: */
! 3322: xmlAddEncodingAlias("UTF-8", "DVEnc");
! 3323: }
! 3324: else if ((!strcmp(argv[i], "-noblanks")) ||
! 3325: (!strcmp(argv[i], "--noblanks"))) {
! 3326: noblanks++;
! 3327: xmlKeepBlanksDefault(0);
! 3328: }
! 3329: else if ((!strcmp(argv[i], "-maxmem")) ||
! 3330: (!strcmp(argv[i], "--maxmem"))) {
! 3331: i++;
! 3332: if (sscanf(argv[i], "%d", &maxmem) == 1) {
! 3333: xmlMemSetup(myFreeFunc, myMallocFunc, myReallocFunc,
! 3334: myStrdupFunc);
! 3335: } else {
! 3336: maxmem = 0;
! 3337: }
! 3338: }
! 3339: else if ((!strcmp(argv[i], "-format")) ||
! 3340: (!strcmp(argv[i], "--format"))) {
! 3341: noblanks++;
! 3342: #ifdef LIBXML_OUTPUT_ENABLED
! 3343: format = 1;
! 3344: #endif /* LIBXML_OUTPUT_ENABLED */
! 3345: xmlKeepBlanksDefault(0);
! 3346: }
! 3347: else if ((!strcmp(argv[i], "-pretty")) ||
! 3348: (!strcmp(argv[i], "--pretty"))) {
! 3349: i++;
! 3350: #ifdef LIBXML_OUTPUT_ENABLED
! 3351: format = atoi(argv[i]);
! 3352: #endif /* LIBXML_OUTPUT_ENABLED */
! 3353: if (format == 1) {
! 3354: noblanks++;
! 3355: xmlKeepBlanksDefault(0);
! 3356: }
! 3357: }
! 3358: #ifdef LIBXML_READER_ENABLED
! 3359: else if ((!strcmp(argv[i], "-stream")) ||
! 3360: (!strcmp(argv[i], "--stream"))) {
! 3361: stream++;
! 3362: }
! 3363: else if ((!strcmp(argv[i], "-walker")) ||
! 3364: (!strcmp(argv[i], "--walker"))) {
! 3365: walker++;
! 3366: noout++;
! 3367: }
! 3368: #endif /* LIBXML_READER_ENABLED */
! 3369: #ifdef LIBXML_SAX1_ENABLED
! 3370: else if ((!strcmp(argv[i], "-sax1")) ||
! 3371: (!strcmp(argv[i], "--sax1"))) {
! 3372: sax1++;
! 3373: options |= XML_PARSE_SAX1;
! 3374: }
! 3375: #endif /* LIBXML_SAX1_ENABLED */
! 3376: else if ((!strcmp(argv[i], "-sax")) ||
! 3377: (!strcmp(argv[i], "--sax"))) {
! 3378: sax++;
! 3379: }
! 3380: else if ((!strcmp(argv[i], "-chkregister")) ||
! 3381: (!strcmp(argv[i], "--chkregister"))) {
! 3382: chkregister++;
! 3383: #ifdef LIBXML_SCHEMAS_ENABLED
! 3384: } else if ((!strcmp(argv[i], "-relaxng")) ||
! 3385: (!strcmp(argv[i], "--relaxng"))) {
! 3386: i++;
! 3387: relaxng = argv[i];
! 3388: noent++;
! 3389: options |= XML_PARSE_NOENT;
! 3390: } else if ((!strcmp(argv[i], "-schema")) ||
! 3391: (!strcmp(argv[i], "--schema"))) {
! 3392: i++;
! 3393: schema = argv[i];
! 3394: noent++;
! 3395: #endif
! 3396: #ifdef LIBXML_SCHEMATRON_ENABLED
! 3397: } else if ((!strcmp(argv[i], "-schematron")) ||
! 3398: (!strcmp(argv[i], "--schematron"))) {
! 3399: i++;
! 3400: schematron = argv[i];
! 3401: noent++;
! 3402: #endif
! 3403: } else if ((!strcmp(argv[i], "-nonet")) ||
! 3404: (!strcmp(argv[i], "--nonet"))) {
! 3405: options |= XML_PARSE_NONET;
! 3406: xmlSetExternalEntityLoader(xmlNoNetExternalEntityLoader);
! 3407: } else if ((!strcmp(argv[i], "-nocompact")) ||
! 3408: (!strcmp(argv[i], "--nocompact"))) {
! 3409: options &= ~XML_PARSE_COMPACT;
! 3410: } else if ((!strcmp(argv[i], "-load-trace")) ||
! 3411: (!strcmp(argv[i], "--load-trace"))) {
! 3412: load_trace++;
! 3413: } else if ((!strcmp(argv[i], "-path")) ||
! 3414: (!strcmp(argv[i], "--path"))) {
! 3415: i++;
! 3416: parsePath(BAD_CAST argv[i]);
! 3417: #ifdef LIBXML_PATTERN_ENABLED
! 3418: } else if ((!strcmp(argv[i], "-pattern")) ||
! 3419: (!strcmp(argv[i], "--pattern"))) {
! 3420: i++;
! 3421: pattern = argv[i];
! 3422: #endif
! 3423: #ifdef LIBXML_XPATH_ENABLED
! 3424: } else if ((!strcmp(argv[i], "-xpath")) ||
! 3425: (!strcmp(argv[i], "--xpath"))) {
! 3426: i++;
! 3427: noout++;
! 3428: xpathquery = argv[i];
! 3429: #endif
! 3430: } else if ((!strcmp(argv[i], "-oldxml10")) ||
! 3431: (!strcmp(argv[i], "--oldxml10"))) {
! 3432: oldxml10++;
! 3433: options |= XML_PARSE_OLD10;
! 3434: } else {
! 3435: fprintf(stderr, "Unknown option %s\n", argv[i]);
! 3436: usage(argv[0]);
! 3437: return(1);
! 3438: }
! 3439: }
! 3440:
! 3441: #ifdef LIBXML_CATALOG_ENABLED
! 3442: if (nocatalogs == 0) {
! 3443: if (catalogs) {
! 3444: const char *catal;
! 3445:
! 3446: catal = getenv("SGML_CATALOG_FILES");
! 3447: if (catal != NULL) {
! 3448: xmlLoadCatalogs(catal);
! 3449: } else {
! 3450: fprintf(stderr, "Variable $SGML_CATALOG_FILES not set\n");
! 3451: }
! 3452: }
! 3453: }
! 3454: #endif
! 3455:
! 3456: #ifdef LIBXML_SAX1_ENABLED
! 3457: if (sax1)
! 3458: xmlSAXDefaultVersion(1);
! 3459: else
! 3460: xmlSAXDefaultVersion(2);
! 3461: #endif /* LIBXML_SAX1_ENABLED */
! 3462:
! 3463: if (chkregister) {
! 3464: xmlRegisterNodeDefault(registerNode);
! 3465: xmlDeregisterNodeDefault(deregisterNode);
! 3466: }
! 3467:
! 3468: indent = getenv("XMLLINT_INDENT");
! 3469: if(indent != NULL) {
! 3470: xmlTreeIndentString = indent;
! 3471: }
! 3472:
! 3473:
! 3474: defaultEntityLoader = xmlGetExternalEntityLoader();
! 3475: xmlSetExternalEntityLoader(xmllintExternalEntityLoader);
! 3476:
! 3477: xmlLineNumbersDefault(1);
! 3478: if (loaddtd != 0)
! 3479: xmlLoadExtDtdDefaultValue |= XML_DETECT_IDS;
! 3480: if (dtdattrs)
! 3481: xmlLoadExtDtdDefaultValue |= XML_COMPLETE_ATTRS;
! 3482: if (noent != 0) xmlSubstituteEntitiesDefault(1);
! 3483: #ifdef LIBXML_VALID_ENABLED
! 3484: if (valid != 0) xmlDoValidityCheckingDefaultValue = 1;
! 3485: #endif /* LIBXML_VALID_ENABLED */
! 3486: if ((htmlout) && (!nowrap)) {
! 3487: xmlGenericError(xmlGenericErrorContext,
! 3488: "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\"\n");
! 3489: xmlGenericError(xmlGenericErrorContext,
! 3490: "\t\"http://www.w3.org/TR/REC-html40/loose.dtd\">\n");
! 3491: xmlGenericError(xmlGenericErrorContext,
! 3492: "<html><head><title>%s output</title></head>\n",
! 3493: argv[0]);
! 3494: xmlGenericError(xmlGenericErrorContext,
! 3495: "<body bgcolor=\"#ffffff\"><h1 align=\"center\">%s output</h1>\n",
! 3496: argv[0]);
! 3497: }
! 3498:
! 3499: #ifdef LIBXML_SCHEMATRON_ENABLED
! 3500: if ((schematron != NULL) && (sax == 0)
! 3501: #ifdef LIBXML_READER_ENABLED
! 3502: && (stream == 0)
! 3503: #endif /* LIBXML_READER_ENABLED */
! 3504: ) {
! 3505: xmlSchematronParserCtxtPtr ctxt;
! 3506:
! 3507: /* forces loading the DTDs */
! 3508: xmlLoadExtDtdDefaultValue |= 1;
! 3509: options |= XML_PARSE_DTDLOAD;
! 3510: if (timing) {
! 3511: startTimer();
! 3512: }
! 3513: ctxt = xmlSchematronNewParserCtxt(schematron);
! 3514: #if 0
! 3515: xmlSchematronSetParserErrors(ctxt,
! 3516: (xmlSchematronValidityErrorFunc) fprintf,
! 3517: (xmlSchematronValidityWarningFunc) fprintf,
! 3518: stderr);
! 3519: #endif
! 3520: wxschematron = xmlSchematronParse(ctxt);
! 3521: if (wxschematron == NULL) {
! 3522: xmlGenericError(xmlGenericErrorContext,
! 3523: "Schematron schema %s failed to compile\n", schematron);
! 3524: progresult = XMLLINT_ERR_SCHEMACOMP;
! 3525: schematron = NULL;
! 3526: }
! 3527: xmlSchematronFreeParserCtxt(ctxt);
! 3528: if (timing) {
! 3529: endTimer("Compiling the schemas");
! 3530: }
! 3531: }
! 3532: #endif
! 3533: #ifdef LIBXML_SCHEMAS_ENABLED
! 3534: if ((relaxng != NULL) && (sax == 0)
! 3535: #ifdef LIBXML_READER_ENABLED
! 3536: && (stream == 0)
! 3537: #endif /* LIBXML_READER_ENABLED */
! 3538: ) {
! 3539: xmlRelaxNGParserCtxtPtr ctxt;
! 3540:
! 3541: /* forces loading the DTDs */
! 3542: xmlLoadExtDtdDefaultValue |= 1;
! 3543: options |= XML_PARSE_DTDLOAD;
! 3544: if (timing) {
! 3545: startTimer();
! 3546: }
! 3547: ctxt = xmlRelaxNGNewParserCtxt(relaxng);
! 3548: xmlRelaxNGSetParserErrors(ctxt,
! 3549: (xmlRelaxNGValidityErrorFunc) fprintf,
! 3550: (xmlRelaxNGValidityWarningFunc) fprintf,
! 3551: stderr);
! 3552: relaxngschemas = xmlRelaxNGParse(ctxt);
! 3553: if (relaxngschemas == NULL) {
! 3554: xmlGenericError(xmlGenericErrorContext,
! 3555: "Relax-NG schema %s failed to compile\n", relaxng);
! 3556: progresult = XMLLINT_ERR_SCHEMACOMP;
! 3557: relaxng = NULL;
! 3558: }
! 3559: xmlRelaxNGFreeParserCtxt(ctxt);
! 3560: if (timing) {
! 3561: endTimer("Compiling the schemas");
! 3562: }
! 3563: } else if ((schema != NULL)
! 3564: #ifdef LIBXML_READER_ENABLED
! 3565: && (stream == 0)
! 3566: #endif
! 3567: ) {
! 3568: xmlSchemaParserCtxtPtr ctxt;
! 3569:
! 3570: if (timing) {
! 3571: startTimer();
! 3572: }
! 3573: ctxt = xmlSchemaNewParserCtxt(schema);
! 3574: xmlSchemaSetParserErrors(ctxt,
! 3575: (xmlSchemaValidityErrorFunc) fprintf,
! 3576: (xmlSchemaValidityWarningFunc) fprintf,
! 3577: stderr);
! 3578: wxschemas = xmlSchemaParse(ctxt);
! 3579: if (wxschemas == NULL) {
! 3580: xmlGenericError(xmlGenericErrorContext,
! 3581: "WXS schema %s failed to compile\n", schema);
! 3582: progresult = XMLLINT_ERR_SCHEMACOMP;
! 3583: schema = NULL;
! 3584: }
! 3585: xmlSchemaFreeParserCtxt(ctxt);
! 3586: if (timing) {
! 3587: endTimer("Compiling the schemas");
! 3588: }
! 3589: }
! 3590: #endif /* LIBXML_SCHEMAS_ENABLED */
! 3591: #ifdef LIBXML_PATTERN_ENABLED
! 3592: if ((pattern != NULL)
! 3593: #ifdef LIBXML_READER_ENABLED
! 3594: && (walker == 0)
! 3595: #endif
! 3596: ) {
! 3597: patternc = xmlPatterncompile((const xmlChar *) pattern, NULL, 0, NULL);
! 3598: if (patternc == NULL) {
! 3599: xmlGenericError(xmlGenericErrorContext,
! 3600: "Pattern %s failed to compile\n", pattern);
! 3601: progresult = XMLLINT_ERR_SCHEMAPAT;
! 3602: pattern = NULL;
! 3603: }
! 3604: }
! 3605: #endif /* LIBXML_PATTERN_ENABLED */
! 3606: for (i = 1; i < argc ; i++) {
! 3607: if ((!strcmp(argv[i], "-encode")) ||
! 3608: (!strcmp(argv[i], "--encode"))) {
! 3609: i++;
! 3610: continue;
! 3611: } else if ((!strcmp(argv[i], "-o")) ||
! 3612: (!strcmp(argv[i], "-output")) ||
! 3613: (!strcmp(argv[i], "--output"))) {
! 3614: i++;
! 3615: continue;
! 3616: }
! 3617: #ifdef LIBXML_VALID_ENABLED
! 3618: if ((!strcmp(argv[i], "-dtdvalid")) ||
! 3619: (!strcmp(argv[i], "--dtdvalid"))) {
! 3620: i++;
! 3621: continue;
! 3622: }
! 3623: if ((!strcmp(argv[i], "-path")) ||
! 3624: (!strcmp(argv[i], "--path"))) {
! 3625: i++;
! 3626: continue;
! 3627: }
! 3628: if ((!strcmp(argv[i], "-dtdvalidfpi")) ||
! 3629: (!strcmp(argv[i], "--dtdvalidfpi"))) {
! 3630: i++;
! 3631: continue;
! 3632: }
! 3633: #endif /* LIBXML_VALID_ENABLED */
! 3634: if ((!strcmp(argv[i], "-relaxng")) ||
! 3635: (!strcmp(argv[i], "--relaxng"))) {
! 3636: i++;
! 3637: continue;
! 3638: }
! 3639: if ((!strcmp(argv[i], "-maxmem")) ||
! 3640: (!strcmp(argv[i], "--maxmem"))) {
! 3641: i++;
! 3642: continue;
! 3643: }
! 3644: if ((!strcmp(argv[i], "-pretty")) ||
! 3645: (!strcmp(argv[i], "--pretty"))) {
! 3646: i++;
! 3647: continue;
! 3648: }
! 3649: if ((!strcmp(argv[i], "-schema")) ||
! 3650: (!strcmp(argv[i], "--schema"))) {
! 3651: i++;
! 3652: continue;
! 3653: }
! 3654: if ((!strcmp(argv[i], "-schematron")) ||
! 3655: (!strcmp(argv[i], "--schematron"))) {
! 3656: i++;
! 3657: continue;
! 3658: }
! 3659: #ifdef LIBXML_PATTERN_ENABLED
! 3660: if ((!strcmp(argv[i], "-pattern")) ||
! 3661: (!strcmp(argv[i], "--pattern"))) {
! 3662: i++;
! 3663: continue;
! 3664: }
! 3665: #endif
! 3666: #ifdef LIBXML_XPATH_ENABLED
! 3667: if ((!strcmp(argv[i], "-xpath")) ||
! 3668: (!strcmp(argv[i], "--xpath"))) {
! 3669: i++;
! 3670: continue;
! 3671: }
! 3672: #endif
! 3673: if ((timing) && (repeat))
! 3674: startTimer();
! 3675: /* Remember file names. "-" means stdin. <sven@zen.org> */
! 3676: if ((argv[i][0] != '-') || (strcmp(argv[i], "-") == 0)) {
! 3677: if (repeat) {
! 3678: xmlParserCtxtPtr ctxt = NULL;
! 3679:
! 3680: for (acount = 0;acount < repeat;acount++) {
! 3681: #ifdef LIBXML_READER_ENABLED
! 3682: if (stream != 0) {
! 3683: streamFile(argv[i]);
! 3684: } else {
! 3685: #endif /* LIBXML_READER_ENABLED */
! 3686: if (sax) {
! 3687: testSAX(argv[i]);
! 3688: } else {
! 3689: if (ctxt == NULL)
! 3690: ctxt = xmlNewParserCtxt();
! 3691: parseAndPrintFile(argv[i], ctxt);
! 3692: }
! 3693: #ifdef LIBXML_READER_ENABLED
! 3694: }
! 3695: #endif /* LIBXML_READER_ENABLED */
! 3696: }
! 3697: if (ctxt != NULL)
! 3698: xmlFreeParserCtxt(ctxt);
! 3699: } else {
! 3700: nbregister = 0;
! 3701:
! 3702: #ifdef LIBXML_READER_ENABLED
! 3703: if (stream != 0)
! 3704: streamFile(argv[i]);
! 3705: else
! 3706: #endif /* LIBXML_READER_ENABLED */
! 3707: if (sax) {
! 3708: testSAX(argv[i]);
! 3709: } else {
! 3710: parseAndPrintFile(argv[i], NULL);
! 3711: }
! 3712:
! 3713: if ((chkregister) && (nbregister != 0)) {
! 3714: fprintf(stderr, "Registration count off: %d\n", nbregister);
! 3715: progresult = XMLLINT_ERR_RDREGIS;
! 3716: }
! 3717: }
! 3718: files ++;
! 3719: if ((timing) && (repeat)) {
! 3720: endTimer("%d iterations", repeat);
! 3721: }
! 3722: }
! 3723: }
! 3724: if (generate)
! 3725: parseAndPrintFile(NULL, NULL);
! 3726: if ((htmlout) && (!nowrap)) {
! 3727: xmlGenericError(xmlGenericErrorContext, "</body></html>\n");
! 3728: }
! 3729: if ((files == 0) && (!generate) && (version == 0)) {
! 3730: usage(argv[0]);
! 3731: }
! 3732: #ifdef LIBXML_SCHEMATRON_ENABLED
! 3733: if (wxschematron != NULL)
! 3734: xmlSchematronFree(wxschematron);
! 3735: #endif
! 3736: #ifdef LIBXML_SCHEMAS_ENABLED
! 3737: if (relaxngschemas != NULL)
! 3738: xmlRelaxNGFree(relaxngschemas);
! 3739: if (wxschemas != NULL)
! 3740: xmlSchemaFree(wxschemas);
! 3741: xmlRelaxNGCleanupTypes();
! 3742: #endif
! 3743: #ifdef LIBXML_PATTERN_ENABLED
! 3744: if (patternc != NULL)
! 3745: xmlFreePattern(patternc);
! 3746: #endif
! 3747: xmlCleanupParser();
! 3748: xmlMemoryDump();
! 3749:
! 3750: return(progresult);
! 3751: }
! 3752:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xmllint.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