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