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("&"), 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

    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("&"), fp);

    72       break;

    73     case T('<'):

    74       fputts(T("<"), fp);

    75       break;

    76     case T('"'):

    77       fputts(T("""), fp);

    78       break;

    79 #ifdef W3C14N

    80     case 9:

    81       fputts(T("	"), fp);

    82       break;

    83     case 10:

    84       fputts(T("
"), fp);

    85       break;

    86     case 13:

    87       fputts(T("
"), fp);

    88       break;

    89 #else

    90     case T('>'):

    91       fputts(T(">"), 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 }