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