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