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