4 / _ \\ /| '_ \ / _` | __|
5 | __// \| |_) | (_| | |_
6 \___/_/\_\ .__/ \__,_|\__|
9 Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
10 Copyright (c) 2000-2017 Expat development team
11 Licensed under the MIT license:
13 Permission is hereby granted, free of charge, to any person obtaining
14 a copy of this software and associated documentation files (the
15 "Software"), to deal in the Software without restriction, including
16 without limitation the rights to use, copy, modify, merge, publish,
17 distribute, sublicense, and/or sell copies of the Software, and to permit
18 persons to whom the Software is furnished to do so, subject to the
21 The above copyright notice and this permission notice shall be included
22 in all copies or substantial portions of the Software.
24 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
27 NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
28 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
29 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
30 USE OR OTHER DEALINGS IN THE SOFTWARE.
41 #include "internal.h" /* for UNUSED_P only */
53 /* Structures for handler user data */
54 typedef struct NotationList {
55 struct NotationList *next;
56 const XML_Char *notationName;
57 const XML_Char *systemId;
58 const XML_Char *publicId;
61 typedef struct xmlwfUserData {
63 NotationList *notationListHead;
64 const XML_Char *currentDoctypeName;
68 /* This ensures proper sorting. */
70 #define NSSEP T('\001')
73 characterData(void *userData, const XML_Char *s, int len)
75 FILE *fp = ((XmlwfUserData *)userData)->fp;
76 for (; len > 0; --len, ++s) {
79 fputts(T("&"), fp);
82 fputts(T("<"), fp);
85 fputts(T(">"), fp);
89 fputts(T("
"), fp);
93 fputts(T("""), fp);
98 ftprintf(fp, T("&#%d;"), *s);
109 attributeValue(FILE *fp, const XML_Char *s)
121 fputts(T("&"), fp);
124 fputts(T("<"), fp);
127 fputts(T("""), fp);
131 fputts(T("	"), fp);
134 fputts(T("
"), fp);
137 fputts(T("
"), fp);
141 fputts(T(">"), fp);
146 ftprintf(fp, T("&#%d;"), *s);
157 /* Lexicographically comparing UTF-8 encoded attribute values,
158 is equivalent to lexicographically comparing based on the character number. */
161 attcmp(const void *att1, const void *att2)
163 return tcscmp(*(const XML_Char **)att1, *(const XML_Char **)att2);
167 startElement(void *userData, const XML_Char *name, const XML_Char **atts)
171 FILE *fp = ((XmlwfUserData *)userData)->fp;
178 nAtts = (int)((p - atts) >> 1);
180 qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, attcmp);
184 attributeValue(fp, *atts);
191 endElement(void *userData, const XML_Char *name)
193 FILE *fp = ((XmlwfUserData *)userData)->fp;
201 nsattcmp(const void *p1, const void *p2)
203 const XML_Char *att1 = *(const XML_Char **)p1;
204 const XML_Char *att2 = *(const XML_Char **)p2;
205 int sep1 = (tcsrchr(att1, NSSEP) != 0);
206 int sep2 = (tcsrchr(att1, NSSEP) != 0);
209 return tcscmp(att1, att2);
213 startElementNS(void *userData, const XML_Char *name, const XML_Char **atts)
218 FILE *fp = ((XmlwfUserData *)userData)->fp;
222 sep = tcsrchr(name, NSSEP);
224 fputts(T("n1:"), fp);
226 fputts(T(" xmlns:n1"), fp);
227 attributeValue(fp, name);
238 nAtts = (int)((p - atts) >> 1);
240 qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, nsattcmp);
243 sep = tcsrchr(name, NSSEP);
246 ftprintf(fp, T("n%d:"), nsi);
251 attributeValue(fp, *atts);
253 ftprintf(fp, T(" xmlns:n%d"), nsi++);
254 attributeValue(fp, name);
262 endElementNS(void *userData, const XML_Char *name)
264 FILE *fp = ((XmlwfUserData *)userData)->fp;
268 sep = tcsrchr(name, NSSEP);
270 fputts(T("n1:"), fp);
281 processingInstruction(void *userData, const XML_Char *target,
282 const XML_Char *data)
284 FILE *fp = ((XmlwfUserData *)userData)->fp;
295 static XML_Char *xcsdup(const XML_Char *s)
301 /* Get the length of the string, including terminator */
302 while (s[count++] != 0) {
305 numBytes = count * sizeof(XML_Char);
306 result = malloc(numBytes);
309 memcpy(result, s, numBytes);
314 startDoctypeDecl(void *userData,
315 const XML_Char *doctypeName,
316 const XML_Char *UNUSED_P(sysid),
317 const XML_Char *UNUSED_P(publid),
318 int UNUSED_P(has_internal_subset))
320 XmlwfUserData *data = (XmlwfUserData *)userData;
321 data->currentDoctypeName = xcsdup(doctypeName);
325 freeNotations(XmlwfUserData *data)
327 NotationList *notationListHead = data->notationListHead;
329 while (notationListHead != NULL) {
330 NotationList *next = notationListHead->next;
331 free((void *)notationListHead->notationName);
332 free((void *)notationListHead->systemId);
333 free((void *)notationListHead->publicId);
334 free(notationListHead);
335 notationListHead = next;
337 data->notationListHead = NULL;
340 static int xcscmp(const XML_Char *xs, const XML_Char *xt)
342 while (*xs != 0 && *xt != 0) {
358 notationCmp(const void *a, const void *b)
360 const NotationList * const n1 = *(NotationList **)a;
361 const NotationList * const n2 = *(NotationList **)b;
363 return xcscmp(n1->notationName, n2->notationName);
367 endDoctypeDecl(void *userData)
369 XmlwfUserData *data = (XmlwfUserData *)userData;
370 NotationList **notations;
371 int notationCount = 0;
375 /* How many notations do we have? */
376 for (p = data->notationListHead; p != NULL; p = p->next)
378 if (notationCount == 0) {
379 /* Nothing to report */
380 free((void *)data->currentDoctypeName);
381 data->currentDoctypeName = NULL;
385 notations = malloc(notationCount * sizeof(NotationList *));
386 if (notations == NULL) {
387 fprintf(stderr, "Unable to sort notations");
392 for (p = data->notationListHead, i = 0;
397 qsort(notations, notationCount, sizeof(NotationList *), notationCmp);
399 /* Output the DOCTYPE header */
400 fputts(T("<!DOCTYPE "), data->fp);
401 fputts(data->currentDoctypeName, data->fp);
402 fputts(T(" [\n"), data->fp);
404 /* Now the NOTATIONs */
405 for (i = 0; i < notationCount; i++) {
406 fputts(T("<!NOTATION "), data->fp);
407 fputts(notations[i]->notationName, data->fp);
408 if (notations[i]->publicId != NULL) {
409 fputts(T(" PUBLIC '"), data->fp);
410 fputts(notations[i]->publicId, data->fp);
411 puttc(T('\''), data->fp);
412 if (notations[i]->systemId != NULL) {
413 puttc(T(' '), data->fp);
414 puttc(T('\''), data->fp);
415 fputts(notations[i]->systemId, data->fp);
416 puttc(T('\''), data->fp);
419 else if (notations[i]->systemId != NULL) {
420 fputts(T(" SYSTEM '"), data->fp);
421 fputts(notations[i]->systemId, data->fp);
422 puttc(T('\''), data->fp);
424 puttc(T('>'), data->fp);
425 puttc(T('\n'), data->fp);
428 /* Finally end the DOCTYPE */
429 fputts(T("]>\n"), data->fp);
433 free((void *)data->currentDoctypeName);
434 data->currentDoctypeName = NULL;
438 notationDecl(void *userData,
439 const XML_Char *notationName,
440 const XML_Char *UNUSED_P(base),
441 const XML_Char *systemId,
442 const XML_Char *publicId)
444 XmlwfUserData *data = (XmlwfUserData *)userData;
445 NotationList *entry = malloc(sizeof(NotationList));
446 const char *errorMessage = "Unable to store NOTATION for output\n";
449 fputs(errorMessage, stderr);
450 return; /* Nothing we can really do about this */
452 entry->notationName = xcsdup(notationName);
453 if (entry->notationName == NULL) {
454 fputs(errorMessage, stderr);
458 if (systemId != NULL) {
459 entry->systemId = xcsdup(systemId);
460 if (entry->systemId == NULL) {
461 fputs(errorMessage, stderr);
462 free((void *)entry->notationName);
468 entry->systemId = NULL;
470 if (publicId != NULL) {
471 entry->publicId = xcsdup(publicId);
472 if (entry->publicId == NULL) {
473 fputs(errorMessage, stderr);
474 free((void *)entry->systemId); /* Safe if it's NULL */
475 free((void *)entry->notationName);
481 entry->publicId = NULL;
484 entry->next = data->notationListHead;
485 data->notationListHead = entry;
488 #endif /* not W3C14N */
491 defaultCharacterData(void *userData, const XML_Char *UNUSED_P(s), int UNUSED_P(len))
493 XML_DefaultCurrent((XML_Parser) userData);
497 defaultStartElement(void *userData, const XML_Char *UNUSED_P(name),
498 const XML_Char **UNUSED_P(atts))
500 XML_DefaultCurrent((XML_Parser) userData);
504 defaultEndElement(void *userData, const XML_Char *UNUSED_P(name))
506 XML_DefaultCurrent((XML_Parser) userData);
510 defaultProcessingInstruction(void *userData, const XML_Char *UNUSED_P(target),
511 const XML_Char *UNUSED_P(data))
513 XML_DefaultCurrent((XML_Parser) userData);
517 nopCharacterData(void *UNUSED_P(userData), const XML_Char *UNUSED_P(s), int UNUSED_P(len))
522 nopStartElement(void *UNUSED_P(userData), const XML_Char *UNUSED_P(name), const XML_Char **UNUSED_P(atts))
527 nopEndElement(void *UNUSED_P(userData), const XML_Char *UNUSED_P(name))
532 nopProcessingInstruction(void *UNUSED_P(userData), const XML_Char *UNUSED_P(target),
533 const XML_Char *UNUSED_P(data))
538 markup(void *userData, const XML_Char *s, int len)
540 FILE *fp = ((XmlwfUserData *)XML_GetUserData((XML_Parser) userData))->fp;
541 for (; len > 0; --len, ++s)
546 metaLocation(XML_Parser parser)
548 const XML_Char *uri = XML_GetBase(parser);
549 FILE *fp = ((XmlwfUserData *)XML_GetUserData(parser))->fp;
551 ftprintf(fp, T(" uri=\"%s\""), uri);
553 T(" byte=\"%") T(XML_FMT_INT_MOD) T("d\"")
555 T(" line=\"%") T(XML_FMT_INT_MOD) T("u\"")
556 T(" col=\"%") T(XML_FMT_INT_MOD) T("u\""),
557 XML_GetCurrentByteIndex(parser),
558 XML_GetCurrentByteCount(parser),
559 XML_GetCurrentLineNumber(parser),
560 XML_GetCurrentColumnNumber(parser));
564 metaStartDocument(void *userData)
566 fputts(T("<document>\n"),
567 ((XmlwfUserData *)XML_GetUserData((XML_Parser) userData))->fp);
571 metaEndDocument(void *userData)
573 fputts(T("</document>\n"),
574 ((XmlwfUserData *)XML_GetUserData((XML_Parser) userData))->fp);
578 metaStartElement(void *userData, const XML_Char *name,
579 const XML_Char **atts)
581 XML_Parser parser = (XML_Parser) userData;
582 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
584 const XML_Char **specifiedAttsEnd
585 = atts + XML_GetSpecifiedAttributeCount(parser);
586 const XML_Char **idAttPtr;
587 int idAttIndex = XML_GetIdAttributeIndex(parser);
591 idAttPtr = atts + idAttIndex;
593 ftprintf(fp, T("<starttag name=\"%s\""), name);
594 metaLocation(parser);
596 fputts(T(">\n"), fp);
598 ftprintf(fp, T("<attribute name=\"%s\" value=\""), atts[0]);
599 characterData(data, atts[1], (int)tcslen(atts[1]));
600 if (atts >= specifiedAttsEnd)
601 fputts(T("\" defaulted=\"yes\"/>\n"), fp);
602 else if (atts == idAttPtr)
603 fputts(T("\" id=\"yes\"/>\n"), fp);
605 fputts(T("\"/>\n"), fp);
606 } while (*(atts += 2));
607 fputts(T("</starttag>\n"), fp);
610 fputts(T("/>\n"), fp);
614 metaEndElement(void *userData, const XML_Char *name)
616 XML_Parser parser = (XML_Parser) userData;
617 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
619 ftprintf(fp, T("<endtag name=\"%s\""), name);
620 metaLocation(parser);
621 fputts(T("/>\n"), fp);
625 metaProcessingInstruction(void *userData, const XML_Char *target,
626 const XML_Char *data)
628 XML_Parser parser = (XML_Parser) userData;
629 XmlwfUserData *usrData = (XmlwfUserData *)XML_GetUserData(parser);
630 FILE *fp = usrData->fp;
631 ftprintf(fp, T("<pi target=\"%s\" data=\""), target);
632 characterData(usrData, data, (int)tcslen(data));
634 metaLocation(parser);
635 fputts(T("/>\n"), fp);
639 metaComment(void *userData, const XML_Char *data)
641 XML_Parser parser = (XML_Parser) userData;
642 XmlwfUserData *usrData = (XmlwfUserData *)XML_GetUserData(parser);
643 FILE *fp = usrData->fp;
644 fputts(T("<comment data=\""), fp);
645 characterData(usrData, data, (int)tcslen(data));
647 metaLocation(parser);
648 fputts(T("/>\n"), fp);
652 metaStartCdataSection(void *userData)
654 XML_Parser parser = (XML_Parser) userData;
655 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
657 fputts(T("<startcdata"), fp);
658 metaLocation(parser);
659 fputts(T("/>\n"), fp);
663 metaEndCdataSection(void *userData)
665 XML_Parser parser = (XML_Parser) userData;
666 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
668 fputts(T("<endcdata"), fp);
669 metaLocation(parser);
670 fputts(T("/>\n"), fp);
674 metaCharacterData(void *userData, const XML_Char *s, int len)
676 XML_Parser parser = (XML_Parser) userData;
677 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
679 fputts(T("<chars str=\""), fp);
680 characterData(data, s, len);
682 metaLocation(parser);
683 fputts(T("/>\n"), fp);
687 metaStartDoctypeDecl(void *userData,
688 const XML_Char *doctypeName,
689 const XML_Char *UNUSED_P(sysid),
690 const XML_Char *UNUSED_P(pubid),
691 int UNUSED_P(has_internal_subset))
693 XML_Parser parser = (XML_Parser) userData;
694 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
696 ftprintf(fp, T("<startdoctype name=\"%s\""), doctypeName);
697 metaLocation(parser);
698 fputts(T("/>\n"), fp);
702 metaEndDoctypeDecl(void *userData)
704 XML_Parser parser = (XML_Parser) userData;
705 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
707 fputts(T("<enddoctype"), fp);
708 metaLocation(parser);
709 fputts(T("/>\n"), fp);
713 metaNotationDecl(void *userData,
714 const XML_Char *notationName,
715 const XML_Char *UNUSED_P(base),
716 const XML_Char *systemId,
717 const XML_Char *publicId)
719 XML_Parser parser = (XML_Parser) userData;
720 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
722 ftprintf(fp, T("<notation name=\"%s\""), notationName);
724 ftprintf(fp, T(" public=\"%s\""), publicId);
726 fputts(T(" system=\""), fp);
727 characterData(data, systemId, (int)tcslen(systemId));
730 metaLocation(parser);
731 fputts(T("/>\n"), fp);
736 metaEntityDecl(void *userData,
737 const XML_Char *entityName,
738 int UNUSED_P(is_param),
739 const XML_Char *value,
741 const XML_Char *UNUSED_P(base),
742 const XML_Char *systemId,
743 const XML_Char *publicId,
744 const XML_Char *notationName)
746 XML_Parser parser = (XML_Parser) userData;
747 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
751 ftprintf(fp, T("<entity name=\"%s\""), entityName);
752 metaLocation(parser);
754 characterData(data, value, value_length);
755 fputts(T("</entity/>\n"), fp);
757 else if (notationName) {
758 ftprintf(fp, T("<entity name=\"%s\""), entityName);
760 ftprintf(fp, T(" public=\"%s\""), publicId);
761 fputts(T(" system=\""), fp);
762 characterData(data, systemId, (int)tcslen(systemId));
764 ftprintf(fp, T(" notation=\"%s\""), notationName);
765 metaLocation(parser);
766 fputts(T("/>\n"), fp);
769 ftprintf(fp, T("<entity name=\"%s\""), entityName);
771 ftprintf(fp, T(" public=\"%s\""), publicId);
772 fputts(T(" system=\""), fp);
773 characterData(data, systemId, (int)tcslen(systemId));
775 metaLocation(parser);
776 fputts(T("/>\n"), fp);
781 metaStartNamespaceDecl(void *userData,
782 const XML_Char *prefix,
785 XML_Parser parser = (XML_Parser) userData;
786 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
788 fputts(T("<startns"), fp);
790 ftprintf(fp, T(" prefix=\"%s\""), prefix);
792 fputts(T(" ns=\""), fp);
793 characterData(data, uri, (int)tcslen(uri));
794 fputts(T("\"/>\n"), fp);
797 fputts(T("/>\n"), fp);
801 metaEndNamespaceDecl(void *userData, const XML_Char *prefix)
803 XML_Parser parser = (XML_Parser) userData;
804 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
807 fputts(T("<endns/>\n"), fp);
809 ftprintf(fp, T("<endns prefix=\"%s\"/>\n"), prefix);
813 unknownEncodingConvert(void *data, const char *p)
815 return codepageConvert(*(int *)data, p);
819 unknownEncoding(void *UNUSED_P(userData), const XML_Char *name, XML_Encoding *info)
822 static const XML_Char prefixL[] = T("windows-");
823 static const XML_Char prefixU[] = T("WINDOWS-");
826 for (i = 0; prefixU[i]; i++)
827 if (name[i] != prefixU[i] && name[i] != prefixL[i])
831 for (; name[i]; i++) {
832 static const XML_Char digits[] = T("0123456789");
833 const XML_Char *s = tcschr(digits, name[i]);
837 cp += (int)(s - digits);
841 if (!codepageMap(cp, info->map))
843 info->convert = unknownEncodingConvert;
844 /* We could just cast the code page integer to a void *,
845 and avoid the use of release. */
846 info->release = free;
847 info->data = malloc(sizeof(int));
850 *(int *)info->data = cp;
855 notStandalone(void *UNUSED_P(userData))
861 showVersion(XML_Char *prog)
865 const XML_Feature *features = XML_GetFeatureList();
866 while ((ch = *s) != 0) {
875 ftprintf(stdout, T("%s using %s\n"), prog, XML_ExpatVersion());
876 if (features != NULL && features[0].feature != XML_FEATURE_END) {
878 ftprintf(stdout, T("%s"), features[0].name);
879 if (features[0].value)
880 ftprintf(stdout, T("=%ld"), features[0].value);
881 while (features[i].feature != XML_FEATURE_END) {
882 ftprintf(stdout, T(", %s"), features[i].name);
883 if (features[i].value)
884 ftprintf(stdout, T("=%ld"), features[i].value);
887 ftprintf(stdout, T("\n"));
892 usage(const XML_Char *prog, int rc)
895 T("usage: %s [-s] [-n] [-p] [-x] [-e encoding] [-w] [-d output-dir] [-c] [-m] [-r] [-t] [-N] [file ...]\n"), prog);
899 #if defined(__MINGW32__) && defined(XML_UNICODE)
900 /* Silence warning about missing prototype */
901 int wmain(int argc, XML_Char **argv);
905 tmain(int argc, XML_Char **argv)
908 const XML_Char *outputDir = NULL;
909 const XML_Char *encoding = NULL;
910 unsigned processFlags = XML_MAP_FILE;
911 int windowsCodePages = 0;
913 int useNamespaces = 0;
914 int requireStandalone = 0;
915 int requiresNotations = 0;
916 enum XML_ParamEntityParsing paramEntityParsing =
917 XML_PARAM_ENTITY_PARSING_NEVER;
919 XmlwfUserData userData = { NULL, NULL, NULL };
922 _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_LEAK_CHECK_DF);
929 if (argv[i][0] != T('-'))
931 if (argv[i][1] == T('-') && argv[i][2] == T('\0')) {
937 switch (argv[i][j]) {
939 processFlags &= ~XML_MAP_FILE;
943 requireStandalone = 1;
951 paramEntityParsing = XML_PARAM_ENTITY_PARSING_ALWAYS;
954 processFlags |= XML_EXTERNAL_ENTITIES;
958 windowsCodePages = 1;
975 requiresNotations = 1;
979 if (argv[i][j + 1] == T('\0')) {
985 outputDir = argv[i] + j + 1;
990 if (argv[i][j + 1] == T('\0')) {
996 encoding = argv[i] + j + 1;
1004 showVersion(argv[0]);
1019 processFlags &= ~XML_MAP_FILE;
1022 for (; i < argc; i++) {
1023 XML_Char *outName = 0;
1027 parser = XML_ParserCreateNS(encoding, NSSEP);
1029 parser = XML_ParserCreate(encoding);
1032 tperror(T("Could not instantiate parser"));
1036 if (requireStandalone)
1037 XML_SetNotStandaloneHandler(parser, notStandalone);
1038 XML_SetParamEntityParsing(parser, paramEntityParsing);
1039 if (outputType == 't') {
1040 /* This is for doing timings; this gives a more realistic estimate of
1041 the parsing time. */
1043 XML_SetElementHandler(parser, nopStartElement, nopEndElement);
1044 XML_SetCharacterDataHandler(parser, nopCharacterData);
1045 XML_SetProcessingInstructionHandler(parser, nopProcessingInstruction);
1047 else if (outputDir) {
1048 const XML_Char * delim = T("/");
1049 const XML_Char *file = useStdin ? T("STDIN") : argv[i];
1051 /* Jump after last (back)slash */
1052 const XML_Char * lastDelim = tcsrchr(file, delim[0]);
1054 file = lastDelim + 1;
1057 const XML_Char * winDelim = T("\\");
1058 lastDelim = tcsrchr(file, winDelim[0]);
1060 file = lastDelim + 1;
1066 outName = (XML_Char *)malloc((tcslen(outputDir) + tcslen(file) + 2)
1067 * sizeof(XML_Char));
1068 tcscpy(outName, outputDir);
1069 tcscat(outName, delim);
1070 tcscat(outName, file);
1071 userData.fp = tfopen(outName, T("wb"));
1076 setvbuf(userData.fp, NULL, _IOFBF, 16384);
1078 puttc(0xFEFF, userData.fp);
1080 XML_SetUserData(parser, &userData);
1081 switch (outputType) {
1083 XML_UseParserAsHandlerArg(parser);
1084 XML_SetElementHandler(parser, metaStartElement, metaEndElement);
1085 XML_SetProcessingInstructionHandler(parser, metaProcessingInstruction);
1086 XML_SetCommentHandler(parser, metaComment);
1087 XML_SetCdataSectionHandler(parser, metaStartCdataSection,
1088 metaEndCdataSection);
1089 XML_SetCharacterDataHandler(parser, metaCharacterData);
1090 XML_SetDoctypeDeclHandler(parser, metaStartDoctypeDecl,
1091 metaEndDoctypeDecl);
1092 XML_SetEntityDeclHandler(parser, metaEntityDecl);
1093 XML_SetNotationDeclHandler(parser, metaNotationDecl);
1094 XML_SetNamespaceDeclHandler(parser, metaStartNamespaceDecl,
1095 metaEndNamespaceDecl);
1096 metaStartDocument(parser);
1099 XML_UseParserAsHandlerArg(parser);
1100 XML_SetDefaultHandler(parser, markup);
1101 XML_SetElementHandler(parser, defaultStartElement, defaultEndElement);
1102 XML_SetCharacterDataHandler(parser, defaultCharacterData);
1103 XML_SetProcessingInstructionHandler(parser,
1104 defaultProcessingInstruction);
1108 XML_SetElementHandler(parser, startElementNS, endElementNS);
1110 XML_SetElementHandler(parser, startElement, endElement);
1111 XML_SetCharacterDataHandler(parser, characterData);
1113 XML_SetProcessingInstructionHandler(parser, processingInstruction);
1114 if (requiresNotations) {
1115 XML_SetDoctypeDeclHandler(parser, startDoctypeDecl, endDoctypeDecl);
1116 XML_SetNotationDeclHandler(parser, notationDecl);
1118 #endif /* not W3C14N */
1122 if (windowsCodePages)
1123 XML_SetUnknownEncodingHandler(parser, unknownEncoding, 0);
1124 result = XML_ProcessFile(parser, useStdin ? NULL : argv[i], processFlags);
1126 if (outputType == 'm')
1127 metaEndDocument(parser);
1128 fclose(userData.fp);
1135 XML_ParserFree(parser);