]> git.saurik.com Git - wxWidgets.git/blob - src/expat/xmlwf/xmlwf.c
Use wxMarkupParser in wxStaticText for dealing with markup.
[wxWidgets.git] / src / expat / xmlwf / xmlwf.c
1 /* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
2 See the file COPYING for copying permission.
3 */
4
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <stddef.h>
8 #include <string.h>
9
10 #include "expat.h"
11 #include "codepage.h"
12 #include "xmlfile.h"
13 #include "xmltchar.h"
14
15 #ifdef _MSC_VER
16 #include <crtdbg.h>
17 #endif
18
19 /* This ensures proper sorting. */
20
21 #define NSSEP T('\001')
22
23 static void
24 characterData(void *userData, const XML_Char *s, int len)
25 {
26 FILE *fp = userData;
27 for (; len > 0; --len, ++s) {
28 switch (*s) {
29 case T('&'):
30 fputts(T("&amp;"), fp);
31 break;
32 case T('<'):
33 fputts(T("&lt;"), fp);
34 break;
35 case T('>'):
36 fputts(T("&gt;"), fp);
37 break;
38 #ifdef W3C14N
39 case 13:
40 fputts(T("&#xD;"), fp);
41 break;
42 #else
43 case T('"'):
44 fputts(T("&quot;"), fp);
45 break;
46 case 9:
47 case 10:
48 case 13:
49 ftprintf(fp, T("&#%d;"), *s);
50 break;
51 #endif
52 default:
53 puttc(*s, fp);
54 break;
55 }
56 }
57 }
58
59 static void
60 attributeValue(FILE *fp, const XML_Char *s)
61 {
62 puttc(T('='), fp);
63 puttc(T('"'), fp);
64 for (;;) {
65 switch (*s) {
66 case 0:
67 case NSSEP:
68 puttc(T('"'), fp);
69 return;
70 case T('&'):
71 fputts(T("&amp;"), fp);
72 break;
73 case T('<'):
74 fputts(T("&lt;"), fp);
75 break;
76 case T('"'):
77 fputts(T("&quot;"), fp);
78 break;
79 #ifdef W3C14N
80 case 9:
81 fputts(T("&#x9;"), fp);
82 break;
83 case 10:
84 fputts(T("&#xA;"), fp);
85 break;
86 case 13:
87 fputts(T("&#xD;"), fp);
88 break;
89 #else
90 case T('>'):
91 fputts(T("&gt;"), fp);
92 break;
93 case 9:
94 case 10:
95 case 13:
96 ftprintf(fp, T("&#%d;"), *s);
97 break;
98 #endif
99 default:
100 puttc(*s, fp);
101 break;
102 }
103 s++;
104 }
105 }
106
107 /* Lexicographically comparing UTF-8 encoded attribute values,
108 is equivalent to lexicographically comparing based on the character number. */
109
110 static int
111 attcmp(const void *att1, const void *att2)
112 {
113 return tcscmp(*(const XML_Char **)att1, *(const XML_Char **)att2);
114 }
115
116 static void
117 startElement(void *userData, const XML_Char *name, const XML_Char **atts)
118 {
119 int nAtts;
120 const XML_Char **p;
121 FILE *fp = userData;
122 puttc(T('<'), fp);
123 fputts(name, fp);
124
125 p = atts;
126 while (*p)
127 ++p;
128 nAtts = (p - atts) >> 1;
129 if (nAtts > 1)
130 qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, attcmp);
131 while (*atts) {
132 puttc(T(' '), fp);
133 fputts(*atts++, fp);
134 attributeValue(fp, *atts);
135 atts++;
136 }
137 puttc(T('>'), fp);
138 }
139
140 static void
141 endElement(void *userData, const XML_Char *name)
142 {
143 FILE *fp = userData;
144 puttc(T('<'), fp);
145 puttc(T('/'), fp);
146 fputts(name, fp);
147 puttc(T('>'), fp);
148 }
149
150 static int
151 nsattcmp(const void *p1, const void *p2)
152 {
153 const XML_Char *att1 = *(const XML_Char **)p1;
154 const XML_Char *att2 = *(const XML_Char **)p2;
155 int sep1 = (tcsrchr(att1, NSSEP) != 0);
156 int sep2 = (tcsrchr(att1, NSSEP) != 0);
157 if (sep1 != sep2)
158 return sep1 - sep2;
159 return tcscmp(att1, att2);
160 }
161
162 static void
163 startElementNS(void *userData, const XML_Char *name, const XML_Char **atts)
164 {
165 int nAtts;
166 int nsi;
167 const XML_Char **p;
168 FILE *fp = userData;
169 const XML_Char *sep;
170 puttc(T('<'), fp);
171
172 sep = tcsrchr(name, NSSEP);
173 if (sep) {
174 fputts(T("n1:"), fp);
175 fputts(sep + 1, fp);
176 fputts(T(" xmlns:n1"), fp);
177 attributeValue(fp, name);
178 nsi = 2;
179 }
180 else {
181 fputts(name, fp);
182 nsi = 1;
183 }
184
185 p = atts;
186 while (*p)
187 ++p;
188 nAtts = (p - atts) >> 1;
189 if (nAtts > 1)
190 qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, nsattcmp);
191 while (*atts) {
192 name = *atts++;
193 sep = tcsrchr(name, NSSEP);
194 puttc(T(' '), fp);
195 if (sep) {
196 ftprintf(fp, T("n%d:"), nsi);
197 fputts(sep + 1, fp);
198 }
199 else
200 fputts(name, fp);
201 attributeValue(fp, *atts);
202 if (sep) {
203 ftprintf(fp, T(" xmlns:n%d"), nsi++);
204 attributeValue(fp, name);
205 }
206 atts++;
207 }
208 puttc(T('>'), fp);
209 }
210
211 static void
212 endElementNS(void *userData, const XML_Char *name)
213 {
214 FILE *fp = userData;
215 const XML_Char *sep;
216 puttc(T('<'), fp);
217 puttc(T('/'), fp);
218 sep = tcsrchr(name, NSSEP);
219 if (sep) {
220 fputts(T("n1:"), fp);
221 fputts(sep + 1, fp);
222 }
223 else
224 fputts(name, fp);
225 puttc(T('>'), fp);
226 }
227
228 #ifndef W3C14N
229
230 static void
231 processingInstruction(void *userData, const XML_Char *target,
232 const XML_Char *data)
233 {
234 FILE *fp = userData;
235 puttc(T('<'), fp);
236 puttc(T('?'), fp);
237 fputts(target, fp);
238 puttc(T(' '), fp);
239 fputts(data, fp);
240 puttc(T('?'), fp);
241 puttc(T('>'), fp);
242 }
243
244 #endif /* not W3C14N */
245
246 static void
247 defaultCharacterData(void *userData, const XML_Char *s, int len)
248 {
249 XML_DefaultCurrent((XML_Parser) userData);
250 }
251
252 static void
253 defaultStartElement(void *userData, const XML_Char *name,
254 const XML_Char **atts)
255 {
256 XML_DefaultCurrent((XML_Parser) userData);
257 }
258
259 static void
260 defaultEndElement(void *userData, const XML_Char *name)
261 {
262 XML_DefaultCurrent((XML_Parser) userData);
263 }
264
265 static void
266 defaultProcessingInstruction(void *userData, const XML_Char *target,
267 const XML_Char *data)
268 {
269 XML_DefaultCurrent((XML_Parser) userData);
270 }
271
272 static void
273 nopCharacterData(void *userData, const XML_Char *s, int len)
274 {
275 }
276
277 static void
278 nopStartElement(void *userData, const XML_Char *name, const XML_Char **atts)
279 {
280 }
281
282 static void
283 nopEndElement(void *userData, const XML_Char *name)
284 {
285 }
286
287 static void
288 nopProcessingInstruction(void *userData, const XML_Char *target,
289 const XML_Char *data)
290 {
291 }
292
293 static void
294 markup(void *userData, const XML_Char *s, int len)
295 {
296 FILE *fp = XML_GetUserData((XML_Parser) userData);
297 for (; len > 0; --len, ++s)
298 puttc(*s, fp);
299 }
300
301 static void
302 metaLocation(XML_Parser parser)
303 {
304 const XML_Char *uri = XML_GetBase(parser);
305 if (uri)
306 ftprintf(XML_GetUserData(parser), T(" uri=\"%s\""), uri);
307 ftprintf(XML_GetUserData(parser),
308 T(" byte=\"%ld\" nbytes=\"%d\" line=\"%d\" col=\"%d\""),
309 XML_GetCurrentByteIndex(parser),
310 XML_GetCurrentByteCount(parser),
311 XML_GetCurrentLineNumber(parser),
312 XML_GetCurrentColumnNumber(parser));
313 }
314
315 static void
316 metaStartDocument(void *userData)
317 {
318 fputts(T("<document>\n"), XML_GetUserData((XML_Parser) userData));
319 }
320
321 static void
322 metaEndDocument(void *userData)
323 {
324 fputts(T("</document>\n"), XML_GetUserData((XML_Parser) userData));
325 }
326
327 static void
328 metaStartElement(void *userData, const XML_Char *name,
329 const XML_Char **atts)
330 {
331 XML_Parser parser = (XML_Parser) userData;
332 FILE *fp = XML_GetUserData(parser);
333 const XML_Char **specifiedAttsEnd
334 = atts + XML_GetSpecifiedAttributeCount(parser);
335 const XML_Char **idAttPtr;
336 int idAttIndex = XML_GetIdAttributeIndex(parser);
337 if (idAttIndex < 0)
338 idAttPtr = 0;
339 else
340 idAttPtr = atts + idAttIndex;
341
342 ftprintf(fp, T("<starttag name=\"%s\""), name);
343 metaLocation(parser);
344 if (*atts) {
345 fputts(T(">\n"), fp);
346 do {
347 ftprintf(fp, T("<attribute name=\"%s\" value=\""), atts[0]);
348 characterData(fp, atts[1], tcslen(atts[1]));
349 if (atts >= specifiedAttsEnd)
350 fputts(T("\" defaulted=\"yes\"/>\n"), fp);
351 else if (atts == idAttPtr)
352 fputts(T("\" id=\"yes\"/>\n"), fp);
353 else
354 fputts(T("\"/>\n"), fp);
355 } while (*(atts += 2));
356 fputts(T("</starttag>\n"), fp);
357 }
358 else
359 fputts(T("/>\n"), fp);
360 }
361
362 static void
363 metaEndElement(void *userData, const XML_Char *name)
364 {
365 XML_Parser parser = (XML_Parser) userData;
366 FILE *fp = XML_GetUserData(parser);
367 ftprintf(fp, T("<endtag name=\"%s\""), name);
368 metaLocation(parser);
369 fputts(T("/>\n"), fp);
370 }
371
372 static void
373 metaProcessingInstruction(void *userData, const XML_Char *target,
374 const XML_Char *data)
375 {
376 XML_Parser parser = (XML_Parser) userData;
377 FILE *fp = XML_GetUserData(parser);
378 ftprintf(fp, T("<pi target=\"%s\" data=\""), target);
379 characterData(fp, data, tcslen(data));
380 puttc(T('"'), fp);
381 metaLocation(parser);
382 fputts(T("/>\n"), fp);
383 }
384
385 static void
386 metaComment(void *userData, const XML_Char *data)
387 {
388 XML_Parser parser = (XML_Parser) userData;
389 FILE *fp = XML_GetUserData(parser);
390 fputts(T("<comment data=\""), fp);
391 characterData(fp, data, tcslen(data));
392 puttc(T('"'), fp);
393 metaLocation(parser);
394 fputts(T("/>\n"), fp);
395 }
396
397 static void
398 metaStartCdataSection(void *userData)
399 {
400 XML_Parser parser = (XML_Parser) userData;
401 FILE *fp = XML_GetUserData(parser);
402 fputts(T("<startcdata"), fp);
403 metaLocation(parser);
404 fputts(T("/>\n"), fp);
405 }
406
407 static void
408 metaEndCdataSection(void *userData)
409 {
410 XML_Parser parser = (XML_Parser) userData;
411 FILE *fp = XML_GetUserData(parser);
412 fputts(T("<endcdata"), fp);
413 metaLocation(parser);
414 fputts(T("/>\n"), fp);
415 }
416
417 static void
418 metaCharacterData(void *userData, const XML_Char *s, int len)
419 {
420 XML_Parser parser = (XML_Parser) userData;
421 FILE *fp = XML_GetUserData(parser);
422 fputts(T("<chars str=\""), fp);
423 characterData(fp, s, len);
424 puttc(T('"'), fp);
425 metaLocation(parser);
426 fputts(T("/>\n"), fp);
427 }
428
429 static void
430 metaStartDoctypeDecl(void *userData,
431 const XML_Char *doctypeName,
432 const XML_Char *sysid,
433 const XML_Char *pubid,
434 int has_internal_subset)
435 {
436 XML_Parser parser = (XML_Parser) userData;
437 FILE *fp = XML_GetUserData(parser);
438 ftprintf(fp, T("<startdoctype name=\"%s\""), doctypeName);
439 metaLocation(parser);
440 fputts(T("/>\n"), fp);
441 }
442
443 static void
444 metaEndDoctypeDecl(void *userData)
445 {
446 XML_Parser parser = (XML_Parser) userData;
447 FILE *fp = XML_GetUserData(parser);
448 fputts(T("<enddoctype"), fp);
449 metaLocation(parser);
450 fputts(T("/>\n"), fp);
451 }
452
453 static void
454 metaNotationDecl(void *userData,
455 const XML_Char *notationName,
456 const XML_Char *base,
457 const XML_Char *systemId,
458 const XML_Char *publicId)
459 {
460 XML_Parser parser = (XML_Parser) userData;
461 FILE *fp = XML_GetUserData(parser);
462 ftprintf(fp, T("<notation name=\"%s\""), notationName);
463 if (publicId)
464 ftprintf(fp, T(" public=\"%s\""), publicId);
465 if (systemId) {
466 fputts(T(" system=\""), fp);
467 characterData(fp, systemId, tcslen(systemId));
468 puttc(T('"'), fp);
469 }
470 metaLocation(parser);
471 fputts(T("/>\n"), fp);
472 }
473
474
475 static void
476 metaEntityDecl(void *userData,
477 const XML_Char *entityName,
478 int is_param,
479 const XML_Char *value,
480 int value_length,
481 const XML_Char *base,
482 const XML_Char *systemId,
483 const XML_Char *publicId,
484 const XML_Char *notationName)
485 {
486 XML_Parser parser = (XML_Parser) userData;
487 FILE *fp = XML_GetUserData(parser);
488
489 if (value) {
490 ftprintf(fp, T("<entity name=\"%s\""), entityName);
491 metaLocation(parser);
492 puttc(T('>'), fp);
493 characterData(fp, value, value_length);
494 fputts(T("</entity/>\n"), fp);
495 }
496 else if (notationName) {
497 ftprintf(fp, T("<entity name=\"%s\""), entityName);
498 if (publicId)
499 ftprintf(fp, T(" public=\"%s\""), publicId);
500 fputts(T(" system=\""), fp);
501 characterData(fp, systemId, tcslen(systemId));
502 puttc(T('"'), fp);
503 ftprintf(fp, T(" notation=\"%s\""), notationName);
504 metaLocation(parser);
505 fputts(T("/>\n"), fp);
506 }
507 else {
508 ftprintf(fp, T("<entity name=\"%s\""), entityName);
509 if (publicId)
510 ftprintf(fp, T(" public=\"%s\""), publicId);
511 fputts(T(" system=\""), fp);
512 characterData(fp, systemId, tcslen(systemId));
513 puttc(T('"'), fp);
514 metaLocation(parser);
515 fputts(T("/>\n"), fp);
516 }
517 }
518
519 static void
520 metaStartNamespaceDecl(void *userData,
521 const XML_Char *prefix,
522 const XML_Char *uri)
523 {
524 XML_Parser parser = (XML_Parser) userData;
525 FILE *fp = XML_GetUserData(parser);
526 fputts(T("<startns"), fp);
527 if (prefix)
528 ftprintf(fp, T(" prefix=\"%s\""), prefix);
529 if (uri) {
530 fputts(T(" ns=\""), fp);
531 characterData(fp, uri, tcslen(uri));
532 fputts(T("\"/>\n"), fp);
533 }
534 else
535 fputts(T("/>\n"), fp);
536 }
537
538 static void
539 metaEndNamespaceDecl(void *userData, const XML_Char *prefix)
540 {
541 XML_Parser parser = (XML_Parser) userData;
542 FILE *fp = XML_GetUserData(parser);
543 if (!prefix)
544 fputts(T("<endns/>\n"), fp);
545 else
546 ftprintf(fp, T("<endns prefix=\"%s\"/>\n"), prefix);
547 }
548
549 static int
550 unknownEncodingConvert(void *data, const char *p)
551 {
552 return codepageConvert(*(int *)data, p);
553 }
554
555 static int
556 unknownEncoding(void *userData, const XML_Char *name, XML_Encoding *info)
557 {
558 int cp;
559 static const XML_Char prefixL[] = T("windows-");
560 static const XML_Char prefixU[] = T("WINDOWS-");
561 int i;
562
563 for (i = 0; prefixU[i]; i++)
564 if (name[i] != prefixU[i] && name[i] != prefixL[i])
565 return 0;
566
567 cp = 0;
568 for (; name[i]; i++) {
569 static const XML_Char digits[] = T("0123456789");
570 const XML_Char *s = tcschr(digits, name[i]);
571 if (!s)
572 return 0;
573 cp *= 10;
574 cp += s - digits;
575 if (cp >= 0x10000)
576 return 0;
577 }
578 if (!codepageMap(cp, info->map))
579 return 0;
580 info->convert = unknownEncodingConvert;
581 /* We could just cast the code page integer to a void *,
582 and avoid the use of release. */
583 info->release = free;
584 info->data = malloc(sizeof(int));
585 if (!info->data)
586 return 0;
587 *(int *)info->data = cp;
588 return 1;
589 }
590
591 static int
592 notStandalone(void *userData)
593 {
594 return 0;
595 }
596
597 static void
598 showVersion(XML_Char *prog)
599 {
600 XML_Char *s = prog;
601 XML_Char ch;
602 const XML_Feature *features = XML_GetFeatureList();
603 while ((ch = *s) != 0) {
604 if (ch == '/'
605 #ifdef WIN32
606 || ch == '\\'
607 #endif
608 )
609 prog = s + 1;
610 ++s;
611 }
612 ftprintf(stdout, T("%s using %s\n"), prog, XML_ExpatVersion());
613 if (features != NULL && features[0].feature != XML_FEATURE_END) {
614 int i = 1;
615 ftprintf(stdout, T("%s"), features[0].name);
616 if (features[0].value)
617 ftprintf(stdout, T("=%ld"), features[0].value);
618 while (features[i].feature != XML_FEATURE_END) {
619 ftprintf(stdout, T(", %s"), features[i].name);
620 if (features[i].value)
621 ftprintf(stdout, T("=%ld"), features[i].value);
622 ++i;
623 }
624 ftprintf(stdout, T("\n"));
625 }
626 }
627
628 static void
629 usage(const XML_Char *prog, int rc)
630 {
631 ftprintf(stderr,
632 T("usage: %s [-n] [-p] [-r] [-s] [-w] [-x] [-d output-dir] "
633 "[-e encoding] file ...\n"), prog);
634 exit(rc);
635 }
636
637 int
638 tmain(int argc, XML_Char **argv)
639 {
640 int i, j;
641 const XML_Char *outputDir = NULL;
642 const XML_Char *encoding = NULL;
643 unsigned processFlags = XML_MAP_FILE;
644 int windowsCodePages = 0;
645 int outputType = 0;
646 int useNamespaces = 0;
647 int requireStandalone = 0;
648 int paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
649 int useStdin = 0;
650
651 #ifdef _MSC_VER
652 _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_LEAK_CHECK_DF);
653 #endif
654
655 i = 1;
656 j = 0;
657 while (i < argc) {
658 if (j == 0) {
659 if (argv[i][0] != T('-'))
660 break;
661 if (argv[i][1] == T('-') && argv[i][2] == T('\0')) {
662 i++;
663 break;
664 }
665 j++;
666 }
667 switch (argv[i][j]) {
668 case T('r'):
669 processFlags &= ~XML_MAP_FILE;
670 j++;
671 break;
672 case T('s'):
673 requireStandalone = 1;
674 j++;
675 break;
676 case T('n'):
677 useNamespaces = 1;
678 j++;
679 break;
680 case T('p'):
681 paramEntityParsing = XML_PARAM_ENTITY_PARSING_ALWAYS;
682 /* fall through */
683 case T('x'):
684 processFlags |= XML_EXTERNAL_ENTITIES;
685 j++;
686 break;
687 case T('w'):
688 windowsCodePages = 1;
689 j++;
690 break;
691 case T('m'):
692 outputType = 'm';
693 j++;
694 break;
695 case T('c'):
696 outputType = 'c';
697 useNamespaces = 0;
698 j++;
699 break;
700 case T('t'):
701 outputType = 't';
702 j++;
703 break;
704 case T('d'):
705 if (argv[i][j + 1] == T('\0')) {
706 if (++i == argc)
707 usage(argv[0], 2);
708 outputDir = argv[i];
709 }
710 else
711 outputDir = argv[i] + j + 1;
712 i++;
713 j = 0;
714 break;
715 case T('e'):
716 if (argv[i][j + 1] == T('\0')) {
717 if (++i == argc)
718 usage(argv[0], 2);
719 encoding = argv[i];
720 }
721 else
722 encoding = argv[i] + j + 1;
723 i++;
724 j = 0;
725 break;
726 case T('h'):
727 usage(argv[0], 0);
728 return 0;
729 case T('v'):
730 showVersion(argv[0]);
731 return 0;
732 case T('\0'):
733 if (j > 1) {
734 i++;
735 j = 0;
736 break;
737 }
738 /* fall through */
739 default:
740 usage(argv[0], 2);
741 }
742 }
743 if (i == argc) {
744 useStdin = 1;
745 processFlags &= ~XML_MAP_FILE;
746 i--;
747 }
748 for (; i < argc; i++) {
749 FILE *fp = 0;
750 XML_Char *outName = 0;
751 int result;
752 XML_Parser parser;
753 if (useNamespaces)
754 parser = XML_ParserCreateNS(encoding, NSSEP);
755 else
756 parser = XML_ParserCreate(encoding);
757 if (requireStandalone)
758 XML_SetNotStandaloneHandler(parser, notStandalone);
759 XML_SetParamEntityParsing(parser, paramEntityParsing);
760 if (outputType == 't') {
761 /* This is for doing timings; this gives a more realistic estimate of
762 the parsing time. */
763 outputDir = 0;
764 XML_SetElementHandler(parser, nopStartElement, nopEndElement);
765 XML_SetCharacterDataHandler(parser, nopCharacterData);
766 XML_SetProcessingInstructionHandler(parser, nopProcessingInstruction);
767 }
768 else if (outputDir) {
769 const XML_Char *file = useStdin ? T("STDIN") : argv[i];
770 if (tcsrchr(file, T('/')))
771 file = tcsrchr(file, T('/')) + 1;
772 #ifdef WIN32
773 if (tcsrchr(file, T('\\')))
774 file = tcsrchr(file, T('\\')) + 1;
775 #endif
776 outName = malloc((tcslen(outputDir) + tcslen(file) + 2)
777 * sizeof(XML_Char));
778 tcscpy(outName, outputDir);
779 tcscat(outName, T("/"));
780 tcscat(outName, file);
781 fp = tfopen(outName, T("wb"));
782 if (!fp) {
783 tperror(outName);
784 exit(1);
785 }
786 setvbuf(fp, NULL, _IOFBF, 16384);
787 #ifdef XML_UNICODE
788 puttc(0xFEFF, fp);
789 #endif
790 XML_SetUserData(parser, fp);
791 switch (outputType) {
792 case 'm':
793 XML_UseParserAsHandlerArg(parser);
794 XML_SetElementHandler(parser, metaStartElement, metaEndElement);
795 XML_SetProcessingInstructionHandler(parser, metaProcessingInstruction);
796 XML_SetCommentHandler(parser, metaComment);
797 XML_SetCdataSectionHandler(parser, metaStartCdataSection,
798 metaEndCdataSection);
799 XML_SetCharacterDataHandler(parser, metaCharacterData);
800 XML_SetDoctypeDeclHandler(parser, metaStartDoctypeDecl,
801 metaEndDoctypeDecl);
802 XML_SetEntityDeclHandler(parser, metaEntityDecl);
803 XML_SetNotationDeclHandler(parser, metaNotationDecl);
804 XML_SetNamespaceDeclHandler(parser, metaStartNamespaceDecl,
805 metaEndNamespaceDecl);
806 metaStartDocument(parser);
807 break;
808 case 'c':
809 XML_UseParserAsHandlerArg(parser);
810 XML_SetDefaultHandler(parser, markup);
811 XML_SetElementHandler(parser, defaultStartElement, defaultEndElement);
812 XML_SetCharacterDataHandler(parser, defaultCharacterData);
813 XML_SetProcessingInstructionHandler(parser,
814 defaultProcessingInstruction);
815 break;
816 default:
817 if (useNamespaces)
818 XML_SetElementHandler(parser, startElementNS, endElementNS);
819 else
820 XML_SetElementHandler(parser, startElement, endElement);
821 XML_SetCharacterDataHandler(parser, characterData);
822 #ifndef W3C14N
823 XML_SetProcessingInstructionHandler(parser, processingInstruction);
824 #endif /* not W3C14N */
825 break;
826 }
827 }
828 if (windowsCodePages)
829 XML_SetUnknownEncodingHandler(parser, unknownEncoding, 0);
830 result = XML_ProcessFile(parser, useStdin ? NULL : argv[i], processFlags);
831 if (outputDir) {
832 if (outputType == 'm')
833 metaEndDocument(parser);
834 fclose(fp);
835 if (!result)
836 tremove(outName);
837 free(outName);
838 }
839 XML_ParserFree(parser);
840 }
841 return 0;
842 }