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