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