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;
67 /* This ensures proper sorting. */
69 #define NSSEP T('\001')
72 characterData(void *userData, const XML_Char *s, int len) {
73 FILE *fp = ((XmlwfUserData *)userData)->fp;
74 for (; len > 0; --len, ++s) {
77 fputts(T("&"), fp);
80 fputts(T("<"), fp);
83 fputts(T(">"), fp);
87 fputts(T("
"), fp);
91 fputts(T("""), fp);
96 ftprintf(fp, T("&#%d;"), *s);
107 attributeValue(FILE *fp, const XML_Char *s) {
118 fputts(T("&"), fp);
121 fputts(T("<"), fp);
124 fputts(T("""), fp);
128 fputts(T("	"), fp);
131 fputts(T("
"), fp);
134 fputts(T("
"), fp);
138 fputts(T(">"), fp);
143 ftprintf(fp, T("&#%d;"), *s);
154 /* Lexicographically comparing UTF-8 encoded attribute values,
155 is equivalent to lexicographically comparing based on the character number. */
158 attcmp(const void *att1, const void *att2) {
159 return tcscmp(*(const XML_Char **)att1, *(const XML_Char **)att2);
163 startElement(void *userData, const XML_Char *name, const XML_Char **atts) {
166 FILE *fp = ((XmlwfUserData *)userData)->fp;
173 nAtts = (int)((p - atts) >> 1);
175 qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, attcmp);
179 attributeValue(fp, *atts);
186 endElement(void *userData, const XML_Char *name) {
187 FILE *fp = ((XmlwfUserData *)userData)->fp;
195 nsattcmp(const void *p1, const void *p2) {
196 const XML_Char *att1 = *(const XML_Char **)p1;
197 const XML_Char *att2 = *(const XML_Char **)p2;
198 int sep1 = (tcsrchr(att1, NSSEP) != 0);
199 int sep2 = (tcsrchr(att1, NSSEP) != 0);
202 return tcscmp(att1, att2);
206 startElementNS(void *userData, const XML_Char *name, const XML_Char **atts) {
210 FILE *fp = ((XmlwfUserData *)userData)->fp;
214 sep = tcsrchr(name, NSSEP);
216 fputts(T("n1:"), fp);
218 fputts(T(" xmlns:n1"), fp);
219 attributeValue(fp, name);
229 nAtts = (int)((p - atts) >> 1);
231 qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, nsattcmp);
234 sep = tcsrchr(name, NSSEP);
237 ftprintf(fp, T("n%d:"), nsi);
241 attributeValue(fp, *atts);
243 ftprintf(fp, T(" xmlns:n%d"), nsi++);
244 attributeValue(fp, name);
252 endElementNS(void *userData, const XML_Char *name) {
253 FILE *fp = ((XmlwfUserData *)userData)->fp;
257 sep = tcsrchr(name, NSSEP);
259 fputts(T("n1:"), fp);
269 processingInstruction(void *userData, const XML_Char *target,
270 const XML_Char *data) {
271 FILE *fp = ((XmlwfUserData *)userData)->fp;
282 xcsdup(const XML_Char *s) {
287 /* Get the length of the string, including terminator */
288 while (s[count++] != 0) {
291 numBytes = count * sizeof(XML_Char);
292 result = malloc(numBytes);
295 memcpy(result, s, numBytes);
300 startDoctypeDecl(void *userData, const XML_Char *doctypeName,
301 const XML_Char *sysid, const XML_Char *publid,
302 int has_internal_subset) {
303 XmlwfUserData *data = (XmlwfUserData *)userData;
306 UNUSED_P(has_internal_subset);
307 data->currentDoctypeName = xcsdup(doctypeName);
311 freeNotations(XmlwfUserData *data) {
312 NotationList *notationListHead = data->notationListHead;
314 while (notationListHead != NULL) {
315 NotationList *next = notationListHead->next;
316 free((void *)notationListHead->notationName);
317 free((void *)notationListHead->systemId);
318 free((void *)notationListHead->publicId);
319 free(notationListHead);
320 notationListHead = next;
322 data->notationListHead = NULL;
326 xcscmp(const XML_Char *xs, const XML_Char *xt) {
327 while (*xs != 0 && *xt != 0) {
343 notationCmp(const void *a, const void *b) {
344 const NotationList *const n1 = *(NotationList **)a;
345 const NotationList *const n2 = *(NotationList **)b;
347 return xcscmp(n1->notationName, n2->notationName);
351 endDoctypeDecl(void *userData) {
352 XmlwfUserData *data = (XmlwfUserData *)userData;
353 NotationList **notations;
354 int notationCount = 0;
358 /* How many notations do we have? */
359 for (p = data->notationListHead; p != NULL; p = p->next)
361 if (notationCount == 0) {
362 /* Nothing to report */
363 free((void *)data->currentDoctypeName);
364 data->currentDoctypeName = NULL;
368 notations = malloc(notationCount * sizeof(NotationList *));
369 if (notations == NULL) {
370 fprintf(stderr, "Unable to sort notations");
375 for (p = data->notationListHead, i = 0; i < notationCount; p = p->next, i++) {
378 qsort(notations, notationCount, sizeof(NotationList *), notationCmp);
380 /* Output the DOCTYPE header */
381 fputts(T("<!DOCTYPE "), data->fp);
382 fputts(data->currentDoctypeName, data->fp);
383 fputts(T(" [\n"), data->fp);
385 /* Now the NOTATIONs */
386 for (i = 0; i < notationCount; i++) {
387 fputts(T("<!NOTATION "), data->fp);
388 fputts(notations[i]->notationName, data->fp);
389 if (notations[i]->publicId != NULL) {
390 fputts(T(" PUBLIC '"), data->fp);
391 fputts(notations[i]->publicId, data->fp);
392 puttc(T('\''), data->fp);
393 if (notations[i]->systemId != NULL) {
394 puttc(T(' '), data->fp);
395 puttc(T('\''), data->fp);
396 fputts(notations[i]->systemId, data->fp);
397 puttc(T('\''), data->fp);
399 } else if (notations[i]->systemId != NULL) {
400 fputts(T(" SYSTEM '"), data->fp);
401 fputts(notations[i]->systemId, data->fp);
402 puttc(T('\''), data->fp);
404 puttc(T('>'), data->fp);
405 puttc(T('\n'), data->fp);
408 /* Finally end the DOCTYPE */
409 fputts(T("]>\n"), data->fp);
413 free((void *)data->currentDoctypeName);
414 data->currentDoctypeName = NULL;
418 notationDecl(void *userData, const XML_Char *notationName, const XML_Char *base,
419 const XML_Char *systemId, const XML_Char *publicId) {
420 XmlwfUserData *data = (XmlwfUserData *)userData;
421 NotationList *entry = malloc(sizeof(NotationList));
422 const char *errorMessage = "Unable to store NOTATION for output\n";
426 fputs(errorMessage, stderr);
427 return; /* Nothing we can really do about this */
429 entry->notationName = xcsdup(notationName);
430 if (entry->notationName == NULL) {
431 fputs(errorMessage, stderr);
435 if (systemId != NULL) {
436 entry->systemId = xcsdup(systemId);
437 if (entry->systemId == NULL) {
438 fputs(errorMessage, stderr);
439 free((void *)entry->notationName);
444 entry->systemId = NULL;
446 if (publicId != NULL) {
447 entry->publicId = xcsdup(publicId);
448 if (entry->publicId == NULL) {
449 fputs(errorMessage, stderr);
450 free((void *)entry->systemId); /* Safe if it's NULL */
451 free((void *)entry->notationName);
456 entry->publicId = NULL;
459 entry->next = data->notationListHead;
460 data->notationListHead = entry;
463 #endif /* not W3C14N */
466 defaultCharacterData(void *userData, const XML_Char *s, int len) {
469 XML_DefaultCurrent((XML_Parser)userData);
473 defaultStartElement(void *userData, const XML_Char *name,
474 const XML_Char **atts) {
477 XML_DefaultCurrent((XML_Parser)userData);
481 defaultEndElement(void *userData, const XML_Char *name) {
483 XML_DefaultCurrent((XML_Parser)userData);
487 defaultProcessingInstruction(void *userData, const XML_Char *target,
488 const XML_Char *data) {
491 XML_DefaultCurrent((XML_Parser)userData);
495 nopCharacterData(void *userData, const XML_Char *s, int len) {
502 nopStartElement(void *userData, const XML_Char *name, const XML_Char **atts) {
509 nopEndElement(void *userData, const XML_Char *name) {
515 nopProcessingInstruction(void *userData, const XML_Char *target,
516 const XML_Char *data) {
523 markup(void *userData, const XML_Char *s, int len) {
524 FILE *fp = ((XmlwfUserData *)XML_GetUserData((XML_Parser)userData))->fp;
525 for (; len > 0; --len, ++s)
530 metaLocation(XML_Parser parser) {
531 const XML_Char *uri = XML_GetBase(parser);
532 FILE *fp = ((XmlwfUserData *)XML_GetUserData(parser))->fp;
534 ftprintf(fp, T(" uri=\"%s\""), uri);
536 T(" byte=\"%") T(XML_FMT_INT_MOD) T("d\"") T(" nbytes=\"%d\"")
537 T(" line=\"%") T(XML_FMT_INT_MOD) T("u\"") T(" col=\"%")
538 T(XML_FMT_INT_MOD) T("u\""),
539 XML_GetCurrentByteIndex(parser), XML_GetCurrentByteCount(parser),
540 XML_GetCurrentLineNumber(parser),
541 XML_GetCurrentColumnNumber(parser));
545 metaStartDocument(void *userData) {
546 fputts(T("<document>\n"),
547 ((XmlwfUserData *)XML_GetUserData((XML_Parser)userData))->fp);
551 metaEndDocument(void *userData) {
552 fputts(T("</document>\n"),
553 ((XmlwfUserData *)XML_GetUserData((XML_Parser)userData))->fp);
557 metaStartElement(void *userData, const XML_Char *name, const XML_Char **atts) {
558 XML_Parser parser = (XML_Parser)userData;
559 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
561 const XML_Char **specifiedAttsEnd
562 = atts + XML_GetSpecifiedAttributeCount(parser);
563 const XML_Char **idAttPtr;
564 int idAttIndex = XML_GetIdAttributeIndex(parser);
568 idAttPtr = atts + idAttIndex;
570 ftprintf(fp, T("<starttag name=\"%s\""), name);
571 metaLocation(parser);
573 fputts(T(">\n"), fp);
575 ftprintf(fp, T("<attribute name=\"%s\" value=\""), atts[0]);
576 characterData(data, atts[1], (int)tcslen(atts[1]));
577 if (atts >= specifiedAttsEnd)
578 fputts(T("\" defaulted=\"yes\"/>\n"), fp);
579 else if (atts == idAttPtr)
580 fputts(T("\" id=\"yes\"/>\n"), fp);
582 fputts(T("\"/>\n"), fp);
583 } while (*(atts += 2));
584 fputts(T("</starttag>\n"), fp);
586 fputts(T("/>\n"), fp);
590 metaEndElement(void *userData, const XML_Char *name) {
591 XML_Parser parser = (XML_Parser)userData;
592 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
594 ftprintf(fp, T("<endtag name=\"%s\""), name);
595 metaLocation(parser);
596 fputts(T("/>\n"), fp);
600 metaProcessingInstruction(void *userData, const XML_Char *target,
601 const XML_Char *data) {
602 XML_Parser parser = (XML_Parser)userData;
603 XmlwfUserData *usrData = (XmlwfUserData *)XML_GetUserData(parser);
604 FILE *fp = usrData->fp;
605 ftprintf(fp, T("<pi target=\"%s\" data=\""), target);
606 characterData(usrData, data, (int)tcslen(data));
608 metaLocation(parser);
609 fputts(T("/>\n"), fp);
613 metaComment(void *userData, const XML_Char *data) {
614 XML_Parser parser = (XML_Parser)userData;
615 XmlwfUserData *usrData = (XmlwfUserData *)XML_GetUserData(parser);
616 FILE *fp = usrData->fp;
617 fputts(T("<comment data=\""), fp);
618 characterData(usrData, data, (int)tcslen(data));
620 metaLocation(parser);
621 fputts(T("/>\n"), fp);
625 metaStartCdataSection(void *userData) {
626 XML_Parser parser = (XML_Parser)userData;
627 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
629 fputts(T("<startcdata"), fp);
630 metaLocation(parser);
631 fputts(T("/>\n"), fp);
635 metaEndCdataSection(void *userData) {
636 XML_Parser parser = (XML_Parser)userData;
637 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
639 fputts(T("<endcdata"), fp);
640 metaLocation(parser);
641 fputts(T("/>\n"), fp);
645 metaCharacterData(void *userData, const XML_Char *s, int len) {
646 XML_Parser parser = (XML_Parser)userData;
647 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
649 fputts(T("<chars str=\""), fp);
650 characterData(data, s, len);
652 metaLocation(parser);
653 fputts(T("/>\n"), fp);
657 metaStartDoctypeDecl(void *userData, const XML_Char *doctypeName,
658 const XML_Char *sysid, const XML_Char *pubid,
659 int has_internal_subset) {
660 XML_Parser parser = (XML_Parser)userData;
661 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
665 UNUSED_P(has_internal_subset);
666 ftprintf(fp, T("<startdoctype name=\"%s\""), doctypeName);
667 metaLocation(parser);
668 fputts(T("/>\n"), fp);
672 metaEndDoctypeDecl(void *userData) {
673 XML_Parser parser = (XML_Parser)userData;
674 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
676 fputts(T("<enddoctype"), fp);
677 metaLocation(parser);
678 fputts(T("/>\n"), fp);
682 metaNotationDecl(void *userData, const XML_Char *notationName,
683 const XML_Char *base, const XML_Char *systemId,
684 const XML_Char *publicId) {
685 XML_Parser parser = (XML_Parser)userData;
686 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
689 ftprintf(fp, T("<notation name=\"%s\""), notationName);
691 ftprintf(fp, T(" public=\"%s\""), publicId);
693 fputts(T(" system=\""), fp);
694 characterData(data, systemId, (int)tcslen(systemId));
697 metaLocation(parser);
698 fputts(T("/>\n"), fp);
702 metaEntityDecl(void *userData, const XML_Char *entityName, int is_param,
703 const XML_Char *value, int value_length, const XML_Char *base,
704 const XML_Char *systemId, const XML_Char *publicId,
705 const XML_Char *notationName) {
706 XML_Parser parser = (XML_Parser)userData;
707 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
713 ftprintf(fp, T("<entity name=\"%s\""), entityName);
714 metaLocation(parser);
716 characterData(data, value, value_length);
717 fputts(T("</entity/>\n"), fp);
718 } else if (notationName) {
719 ftprintf(fp, T("<entity name=\"%s\""), entityName);
721 ftprintf(fp, T(" public=\"%s\""), publicId);
722 fputts(T(" system=\""), fp);
723 characterData(data, systemId, (int)tcslen(systemId));
725 ftprintf(fp, T(" notation=\"%s\""), notationName);
726 metaLocation(parser);
727 fputts(T("/>\n"), fp);
729 ftprintf(fp, T("<entity name=\"%s\""), entityName);
731 ftprintf(fp, T(" public=\"%s\""), publicId);
732 fputts(T(" system=\""), fp);
733 characterData(data, systemId, (int)tcslen(systemId));
735 metaLocation(parser);
736 fputts(T("/>\n"), fp);
741 metaStartNamespaceDecl(void *userData, const XML_Char *prefix,
742 const XML_Char *uri) {
743 XML_Parser parser = (XML_Parser)userData;
744 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
746 fputts(T("<startns"), fp);
748 ftprintf(fp, T(" prefix=\"%s\""), prefix);
750 fputts(T(" ns=\""), fp);
751 characterData(data, uri, (int)tcslen(uri));
752 fputts(T("\"/>\n"), fp);
754 fputts(T("/>\n"), fp);
758 metaEndNamespaceDecl(void *userData, const XML_Char *prefix) {
759 XML_Parser parser = (XML_Parser)userData;
760 XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
763 fputts(T("<endns/>\n"), fp);
765 ftprintf(fp, T("<endns prefix=\"%s\"/>\n"), prefix);
769 unknownEncodingConvert(void *data, const char *p) {
770 return codepageConvert(*(int *)data, p);
774 unknownEncoding(void *userData, const XML_Char *name, XML_Encoding *info) {
776 static const XML_Char prefixL[] = T("windows-");
777 static const XML_Char prefixU[] = T("WINDOWS-");
781 for (i = 0; prefixU[i]; i++)
782 if (name[i] != prefixU[i] && name[i] != prefixL[i])
786 for (; name[i]; i++) {
787 static const XML_Char digits[] = T("0123456789");
788 const XML_Char *s = tcschr(digits, name[i]);
792 cp += (int)(s - digits);
796 if (! codepageMap(cp, info->map))
798 info->convert = unknownEncodingConvert;
799 /* We could just cast the code page integer to a void *,
800 and avoid the use of release. */
801 info->release = free;
802 info->data = malloc(sizeof(int));
805 *(int *)info->data = cp;
810 notStandalone(void *userData) {
816 showVersion(XML_Char *prog) {
819 const XML_Feature *features = XML_GetFeatureList();
820 while ((ch = *s) != 0) {
829 ftprintf(stdout, T("%s using %s\n"), prog, XML_ExpatVersion());
830 if (features != NULL && features[0].feature != XML_FEATURE_END) {
832 ftprintf(stdout, T("%s"), features[0].name);
833 if (features[0].value)
834 ftprintf(stdout, T("=%ld"), features[0].value);
835 while (features[i].feature != XML_FEATURE_END) {
836 ftprintf(stdout, T(", %s"), features[i].name);
837 if (features[i].value)
838 ftprintf(stdout, T("=%ld"), features[i].value);
841 ftprintf(stdout, T("\n"));
846 usage(const XML_Char *prog, int rc) {
850 * $ xmlwf/xmlwf_helpgen.sh
852 /* clang-format off */
853 T("usage: %s [-s] [-n] [-p] [-x] [-e ENCODING] [-w] [-r] [-d DIRECTORY]\n")
854 T(" [-c | -m | -t] [-N]\n")
855 T(" [FILE [FILE ...]]\n")
857 T("xmlwf - Determines if an XML document is well-formed\n")
859 T("positional arguments:\n")
860 T(" FILE files to process (default: STDIN)\n")
862 T("input control arguments:\n")
863 T(" -s print an error if the document is not [s]tandalone\n")
864 T(" -n enable [n]amespace processing\n")
865 T(" -p enable processing external DTDs and [p]arameter entities\n")
866 T(" -x enable processing of e[x]ternal entities\n")
867 T(" -e ENCODING override any in-document [e]ncoding declaration\n")
868 T(" -w enable support for [W]indows code pages\n")
869 T(" -r disable memory-mapping and use normal file [r]ead IO calls instead\n")
871 T("output control arguments:\n")
872 T(" -d DIRECTORY output [d]estination directory\n")
873 T(" -c write a [c]opy of input XML, not canonical XML\n")
874 T(" -m write [m]eta XML, not canonical XML\n")
875 T(" -t write no XML output for [t]iming of plain parsing\n")
876 T(" -N enable adding doctype and [n]otation declarations\n")
878 T("info arguments:\n")
879 T(" -h show this [h]elp message and exit\n")
880 T(" -v show program's [v]ersion number and exit\n")
882 T("libexpat is software libre, licensed under the MIT license.\n")
883 T("Please report bugs at https://github.com/libexpat/libexpat/issues. Thank you!\n")
884 , /* clang-format on */
889 #if defined(__MINGW32__) && defined(XML_UNICODE)
890 /* Silence warning about missing prototype */
891 int wmain(int argc, XML_Char **argv);
895 tmain(int argc, XML_Char **argv) {
897 const XML_Char *outputDir = NULL;
898 const XML_Char *encoding = NULL;
899 unsigned processFlags = XML_MAP_FILE;
900 int windowsCodePages = 0;
902 int useNamespaces = 0;
903 int requireStandalone = 0;
904 int requiresNotations = 0;
905 enum XML_ParamEntityParsing paramEntityParsing
906 = XML_PARAM_ENTITY_PARSING_NEVER;
908 XmlwfUserData userData = {NULL, NULL, NULL};
911 _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
918 if (argv[i][0] != T('-'))
920 if (argv[i][1] == T('-') && argv[i][2] == T('\0')) {
926 switch (argv[i][j]) {
928 processFlags &= ~XML_MAP_FILE;
932 requireStandalone = 1;
940 paramEntityParsing = XML_PARAM_ENTITY_PARSING_ALWAYS;
943 processFlags |= XML_EXTERNAL_ENTITIES;
947 windowsCodePages = 1;
964 requiresNotations = 1;
968 if (argv[i][j + 1] == T('\0')) {
973 outputDir = argv[i] + j + 1;
978 if (argv[i][j + 1] == T('\0')) {
983 encoding = argv[i] + j + 1;
991 showVersion(argv[0]);
1006 processFlags &= ~XML_MAP_FILE;
1009 for (; i < argc; i++) {
1010 XML_Char *outName = 0;
1014 parser = XML_ParserCreateNS(encoding, NSSEP);
1016 parser = XML_ParserCreate(encoding);
1019 tperror(T("Could not instantiate parser"));
1023 if (requireStandalone)
1024 XML_SetNotStandaloneHandler(parser, notStandalone);
1025 XML_SetParamEntityParsing(parser, paramEntityParsing);
1026 if (outputType == 't') {
1027 /* This is for doing timings; this gives a more realistic estimate of
1028 the parsing time. */
1030 XML_SetElementHandler(parser, nopStartElement, nopEndElement);
1031 XML_SetCharacterDataHandler(parser, nopCharacterData);
1032 XML_SetProcessingInstructionHandler(parser, nopProcessingInstruction);
1033 } else if (outputDir) {
1034 const XML_Char *delim = T("/");
1035 const XML_Char *file = useStdin ? T("STDIN") : argv[i];
1037 /* Jump after last (back)slash */
1038 const XML_Char *lastDelim = tcsrchr(file, delim[0]);
1040 file = lastDelim + 1;
1043 const XML_Char *winDelim = T("\\");
1044 lastDelim = tcsrchr(file, winDelim[0]);
1046 file = lastDelim + 1;
1052 outName = (XML_Char *)malloc((tcslen(outputDir) + tcslen(file) + 2)
1053 * sizeof(XML_Char));
1054 tcscpy(outName, outputDir);
1055 tcscat(outName, delim);
1056 tcscat(outName, file);
1057 userData.fp = tfopen(outName, T("wb"));
1058 if (! userData.fp) {
1062 setvbuf(userData.fp, NULL, _IOFBF, 16384);
1064 puttc(0xFEFF, userData.fp);
1066 XML_SetUserData(parser, &userData);
1067 switch (outputType) {
1069 XML_UseParserAsHandlerArg(parser);
1070 XML_SetElementHandler(parser, metaStartElement, metaEndElement);
1071 XML_SetProcessingInstructionHandler(parser, metaProcessingInstruction);
1072 XML_SetCommentHandler(parser, metaComment);
1073 XML_SetCdataSectionHandler(parser, metaStartCdataSection,
1074 metaEndCdataSection);
1075 XML_SetCharacterDataHandler(parser, metaCharacterData);
1076 XML_SetDoctypeDeclHandler(parser, metaStartDoctypeDecl,
1077 metaEndDoctypeDecl);
1078 XML_SetEntityDeclHandler(parser, metaEntityDecl);
1079 XML_SetNotationDeclHandler(parser, metaNotationDecl);
1080 XML_SetNamespaceDeclHandler(parser, metaStartNamespaceDecl,
1081 metaEndNamespaceDecl);
1082 metaStartDocument(parser);
1085 XML_UseParserAsHandlerArg(parser);
1086 XML_SetDefaultHandler(parser, markup);
1087 XML_SetElementHandler(parser, defaultStartElement, defaultEndElement);
1088 XML_SetCharacterDataHandler(parser, defaultCharacterData);
1089 XML_SetProcessingInstructionHandler(parser,
1090 defaultProcessingInstruction);
1094 XML_SetElementHandler(parser, startElementNS, endElementNS);
1096 XML_SetElementHandler(parser, startElement, endElement);
1097 XML_SetCharacterDataHandler(parser, characterData);
1099 XML_SetProcessingInstructionHandler(parser, processingInstruction);
1100 if (requiresNotations) {
1101 XML_SetDoctypeDeclHandler(parser, startDoctypeDecl, endDoctypeDecl);
1102 XML_SetNotationDeclHandler(parser, notationDecl);
1104 #endif /* not W3C14N */
1108 if (windowsCodePages)
1109 XML_SetUnknownEncodingHandler(parser, unknownEncoding, 0);
1110 result = XML_ProcessFile(parser, useStdin ? NULL : argv[i], processFlags);
1112 if (outputType == 'm')
1113 metaEndDocument(parser);
1114 fclose(userData.fp);
1120 XML_ParserFree(parser);