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