src/third_party/libxml/src/xmllint.c

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