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