src/expat/xmlwf/xmlwf.c

   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("&amp;"), fp);
  31       break;
  32     case T('<'):
  33       fputts(T("&lt;"), fp);
  34       break;
  35     case T('>'):
  36       fputts(T("&gt;"), fp);
  37       break;
  38 #ifdef W3C14N
  39     case 13:
  40       fputts(T("&#xD;"), fp);
  41       break;
  42 #else
  43     case T('"'):
  44       fputts(T("&quot;"), 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("&amp;"), fp);
  72       break;
  73     case T('<'):
  74       fputts(T("&lt;"), fp);
  75       break;
  76     case T('"'):
  77       fputts(T("&quot;"), fp);
  78       break;
  79 #ifdef W3C14N
  80     case 9:
  81       fputts(T("&#x9;"), fp);
  82       break;
  83     case 10:
  84       fputts(T("&#xA;"), fp);
  85       break;
  86     case 13:
  87       fputts(T("&#xD;"), fp);
  88       break;
  89 #else
  90     case T('>'):
  91       fputts(T("&gt;"), 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 }