1: /*
2: * testSAX.c : a small tester program for parsing using the SAX API.
3: *
4: * See Copyright for the status of this software.
5: *
6: * daniel@veillard.com
7: */
8:
9: #include "libxml.h"
10:
11: #ifdef HAVE_SYS_TIME_H
12: #include <sys/time.h>
13: #endif
14: #ifdef HAVE_SYS_TIMEB_H
15: #include <sys/timeb.h>
16: #endif
17: #ifdef HAVE_TIME_H
18: #include <time.h>
19: #endif
20:
21: #ifdef LIBXML_SAX1_ENABLED
22: #include <string.h>
23: #include <stdarg.h>
24:
25: #ifdef HAVE_SYS_TYPES_H
26: #include <sys/types.h>
27: #endif
28: #ifdef HAVE_SYS_STAT_H
29: #include <sys/stat.h>
30: #endif
31: #ifdef HAVE_FCNTL_H
32: #include <fcntl.h>
33: #endif
34: #ifdef HAVE_UNISTD_H
35: #include <unistd.h>
36: #endif
37: #ifdef HAVE_STDLIB_H
38: #include <stdlib.h>
39: #endif
40: #ifdef HAVE_STRING_H
41: #include <string.h>
42: #endif
43:
44:
45: #include <libxml/globals.h>
46: #include <libxml/xmlerror.h>
47: #include <libxml/parser.h>
48: #include <libxml/parserInternals.h> /* only for xmlNewInputFromFile() */
49: #include <libxml/tree.h>
50: #include <libxml/debugXML.h>
51: #include <libxml/xmlmemory.h>
52:
53: static int debug = 0;
54: static int copy = 0;
55: static int recovery = 0;
56: static int push = 0;
57: static int speed = 0;
58: static int noent = 0;
59: static int quiet = 0;
60: static int nonull = 0;
61: static int sax2 = 0;
62: static int repeat = 0;
63: static int callbacks = 0;
64: static int timing = 0;
65:
66: /*
67: * Timing routines.
68: */
69: /*
70: * Internal timing routines to remove the necessity to have unix-specific
71: * function calls
72: */
73:
74: #ifndef HAVE_GETTIMEOFDAY
75: #ifdef HAVE_SYS_TIMEB_H
76: #ifdef HAVE_SYS_TIME_H
77: #ifdef HAVE_FTIME
78:
79: static int
80: my_gettimeofday(struct timeval *tvp, void *tzp)
81: {
82: struct timeb timebuffer;
83:
84: ftime(&timebuffer);
85: if (tvp) {
86: tvp->tv_sec = timebuffer.time;
87: tvp->tv_usec = timebuffer.millitm * 1000L;
88: }
89: return (0);
90: }
91: #define HAVE_GETTIMEOFDAY 1
92: #define gettimeofday my_gettimeofday
93:
94: #endif /* HAVE_FTIME */
95: #endif /* HAVE_SYS_TIME_H */
96: #endif /* HAVE_SYS_TIMEB_H */
97: #endif /* !HAVE_GETTIMEOFDAY */
98:
99: #if defined(HAVE_GETTIMEOFDAY)
100: static struct timeval begin, end;
101:
102: /*
103: * startTimer: call where you want to start timing
104: */
105: static void
106: startTimer(void)
107: {
108: gettimeofday(&begin, NULL);
109: }
110:
111: /*
112: * endTimer: call where you want to stop timing and to print out a
113: * message about the timing performed; format is a printf
114: * type argument
115: */
116: static void XMLCDECL
117: endTimer(const char *fmt, ...)
118: {
119: long msec;
120: va_list ap;
121:
122: gettimeofday(&end, NULL);
123: msec = end.tv_sec - begin.tv_sec;
124: msec *= 1000;
125: msec += (end.tv_usec - begin.tv_usec) / 1000;
126:
127: #ifndef HAVE_STDARG_H
128: #error "endTimer required stdarg functions"
129: #endif
130: va_start(ap, fmt);
131: vfprintf(stderr, fmt, ap);
132: va_end(ap);
133:
134: fprintf(stderr, " took %ld ms\n", msec);
135: }
136: #elif defined(HAVE_TIME_H)
137: /*
138: * No gettimeofday function, so we have to make do with calling clock.
139: * This is obviously less accurate, but there's little we can do about
140: * that.
141: */
142: #ifndef CLOCKS_PER_SEC
143: #define CLOCKS_PER_SEC 100
144: #endif
145:
146: static clock_t begin, end;
147: static void
148: startTimer(void)
149: {
150: begin = clock();
151: }
152: static void XMLCDECL
153: endTimer(const char *fmt, ...)
154: {
155: long msec;
156: va_list ap;
157:
158: end = clock();
159: msec = ((end - begin) * 1000) / CLOCKS_PER_SEC;
160:
161: #ifndef HAVE_STDARG_H
162: #error "endTimer required stdarg functions"
163: #endif
164: va_start(ap, fmt);
165: vfprintf(stderr, fmt, ap);
166: va_end(ap);
167: fprintf(stderr, " took %ld ms\n", msec);
168: }
169: #else
170:
171: /*
172: * We don't have a gettimeofday or time.h, so we just don't do timing
173: */
174: static void
175: startTimer(void)
176: {
177: /*
178: * Do nothing
179: */
180: }
181: static void XMLCDECL
182: endTimer(char *format, ...)
183: {
184: /*
185: * We cannot do anything because we don't have a timing function
186: */
187: #ifdef HAVE_STDARG_H
188: va_start(ap, format);
189: vfprintf(stderr, format, ap);
190: va_end(ap);
191: fprintf(stderr, " was not timed\n", msec);
192: #else
193: /* We don't have gettimeofday, time or stdarg.h, what crazy world is
194: * this ?!
195: */
196: #endif
197: }
198: #endif
199:
200: /*
201: * empty SAX block
202: */
203: static xmlSAXHandler emptySAXHandlerStruct = {
204: NULL, /* internalSubset */
205: NULL, /* isStandalone */
206: NULL, /* hasInternalSubset */
207: NULL, /* hasExternalSubset */
208: NULL, /* resolveEntity */
209: NULL, /* getEntity */
210: NULL, /* entityDecl */
211: NULL, /* notationDecl */
212: NULL, /* attributeDecl */
213: NULL, /* elementDecl */
214: NULL, /* unparsedEntityDecl */
215: NULL, /* setDocumentLocator */
216: NULL, /* startDocument */
217: NULL, /* endDocument */
218: NULL, /* startElement */
219: NULL, /* endElement */
220: NULL, /* reference */
221: NULL, /* characters */
222: NULL, /* ignorableWhitespace */
223: NULL, /* processingInstruction */
224: NULL, /* comment */
225: NULL, /* xmlParserWarning */
226: NULL, /* xmlParserError */
227: NULL, /* xmlParserError */
228: NULL, /* getParameterEntity */
229: NULL, /* cdataBlock; */
230: NULL, /* externalSubset; */
231: 1,
232: NULL,
233: NULL, /* startElementNs */
234: NULL, /* endElementNs */
235: NULL /* xmlStructuredErrorFunc */
236: };
237:
238: static xmlSAXHandlerPtr emptySAXHandler = &emptySAXHandlerStruct;
239: extern xmlSAXHandlerPtr debugSAXHandler;
240:
241: /************************************************************************
242: * *
243: * Debug Handlers *
244: * *
245: ************************************************************************/
246:
247: /**
248: * isStandaloneDebug:
249: * @ctxt: An XML parser context
250: *
251: * Is this document tagged standalone ?
252: *
253: * Returns 1 if true
254: */
255: static int
256: isStandaloneDebug(void *ctx ATTRIBUTE_UNUSED)
257: {
258: callbacks++;
259: if (quiet)
260: return(0);
261: fprintf(stdout, "SAX.isStandalone()\n");
262: return(0);
263: }
264:
265: /**
266: * hasInternalSubsetDebug:
267: * @ctxt: An XML parser context
268: *
269: * Does this document has an internal subset
270: *
271: * Returns 1 if true
272: */
273: static int
274: hasInternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
275: {
276: callbacks++;
277: if (quiet)
278: return(0);
279: fprintf(stdout, "SAX.hasInternalSubset()\n");
280: return(0);
281: }
282:
283: /**
284: * hasExternalSubsetDebug:
285: * @ctxt: An XML parser context
286: *
287: * Does this document has an external subset
288: *
289: * Returns 1 if true
290: */
291: static int
292: hasExternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
293: {
294: callbacks++;
295: if (quiet)
296: return(0);
297: fprintf(stdout, "SAX.hasExternalSubset()\n");
298: return(0);
299: }
300:
301: /**
302: * internalSubsetDebug:
303: * @ctxt: An XML parser context
304: *
305: * Does this document has an internal subset
306: */
307: static void
308: internalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
309: const xmlChar *ExternalID, const xmlChar *SystemID)
310: {
311: callbacks++;
312: if (quiet)
313: return;
314: fprintf(stdout, "SAX.internalSubset(%s,", name);
315: if (ExternalID == NULL)
316: fprintf(stdout, " ,");
317: else
318: fprintf(stdout, " %s,", ExternalID);
319: if (SystemID == NULL)
320: fprintf(stdout, " )\n");
321: else
322: fprintf(stdout, " %s)\n", SystemID);
323: }
324:
325: /**
326: * externalSubsetDebug:
327: * @ctxt: An XML parser context
328: *
329: * Does this document has an external subset
330: */
331: static void
332: externalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
333: const xmlChar *ExternalID, const xmlChar *SystemID)
334: {
335: callbacks++;
336: if (quiet)
337: return;
338: fprintf(stdout, "SAX.externalSubset(%s,", name);
339: if (ExternalID == NULL)
340: fprintf(stdout, " ,");
341: else
342: fprintf(stdout, " %s,", ExternalID);
343: if (SystemID == NULL)
344: fprintf(stdout, " )\n");
345: else
346: fprintf(stdout, " %s)\n", SystemID);
347: }
348:
349: /**
350: * resolveEntityDebug:
351: * @ctxt: An XML parser context
352: * @publicId: The public ID of the entity
353: * @systemId: The system ID of the entity
354: *
355: * Special entity resolver, better left to the parser, it has
356: * more context than the application layer.
357: * The default behaviour is to NOT resolve the entities, in that case
358: * the ENTITY_REF nodes are built in the structure (and the parameter
359: * values).
360: *
361: * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
362: */
363: static xmlParserInputPtr
364: resolveEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *publicId, const xmlChar *systemId)
365: {
366: callbacks++;
367: if (quiet)
368: return(NULL);
369: /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
370:
371:
372: fprintf(stdout, "SAX.resolveEntity(");
373: if (publicId != NULL)
374: fprintf(stdout, "%s", (char *)publicId);
375: else
376: fprintf(stdout, " ");
377: if (systemId != NULL)
378: fprintf(stdout, ", %s)\n", (char *)systemId);
379: else
380: fprintf(stdout, ", )\n");
381: /*********
382: if (systemId != NULL) {
383: return(xmlNewInputFromFile(ctxt, (char *) systemId));
384: }
385: *********/
386: return(NULL);
387: }
388:
389: /**
390: * getEntityDebug:
391: * @ctxt: An XML parser context
392: * @name: The entity name
393: *
394: * Get an entity by name
395: *
396: * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
397: */
398: static xmlEntityPtr
399: getEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
400: {
401: callbacks++;
402: if (quiet)
403: return(NULL);
404: fprintf(stdout, "SAX.getEntity(%s)\n", name);
405: return(NULL);
406: }
407:
408: /**
409: * getParameterEntityDebug:
410: * @ctxt: An XML parser context
411: * @name: The entity name
412: *
413: * Get a parameter entity by name
414: *
415: * Returns the xmlParserInputPtr
416: */
417: static xmlEntityPtr
418: getParameterEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
419: {
420: callbacks++;
421: if (quiet)
422: return(NULL);
423: fprintf(stdout, "SAX.getParameterEntity(%s)\n", name);
424: return(NULL);
425: }
426:
427:
428: /**
429: * entityDeclDebug:
430: * @ctxt: An XML parser context
431: * @name: the entity name
432: * @type: the entity type
433: * @publicId: The public ID of the entity
434: * @systemId: The system ID of the entity
435: * @content: the entity value (without processing).
436: *
437: * An entity definition has been parsed
438: */
439: static void
440: entityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
441: const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
442: {
443: const xmlChar *nullstr = BAD_CAST "(null)";
444: /* not all libraries handle printing null pointers nicely */
445: if (publicId == NULL)
446: publicId = nullstr;
447: if (systemId == NULL)
448: systemId = nullstr;
449: if (content == NULL)
450: content = (xmlChar *)nullstr;
451: callbacks++;
452: if (quiet)
453: return;
454: fprintf(stdout, "SAX.entityDecl(%s, %d, %s, %s, %s)\n",
455: name, type, publicId, systemId, content);
456: }
457:
458: /**
459: * attributeDeclDebug:
460: * @ctxt: An XML parser context
461: * @name: the attribute name
462: * @type: the attribute type
463: *
464: * An attribute definition has been parsed
465: */
466: static void
467: attributeDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar * elem,
468: const xmlChar * name, int type, int def,
469: const xmlChar * defaultValue, xmlEnumerationPtr tree)
470: {
471: callbacks++;
472: if (quiet)
473: return;
474: if (defaultValue == NULL)
475: fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, NULL, ...)\n",
476: elem, name, type, def);
477: else
478: fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, %s, ...)\n",
479: elem, name, type, def, defaultValue);
480: xmlFreeEnumeration(tree);
481: }
482:
483: /**
484: * elementDeclDebug:
485: * @ctxt: An XML parser context
486: * @name: the element name
487: * @type: the element type
488: * @content: the element value (without processing).
489: *
490: * An element definition has been parsed
491: */
492: static void
493: elementDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
494: xmlElementContentPtr content ATTRIBUTE_UNUSED)
495: {
496: callbacks++;
497: if (quiet)
498: return;
499: fprintf(stdout, "SAX.elementDecl(%s, %d, ...)\n",
500: name, type);
501: }
502:
503: /**
504: * notationDeclDebug:
505: * @ctxt: An XML parser context
506: * @name: The name of the notation
507: * @publicId: The public ID of the entity
508: * @systemId: The system ID of the entity
509: *
510: * What to do when a notation declaration has been parsed.
511: */
512: static void
513: notationDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
514: const xmlChar *publicId, const xmlChar *systemId)
515: {
516: callbacks++;
517: if (quiet)
518: return;
519: fprintf(stdout, "SAX.notationDecl(%s, %s, %s)\n",
520: (char *) name, (char *) publicId, (char *) systemId);
521: }
522:
523: /**
524: * unparsedEntityDeclDebug:
525: * @ctxt: An XML parser context
526: * @name: The name of the entity
527: * @publicId: The public ID of the entity
528: * @systemId: The system ID of the entity
529: * @notationName: the name of the notation
530: *
531: * What to do when an unparsed entity declaration is parsed
532: */
533: static void
534: unparsedEntityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
535: const xmlChar *publicId, const xmlChar *systemId,
536: const xmlChar *notationName)
537: {
538: const xmlChar *nullstr = BAD_CAST "(null)";
539:
540: if (publicId == NULL)
541: publicId = nullstr;
542: if (systemId == NULL)
543: systemId = nullstr;
544: if (notationName == NULL)
545: notationName = nullstr;
546: callbacks++;
547: if (quiet)
548: return;
549: fprintf(stdout, "SAX.unparsedEntityDecl(%s, %s, %s, %s)\n",
550: (char *) name, (char *) publicId, (char *) systemId,
551: (char *) notationName);
552: }
553:
554: /**
555: * setDocumentLocatorDebug:
556: * @ctxt: An XML parser context
557: * @loc: A SAX Locator
558: *
559: * Receive the document locator at startup, actually xmlDefaultSAXLocator
560: * Everything is available on the context, so this is useless in our case.
561: */
562: static void
563: setDocumentLocatorDebug(void *ctx ATTRIBUTE_UNUSED, xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
564: {
565: callbacks++;
566: if (quiet)
567: return;
568: fprintf(stdout, "SAX.setDocumentLocator()\n");
569: }
570:
571: /**
572: * startDocumentDebug:
573: * @ctxt: An XML parser context
574: *
575: * called when the document start being processed.
576: */
577: static void
578: startDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
579: {
580: callbacks++;
581: if (quiet)
582: return;
583: fprintf(stdout, "SAX.startDocument()\n");
584: }
585:
586: /**
587: * endDocumentDebug:
588: * @ctxt: An XML parser context
589: *
590: * called when the document end has been detected.
591: */
592: static void
593: endDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
594: {
595: callbacks++;
596: if (quiet)
597: return;
598: fprintf(stdout, "SAX.endDocument()\n");
599: }
600:
601: /**
602: * startElementDebug:
603: * @ctxt: An XML parser context
604: * @name: The element name
605: *
606: * called when an opening tag has been processed.
607: */
608: static void
609: startElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, const xmlChar **atts)
610: {
611: int i;
612:
613: callbacks++;
614: if (quiet)
615: return;
616: fprintf(stdout, "SAX.startElement(%s", (char *) name);
617: if (atts != NULL) {
618: for (i = 0;(atts[i] != NULL);i++) {
619: fprintf(stdout, ", %s='", atts[i++]);
620: if (atts[i] != NULL)
621: fprintf(stdout, "%s'", atts[i]);
622: }
623: }
624: fprintf(stdout, ")\n");
625: }
626:
627: /**
628: * endElementDebug:
629: * @ctxt: An XML parser context
630: * @name: The element name
631: *
632: * called when the end of an element has been detected.
633: */
634: static void
635: endElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
636: {
637: callbacks++;
638: if (quiet)
639: return;
640: fprintf(stdout, "SAX.endElement(%s)\n", (char *) name);
641: }
642:
643: /**
644: * charactersDebug:
645: * @ctxt: An XML parser context
646: * @ch: a xmlChar string
647: * @len: the number of xmlChar
648: *
649: * receiving some chars from the parser.
650: * Question: how much at a time ???
651: */
652: static void
653: charactersDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
654: {
655: char output[40];
656: int i;
657:
658: callbacks++;
659: if (quiet)
660: return;
661: for (i = 0;(i<len) && (i < 30);i++)
662: output[i] = ch[i];
663: output[i] = 0;
664:
665: fprintf(stdout, "SAX.characters(%s, %d)\n", output, len);
666: }
667:
668: /**
669: * referenceDebug:
670: * @ctxt: An XML parser context
671: * @name: The entity name
672: *
673: * called when an entity reference is detected.
674: */
675: static void
676: referenceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
677: {
678: callbacks++;
679: if (quiet)
680: return;
681: fprintf(stdout, "SAX.reference(%s)\n", name);
682: }
683:
684: /**
685: * ignorableWhitespaceDebug:
686: * @ctxt: An XML parser context
687: * @ch: a xmlChar string
688: * @start: the first char in the string
689: * @len: the number of xmlChar
690: *
691: * receiving some ignorable whitespaces from the parser.
692: * Question: how much at a time ???
693: */
694: static void
695: ignorableWhitespaceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
696: {
697: char output[40];
698: int i;
699:
700: callbacks++;
701: if (quiet)
702: return;
703: for (i = 0;(i<len) && (i < 30);i++)
704: output[i] = ch[i];
705: output[i] = 0;
706: fprintf(stdout, "SAX.ignorableWhitespace(%s, %d)\n", output, len);
707: }
708:
709: /**
710: * processingInstructionDebug:
711: * @ctxt: An XML parser context
712: * @target: the target name
713: * @data: the PI data's
714: * @len: the number of xmlChar
715: *
716: * A processing instruction has been parsed.
717: */
718: static void
719: processingInstructionDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *target,
720: const xmlChar *data)
721: {
722: callbacks++;
723: if (quiet)
724: return;
725: if (data != NULL)
726: fprintf(stdout, "SAX.processingInstruction(%s, %s)\n",
727: (char *) target, (char *) data);
728: else
729: fprintf(stdout, "SAX.processingInstruction(%s, NULL)\n",
730: (char *) target);
731: }
732:
733: /**
734: * cdataBlockDebug:
735: * @ctx: the user data (XML parser context)
736: * @value: The pcdata content
737: * @len: the block length
738: *
739: * called when a pcdata block has been parsed
740: */
741: static void
742: cdataBlockDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value, int len)
743: {
744: callbacks++;
745: if (quiet)
746: return;
747: fprintf(stdout, "SAX.pcdata(%.20s, %d)\n",
748: (char *) value, len);
749: }
750:
751: /**
752: * commentDebug:
753: * @ctxt: An XML parser context
754: * @value: the comment content
755: *
756: * A comment has been parsed.
757: */
758: static void
759: commentDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value)
760: {
761: callbacks++;
762: if (quiet)
763: return;
764: fprintf(stdout, "SAX.comment(%s)\n", value);
765: }
766:
767: /**
768: * warningDebug:
769: * @ctxt: An XML parser context
770: * @msg: the message to display/transmit
771: * @...: extra parameters for the message display
772: *
773: * Display and format a warning messages, gives file, line, position and
774: * extra parameters.
775: */
776: static void XMLCDECL
777: warningDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
778: {
779: va_list args;
780:
781: callbacks++;
782: if (quiet)
783: return;
784: va_start(args, msg);
785: fprintf(stdout, "SAX.warning: ");
786: vfprintf(stdout, msg, args);
787: va_end(args);
788: }
789:
790: /**
791: * errorDebug:
792: * @ctxt: An XML parser context
793: * @msg: the message to display/transmit
794: * @...: extra parameters for the message display
795: *
796: * Display and format a error messages, gives file, line, position and
797: * extra parameters.
798: */
799: static void XMLCDECL
800: errorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
801: {
802: va_list args;
803:
804: callbacks++;
805: if (quiet)
806: return;
807: va_start(args, msg);
808: fprintf(stdout, "SAX.error: ");
809: vfprintf(stdout, msg, args);
810: va_end(args);
811: }
812:
813: /**
814: * fatalErrorDebug:
815: * @ctxt: An XML parser context
816: * @msg: the message to display/transmit
817: * @...: extra parameters for the message display
818: *
819: * Display and format a fatalError messages, gives file, line, position and
820: * extra parameters.
821: */
822: static void XMLCDECL
823: fatalErrorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
824: {
825: va_list args;
826:
827: callbacks++;
828: if (quiet)
829: return;
830: va_start(args, msg);
831: fprintf(stdout, "SAX.fatalError: ");
832: vfprintf(stdout, msg, args);
833: va_end(args);
834: }
835:
836: static xmlSAXHandler debugSAXHandlerStruct = {
837: internalSubsetDebug,
838: isStandaloneDebug,
839: hasInternalSubsetDebug,
840: hasExternalSubsetDebug,
841: resolveEntityDebug,
842: getEntityDebug,
843: entityDeclDebug,
844: notationDeclDebug,
845: attributeDeclDebug,
846: elementDeclDebug,
847: unparsedEntityDeclDebug,
848: setDocumentLocatorDebug,
849: startDocumentDebug,
850: endDocumentDebug,
851: startElementDebug,
852: endElementDebug,
853: referenceDebug,
854: charactersDebug,
855: ignorableWhitespaceDebug,
856: processingInstructionDebug,
857: commentDebug,
858: warningDebug,
859: errorDebug,
860: fatalErrorDebug,
861: getParameterEntityDebug,
862: cdataBlockDebug,
863: externalSubsetDebug,
864: 1,
865: NULL,
866: NULL,
867: NULL,
868: NULL
869: };
870:
871: xmlSAXHandlerPtr debugSAXHandler = &debugSAXHandlerStruct;
872:
873: /*
874: * SAX2 specific callbacks
875: */
876: /**
877: * startElementNsDebug:
878: * @ctxt: An XML parser context
879: * @name: The element name
880: *
881: * called when an opening tag has been processed.
882: */
883: static void
884: startElementNsDebug(void *ctx ATTRIBUTE_UNUSED,
885: const xmlChar *localname,
886: const xmlChar *prefix,
887: const xmlChar *URI,
888: int nb_namespaces,
889: const xmlChar **namespaces,
890: int nb_attributes,
891: int nb_defaulted,
892: const xmlChar **attributes)
893: {
894: int i;
895:
896: callbacks++;
897: if (quiet)
898: return;
899: fprintf(stdout, "SAX.startElementNs(%s", (char *) localname);
900: if (prefix == NULL)
901: fprintf(stdout, ", NULL");
902: else
903: fprintf(stdout, ", %s", (char *) prefix);
904: if (URI == NULL)
905: fprintf(stdout, ", NULL");
906: else
907: fprintf(stdout, ", '%s'", (char *) URI);
908: fprintf(stdout, ", %d", nb_namespaces);
909:
910: if (namespaces != NULL) {
911: for (i = 0;i < nb_namespaces * 2;i++) {
912: fprintf(stdout, ", xmlns");
913: if (namespaces[i] != NULL)
914: fprintf(stdout, ":%s", namespaces[i]);
915: i++;
916: fprintf(stdout, "='%s'", namespaces[i]);
917: }
918: }
919: fprintf(stdout, ", %d, %d", nb_attributes, nb_defaulted);
920: if (attributes != NULL) {
921: for (i = 0;i < nb_attributes * 5;i += 5) {
922: if (attributes[i + 1] != NULL)
923: fprintf(stdout, ", %s:%s='", attributes[i + 1], attributes[i]);
924: else
925: fprintf(stdout, ", %s='", attributes[i]);
926: fprintf(stdout, "%.4s...', %d", attributes[i + 3],
927: (int)(attributes[i + 4] - attributes[i + 3]));
928: }
929: }
930: fprintf(stdout, ")\n");
931: }
932:
933: /**
934: * endElementDebug:
935: * @ctxt: An XML parser context
936: * @name: The element name
937: *
938: * called when the end of an element has been detected.
939: */
940: static void
941: endElementNsDebug(void *ctx ATTRIBUTE_UNUSED,
942: const xmlChar *localname,
943: const xmlChar *prefix,
944: const xmlChar *URI)
945: {
946: callbacks++;
947: if (quiet)
948: return;
949: fprintf(stdout, "SAX.endElementNs(%s", (char *) localname);
950: if (prefix == NULL)
951: fprintf(stdout, ", NULL");
952: else
953: fprintf(stdout, ", %s", (char *) prefix);
954: if (URI == NULL)
955: fprintf(stdout, ", NULL)\n");
956: else
957: fprintf(stdout, ", '%s')\n", (char *) URI);
958: }
959:
960: static xmlSAXHandler debugSAX2HandlerStruct = {
961: internalSubsetDebug,
962: isStandaloneDebug,
963: hasInternalSubsetDebug,
964: hasExternalSubsetDebug,
965: resolveEntityDebug,
966: getEntityDebug,
967: entityDeclDebug,
968: notationDeclDebug,
969: attributeDeclDebug,
970: elementDeclDebug,
971: unparsedEntityDeclDebug,
972: setDocumentLocatorDebug,
973: startDocumentDebug,
974: endDocumentDebug,
975: NULL,
976: NULL,
977: referenceDebug,
978: charactersDebug,
979: ignorableWhitespaceDebug,
980: processingInstructionDebug,
981: commentDebug,
982: warningDebug,
983: errorDebug,
984: fatalErrorDebug,
985: getParameterEntityDebug,
986: cdataBlockDebug,
987: externalSubsetDebug,
988: XML_SAX2_MAGIC,
989: NULL,
990: startElementNsDebug,
991: endElementNsDebug,
992: NULL
993: };
994:
995: static xmlSAXHandlerPtr debugSAX2Handler = &debugSAX2HandlerStruct;
996:
997: /************************************************************************
998: * *
999: * Debug *
1000: * *
1001: ************************************************************************/
1002:
1003: static void
1004: parseAndPrintFile(char *filename) {
1005: int res;
1006:
1007: #ifdef LIBXML_PUSH_ENABLED
1008: if (push) {
1009: FILE *f;
1010:
1011: if ((!quiet) && (!nonull)) {
1012: /*
1013: * Empty callbacks for checking
1014: */
1015: #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
1016: f = fopen(filename, "rb");
1017: #else
1018: f = fopen(filename, "r");
1019: #endif
1020: if (f != NULL) {
1021: int ret;
1022: char chars[10];
1023: xmlParserCtxtPtr ctxt;
1024:
1025: ret = fread(chars, 1, 4, f);
1026: if (ret > 0) {
1027: ctxt = xmlCreatePushParserCtxt(emptySAXHandler, NULL,
1028: chars, ret, filename);
1029: while ((ret = fread(chars, 1, 3, f)) > 0) {
1030: xmlParseChunk(ctxt, chars, ret, 0);
1031: }
1032: xmlParseChunk(ctxt, chars, 0, 1);
1033: xmlFreeParserCtxt(ctxt);
1034: }
1035: fclose(f);
1036: } else {
1037: xmlGenericError(xmlGenericErrorContext,
1038: "Cannot read file %s\n", filename);
1039: }
1040: }
1041: /*
1042: * Debug callback
1043: */
1044: #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
1045: f = fopen(filename, "rb");
1046: #else
1047: f = fopen(filename, "r");
1048: #endif
1049: if (f != NULL) {
1050: int ret;
1051: char chars[10];
1052: xmlParserCtxtPtr ctxt;
1053:
1054: ret = fread(chars, 1, 4, f);
1055: if (ret > 0) {
1056: if (sax2)
1057: ctxt = xmlCreatePushParserCtxt(debugSAX2Handler, NULL,
1058: chars, ret, filename);
1059: else
1060: ctxt = xmlCreatePushParserCtxt(debugSAXHandler, NULL,
1061: chars, ret, filename);
1062: while ((ret = fread(chars, 1, 3, f)) > 0) {
1063: xmlParseChunk(ctxt, chars, ret, 0);
1064: }
1065: ret = xmlParseChunk(ctxt, chars, 0, 1);
1066: xmlFreeParserCtxt(ctxt);
1067: if (ret != 0) {
1068: fprintf(stdout,
1069: "xmlSAXUserParseFile returned error %d\n", ret);
1070: }
1071: }
1072: fclose(f);
1073: }
1074: } else {
1075: #endif /* LIBXML_PUSH_ENABLED */
1076: if (!speed) {
1077: /*
1078: * Empty callbacks for checking
1079: */
1080: if ((!quiet) && (!nonull)) {
1081: res = xmlSAXUserParseFile(emptySAXHandler, NULL, filename);
1082: if (res != 0) {
1083: fprintf(stdout, "xmlSAXUserParseFile returned error %d\n", res);
1084: }
1085: }
1086:
1087: /*
1088: * Debug callback
1089: */
1090: callbacks = 0;
1091: if (repeat) {
1092: int i;
1093: for (i = 0;i < 99;i++) {
1094: if (sax2)
1095: res = xmlSAXUserParseFile(debugSAX2Handler, NULL,
1096: filename);
1097: else
1098: res = xmlSAXUserParseFile(debugSAXHandler, NULL,
1099: filename);
1100: }
1101: }
1102: if (sax2)
1103: res = xmlSAXUserParseFile(debugSAX2Handler, NULL, filename);
1104: else
1105: res = xmlSAXUserParseFile(debugSAXHandler, NULL, filename);
1106: if (res != 0) {
1107: fprintf(stdout, "xmlSAXUserParseFile returned error %d\n", res);
1108: }
1109: if (quiet)
1110: fprintf(stdout, "%d callbacks generated\n", callbacks);
1111: } else {
1112: /*
1113: * test 100x the SAX parse
1114: */
1115: int i;
1116:
1117: for (i = 0; i<100;i++)
1118: res = xmlSAXUserParseFile(emptySAXHandler, NULL, filename);
1119: if (res != 0) {
1120: fprintf(stdout, "xmlSAXUserParseFile returned error %d\n", res);
1121: }
1122: }
1123: #ifdef LIBXML_PUSH_ENABLED
1124: }
1125: #endif
1126: }
1127:
1128:
1129: int main(int argc, char **argv) {
1130: int i;
1131: int files = 0;
1132:
1133: LIBXML_TEST_VERSION /* be safe, plus calls xmlInitParser */
1134:
1135: for (i = 1; i < argc ; i++) {
1136: if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
1137: debug++;
1138: else if ((!strcmp(argv[i], "-copy")) || (!strcmp(argv[i], "--copy")))
1139: copy++;
1140: else if ((!strcmp(argv[i], "-recover")) ||
1141: (!strcmp(argv[i], "--recover")))
1142: recovery++;
1143: else if ((!strcmp(argv[i], "-push")) ||
1144: (!strcmp(argv[i], "--push")))
1145: #ifdef LIBXML_PUSH_ENABLED
1146: push++;
1147: #else
1148: fprintf(stderr,"'push' not enabled in library - ignoring\n");
1149: #endif /* LIBXML_PUSH_ENABLED */
1150: else if ((!strcmp(argv[i], "-speed")) ||
1151: (!strcmp(argv[i], "--speed")))
1152: speed++;
1153: else if ((!strcmp(argv[i], "-timing")) ||
1154: (!strcmp(argv[i], "--timing"))) {
1155: nonull++;
1156: timing++;
1157: quiet++;
1158: } else if ((!strcmp(argv[i], "-repeat")) ||
1159: (!strcmp(argv[i], "--repeat"))) {
1160: repeat++;
1161: quiet++;
1162: } else if ((!strcmp(argv[i], "-noent")) ||
1163: (!strcmp(argv[i], "--noent")))
1164: noent++;
1165: else if ((!strcmp(argv[i], "-quiet")) ||
1166: (!strcmp(argv[i], "--quiet")))
1167: quiet++;
1168: else if ((!strcmp(argv[i], "-sax2")) ||
1169: (!strcmp(argv[i], "--sax2")))
1170: sax2++;
1171: else if ((!strcmp(argv[i], "-nonull")) ||
1172: (!strcmp(argv[i], "--nonull")))
1173: nonull++;
1174: }
1175: if (noent != 0) xmlSubstituteEntitiesDefault(1);
1176: for (i = 1; i < argc ; i++) {
1177: if (argv[i][0] != '-') {
1178: if (timing) {
1179: startTimer();
1180: }
1181: parseAndPrintFile(argv[i]);
1182: if (timing) {
1183: endTimer("Parsing");
1184: }
1185: files ++;
1186: }
1187: }
1188: xmlCleanupParser();
1189: xmlMemoryDump();
1190:
1191: return(0);
1192: }
1193: #else
1194: int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
1195: printf("%s : SAX1 parsing support not compiled in\n", argv[0]);
1196: return(0);
1197: }
1198: #endif /* LIBXML_SAX1_ENABLED */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to testSAX.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