Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(4)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: third_party/libxml/src/xmllint.c

Issue 1977213002: Roll libxml to 8effcb578e0590cc01bbcab0f9dccefc6bdbcdbd (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Update README.chromium. Created 4 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« third_party/libxml/src/COPYING ('K') | « third_party/libxml/src/xmlcatalog.c ('k') | third_party/libxml/src/xmlreader.c » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
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->filen ame,
571 input->line);
572 } else {
573 snprintf(&buffer[len], sizeof(buffer) - len, "Entity: line %d: ", in put->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 xm lChar *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 ATTRIBU TE_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 close(fd);
1842 fprintf(stderr, "mmap failure for file %s\n", filename);
1843 progresult = XMLLINT_ERR_RDFILE;
1844 return;
1845 }
1846
1847 reader = xmlReaderForMemory(base, info.st_size, filename,
1848 NULL, options);
1849 } else
1850 #endif
1851 reader = xmlReaderForFile(filename, NULL, options);
1852 #ifdef LIBXML_PATTERN_ENABLED
1853 if (pattern != NULL) {
1854 patternc = xmlPatterncompile((const xmlChar *) pattern, NULL, 0, NULL);
1855 if (patternc == NULL) {
1856 xmlGenericError(xmlGenericErrorContext,
1857 "Pattern %s failed to compile\n", pattern);
1858 progresult = XMLLINT_ERR_SCHEMAPAT;
1859 pattern = NULL;
1860 }
1861 }
1862 if (patternc != NULL) {
1863 patstream = xmlPatternGetStreamCtxt(patternc);
1864 if (patstream != NULL) {
1865 ret = xmlStreamPush(patstream, NULL, NULL);
1866 if (ret < 0) {
1867 fprintf(stderr, "xmlStreamPush() failure\n");
1868 xmlFreeStreamCtxt(patstream);
1869 patstream = NULL;
1870 }
1871 }
1872 }
1873 #endif
1874
1875
1876 if (reader != NULL) {
1877 #ifdef LIBXML_VALID_ENABLED
1878 if (valid)
1879 xmlTextReaderSetParserProp(reader, XML_PARSER_VALIDATE, 1);
1880 else
1881 #endif /* LIBXML_VALID_ENABLED */
1882 if (loaddtd)
1883 xmlTextReaderSetParserProp(reader, XML_PARSER_LOADDTD, 1);
1884 #ifdef LIBXML_SCHEMAS_ENABLED
1885 if (relaxng != NULL) {
1886 if ((timing) && (!repeat)) {
1887 startTimer();
1888 }
1889 ret = xmlTextReaderRelaxNGValidate(reader, relaxng);
1890 if (ret < 0) {
1891 xmlGenericError(xmlGenericErrorContext,
1892 "Relax-NG schema %s failed to compile\n", relaxng);
1893 progresult = XMLLINT_ERR_SCHEMACOMP;
1894 relaxng = NULL;
1895 }
1896 if ((timing) && (!repeat)) {
1897 endTimer("Compiling the schemas");
1898 }
1899 }
1900 if (schema != NULL) {
1901 if ((timing) && (!repeat)) {
1902 startTimer();
1903 }
1904 ret = xmlTextReaderSchemaValidate(reader, schema);
1905 if (ret < 0) {
1906 xmlGenericError(xmlGenericErrorContext,
1907 "XSD schema %s failed to compile\n", schema);
1908 progresult = XMLLINT_ERR_SCHEMACOMP;
1909 schema = NULL;
1910 }
1911 if ((timing) && (!repeat)) {
1912 endTimer("Compiling the schemas");
1913 }
1914 }
1915 #endif
1916
1917 /*
1918 * Process all nodes in sequence
1919 */
1920 if ((timing) && (!repeat)) {
1921 startTimer();
1922 }
1923 ret = xmlTextReaderRead(reader);
1924 while (ret == 1) {
1925 if ((debug)
1926 #ifdef LIBXML_PATTERN_ENABLED
1927 || (patternc)
1928 #endif
1929 )
1930 processNode(reader);
1931 ret = xmlTextReaderRead(reader);
1932 }
1933 if ((timing) && (!repeat)) {
1934 #ifdef LIBXML_SCHEMAS_ENABLED
1935 if (relaxng != NULL)
1936 endTimer("Parsing and validating");
1937 else
1938 #endif
1939 #ifdef LIBXML_VALID_ENABLED
1940 if (valid)
1941 endTimer("Parsing and validating");
1942 else
1943 #endif
1944 endTimer("Parsing");
1945 }
1946
1947 #ifdef LIBXML_VALID_ENABLED
1948 if (valid) {
1949 if (xmlTextReaderIsValid(reader) != 1) {
1950 xmlGenericError(xmlGenericErrorContext,
1951 "Document %s does not validate\n", filename);
1952 progresult = XMLLINT_ERR_VALID;
1953 }
1954 }
1955 #endif /* LIBXML_VALID_ENABLED */
1956 #ifdef LIBXML_SCHEMAS_ENABLED
1957 if ((relaxng != NULL) || (schema != NULL)) {
1958 if (xmlTextReaderIsValid(reader) != 1) {
1959 fprintf(stderr, "%s fails to validate\n", filename);
1960 progresult = XMLLINT_ERR_VALID;
1961 } else {
1962 fprintf(stderr, "%s validates\n", filename);
1963 }
1964 }
1965 #endif
1966 /*
1967 * Done, cleanup and status
1968 */
1969 xmlFreeTextReader(reader);
1970 if (ret != 0) {
1971 fprintf(stderr, "%s : failed to parse\n", filename);
1972 progresult = XMLLINT_ERR_UNCLASS;
1973 }
1974 } else {
1975 fprintf(stderr, "Unable to open %s\n", filename);
1976 progresult = XMLLINT_ERR_UNCLASS;
1977 }
1978 #ifdef LIBXML_PATTERN_ENABLED
1979 if (patstream != NULL) {
1980 xmlFreeStreamCtxt(patstream);
1981 patstream = NULL;
1982 }
1983 #endif
1984 #ifdef HAVE_MMAP
1985 if (memory) {
1986 xmlFreeParserInputBuffer(input);
1987 munmap((char *) base, info.st_size);
1988 close(fd);
1989 }
1990 #endif
1991 }
1992
1993 static void walkDoc(xmlDocPtr doc) {
1994 xmlTextReaderPtr reader;
1995 int ret;
1996
1997 #ifdef LIBXML_PATTERN_ENABLED
1998 xmlNodePtr root;
1999 const xmlChar *namespaces[22];
2000 int i;
2001 xmlNsPtr ns;
2002
2003 root = xmlDocGetRootElement(doc);
2004 for (ns = root->nsDef, i = 0;ns != NULL && i < 20;ns=ns->next) {
2005 namespaces[i++] = ns->href;
2006 namespaces[i++] = ns->prefix;
2007 }
2008 namespaces[i++] = NULL;
2009 namespaces[i] = NULL;
2010
2011 if (pattern != NULL) {
2012 patternc = xmlPatterncompile((const xmlChar *) pattern, doc->dict,
2013 0, &namespaces[0]);
2014 if (patternc == NULL) {
2015 xmlGenericError(xmlGenericErrorContext,
2016 "Pattern %s failed to compile\n", pattern);
2017 progresult = XMLLINT_ERR_SCHEMAPAT;
2018 pattern = NULL;
2019 }
2020 }
2021 if (patternc != NULL) {
2022 patstream = xmlPatternGetStreamCtxt(patternc);
2023 if (patstream != NULL) {
2024 ret = xmlStreamPush(patstream, NULL, NULL);
2025 if (ret < 0) {
2026 fprintf(stderr, "xmlStreamPush() failure\n");
2027 xmlFreeStreamCtxt(patstream);
2028 patstream = NULL;
2029 }
2030 }
2031 }
2032 #endif /* LIBXML_PATTERN_ENABLED */
2033 reader = xmlReaderWalker(doc);
2034 if (reader != NULL) {
2035 if ((timing) && (!repeat)) {
2036 startTimer();
2037 }
2038 ret = xmlTextReaderRead(reader);
2039 while (ret == 1) {
2040 if ((debug)
2041 #ifdef LIBXML_PATTERN_ENABLED
2042 || (patternc)
2043 #endif
2044 )
2045 processNode(reader);
2046 ret = xmlTextReaderRead(reader);
2047 }
2048 if ((timing) && (!repeat)) {
2049 endTimer("walking through the doc");
2050 }
2051 xmlFreeTextReader(reader);
2052 if (ret != 0) {
2053 fprintf(stderr, "failed to walk through the doc\n");
2054 progresult = XMLLINT_ERR_UNCLASS;
2055 }
2056 } else {
2057 fprintf(stderr, "Failed to crate a reader from the document\n");
2058 progresult = XMLLINT_ERR_UNCLASS;
2059 }
2060 #ifdef LIBXML_PATTERN_ENABLED
2061 if (patstream != NULL) {
2062 xmlFreeStreamCtxt(patstream);
2063 patstream = NULL;
2064 }
2065 #endif
2066 }
2067 #endif /* LIBXML_READER_ENABLED */
2068
2069 #ifdef LIBXML_XPATH_ENABLED
2070 /************************************************************************
2071 * *
2072 * XPath Query *
2073 * *
2074 ************************************************************************/
2075
2076 static void doXPathDump(xmlXPathObjectPtr cur) {
2077 switch(cur->type) {
2078 case XPATH_NODESET: {
2079 int i;
2080 xmlNodePtr node;
2081 #ifdef LIBXML_OUTPUT_ENABLED
2082 xmlSaveCtxtPtr ctxt;
2083
2084 if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr <= 0)) {
2085 fprintf(stderr, "XPath set is empty\n");
2086 progresult = XMLLINT_ERR_XPATH;
2087 break;
2088 }
2089 ctxt = xmlSaveToFd(1, NULL, 0);
2090 if (ctxt == NULL) {
2091 fprintf(stderr, "Out of memory for XPath\n");
2092 progresult = XMLLINT_ERR_MEM;
2093 return;
2094 }
2095 for (i = 0;i < cur->nodesetval->nodeNr;i++) {
2096 node = cur->nodesetval->nodeTab[i];
2097 xmlSaveTree(ctxt, node);
2098 }
2099 xmlSaveClose(ctxt);
2100 #else
2101 printf("xpath returned %d nodes\n", cur->nodesetval->nodeNr);
2102 #endif
2103 break;
2104 }
2105 case XPATH_BOOLEAN:
2106 if (cur->boolval) printf("true");
2107 else printf("false");
2108 break;
2109 case XPATH_NUMBER:
2110 switch (xmlXPathIsInf(cur->floatval)) {
2111 case 1:
2112 printf("Infinity");
2113 break;
2114 case -1:
2115 printf("-Infinity");
2116 break;
2117 default:
2118 if (xmlXPathIsNaN(cur->floatval)) {
2119 printf("NaN");
2120 } else {
2121 printf("%0g", cur->floatval);
2122 }
2123 }
2124 break;
2125 case XPATH_STRING:
2126 printf("%s", (const char *) cur->stringval);
2127 break;
2128 case XPATH_UNDEFINED:
2129 fprintf(stderr, "XPath Object is uninitialized\n");
2130 progresult = XMLLINT_ERR_XPATH;
2131 break;
2132 default:
2133 fprintf(stderr, "XPath object of unexpected type\n");
2134 progresult = XMLLINT_ERR_XPATH;
2135 break;
2136 }
2137 }
2138
2139 static void doXPathQuery(xmlDocPtr doc, const char *query) {
2140 xmlXPathContextPtr ctxt;
2141 xmlXPathObjectPtr res;
2142
2143 ctxt = xmlXPathNewContext(doc);
2144 if (ctxt == NULL) {
2145 fprintf(stderr, "Out of memory for XPath\n");
2146 progresult = XMLLINT_ERR_MEM;
2147 return;
2148 }
2149 ctxt->node = (xmlNodePtr) doc;
2150 res = xmlXPathEval(BAD_CAST query, ctxt);
2151 xmlXPathFreeContext(ctxt);
2152
2153 if (res == NULL) {
2154 fprintf(stderr, "XPath evaluation failure\n");
2155 progresult = XMLLINT_ERR_XPATH;
2156 return;
2157 }
2158 doXPathDump(res);
2159 xmlXPathFreeObject(res);
2160 }
2161 #endif /* LIBXML_XPATH_ENABLED */
2162
2163 /************************************************************************
2164 * *
2165 * Tree Test processing *
2166 * *
2167 ************************************************************************/
2168 static void parseAndPrintFile(char *filename, xmlParserCtxtPtr rectxt) {
2169 xmlDocPtr doc = NULL;
2170 #ifdef LIBXML_TREE_ENABLED
2171 xmlDocPtr tmp;
2172 #endif /* LIBXML_TREE_ENABLED */
2173
2174 if ((timing) && (!repeat))
2175 startTimer();
2176
2177
2178 #ifdef LIBXML_TREE_ENABLED
2179 if (filename == NULL) {
2180 if (generate) {
2181 xmlNodePtr n;
2182
2183 doc = xmlNewDoc(BAD_CAST "1.0");
2184 n = xmlNewDocNode(doc, NULL, BAD_CAST "info", NULL);
2185 xmlNodeSetContent(n, BAD_CAST "abc");
2186 xmlDocSetRootElement(doc, n);
2187 }
2188 }
2189 #endif /* LIBXML_TREE_ENABLED */
2190 #ifdef LIBXML_HTML_ENABLED
2191 #ifdef LIBXML_PUSH_ENABLED
2192 else if ((html) && (push)) {
2193 FILE *f;
2194
2195 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
2196 f = fopen(filename, "rb");
2197 #elif defined(__OS400__)
2198 f = fopen(filename, "rb");
2199 #else
2200 f = fopen(filename, "r");
2201 #endif
2202 if (f != NULL) {
2203 int res;
2204 char chars[4096];
2205 htmlParserCtxtPtr ctxt;
2206
2207 res = fread(chars, 1, 4, f);
2208 if (res > 0) {
2209 ctxt = htmlCreatePushParserCtxt(NULL, NULL,
2210 chars, res, filename, XML_CHAR_ENCODING_NONE);
2211 xmlCtxtUseOptions(ctxt, options);
2212 while ((res = fread(chars, 1, pushsize, f)) > 0) {
2213 htmlParseChunk(ctxt, chars, res, 0);
2214 }
2215 htmlParseChunk(ctxt, chars, 0, 1);
2216 doc = ctxt->myDoc;
2217 htmlFreeParserCtxt(ctxt);
2218 }
2219 fclose(f);
2220 }
2221 }
2222 #endif /* LIBXML_PUSH_ENABLED */
2223 #ifdef HAVE_MMAP
2224 else if ((html) && (memory)) {
2225 int fd;
2226 struct stat info;
2227 const char *base;
2228 if (stat(filename, &info) < 0)
2229 return;
2230 if ((fd = open(filename, O_RDONLY)) < 0)
2231 return;
2232 base = mmap(NULL, info.st_size, PROT_READ, MAP_SHARED, fd, 0) ;
2233 if (base == (void *) MAP_FAILED) {
2234 close(fd);
2235 fprintf(stderr, "mmap failure for file %s\n", filename);
2236 progresult = XMLLINT_ERR_RDFILE;
2237 return;
2238 }
2239
2240 doc = htmlReadMemory((char *) base, info.st_size, filename,
2241 NULL, options);
2242
2243 munmap((char *) base, info.st_size);
2244 close(fd);
2245 }
2246 #endif
2247 else if (html) {
2248 doc = htmlReadFile(filename, NULL, options);
2249 }
2250 #endif /* LIBXML_HTML_ENABLED */
2251 else {
2252 #ifdef LIBXML_PUSH_ENABLED
2253 /*
2254 * build an XML tree from a string;
2255 */
2256 if (push) {
2257 FILE *f;
2258
2259 /* '-' Usually means stdin -<sven@zen.org> */
2260 if ((filename[0] == '-') && (filename[1] == 0)) {
2261 f = stdin;
2262 } else {
2263 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
2264 f = fopen(filename, "rb");
2265 #elif defined(__OS400__)
2266 f = fopen(filename, "rb");
2267 #else
2268 f = fopen(filename, "r");
2269 #endif
2270 }
2271 if (f != NULL) {
2272 int ret;
2273 int res, size = 1024;
2274 char chars[1024];
2275 xmlParserCtxtPtr ctxt;
2276
2277 /* if (repeat) size = 1024; */
2278 res = fread(chars, 1, 4, f);
2279 if (res > 0) {
2280 ctxt = xmlCreatePushParserCtxt(NULL, NULL,
2281 chars, res, filename);
2282 xmlCtxtUseOptions(ctxt, options);
2283 while ((res = fread(chars, 1, size, f)) > 0) {
2284 xmlParseChunk(ctxt, chars, res, 0);
2285 }
2286 xmlParseChunk(ctxt, chars, 0, 1);
2287 doc = ctxt->myDoc;
2288 ret = ctxt->wellFormed;
2289 xmlFreeParserCtxt(ctxt);
2290 if (!ret) {
2291 xmlFreeDoc(doc);
2292 doc = NULL;
2293 }
2294 }
2295 if (f != stdin)
2296 fclose(f);
2297 }
2298 } else
2299 #endif /* LIBXML_PUSH_ENABLED */
2300 if (testIO) {
2301 if ((filename[0] == '-') && (filename[1] == 0)) {
2302 doc = xmlReadFd(0, NULL, NULL, options);
2303 } else {
2304 FILE *f;
2305
2306 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
2307 f = fopen(filename, "rb");
2308 #elif defined(__OS400__)
2309 f = fopen(filename, "rb");
2310 #else
2311 f = fopen(filename, "r");
2312 #endif
2313 if (f != NULL) {
2314 if (rectxt == NULL)
2315 doc = xmlReadIO((xmlInputReadCallback) myRead,
2316 (xmlInputCloseCallback) myClose, f,
2317 filename, NULL, options);
2318 else
2319 doc = xmlCtxtReadIO(rectxt,
2320 (xmlInputReadCallback) myRead,
2321 (xmlInputCloseCallback) myClose, f,
2322 filename, NULL, options);
2323 } else
2324 doc = NULL;
2325 }
2326 } else if (htmlout) {
2327 xmlParserCtxtPtr ctxt;
2328
2329 if (rectxt == NULL)
2330 ctxt = xmlNewParserCtxt();
2331 else
2332 ctxt = rectxt;
2333 if (ctxt == NULL) {
2334 doc = NULL;
2335 } else {
2336 ctxt->sax->error = xmlHTMLError;
2337 ctxt->sax->warning = xmlHTMLWarning;
2338 ctxt->vctxt.error = xmlHTMLValidityError;
2339 ctxt->vctxt.warning = xmlHTMLValidityWarning;
2340
2341 doc = xmlCtxtReadFile(ctxt, filename, NULL, options);
2342
2343 if (rectxt == NULL)
2344 xmlFreeParserCtxt(ctxt);
2345 }
2346 #ifdef HAVE_MMAP
2347 } else if (memory) {
2348 int fd;
2349 struct stat info;
2350 const char *base;
2351 if (stat(filename, &info) < 0)
2352 return;
2353 if ((fd = open(filename, O_RDONLY)) < 0)
2354 return;
2355 base = mmap(NULL, info.st_size, PROT_READ, MAP_SHARED, fd, 0) ;
2356 if (base == (void *) MAP_FAILED) {
2357 close(fd);
2358 fprintf(stderr, "mmap failure for file %s\n", filename);
2359 progresult = XMLLINT_ERR_RDFILE;
2360 return;
2361 }
2362
2363 if (rectxt == NULL)
2364 doc = xmlReadMemory((char *) base, info.st_size,
2365 filename, NULL, options);
2366 else
2367 doc = xmlCtxtReadMemory(rectxt, (char *) base, info.st_size,
2368 filename, NULL, options);
2369
2370 munmap((char *) base, info.st_size);
2371 close(fd);
2372 #endif
2373 #ifdef LIBXML_VALID_ENABLED
2374 } else if (valid) {
2375 xmlParserCtxtPtr ctxt = NULL;
2376
2377 if (rectxt == NULL)
2378 ctxt = xmlNewParserCtxt();
2379 else
2380 ctxt = rectxt;
2381 if (ctxt == NULL) {
2382 doc = NULL;
2383 } else {
2384 doc = xmlCtxtReadFile(ctxt, filename, NULL, options);
2385
2386 if (ctxt->valid == 0)
2387 progresult = XMLLINT_ERR_RDFILE;
2388 if (rectxt == NULL)
2389 xmlFreeParserCtxt(ctxt);
2390 }
2391 #endif /* LIBXML_VALID_ENABLED */
2392 } else {
2393 if (rectxt != NULL)
2394 doc = xmlCtxtReadFile(rectxt, filename, NULL, options);
2395 else {
2396 #ifdef LIBXML_SAX1_ENABLED
2397 if (sax1)
2398 doc = xmlParseFile(filename);
2399 else
2400 #endif /* LIBXML_SAX1_ENABLED */
2401 doc = xmlReadFile(filename, NULL, options);
2402 }
2403 }
2404 }
2405
2406 /*
2407 * If we don't have a document we might as well give up. Do we
2408 * want an error message here? <sven@zen.org> */
2409 if (doc == NULL) {
2410 progresult = XMLLINT_ERR_UNCLASS;
2411 return;
2412 }
2413
2414 if ((timing) && (!repeat)) {
2415 endTimer("Parsing");
2416 }
2417
2418 /*
2419 * Remove DOCTYPE nodes
2420 */
2421 if (dropdtd) {
2422 xmlDtdPtr dtd;
2423
2424 dtd = xmlGetIntSubset(doc);
2425 if (dtd != NULL) {
2426 xmlUnlinkNode((xmlNodePtr)dtd);
2427 xmlFreeDtd(dtd);
2428 }
2429 }
2430
2431 #ifdef LIBXML_XINCLUDE_ENABLED
2432 if (xinclude) {
2433 if ((timing) && (!repeat)) {
2434 startTimer();
2435 }
2436 if (xmlXIncludeProcessFlags(doc, options) < 0)
2437 progresult = XMLLINT_ERR_UNCLASS;
2438 if ((timing) && (!repeat)) {
2439 endTimer("Xinclude processing");
2440 }
2441 }
2442 #endif
2443
2444 #ifdef LIBXML_XPATH_ENABLED
2445 if (xpathquery != NULL) {
2446 doXPathQuery(doc, xpathquery);
2447 }
2448 #endif
2449
2450 #ifdef LIBXML_DEBUG_ENABLED
2451 #ifdef LIBXML_XPATH_ENABLED
2452 /*
2453 * shell interaction
2454 */
2455 if (shell) {
2456 xmlXPathOrderDocElems(doc);
2457 xmlShell(doc, filename, xmlShellReadline, stdout);
2458 }
2459 #endif
2460 #endif
2461
2462 #ifdef LIBXML_TREE_ENABLED
2463 /*
2464 * test intermediate copy if needed.
2465 */
2466 if (copy) {
2467 tmp = doc;
2468 if (timing) {
2469 startTimer();
2470 }
2471 doc = xmlCopyDoc(doc, 1);
2472 if (timing) {
2473 endTimer("Copying");
2474 }
2475 if (timing) {
2476 startTimer();
2477 }
2478 xmlFreeDoc(tmp);
2479 if (timing) {
2480 endTimer("Freeing original");
2481 }
2482 }
2483 #endif /* LIBXML_TREE_ENABLED */
2484
2485 #ifdef LIBXML_VALID_ENABLED
2486 if ((insert) && (!html)) {
2487 const xmlChar* list[256];
2488 int nb, i;
2489 xmlNodePtr node;
2490
2491 if (doc->children != NULL) {
2492 node = doc->children;
2493 while ((node != NULL) && (node->last == NULL)) node = node->next;
2494 if (node != NULL) {
2495 nb = xmlValidGetValidElements(node->last, NULL, list, 256);
2496 if (nb < 0) {
2497 fprintf(stderr, "could not get valid list of elements\n");
2498 } else if (nb == 0) {
2499 fprintf(stderr, "No element can be inserted under root\n");
2500 } else {
2501 fprintf(stderr, "%d element types can be inserted under root :\n",
2502 nb);
2503 for (i = 0;i < nb;i++) {
2504 fprintf(stderr, "%s\n", (char *) list[i]);
2505 }
2506 }
2507 }
2508 }
2509 }else
2510 #endif /* LIBXML_VALID_ENABLED */
2511 #ifdef LIBXML_READER_ENABLED
2512 if (walker) {
2513 walkDoc(doc);
2514 }
2515 #endif /* LIBXML_READER_ENABLED */
2516 #ifdef LIBXML_OUTPUT_ENABLED
2517 if (noout == 0) {
2518 int ret;
2519
2520 /*
2521 * print it.
2522 */
2523 #ifdef LIBXML_DEBUG_ENABLED
2524 if (!debug) {
2525 #endif
2526 if ((timing) && (!repeat)) {
2527 startTimer();
2528 }
2529 #ifdef LIBXML_HTML_ENABLED
2530 if ((html) && (!xmlout)) {
2531 if (compress) {
2532 htmlSaveFile(output ? output : "-", doc);
2533 }
2534 else if (encoding != NULL) {
2535 if (format == 1) {
2536 htmlSaveFileFormat(output ? output : "-", doc, encoding, 1);
2537 }
2538 else {
2539 htmlSaveFileFormat(output ? output : "-", doc, encoding, 0);
2540 }
2541 }
2542 else if (format == 1) {
2543 htmlSaveFileFormat(output ? output : "-", doc, NULL, 1);
2544 }
2545 else {
2546 FILE *out;
2547 if (output == NULL)
2548 out = stdout;
2549 else {
2550 out = fopen(output,"wb");
2551 }
2552 if (out != NULL) {
2553 if (htmlDocDump(out, doc) < 0)
2554 progresult = XMLLINT_ERR_OUT;
2555
2556 if (output != NULL)
2557 fclose(out);
2558 } else {
2559 fprintf(stderr, "failed to open %s\n", output);
2560 progresult = XMLLINT_ERR_OUT;
2561 }
2562 }
2563 if ((timing) && (!repeat)) {
2564 endTimer("Saving");
2565 }
2566 } else
2567 #endif
2568 #ifdef LIBXML_C14N_ENABLED
2569 if (canonical) {
2570 xmlChar *result = NULL;
2571 int size;
2572
2573 size = xmlC14NDocDumpMemory(doc, NULL, XML_C14N_1_0, NULL, 1, &r esult);
2574 if (size >= 0) {
2575 if (write(1, result, size) == -1) {
2576 fprintf(stderr, "Can't write data\n");
2577 }
2578 xmlFree(result);
2579 } else {
2580 fprintf(stderr, "Failed to canonicalize\n");
2581 progresult = XMLLINT_ERR_OUT;
2582 }
2583 } else if (canonical_11) {
2584 xmlChar *result = NULL;
2585 int size;
2586
2587 size = xmlC14NDocDumpMemory(doc, NULL, XML_C14N_1_1, NULL, 1, &r esult);
2588 if (size >= 0) {
2589 if (write(1, result, size) == -1) {
2590 fprintf(stderr, "Can't write data\n");
2591 }
2592 xmlFree(result);
2593 } else {
2594 fprintf(stderr, "Failed to canonicalize\n");
2595 progresult = XMLLINT_ERR_OUT;
2596 }
2597 } else
2598 if (exc_canonical) {
2599 xmlChar *result = NULL;
2600 int size;
2601
2602 size = xmlC14NDocDumpMemory(doc, NULL, XML_C14N_EXCLUSIVE_1_0, N ULL, 1, &result);
2603 if (size >= 0) {
2604 if (write(1, result, size) == -1) {
2605 fprintf(stderr, "Can't write data\n");
2606 }
2607 xmlFree(result);
2608 } else {
2609 fprintf(stderr, "Failed to canonicalize\n");
2610 progresult = XMLLINT_ERR_OUT;
2611 }
2612 } else
2613 #endif
2614 #ifdef HAVE_MMAP
2615 if (memory) {
2616 xmlChar *result;
2617 int len;
2618
2619 if (encoding != NULL) {
2620 if (format == 1) {
2621 xmlDocDumpFormatMemoryEnc(doc, &result, &len, encoding, 1);
2622 } else {
2623 xmlDocDumpMemoryEnc(doc, &result, &len, encoding);
2624 }
2625 } else {
2626 if (format == 1)
2627 xmlDocDumpFormatMemory(doc, &result, &len, 1);
2628 else
2629 xmlDocDumpMemory(doc, &result, &len);
2630 }
2631 if (result == NULL) {
2632 fprintf(stderr, "Failed to save\n");
2633 progresult = XMLLINT_ERR_OUT;
2634 } else {
2635 if (write(1, result, len) == -1) {
2636 fprintf(stderr, "Can't write data\n");
2637 }
2638 xmlFree(result);
2639 }
2640
2641 } else
2642 #endif /* HAVE_MMAP */
2643 if (compress) {
2644 xmlSaveFile(output ? output : "-", doc);
2645 } else if (oldout) {
2646 if (encoding != NULL) {
2647 if (format == 1) {
2648 ret = xmlSaveFormatFileEnc(output ? output : "-", doc,
2649 encoding, 1);
2650 }
2651 else {
2652 ret = xmlSaveFileEnc(output ? output : "-", doc,
2653 encoding);
2654 }
2655 if (ret < 0) {
2656 fprintf(stderr, "failed save to %s\n",
2657 output ? output : "-");
2658 progresult = XMLLINT_ERR_OUT;
2659 }
2660 } else if (format == 1) {
2661 ret = xmlSaveFormatFile(output ? output : "-", doc, 1);
2662 if (ret < 0) {
2663 fprintf(stderr, "failed save to %s\n",
2664 output ? output : "-");
2665 progresult = XMLLINT_ERR_OUT;
2666 }
2667 } else {
2668 FILE *out;
2669 if (output == NULL)
2670 out = stdout;
2671 else {
2672 out = fopen(output,"wb");
2673 }
2674 if (out != NULL) {
2675 if (xmlDocDump(out, doc) < 0)
2676 progresult = XMLLINT_ERR_OUT;
2677
2678 if (output != NULL)
2679 fclose(out);
2680 } else {
2681 fprintf(stderr, "failed to open %s\n", output);
2682 progresult = XMLLINT_ERR_OUT;
2683 }
2684 }
2685 } else {
2686 xmlSaveCtxtPtr ctxt;
2687 int saveOpts = 0;
2688
2689 if (format == 1)
2690 saveOpts |= XML_SAVE_FORMAT;
2691 else if (format == 2)
2692 saveOpts |= XML_SAVE_WSNONSIG;
2693
2694 #if defined(LIBXML_HTML_ENABLED) || defined(LIBXML_VALID_ENABLED)
2695 if (xmlout)
2696 saveOpts |= XML_SAVE_AS_XML;
2697 #endif
2698
2699 if (output == NULL)
2700 ctxt = xmlSaveToFd(1, encoding, saveOpts);
2701 else
2702 ctxt = xmlSaveToFilename(output, encoding, saveOpts);
2703
2704 if (ctxt != NULL) {
2705 if (xmlSaveDoc(ctxt, doc) < 0) {
2706 fprintf(stderr, "failed save to %s\n",
2707 output ? output : "-");
2708 progresult = XMLLINT_ERR_OUT;
2709 }
2710 xmlSaveClose(ctxt);
2711 } else {
2712 progresult = XMLLINT_ERR_OUT;
2713 }
2714 }
2715 if ((timing) && (!repeat)) {
2716 endTimer("Saving");
2717 }
2718 #ifdef LIBXML_DEBUG_ENABLED
2719 } else {
2720 FILE *out;
2721 if (output == NULL)
2722 out = stdout;
2723 else {
2724 out = fopen(output,"wb");
2725 }
2726 if (out != NULL) {
2727 xmlDebugDumpDocument(out, doc);
2728
2729 if (output != NULL)
2730 fclose(out);
2731 } else {
2732 fprintf(stderr, "failed to open %s\n", output);
2733 progresult = XMLLINT_ERR_OUT;
2734 }
2735 }
2736 #endif
2737 }
2738 #endif /* LIBXML_OUTPUT_ENABLED */
2739
2740 #ifdef LIBXML_VALID_ENABLED
2741 /*
2742 * A posteriori validation test
2743 */
2744 if ((dtdvalid != NULL) || (dtdvalidfpi != NULL)) {
2745 xmlDtdPtr dtd;
2746
2747 if ((timing) && (!repeat)) {
2748 startTimer();
2749 }
2750 if (dtdvalid != NULL)
2751 dtd = xmlParseDTD(NULL, (const xmlChar *)dtdvalid);
2752 else
2753 dtd = xmlParseDTD((const xmlChar *)dtdvalidfpi, NULL);
2754 if ((timing) && (!repeat)) {
2755 endTimer("Parsing DTD");
2756 }
2757 if (dtd == NULL) {
2758 if (dtdvalid != NULL)
2759 xmlGenericError(xmlGenericErrorContext,
2760 "Could not parse DTD %s\n", dtdvalid);
2761 else
2762 xmlGenericError(xmlGenericErrorContext,
2763 "Could not parse DTD %s\n", dtdvalidfpi);
2764 progresult = XMLLINT_ERR_DTD;
2765 } else {
2766 xmlValidCtxtPtr cvp;
2767
2768 if ((cvp = xmlNewValidCtxt()) == NULL) {
2769 xmlGenericError(xmlGenericErrorContext,
2770 "Couldn't allocate validation context\n");
2771 exit(-1);
2772 }
2773 cvp->userData = (void *) stderr;
2774 cvp->error = (xmlValidityErrorFunc) fprintf;
2775 cvp->warning = (xmlValidityWarningFunc) fprintf;
2776
2777 if ((timing) && (!repeat)) {
2778 startTimer();
2779 }
2780 if (!xmlValidateDtd(cvp, doc, dtd)) {
2781 if (dtdvalid != NULL)
2782 xmlGenericError(xmlGenericErrorContext,
2783 "Document %s does not validate against %s\n",
2784 filename, dtdvalid);
2785 else
2786 xmlGenericError(xmlGenericErrorContext,
2787 "Document %s does not validate against %s\n",
2788 filename, dtdvalidfpi);
2789 progresult = XMLLINT_ERR_VALID;
2790 }
2791 if ((timing) && (!repeat)) {
2792 endTimer("Validating against DTD");
2793 }
2794 xmlFreeValidCtxt(cvp);
2795 xmlFreeDtd(dtd);
2796 }
2797 } else if (postvalid) {
2798 xmlValidCtxtPtr cvp;
2799
2800 if ((cvp = xmlNewValidCtxt()) == NULL) {
2801 xmlGenericError(xmlGenericErrorContext,
2802 "Couldn't allocate validation context\n");
2803 exit(-1);
2804 }
2805
2806 if ((timing) && (!repeat)) {
2807 startTimer();
2808 }
2809 cvp->userData = (void *) stderr;
2810 cvp->error = (xmlValidityErrorFunc) fprintf;
2811 cvp->warning = (xmlValidityWarningFunc) fprintf;
2812 if (!xmlValidateDocument(cvp, doc)) {
2813 xmlGenericError(xmlGenericErrorContext,
2814 "Document %s does not validate\n", filename);
2815 progresult = XMLLINT_ERR_VALID;
2816 }
2817 if ((timing) && (!repeat)) {
2818 endTimer("Validating");
2819 }
2820 xmlFreeValidCtxt(cvp);
2821 }
2822 #endif /* LIBXML_VALID_ENABLED */
2823 #ifdef LIBXML_SCHEMATRON_ENABLED
2824 if (wxschematron != NULL) {
2825 xmlSchematronValidCtxtPtr ctxt;
2826 int ret;
2827 int flag;
2828
2829 if ((timing) && (!repeat)) {
2830 startTimer();
2831 }
2832
2833 if (debug)
2834 flag = XML_SCHEMATRON_OUT_XML;
2835 else
2836 flag = XML_SCHEMATRON_OUT_TEXT;
2837 if (noout)
2838 flag |= XML_SCHEMATRON_OUT_QUIET;
2839 ctxt = xmlSchematronNewValidCtxt(wxschematron, flag);
2840 #if 0
2841 xmlSchematronSetValidErrors(ctxt,
2842 (xmlSchematronValidityErrorFunc) fprintf,
2843 (xmlSchematronValidityWarningFunc) fprintf,
2844 stderr);
2845 #endif
2846 ret = xmlSchematronValidateDoc(ctxt, doc);
2847 if (ret == 0) {
2848 fprintf(stderr, "%s validates\n", filename);
2849 } else if (ret > 0) {
2850 fprintf(stderr, "%s fails to validate\n", filename);
2851 progresult = XMLLINT_ERR_VALID;
2852 } else {
2853 fprintf(stderr, "%s validation generated an internal error\n",
2854 filename);
2855 progresult = XMLLINT_ERR_VALID;
2856 }
2857 xmlSchematronFreeValidCtxt(ctxt);
2858 if ((timing) && (!repeat)) {
2859 endTimer("Validating");
2860 }
2861 }
2862 #endif
2863 #ifdef LIBXML_SCHEMAS_ENABLED
2864 if (relaxngschemas != NULL) {
2865 xmlRelaxNGValidCtxtPtr ctxt;
2866 int ret;
2867
2868 if ((timing) && (!repeat)) {
2869 startTimer();
2870 }
2871
2872 ctxt = xmlRelaxNGNewValidCtxt(relaxngschemas);
2873 xmlRelaxNGSetValidErrors(ctxt,
2874 (xmlRelaxNGValidityErrorFunc) fprintf,
2875 (xmlRelaxNGValidityWarningFunc) fprintf,
2876 stderr);
2877 ret = xmlRelaxNGValidateDoc(ctxt, doc);
2878 if (ret == 0) {
2879 fprintf(stderr, "%s validates\n", filename);
2880 } else if (ret > 0) {
2881 fprintf(stderr, "%s fails to validate\n", filename);
2882 progresult = XMLLINT_ERR_VALID;
2883 } else {
2884 fprintf(stderr, "%s validation generated an internal error\n",
2885 filename);
2886 progresult = XMLLINT_ERR_VALID;
2887 }
2888 xmlRelaxNGFreeValidCtxt(ctxt);
2889 if ((timing) && (!repeat)) {
2890 endTimer("Validating");
2891 }
2892 } else if (wxschemas != NULL) {
2893 xmlSchemaValidCtxtPtr ctxt;
2894 int ret;
2895
2896 if ((timing) && (!repeat)) {
2897 startTimer();
2898 }
2899
2900 ctxt = xmlSchemaNewValidCtxt(wxschemas);
2901 xmlSchemaSetValidErrors(ctxt,
2902 (xmlSchemaValidityErrorFunc) fprintf,
2903 (xmlSchemaValidityWarningFunc) fprintf,
2904 stderr);
2905 ret = xmlSchemaValidateDoc(ctxt, doc);
2906 if (ret == 0) {
2907 fprintf(stderr, "%s validates\n", filename);
2908 } else if (ret > 0) {
2909 fprintf(stderr, "%s fails to validate\n", filename);
2910 progresult = XMLLINT_ERR_VALID;
2911 } else {
2912 fprintf(stderr, "%s validation generated an internal error\n",
2913 filename);
2914 progresult = XMLLINT_ERR_VALID;
2915 }
2916 xmlSchemaFreeValidCtxt(ctxt);
2917 if ((timing) && (!repeat)) {
2918 endTimer("Validating");
2919 }
2920 }
2921 #endif
2922
2923 #ifdef LIBXML_DEBUG_ENABLED
2924 #if defined(LIBXML_HTML_ENABLED) || defined(LIBXML_VALID_ENABLED)
2925 if ((debugent) && (!html))
2926 xmlDebugDumpEntities(stderr, doc);
2927 #endif
2928 #endif
2929
2930 /*
2931 * free it.
2932 */
2933 if ((timing) && (!repeat)) {
2934 startTimer();
2935 }
2936 xmlFreeDoc(doc);
2937 if ((timing) && (!repeat)) {
2938 endTimer("Freeing");
2939 }
2940 }
2941
2942 /************************************************************************
2943 * *
2944 * Usage and Main *
2945 * *
2946 ************************************************************************/
2947
2948 static void showVersion(const char *name) {
2949 fprintf(stderr, "%s: using libxml version %s\n", name, xmlParserVersion);
2950 fprintf(stderr, " compiled with: ");
2951 if (xmlHasFeature(XML_WITH_THREAD)) fprintf(stderr, "Threads ");
2952 if (xmlHasFeature(XML_WITH_TREE)) fprintf(stderr, "Tree ");
2953 if (xmlHasFeature(XML_WITH_OUTPUT)) fprintf(stderr, "Output ");
2954 if (xmlHasFeature(XML_WITH_PUSH)) fprintf(stderr, "Push ");
2955 if (xmlHasFeature(XML_WITH_READER)) fprintf(stderr, "Reader ");
2956 if (xmlHasFeature(XML_WITH_PATTERN)) fprintf(stderr, "Patterns ");
2957 if (xmlHasFeature(XML_WITH_WRITER)) fprintf(stderr, "Writer ");
2958 if (xmlHasFeature(XML_WITH_SAX1)) fprintf(stderr, "SAXv1 ");
2959 if (xmlHasFeature(XML_WITH_FTP)) fprintf(stderr, "FTP ");
2960 if (xmlHasFeature(XML_WITH_HTTP)) fprintf(stderr, "HTTP ");
2961 if (xmlHasFeature(XML_WITH_VALID)) fprintf(stderr, "DTDValid ");
2962 if (xmlHasFeature(XML_WITH_HTML)) fprintf(stderr, "HTML ");
2963 if (xmlHasFeature(XML_WITH_LEGACY)) fprintf(stderr, "Legacy ");
2964 if (xmlHasFeature(XML_WITH_C14N)) fprintf(stderr, "C14N ");
2965 if (xmlHasFeature(XML_WITH_CATALOG)) fprintf(stderr, "Catalog ");
2966 if (xmlHasFeature(XML_WITH_XPATH)) fprintf(stderr, "XPath ");
2967 if (xmlHasFeature(XML_WITH_XPTR)) fprintf(stderr, "XPointer ");
2968 if (xmlHasFeature(XML_WITH_XINCLUDE)) fprintf(stderr, "XInclude ");
2969 if (xmlHasFeature(XML_WITH_ICONV)) fprintf(stderr, "Iconv ");
2970 if (xmlHasFeature(XML_WITH_ISO8859X)) fprintf(stderr, "ISO8859X ");
2971 if (xmlHasFeature(XML_WITH_UNICODE)) fprintf(stderr, "Unicode ");
2972 if (xmlHasFeature(XML_WITH_REGEXP)) fprintf(stderr, "Regexps ");
2973 if (xmlHasFeature(XML_WITH_AUTOMATA)) fprintf(stderr, "Automata ");
2974 if (xmlHasFeature(XML_WITH_EXPR)) fprintf(stderr, "Expr ");
2975 if (xmlHasFeature(XML_WITH_SCHEMAS)) fprintf(stderr, "Schemas ");
2976 if (xmlHasFeature(XML_WITH_SCHEMATRON)) fprintf(stderr, "Schematron ");
2977 if (xmlHasFeature(XML_WITH_MODULES)) fprintf(stderr, "Modules ");
2978 if (xmlHasFeature(XML_WITH_DEBUG)) fprintf(stderr, "Debug ");
2979 if (xmlHasFeature(XML_WITH_DEBUG_MEM)) fprintf(stderr, "MemDebug ");
2980 if (xmlHasFeature(XML_WITH_DEBUG_RUN)) fprintf(stderr, "RunDebug ");
2981 if (xmlHasFeature(XML_WITH_ZLIB)) fprintf(stderr, "Zlib ");
2982 if (xmlHasFeature(XML_WITH_LZMA)) fprintf(stderr, "Lzma ");
2983 fprintf(stderr, "\n");
2984 }
2985
2986 static void usage(const char *name) {
2987 printf("Usage : %s [options] XMLfiles ...\n", name);
2988 #ifdef LIBXML_OUTPUT_ENABLED
2989 printf("\tParse the XML files and output the result of the parsing\n");
2990 #else
2991 printf("\tParse the XML files\n");
2992 #endif /* LIBXML_OUTPUT_ENABLED */
2993 printf("\t--version : display the version of the XML library used\n");
2994 #ifdef LIBXML_DEBUG_ENABLED
2995 printf("\t--debug : dump a debug tree of the in-memory document\n");
2996 printf("\t--shell : run a navigating shell\n");
2997 printf("\t--debugent : debug the entities defined in the document\n");
2998 #else
2999 #ifdef LIBXML_READER_ENABLED
3000 printf("\t--debug : dump the nodes content when using --stream\n");
3001 #endif /* LIBXML_READER_ENABLED */
3002 #endif
3003 #ifdef LIBXML_TREE_ENABLED
3004 printf("\t--copy : used to test the internal copy implementation\n");
3005 #endif /* LIBXML_TREE_ENABLED */
3006 printf("\t--recover : output what was parsable on broken XML documents\n");
3007 printf("\t--huge : remove any internal arbitrary parser limits\n");
3008 printf("\t--noent : substitute entity references by their value\n");
3009 printf("\t--noenc : ignore any encoding specified inside the document\n");
3010 printf("\t--noout : don't output the result tree\n");
3011 printf("\t--path 'paths': provide a set of paths for resources\n");
3012 printf("\t--load-trace : print trace of all external entities loaded\n");
3013 printf("\t--nonet : refuse to fetch DTDs or entities over network\n");
3014 printf("\t--nocompact : do not generate compact text nodes\n");
3015 printf("\t--htmlout : output results as HTML\n");
3016 printf("\t--nowrap : do not put HTML doc wrapper\n");
3017 #ifdef LIBXML_VALID_ENABLED
3018 printf("\t--valid : validate the document in addition to std well-formed che ck\n");
3019 printf("\t--postvalid : do a posteriori validation, i.e after parsing\n");
3020 printf("\t--dtdvalid URL : do a posteriori validation against a given DTD\n" );
3021 printf("\t--dtdvalidfpi FPI : same but name the DTD with a Public Identifier \n");
3022 #endif /* LIBXML_VALID_ENABLED */
3023 printf("\t--timing : print some timings\n");
3024 printf("\t--output file or -o file: save to a given file\n");
3025 printf("\t--repeat : repeat 100 times, for timing or profiling\n");
3026 printf("\t--insert : ad-hoc test for valid insertions\n");
3027 #ifdef LIBXML_OUTPUT_ENABLED
3028 #ifdef HAVE_ZLIB_H
3029 printf("\t--compress : turn on gzip compression of output\n");
3030 #endif
3031 #endif /* LIBXML_OUTPUT_ENABLED */
3032 #ifdef LIBXML_HTML_ENABLED
3033 printf("\t--html : use the HTML parser\n");
3034 printf("\t--xmlout : force to use the XML serializer when using --html\n");
3035 printf("\t--nodefdtd : do not default HTML doctype\n");
3036 #endif
3037 #ifdef LIBXML_PUSH_ENABLED
3038 printf("\t--push : use the push mode of the parser\n");
3039 printf("\t--pushsmall : use the push mode of the parser using tiny increment s\n");
3040 #endif /* LIBXML_PUSH_ENABLED */
3041 #ifdef HAVE_MMAP
3042 printf("\t--memory : parse from memory\n");
3043 #endif
3044 printf("\t--maxmem nbbytes : limits memory allocation to nbbytes bytes\n");
3045 printf("\t--nowarning : do not emit warnings from parser/validator\n");
3046 printf("\t--noblanks : drop (ignorable?) blanks spaces\n");
3047 printf("\t--nocdata : replace cdata section with text nodes\n");
3048 #ifdef LIBXML_OUTPUT_ENABLED
3049 printf("\t--format : reformat/reindent the output\n");
3050 printf("\t--encode encoding : output in the given encoding\n");
3051 printf("\t--dropdtd : remove the DOCTYPE of the input docs\n");
3052 printf("\t--pretty STYLE : pretty-print in a particular style\n");
3053 printf("\t 0 Do not pretty print\n");
3054 printf("\t 1 Format the XML content, as --format\n");
3055 printf("\t 2 Add whitespace inside tags, preserving content\ n");
3056 #endif /* LIBXML_OUTPUT_ENABLED */
3057 printf("\t--c14n : save in W3C canonical format v1.0 (with comments)\n");
3058 printf("\t--c14n11 : save in W3C canonical format v1.1 (with comments)\n");
3059 printf("\t--exc-c14n : save in W3C exclusive canonical format (with comments )\n");
3060 #ifdef LIBXML_C14N_ENABLED
3061 #endif /* LIBXML_C14N_ENABLED */
3062 printf("\t--nsclean : remove redundant namespace declarations\n");
3063 printf("\t--testIO : test user I/O support\n");
3064 #ifdef LIBXML_CATALOG_ENABLED
3065 printf("\t--catalogs : use SGML catalogs from $SGML_CATALOG_FILES\n");
3066 printf("\t otherwise XML Catalogs starting from \n");
3067 printf("\t %s are activated by default\n", XML_XML_DEFAULT_CATALOG);
3068 printf("\t--nocatalogs: deactivate all catalogs\n");
3069 #endif
3070 printf("\t--auto : generate a small doc on the fly\n");
3071 #ifdef LIBXML_XINCLUDE_ENABLED
3072 printf("\t--xinclude : do XInclude processing\n");
3073 printf("\t--noxincludenode : same but do not generate XInclude nodes\n");
3074 printf("\t--nofixup-base-uris : do not fixup xml:base uris\n");
3075 #endif
3076 printf("\t--loaddtd : fetch external DTD\n");
3077 printf("\t--dtdattr : loaddtd + populate the tree with inherited attributes \n");
3078 #ifdef LIBXML_READER_ENABLED
3079 printf("\t--stream : use the streaming interface to process very large files \n");
3080 printf("\t--walker : create a reader and walk though the resulting doc\n");
3081 #endif /* LIBXML_READER_ENABLED */
3082 #ifdef LIBXML_PATTERN_ENABLED
3083 printf("\t--pattern pattern_value : test the pattern support\n");
3084 #endif
3085 printf("\t--chkregister : verify the node registration code\n");
3086 #ifdef LIBXML_SCHEMAS_ENABLED
3087 printf("\t--relaxng schema : do RelaxNG validation against the schema\n");
3088 printf("\t--schema schema : do validation against the WXS schema\n");
3089 #endif
3090 #ifdef LIBXML_SCHEMATRON_ENABLED
3091 printf("\t--schematron schema : do validation against a schematron\n");
3092 #endif
3093 #ifdef LIBXML_SAX1_ENABLED
3094 printf("\t--sax1: use the old SAX1 interfaces for processing\n");
3095 #endif
3096 printf("\t--sax: do not build a tree but work just at the SAX level\n");
3097 printf("\t--oldxml10: use XML-1.0 parsing rules before the 5th edition\n");
3098 #ifdef LIBXML_XPATH_ENABLED
3099 printf("\t--xpath expr: evaluate the XPath expression, imply --noout\n");
3100 #endif
3101
3102 printf("\nLibxml project home page: http://xmlsoft.org/\n");
3103 printf("To report bugs or get some help check: http://xmlsoft.org/bugs.html\ n");
3104 }
3105
3106 static void registerNode(xmlNodePtr node)
3107 {
3108 node->_private = malloc(sizeof(long));
3109 if (node->_private == NULL) {
3110 fprintf(stderr, "Out of memory in xmllint:registerNode()\n");
3111 exit(XMLLINT_ERR_MEM);
3112 }
3113 *(long*)node->_private = (long) 0x81726354;
3114 nbregister++;
3115 }
3116
3117 static void deregisterNode(xmlNodePtr node)
3118 {
3119 assert(node->_private != NULL);
3120 assert(*(long*)node->_private == (long) 0x81726354);
3121 free(node->_private);
3122 nbregister--;
3123 }
3124
3125 int
3126 main(int argc, char **argv) {
3127 int i, acount;
3128 int files = 0;
3129 int version = 0;
3130 const char* indent;
3131
3132 if (argc <= 1) {
3133 usage(argv[0]);
3134 return(1);
3135 }
3136 LIBXML_TEST_VERSION
3137 for (i = 1; i < argc ; i++) {
3138 if (!strcmp(argv[i], "-"))
3139 break;
3140
3141 if (argv[i][0] != '-')
3142 continue;
3143 if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
3144 debug++;
3145 else
3146 #ifdef LIBXML_DEBUG_ENABLED
3147 if ((!strcmp(argv[i], "-shell")) ||
3148 (!strcmp(argv[i], "--shell"))) {
3149 shell++;
3150 noout = 1;
3151 } else
3152 #endif
3153 #ifdef LIBXML_TREE_ENABLED
3154 if ((!strcmp(argv[i], "-copy")) || (!strcmp(argv[i], "--copy")))
3155 copy++;
3156 else
3157 #endif /* LIBXML_TREE_ENABLED */
3158 if ((!strcmp(argv[i], "-recover")) ||
3159 (!strcmp(argv[i], "--recover"))) {
3160 recovery++;
3161 options |= XML_PARSE_RECOVER;
3162 } else if ((!strcmp(argv[i], "-huge")) ||
3163 (!strcmp(argv[i], "--huge"))) {
3164 options |= XML_PARSE_HUGE;
3165 } else if ((!strcmp(argv[i], "-noent")) ||
3166 (!strcmp(argv[i], "--noent"))) {
3167 noent++;
3168 options |= XML_PARSE_NOENT;
3169 } else if ((!strcmp(argv[i], "-noenc")) ||
3170 (!strcmp(argv[i], "--noenc"))) {
3171 noenc++;
3172 options |= XML_PARSE_IGNORE_ENC;
3173 } else if ((!strcmp(argv[i], "-nsclean")) ||
3174 (!strcmp(argv[i], "--nsclean"))) {
3175 options |= XML_PARSE_NSCLEAN;
3176 } else if ((!strcmp(argv[i], "-nocdata")) ||
3177 (!strcmp(argv[i], "--nocdata"))) {
3178 options |= XML_PARSE_NOCDATA;
3179 } else if ((!strcmp(argv[i], "-nodict")) ||
3180 (!strcmp(argv[i], "--nodict"))) {
3181 options |= XML_PARSE_NODICT;
3182 } else if ((!strcmp(argv[i], "-version")) ||
3183 (!strcmp(argv[i], "--version"))) {
3184 showVersion(argv[0]);
3185 version = 1;
3186 } else if ((!strcmp(argv[i], "-noout")) ||
3187 (!strcmp(argv[i], "--noout")))
3188 noout++;
3189 #ifdef LIBXML_OUTPUT_ENABLED
3190 else if ((!strcmp(argv[i], "-o")) ||
3191 (!strcmp(argv[i], "-output")) ||
3192 (!strcmp(argv[i], "--output"))) {
3193 i++;
3194 output = argv[i];
3195 }
3196 #endif /* LIBXML_OUTPUT_ENABLED */
3197 else if ((!strcmp(argv[i], "-htmlout")) ||
3198 (!strcmp(argv[i], "--htmlout")))
3199 htmlout++;
3200 else if ((!strcmp(argv[i], "-nowrap")) ||
3201 (!strcmp(argv[i], "--nowrap")))
3202 nowrap++;
3203 #ifdef LIBXML_HTML_ENABLED
3204 else if ((!strcmp(argv[i], "-html")) ||
3205 (!strcmp(argv[i], "--html"))) {
3206 html++;
3207 }
3208 else if ((!strcmp(argv[i], "-xmlout")) ||
3209 (!strcmp(argv[i], "--xmlout"))) {
3210 xmlout++;
3211 } else if ((!strcmp(argv[i], "-nodefdtd")) ||
3212 (!strcmp(argv[i], "--nodefdtd"))) {
3213 nodefdtd++;
3214 options |= HTML_PARSE_NODEFDTD;
3215 }
3216 #endif /* LIBXML_HTML_ENABLED */
3217 else if ((!strcmp(argv[i], "-loaddtd")) ||
3218 (!strcmp(argv[i], "--loaddtd"))) {
3219 loaddtd++;
3220 options |= XML_PARSE_DTDLOAD;
3221 } else if ((!strcmp(argv[i], "-dtdattr")) ||
3222 (!strcmp(argv[i], "--dtdattr"))) {
3223 loaddtd++;
3224 dtdattrs++;
3225 options |= XML_PARSE_DTDATTR;
3226 }
3227 #ifdef LIBXML_VALID_ENABLED
3228 else if ((!strcmp(argv[i], "-valid")) ||
3229 (!strcmp(argv[i], "--valid"))) {
3230 valid++;
3231 options |= XML_PARSE_DTDVALID;
3232 } else if ((!strcmp(argv[i], "-postvalid")) ||
3233 (!strcmp(argv[i], "--postvalid"))) {
3234 postvalid++;
3235 loaddtd++;
3236 options |= XML_PARSE_DTDLOAD;
3237 } else if ((!strcmp(argv[i], "-dtdvalid")) ||
3238 (!strcmp(argv[i], "--dtdvalid"))) {
3239 i++;
3240 dtdvalid = argv[i];
3241 loaddtd++;
3242 options |= XML_PARSE_DTDLOAD;
3243 } else if ((!strcmp(argv[i], "-dtdvalidfpi")) ||
3244 (!strcmp(argv[i], "--dtdvalidfpi"))) {
3245 i++;
3246 dtdvalidfpi = argv[i];
3247 loaddtd++;
3248 options |= XML_PARSE_DTDLOAD;
3249 }
3250 #endif /* LIBXML_VALID_ENABLED */
3251 else if ((!strcmp(argv[i], "-dropdtd")) ||
3252 (!strcmp(argv[i], "--dropdtd")))
3253 dropdtd++;
3254 else if ((!strcmp(argv[i], "-insert")) ||
3255 (!strcmp(argv[i], "--insert")))
3256 insert++;
3257 else if ((!strcmp(argv[i], "-timing")) ||
3258 (!strcmp(argv[i], "--timing")))
3259 timing++;
3260 else if ((!strcmp(argv[i], "-auto")) ||
3261 (!strcmp(argv[i], "--auto")))
3262 generate++;
3263 else if ((!strcmp(argv[i], "-repeat")) ||
3264 (!strcmp(argv[i], "--repeat"))) {
3265 if (repeat)
3266 repeat *= 10;
3267 else
3268 repeat = 100;
3269 }
3270 #ifdef LIBXML_PUSH_ENABLED
3271 else if ((!strcmp(argv[i], "-push")) ||
3272 (!strcmp(argv[i], "--push")))
3273 push++;
3274 else if ((!strcmp(argv[i], "-pushsmall")) ||
3275 (!strcmp(argv[i], "--pushsmall"))) {
3276 push++;
3277 pushsize = 10;
3278 }
3279 #endif /* LIBXML_PUSH_ENABLED */
3280 #ifdef HAVE_MMAP
3281 else if ((!strcmp(argv[i], "-memory")) ||
3282 (!strcmp(argv[i], "--memory")))
3283 memory++;
3284 #endif
3285 else if ((!strcmp(argv[i], "-testIO")) ||
3286 (!strcmp(argv[i], "--testIO")))
3287 testIO++;
3288 #ifdef LIBXML_XINCLUDE_ENABLED
3289 else if ((!strcmp(argv[i], "-xinclude")) ||
3290 (!strcmp(argv[i], "--xinclude"))) {
3291 xinclude++;
3292 options |= XML_PARSE_XINCLUDE;
3293 }
3294 else if ((!strcmp(argv[i], "-noxincludenode")) ||
3295 (!strcmp(argv[i], "--noxincludenode"))) {
3296 xinclude++;
3297 options |= XML_PARSE_XINCLUDE;
3298 options |= XML_PARSE_NOXINCNODE;
3299 }
3300 else if ((!strcmp(argv[i], "-nofixup-base-uris")) ||
3301 (!strcmp(argv[i], "--nofixup-base-uris"))) {
3302 xinclude++;
3303 options |= XML_PARSE_XINCLUDE;
3304 options |= XML_PARSE_NOBASEFIX;
3305 }
3306 #endif
3307 #ifdef LIBXML_OUTPUT_ENABLED
3308 #ifdef HAVE_ZLIB_H
3309 else if ((!strcmp(argv[i], "-compress")) ||
3310 (!strcmp(argv[i], "--compress"))) {
3311 compress++;
3312 xmlSetCompressMode(9);
3313 }
3314 #endif
3315 #endif /* LIBXML_OUTPUT_ENABLED */
3316 else if ((!strcmp(argv[i], "-nowarning")) ||
3317 (!strcmp(argv[i], "--nowarning"))) {
3318 xmlGetWarningsDefaultValue = 0;
3319 xmlPedanticParserDefault(0);
3320 options |= XML_PARSE_NOWARNING;
3321 }
3322 else if ((!strcmp(argv[i], "-pedantic")) ||
3323 (!strcmp(argv[i], "--pedantic"))) {
3324 xmlGetWarningsDefaultValue = 1;
3325 xmlPedanticParserDefault(1);
3326 options |= XML_PARSE_PEDANTIC;
3327 }
3328 #ifdef LIBXML_DEBUG_ENABLED
3329 else if ((!strcmp(argv[i], "-debugent")) ||
3330 (!strcmp(argv[i], "--debugent"))) {
3331 debugent++;
3332 xmlParserDebugEntities = 1;
3333 }
3334 #endif
3335 #ifdef LIBXML_C14N_ENABLED
3336 else if ((!strcmp(argv[i], "-c14n")) ||
3337 (!strcmp(argv[i], "--c14n"))) {
3338 canonical++;
3339 options |= XML_PARSE_NOENT | XML_PARSE_DTDATTR | XML_PARSE_DTDLOAD;
3340 }
3341 else if ((!strcmp(argv[i], "-c14n11")) ||
3342 (!strcmp(argv[i], "--c14n11"))) {
3343 canonical_11++;
3344 options |= XML_PARSE_NOENT | XML_PARSE_DTDATTR | XML_PARSE_DTDLOAD;
3345 }
3346 else if ((!strcmp(argv[i], "-exc-c14n")) ||
3347 (!strcmp(argv[i], "--exc-c14n"))) {
3348 exc_canonical++;
3349 options |= XML_PARSE_NOENT | XML_PARSE_DTDATTR | XML_PARSE_DTDLOAD;
3350 }
3351 #endif
3352 #ifdef LIBXML_CATALOG_ENABLED
3353 else if ((!strcmp(argv[i], "-catalogs")) ||
3354 (!strcmp(argv[i], "--catalogs"))) {
3355 catalogs++;
3356 } else if ((!strcmp(argv[i], "-nocatalogs")) ||
3357 (!strcmp(argv[i], "--nocatalogs"))) {
3358 nocatalogs++;
3359 }
3360 #endif
3361 else if ((!strcmp(argv[i], "-encode")) ||
3362 (!strcmp(argv[i], "--encode"))) {
3363 i++;
3364 encoding = argv[i];
3365 /*
3366 * OK it's for testing purposes
3367 */
3368 xmlAddEncodingAlias("UTF-8", "DVEnc");
3369 }
3370 else if ((!strcmp(argv[i], "-noblanks")) ||
3371 (!strcmp(argv[i], "--noblanks"))) {
3372 noblanks++;
3373 xmlKeepBlanksDefault(0);
3374 options |= XML_PARSE_NOBLANKS;
3375 }
3376 else if ((!strcmp(argv[i], "-maxmem")) ||
3377 (!strcmp(argv[i], "--maxmem"))) {
3378 i++;
3379 if (sscanf(argv[i], "%d", &maxmem) == 1) {
3380 xmlMemSetup(myFreeFunc, myMallocFunc, myReallocFunc,
3381 myStrdupFunc);
3382 } else {
3383 maxmem = 0;
3384 }
3385 }
3386 else if ((!strcmp(argv[i], "-format")) ||
3387 (!strcmp(argv[i], "--format"))) {
3388 noblanks++;
3389 #ifdef LIBXML_OUTPUT_ENABLED
3390 format = 1;
3391 #endif /* LIBXML_OUTPUT_ENABLED */
3392 xmlKeepBlanksDefault(0);
3393 }
3394 else if ((!strcmp(argv[i], "-pretty")) ||
3395 (!strcmp(argv[i], "--pretty"))) {
3396 i++;
3397 #ifdef LIBXML_OUTPUT_ENABLED
3398 if (argv[i] != NULL) {
3399 format = atoi(argv[i]);
3400 if (format == 1) {
3401 noblanks++;
3402 xmlKeepBlanksDefault(0);
3403 }
3404 }
3405 #endif /* LIBXML_OUTPUT_ENABLED */
3406 }
3407 #ifdef LIBXML_READER_ENABLED
3408 else if ((!strcmp(argv[i], "-stream")) ||
3409 (!strcmp(argv[i], "--stream"))) {
3410 stream++;
3411 }
3412 else if ((!strcmp(argv[i], "-walker")) ||
3413 (!strcmp(argv[i], "--walker"))) {
3414 walker++;
3415 noout++;
3416 }
3417 #endif /* LIBXML_READER_ENABLED */
3418 #ifdef LIBXML_SAX1_ENABLED
3419 else if ((!strcmp(argv[i], "-sax1")) ||
3420 (!strcmp(argv[i], "--sax1"))) {
3421 sax1++;
3422 options |= XML_PARSE_SAX1;
3423 }
3424 #endif /* LIBXML_SAX1_ENABLED */
3425 else if ((!strcmp(argv[i], "-sax")) ||
3426 (!strcmp(argv[i], "--sax"))) {
3427 sax++;
3428 }
3429 else if ((!strcmp(argv[i], "-chkregister")) ||
3430 (!strcmp(argv[i], "--chkregister"))) {
3431 chkregister++;
3432 #ifdef LIBXML_SCHEMAS_ENABLED
3433 } else if ((!strcmp(argv[i], "-relaxng")) ||
3434 (!strcmp(argv[i], "--relaxng"))) {
3435 i++;
3436 relaxng = argv[i];
3437 noent++;
3438 options |= XML_PARSE_NOENT;
3439 } else if ((!strcmp(argv[i], "-schema")) ||
3440 (!strcmp(argv[i], "--schema"))) {
3441 i++;
3442 schema = argv[i];
3443 noent++;
3444 #endif
3445 #ifdef LIBXML_SCHEMATRON_ENABLED
3446 } else if ((!strcmp(argv[i], "-schematron")) ||
3447 (!strcmp(argv[i], "--schematron"))) {
3448 i++;
3449 schematron = argv[i];
3450 noent++;
3451 #endif
3452 } else if ((!strcmp(argv[i], "-nonet")) ||
3453 (!strcmp(argv[i], "--nonet"))) {
3454 options |= XML_PARSE_NONET;
3455 xmlSetExternalEntityLoader(xmlNoNetExternalEntityLoader);
3456 } else if ((!strcmp(argv[i], "-nocompact")) ||
3457 (!strcmp(argv[i], "--nocompact"))) {
3458 options &= ~XML_PARSE_COMPACT;
3459 } else if ((!strcmp(argv[i], "-load-trace")) ||
3460 (!strcmp(argv[i], "--load-trace"))) {
3461 load_trace++;
3462 } else if ((!strcmp(argv[i], "-path")) ||
3463 (!strcmp(argv[i], "--path"))) {
3464 i++;
3465 parsePath(BAD_CAST argv[i]);
3466 #ifdef LIBXML_PATTERN_ENABLED
3467 } else if ((!strcmp(argv[i], "-pattern")) ||
3468 (!strcmp(argv[i], "--pattern"))) {
3469 i++;
3470 pattern = argv[i];
3471 #endif
3472 #ifdef LIBXML_XPATH_ENABLED
3473 } else if ((!strcmp(argv[i], "-xpath")) ||
3474 (!strcmp(argv[i], "--xpath"))) {
3475 i++;
3476 noout++;
3477 xpathquery = argv[i];
3478 #endif
3479 } else if ((!strcmp(argv[i], "-oldxml10")) ||
3480 (!strcmp(argv[i], "--oldxml10"))) {
3481 oldxml10++;
3482 options |= XML_PARSE_OLD10;
3483 } else {
3484 fprintf(stderr, "Unknown option %s\n", argv[i]);
3485 usage(argv[0]);
3486 return(1);
3487 }
3488 }
3489
3490 #ifdef LIBXML_CATALOG_ENABLED
3491 if (nocatalogs == 0) {
3492 if (catalogs) {
3493 const char *catal;
3494
3495 catal = getenv("SGML_CATALOG_FILES");
3496 if (catal != NULL) {
3497 xmlLoadCatalogs(catal);
3498 } else {
3499 fprintf(stderr, "Variable $SGML_CATALOG_FILES not set\n");
3500 }
3501 }
3502 }
3503 #endif
3504
3505 #ifdef LIBXML_SAX1_ENABLED
3506 if (sax1)
3507 xmlSAXDefaultVersion(1);
3508 else
3509 xmlSAXDefaultVersion(2);
3510 #endif /* LIBXML_SAX1_ENABLED */
3511
3512 if (chkregister) {
3513 xmlRegisterNodeDefault(registerNode);
3514 xmlDeregisterNodeDefault(deregisterNode);
3515 }
3516
3517 indent = getenv("XMLLINT_INDENT");
3518 if(indent != NULL) {
3519 xmlTreeIndentString = indent;
3520 }
3521
3522
3523 defaultEntityLoader = xmlGetExternalEntityLoader();
3524 xmlSetExternalEntityLoader(xmllintExternalEntityLoader);
3525
3526 xmlLineNumbersDefault(1);
3527 if (loaddtd != 0)
3528 xmlLoadExtDtdDefaultValue |= XML_DETECT_IDS;
3529 if (dtdattrs)
3530 xmlLoadExtDtdDefaultValue |= XML_COMPLETE_ATTRS;
3531 if (noent != 0) xmlSubstituteEntitiesDefault(1);
3532 #ifdef LIBXML_VALID_ENABLED
3533 if (valid != 0) xmlDoValidityCheckingDefaultValue = 1;
3534 #endif /* LIBXML_VALID_ENABLED */
3535 if ((htmlout) && (!nowrap)) {
3536 xmlGenericError(xmlGenericErrorContext,
3537 "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\"\n");
3538 xmlGenericError(xmlGenericErrorContext,
3539 "\t\"http://www.w3.org/TR/REC-html40/loose.dtd\">\n");
3540 xmlGenericError(xmlGenericErrorContext,
3541 "<html><head><title>%s output</title></head>\n",
3542 argv[0]);
3543 xmlGenericError(xmlGenericErrorContext,
3544 "<body bgcolor=\"#ffffff\"><h1 align=\"center\">%s output</h1>\n",
3545 argv[0]);
3546 }
3547
3548 #ifdef LIBXML_SCHEMATRON_ENABLED
3549 if ((schematron != NULL) && (sax == 0)
3550 #ifdef LIBXML_READER_ENABLED
3551 && (stream == 0)
3552 #endif /* LIBXML_READER_ENABLED */
3553 ) {
3554 xmlSchematronParserCtxtPtr ctxt;
3555
3556 /* forces loading the DTDs */
3557 xmlLoadExtDtdDefaultValue |= 1;
3558 options |= XML_PARSE_DTDLOAD;
3559 if (timing) {
3560 startTimer();
3561 }
3562 ctxt = xmlSchematronNewParserCtxt(schematron);
3563 #if 0
3564 xmlSchematronSetParserErrors(ctxt,
3565 (xmlSchematronValidityErrorFunc) fprintf,
3566 (xmlSchematronValidityWarningFunc) fprintf,
3567 stderr);
3568 #endif
3569 wxschematron = xmlSchematronParse(ctxt);
3570 if (wxschematron == NULL) {
3571 xmlGenericError(xmlGenericErrorContext,
3572 "Schematron schema %s failed to compile\n", schematron);
3573 progresult = XMLLINT_ERR_SCHEMACOMP;
3574 schematron = NULL;
3575 }
3576 xmlSchematronFreeParserCtxt(ctxt);
3577 if (timing) {
3578 endTimer("Compiling the schemas");
3579 }
3580 }
3581 #endif
3582 #ifdef LIBXML_SCHEMAS_ENABLED
3583 if ((relaxng != NULL) && (sax == 0)
3584 #ifdef LIBXML_READER_ENABLED
3585 && (stream == 0)
3586 #endif /* LIBXML_READER_ENABLED */
3587 ) {
3588 xmlRelaxNGParserCtxtPtr ctxt;
3589
3590 /* forces loading the DTDs */
3591 xmlLoadExtDtdDefaultValue |= 1;
3592 options |= XML_PARSE_DTDLOAD;
3593 if (timing) {
3594 startTimer();
3595 }
3596 ctxt = xmlRelaxNGNewParserCtxt(relaxng);
3597 xmlRelaxNGSetParserErrors(ctxt,
3598 (xmlRelaxNGValidityErrorFunc) fprintf,
3599 (xmlRelaxNGValidityWarningFunc) fprintf,
3600 stderr);
3601 relaxngschemas = xmlRelaxNGParse(ctxt);
3602 if (relaxngschemas == NULL) {
3603 xmlGenericError(xmlGenericErrorContext,
3604 "Relax-NG schema %s failed to compile\n", relaxng);
3605 progresult = XMLLINT_ERR_SCHEMACOMP;
3606 relaxng = NULL;
3607 }
3608 xmlRelaxNGFreeParserCtxt(ctxt);
3609 if (timing) {
3610 endTimer("Compiling the schemas");
3611 }
3612 } else if ((schema != NULL)
3613 #ifdef LIBXML_READER_ENABLED
3614 && (stream == 0)
3615 #endif
3616 ) {
3617 xmlSchemaParserCtxtPtr ctxt;
3618
3619 if (timing) {
3620 startTimer();
3621 }
3622 ctxt = xmlSchemaNewParserCtxt(schema);
3623 xmlSchemaSetParserErrors(ctxt,
3624 (xmlSchemaValidityErrorFunc) fprintf,
3625 (xmlSchemaValidityWarningFunc) fprintf,
3626 stderr);
3627 wxschemas = xmlSchemaParse(ctxt);
3628 if (wxschemas == NULL) {
3629 xmlGenericError(xmlGenericErrorContext,
3630 "WXS schema %s failed to compile\n", schema);
3631 progresult = XMLLINT_ERR_SCHEMACOMP;
3632 schema = NULL;
3633 }
3634 xmlSchemaFreeParserCtxt(ctxt);
3635 if (timing) {
3636 endTimer("Compiling the schemas");
3637 }
3638 }
3639 #endif /* LIBXML_SCHEMAS_ENABLED */
3640 #ifdef LIBXML_PATTERN_ENABLED
3641 if ((pattern != NULL)
3642 #ifdef LIBXML_READER_ENABLED
3643 && (walker == 0)
3644 #endif
3645 ) {
3646 patternc = xmlPatterncompile((const xmlChar *) pattern, NULL, 0, NULL);
3647 if (patternc == NULL) {
3648 xmlGenericError(xmlGenericErrorContext,
3649 "Pattern %s failed to compile\n", pattern);
3650 progresult = XMLLINT_ERR_SCHEMAPAT;
3651 pattern = NULL;
3652 }
3653 }
3654 #endif /* LIBXML_PATTERN_ENABLED */
3655 for (i = 1; i < argc ; i++) {
3656 if ((!strcmp(argv[i], "-encode")) ||
3657 (!strcmp(argv[i], "--encode"))) {
3658 i++;
3659 continue;
3660 } else if ((!strcmp(argv[i], "-o")) ||
3661 (!strcmp(argv[i], "-output")) ||
3662 (!strcmp(argv[i], "--output"))) {
3663 i++;
3664 continue;
3665 }
3666 #ifdef LIBXML_VALID_ENABLED
3667 if ((!strcmp(argv[i], "-dtdvalid")) ||
3668 (!strcmp(argv[i], "--dtdvalid"))) {
3669 i++;
3670 continue;
3671 }
3672 if ((!strcmp(argv[i], "-path")) ||
3673 (!strcmp(argv[i], "--path"))) {
3674 i++;
3675 continue;
3676 }
3677 if ((!strcmp(argv[i], "-dtdvalidfpi")) ||
3678 (!strcmp(argv[i], "--dtdvalidfpi"))) {
3679 i++;
3680 continue;
3681 }
3682 #endif /* LIBXML_VALID_ENABLED */
3683 if ((!strcmp(argv[i], "-relaxng")) ||
3684 (!strcmp(argv[i], "--relaxng"))) {
3685 i++;
3686 continue;
3687 }
3688 if ((!strcmp(argv[i], "-maxmem")) ||
3689 (!strcmp(argv[i], "--maxmem"))) {
3690 i++;
3691 continue;
3692 }
3693 if ((!strcmp(argv[i], "-pretty")) ||
3694 (!strcmp(argv[i], "--pretty"))) {
3695 i++;
3696 continue;
3697 }
3698 if ((!strcmp(argv[i], "-schema")) ||
3699 (!strcmp(argv[i], "--schema"))) {
3700 i++;
3701 continue;
3702 }
3703 if ((!strcmp(argv[i], "-schematron")) ||
3704 (!strcmp(argv[i], "--schematron"))) {
3705 i++;
3706 continue;
3707 }
3708 #ifdef LIBXML_PATTERN_ENABLED
3709 if ((!strcmp(argv[i], "-pattern")) ||
3710 (!strcmp(argv[i], "--pattern"))) {
3711 i++;
3712 continue;
3713 }
3714 #endif
3715 #ifdef LIBXML_XPATH_ENABLED
3716 if ((!strcmp(argv[i], "-xpath")) ||
3717 (!strcmp(argv[i], "--xpath"))) {
3718 i++;
3719 continue;
3720 }
3721 #endif
3722 if ((timing) && (repeat))
3723 startTimer();
3724 /* Remember file names. "-" means stdin. <sven@zen.org> */
3725 if ((argv[i][0] != '-') || (strcmp(argv[i], "-") == 0)) {
3726 if (repeat) {
3727 xmlParserCtxtPtr ctxt = NULL;
3728
3729 for (acount = 0;acount < repeat;acount++) {
3730 #ifdef LIBXML_READER_ENABLED
3731 if (stream != 0) {
3732 streamFile(argv[i]);
3733 } else {
3734 #endif /* LIBXML_READER_ENABLED */
3735 if (sax) {
3736 testSAX(argv[i]);
3737 } else {
3738 if (ctxt == NULL)
3739 ctxt = xmlNewParserCtxt();
3740 parseAndPrintFile(argv[i], ctxt);
3741 }
3742 #ifdef LIBXML_READER_ENABLED
3743 }
3744 #endif /* LIBXML_READER_ENABLED */
3745 }
3746 if (ctxt != NULL)
3747 xmlFreeParserCtxt(ctxt);
3748 } else {
3749 nbregister = 0;
3750
3751 #ifdef LIBXML_READER_ENABLED
3752 if (stream != 0)
3753 streamFile(argv[i]);
3754 else
3755 #endif /* LIBXML_READER_ENABLED */
3756 if (sax) {
3757 testSAX(argv[i]);
3758 } else {
3759 parseAndPrintFile(argv[i], NULL);
3760 }
3761
3762 if ((chkregister) && (nbregister != 0)) {
3763 fprintf(stderr, "Registration count off: %d\n", nbregister);
3764 progresult = XMLLINT_ERR_RDREGIS;
3765 }
3766 }
3767 files ++;
3768 if ((timing) && (repeat)) {
3769 endTimer("%d iterations", repeat);
3770 }
3771 }
3772 }
3773 if (generate)
3774 parseAndPrintFile(NULL, NULL);
3775 if ((htmlout) && (!nowrap)) {
3776 xmlGenericError(xmlGenericErrorContext, "</body></html>\n");
3777 }
3778 if ((files == 0) && (!generate) && (version == 0)) {
3779 usage(argv[0]);
3780 }
3781 #ifdef LIBXML_SCHEMATRON_ENABLED
3782 if (wxschematron != NULL)
3783 xmlSchematronFree(wxschematron);
3784 #endif
3785 #ifdef LIBXML_SCHEMAS_ENABLED
3786 if (relaxngschemas != NULL)
3787 xmlRelaxNGFree(relaxngschemas);
3788 if (wxschemas != NULL)
3789 xmlSchemaFree(wxschemas);
3790 xmlRelaxNGCleanupTypes();
3791 #endif
3792 #ifdef LIBXML_PATTERN_ENABLED
3793 if (patternc != NULL)
3794 xmlFreePattern(patternc);
3795 #endif
3796 xmlCleanupParser();
3797 xmlMemoryDump();
3798
3799 return(progresult);
3800 }
3801
OLDNEW
« third_party/libxml/src/COPYING ('K') | « third_party/libxml/src/xmlcatalog.c ('k') | third_party/libxml/src/xmlreader.c » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698