xmllint.c

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