xmllint.c

   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