xmllint.c

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