Home | History | Annotate | Download | only in xmlwf 
      1 /*
      2                             __  __            _
      3                          ___\ \/ /_ __   __ _| |_
      4                         / _ \\  /| '_ \ / _` | __|
      5                        |  __//  \| |_) | (_| | |_
      6                         \___/_/\_\ .__/ \__,_|\__|
      7                                  |_| XML parser
      8 
      9    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
     10    Copyright (c) 2000-2017 Expat development team
     11    Licensed under the MIT license:
     12 
     13    Permission is  hereby granted,  free of charge,  to any  person obtaining
     14    a  copy  of  this  software   and  associated  documentation  files  (the
     15    "Software"),  to  deal in  the  Software  without restriction,  including
     16    without  limitation the  rights  to use,  copy,  modify, merge,  publish,
     17    distribute, sublicense, and/or sell copies of the Software, and to permit
     18    persons  to whom  the Software  is  furnished to  do so,  subject to  the
     19    following conditions:
     20 
     21    The above copyright  notice and this permission notice  shall be included
     22    in all copies or substantial portions of the Software.
     23 
     24    THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
     25    EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
     26    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
     27    NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
     28    DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
     29    OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
     30    USE OR OTHER DEALINGS IN THE SOFTWARE.
     31 */
     32 
     33 #include <assert.h>
     34 #include <stdio.h>
     35 #include <stdlib.h>
     36 #include <stddef.h>
     37 #include <string.h>
     38 
     39 #include "expat.h"
     40 #include "codepage.h"
     41 #include "internal.h"  /* for UNUSED_P only */
     42 #include "xmlfile.h"
     43 #include "xmltchar.h"
     44 
     45 #ifdef _MSC_VER
     46 # include <crtdbg.h>
     47 #endif
     48 
     49 #ifdef XML_UNICODE
     50 # include <wchar.h>
     51 #endif
     52 
     53 /* Structures for handler user data */
     54 typedef struct NotationList {
     55   struct NotationList *next;
     56   const XML_Char *notationName;
     57   const XML_Char *systemId;
     58   const XML_Char *publicId;
     59 } NotationList;
     60 
     61 typedef struct xmlwfUserData {
     62   FILE *fp;
     63   NotationList *notationListHead;
     64   const XML_Char *currentDoctypeName;
     65 } XmlwfUserData;
     66 
     67 
     68 /* This ensures proper sorting. */
     69 
     70 #define NSSEP T('\001')
     71 
     72 static void XMLCALL
     73 characterData(void *userData, const XML_Char *s, int len)
     74 {
     75   FILE *fp = ((XmlwfUserData *)userData)->fp;
     76   for (; len > 0; --len, ++s) {
     77     switch (*s) {
     78     case T('&'):
     79       fputts(T("&amp;"), fp);
     80       break;
     81     case T('<'):
     82       fputts(T("&lt;"), fp);
     83       break;
     84     case T('>'):
     85       fputts(T("&gt;"), fp);
     86       break;
     87 #ifdef W3C14N
     88     case 13:
     89       fputts(T("&#xD;"), fp);
     90       break;
     91 #else
     92     case T('"'):
     93       fputts(T("&quot;"), fp);
     94       break;
     95     case 9:
     96     case 10:
     97     case 13:
     98       ftprintf(fp, T("&#%d;"), *s);
     99       break;
    100 #endif
    101     default:
    102       puttc(*s, fp);
    103       break;
    104     }
    105   }
    106 }
    107 
    108 static void
    109 attributeValue(FILE *fp, const XML_Char *s)
    110 {
    111   puttc(T('='), fp);
    112   puttc(T('"'), fp);
    113   assert(s);
    114   for (;;) {
    115     switch (*s) {
    116     case 0:
    117     case NSSEP:
    118       puttc(T('"'), fp);
    119       return;
    120     case T('&'):
    121       fputts(T("&amp;"), fp);
    122       break;
    123     case T('<'):
    124       fputts(T("&lt;"), fp);
    125       break;
    126     case T('"'):
    127       fputts(T("&quot;"), fp);
    128       break;
    129 #ifdef W3C14N
    130     case 9:
    131       fputts(T("&#x9;"), fp);
    132       break;
    133     case 10:
    134       fputts(T("&#xA;"), fp);
    135       break;
    136     case 13:
    137       fputts(T("&#xD;"), fp);
    138       break;
    139 #else
    140     case T('>'):
    141       fputts(T("&gt;"), fp);
    142       break;
    143     case 9:
    144     case 10:
    145     case 13:
    146       ftprintf(fp, T("&#%d;"), *s);
    147       break;
    148 #endif
    149     default:
    150       puttc(*s, fp);
    151       break;
    152     }
    153     s++;
    154   }
    155 }
    156 
    157 /* Lexicographically comparing UTF-8 encoded attribute values,
    158 is equivalent to lexicographically comparing based on the character number. */
    159 
    160 static int
    161 attcmp(const void *att1, const void *att2)
    162 {
    163   return tcscmp(*(const XML_Char **)att1, *(const XML_Char **)att2);
    164 }
    165 
    166 static void XMLCALL
    167 startElement(void *userData, const XML_Char *name, const XML_Char **atts)
    168 {
    169   int nAtts;
    170   const XML_Char **p;
    171   FILE *fp = ((XmlwfUserData *)userData)->fp;
    172   puttc(T('<'), fp);
    173   fputts(name, fp);
    174 
    175   p = atts;
    176   while (*p)
    177     ++p;
    178   nAtts = (int)((p - atts) >> 1);
    179   if (nAtts > 1)
    180     qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, attcmp);
    181   while (*atts) {
    182     puttc(T(' '), fp);
    183     fputts(*atts++, fp);
    184     attributeValue(fp, *atts);
    185     atts++;
    186   }
    187   puttc(T('>'), fp);
    188 }
    189 
    190 static void XMLCALL
    191 endElement(void *userData, const XML_Char *name)
    192 {
    193   FILE *fp = ((XmlwfUserData *)userData)->fp;
    194   puttc(T('<'), fp);
    195   puttc(T('/'), fp);
    196   fputts(name, fp);
    197   puttc(T('>'), fp);
    198 }
    199 
    200 static int
    201 nsattcmp(const void *p1, const void *p2)
    202 {
    203   const XML_Char *att1 = *(const XML_Char **)p1;
    204   const XML_Char *att2 = *(const XML_Char **)p2;
    205   int sep1 = (tcsrchr(att1, NSSEP) != 0);
    206   int sep2 = (tcsrchr(att1, NSSEP) != 0);
    207   if (sep1 != sep2)
    208     return sep1 - sep2;
    209   return tcscmp(att1, att2);
    210 }
    211 
    212 static void XMLCALL
    213 startElementNS(void *userData, const XML_Char *name, const XML_Char **atts)
    214 {
    215   int nAtts;
    216   int nsi;
    217   const XML_Char **p;
    218   FILE *fp = ((XmlwfUserData *)userData)->fp;
    219   const XML_Char *sep;
    220   puttc(T('<'), fp);
    221 
    222   sep = tcsrchr(name, NSSEP);
    223   if (sep) {
    224     fputts(T("n1:"), fp);
    225     fputts(sep + 1, fp);
    226     fputts(T(" xmlns:n1"), fp);
    227     attributeValue(fp, name);
    228     nsi = 2;
    229   }
    230   else {
    231     fputts(name, fp);
    232     nsi = 1;
    233   }
    234 
    235   p = atts;
    236   while (*p)
    237     ++p;
    238   nAtts = (int)((p - atts) >> 1);
    239   if (nAtts > 1)
    240     qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, nsattcmp);
    241   while (*atts) {
    242     name = *atts++;
    243     sep = tcsrchr(name, NSSEP);
    244     puttc(T(' '), fp);
    245     if (sep) {
    246       ftprintf(fp, T("n%d:"), nsi);
    247       fputts(sep + 1, fp);
    248     }
    249     else
    250       fputts(name, fp);
    251     attributeValue(fp, *atts);
    252     if (sep) {
    253       ftprintf(fp, T(" xmlns:n%d"), nsi++);
    254       attributeValue(fp, name);
    255     }
    256     atts++;
    257   }
    258   puttc(T('>'), fp);
    259 }
    260 
    261 static void XMLCALL
    262 endElementNS(void *userData, const XML_Char *name)
    263 {
    264   FILE *fp = ((XmlwfUserData *)userData)->fp;
    265   const XML_Char *sep;
    266   puttc(T('<'), fp);
    267   puttc(T('/'), fp);
    268   sep = tcsrchr(name, NSSEP);
    269   if (sep) {
    270     fputts(T("n1:"), fp);
    271     fputts(sep + 1, fp);
    272   }
    273   else
    274     fputts(name, fp);
    275   puttc(T('>'), fp);
    276 }
    277 
    278 #ifndef W3C14N
    279 
    280 static void XMLCALL
    281 processingInstruction(void *userData, const XML_Char *target,
    282                       const XML_Char *data)
    283 {
    284   FILE *fp = ((XmlwfUserData *)userData)->fp;
    285   puttc(T('<'), fp);
    286   puttc(T('?'), fp);
    287   fputts(target, fp);
    288   puttc(T(' '), fp);
    289   fputts(data, fp);
    290   puttc(T('?'), fp);
    291   puttc(T('>'), fp);
    292 }
    293 
    294 
    295 static XML_Char *xcsdup(const XML_Char *s)
    296 {
    297   XML_Char *result;
    298   int count = 0;
    299   int numBytes;
    300 
    301   /* Get the length of the string, including terminator */
    302   while (s[count++] != 0) {
    303     /* Do nothing */
    304   }
    305   numBytes = count * sizeof(XML_Char);
    306   result = malloc(numBytes);
    307   if (result == NULL)
    308     return NULL;
    309   memcpy(result, s, numBytes);
    310   return result;
    311 }
    312 
    313 static void XMLCALL
    314 startDoctypeDecl(void *userData,
    315                  const XML_Char *doctypeName,
    316                  const XML_Char *UNUSED_P(sysid),
    317                  const XML_Char *UNUSED_P(publid),
    318                  int UNUSED_P(has_internal_subset))
    319 {
    320   XmlwfUserData *data = (XmlwfUserData *)userData;
    321   data->currentDoctypeName = xcsdup(doctypeName);
    322 }
    323 
    324 static void
    325 freeNotations(XmlwfUserData *data)
    326 {
    327   NotationList *notationListHead = data->notationListHead;
    328 
    329   while (notationListHead != NULL) {
    330     NotationList *next = notationListHead->next;
    331     free((void *)notationListHead->notationName);
    332     free((void *)notationListHead->systemId);
    333     free((void *)notationListHead->publicId);
    334     free(notationListHead);
    335     notationListHead = next;
    336   }
    337   data->notationListHead = NULL;
    338 }
    339 
    340 static int xcscmp(const XML_Char *xs, const XML_Char *xt)
    341 {
    342   while (*xs != 0 && *xt != 0) {
    343     if (*xs < *xt)
    344       return -1;
    345     if (*xs > *xt)
    346       return 1;
    347     xs++;
    348     xt++;
    349   }
    350   if (*xs < *xt)
    351     return -1;
    352   if (*xs > *xt)
    353     return 1;
    354   return 0;
    355 }
    356 
    357 static int
    358 notationCmp(const void *a, const void *b)
    359 {
    360   const NotationList * const n1 = *(NotationList **)a;
    361   const NotationList * const n2 = *(NotationList **)b;
    362 
    363   return xcscmp(n1->notationName, n2->notationName);
    364 }
    365 
    366 static void XMLCALL
    367 endDoctypeDecl(void *userData)
    368 {
    369   XmlwfUserData *data = (XmlwfUserData *)userData;
    370   NotationList **notations;
    371   int notationCount = 0;
    372   NotationList *p;
    373   int i;
    374 
    375   /* How many notations do we have? */
    376   for (p = data->notationListHead; p != NULL; p = p->next)
    377     notationCount++;
    378   if (notationCount == 0) {
    379     /* Nothing to report */
    380     free((void *)data->currentDoctypeName);
    381     data->currentDoctypeName = NULL;
    382     return;
    383   }
    384 
    385   notations = malloc(notationCount * sizeof(NotationList *));
    386   if (notations == NULL) {
    387     fprintf(stderr, "Unable to sort notations");
    388     freeNotations(data);
    389     return;
    390   }
    391 
    392   for (p = data->notationListHead, i = 0;
    393        i < notationCount;
    394        p = p->next, i++) {
    395     notations[i] = p;
    396   }
    397   qsort(notations, notationCount, sizeof(NotationList *), notationCmp);
    398 
    399   /* Output the DOCTYPE header */
    400   fputts(T("<!DOCTYPE "), data->fp);
    401   fputts(data->currentDoctypeName, data->fp);
    402   fputts(T(" [\n"), data->fp);
    403 
    404   /* Now the NOTATIONs */
    405   for (i = 0; i < notationCount; i++) {
    406     fputts(T("<!NOTATION "), data->fp);
    407     fputts(notations[i]->notationName, data->fp);
    408     if (notations[i]->publicId != NULL) {
    409       fputts(T(" PUBLIC '"), data->fp);
    410       fputts(notations[i]->publicId, data->fp);
    411       puttc(T('\''), data->fp);
    412       if (notations[i]->systemId != NULL) {
    413         puttc(T(' '), data->fp);
    414         puttc(T('\''), data->fp);
    415         fputts(notations[i]->systemId, data->fp);
    416         puttc(T('\''), data->fp);
    417       }
    418     }
    419     else if (notations[i]->systemId != NULL) {
    420       fputts(T(" SYSTEM '"), data->fp);
    421       fputts(notations[i]->systemId, data->fp);
    422       puttc(T('\''), data->fp);
    423     }
    424     puttc(T('>'), data->fp);
    425     puttc(T('\n'), data->fp);
    426   }
    427 
    428   /* Finally end the DOCTYPE */
    429   fputts(T("]>\n"), data->fp);
    430 
    431   free(notations);
    432   freeNotations(data);
    433   free((void *)data->currentDoctypeName);
    434   data->currentDoctypeName = NULL;
    435 }
    436 
    437 static void XMLCALL
    438 notationDecl(void *userData,
    439              const XML_Char *notationName,
    440              const XML_Char *UNUSED_P(base),
    441              const XML_Char *systemId,
    442              const XML_Char *publicId)
    443 {
    444   XmlwfUserData *data = (XmlwfUserData *)userData;
    445   NotationList *entry = malloc(sizeof(NotationList));
    446   const char *errorMessage = "Unable to store NOTATION for output\n";
    447 
    448   if (entry == NULL) {
    449     fputs(errorMessage, stderr);
    450     return; /* Nothing we can really do about this */
    451   }
    452   entry->notationName = xcsdup(notationName);
    453   if (entry->notationName == NULL) {
    454     fputs(errorMessage, stderr);
    455     free(entry);
    456     return;
    457   }
    458   if (systemId != NULL) {
    459     entry->systemId = xcsdup(systemId);
    460     if (entry->systemId == NULL) {
    461       fputs(errorMessage, stderr);
    462       free((void *)entry->notationName);
    463       free(entry);
    464       return;
    465     }
    466   }
    467   else {
    468     entry->systemId = NULL;
    469   }
    470   if (publicId != NULL) {
    471     entry->publicId = xcsdup(publicId);
    472     if (entry->publicId == NULL) {
    473       fputs(errorMessage, stderr);
    474       free((void *)entry->systemId); /* Safe if it's NULL */
    475       free((void *)entry->notationName);
    476       free(entry);
    477       return;
    478     }
    479   }
    480   else {
    481     entry->publicId = NULL;
    482   }
    483 
    484   entry->next = data->notationListHead;
    485   data->notationListHead = entry;
    486 }
    487 
    488 #endif /* not W3C14N */
    489 
    490 static void XMLCALL
    491 defaultCharacterData(void *userData, const XML_Char *UNUSED_P(s), int UNUSED_P(len))
    492 {
    493   XML_DefaultCurrent((XML_Parser) userData);
    494 }
    495 
    496 static void XMLCALL
    497 defaultStartElement(void *userData, const XML_Char *UNUSED_P(name),
    498                     const XML_Char **UNUSED_P(atts))
    499 {
    500   XML_DefaultCurrent((XML_Parser) userData);
    501 }
    502 
    503 static void XMLCALL
    504 defaultEndElement(void *userData, const XML_Char *UNUSED_P(name))
    505 {
    506   XML_DefaultCurrent((XML_Parser) userData);
    507 }
    508 
    509 static void XMLCALL
    510 defaultProcessingInstruction(void *userData, const XML_Char *UNUSED_P(target),
    511                              const XML_Char *UNUSED_P(data))
    512 {
    513   XML_DefaultCurrent((XML_Parser) userData);
    514 }
    515 
    516 static void XMLCALL
    517 nopCharacterData(void *UNUSED_P(userData), const XML_Char *UNUSED_P(s), int UNUSED_P(len))
    518 {
    519 }
    520 
    521 static void XMLCALL
    522 nopStartElement(void *UNUSED_P(userData), const XML_Char *UNUSED_P(name), const XML_Char **UNUSED_P(atts))
    523 {
    524 }
    525 
    526 static void XMLCALL
    527 nopEndElement(void *UNUSED_P(userData), const XML_Char *UNUSED_P(name))
    528 {
    529 }
    530 
    531 static void XMLCALL
    532 nopProcessingInstruction(void *UNUSED_P(userData), const XML_Char *UNUSED_P(target),
    533                          const XML_Char *UNUSED_P(data))
    534 {
    535 }
    536 
    537 static void XMLCALL
    538 markup(void *userData, const XML_Char *s, int len)
    539 {
    540   FILE *fp = ((XmlwfUserData *)XML_GetUserData((XML_Parser) userData))->fp;
    541   for (; len > 0; --len, ++s)
    542     puttc(*s, fp);
    543 }
    544 
    545 static void
    546 metaLocation(XML_Parser parser)
    547 {
    548   const XML_Char *uri = XML_GetBase(parser);
    549   FILE *fp = ((XmlwfUserData *)XML_GetUserData(parser))->fp;
    550   if (uri)
    551     ftprintf(fp, T(" uri=\"%s\""), uri);
    552   ftprintf(fp,
    553            T(" byte=\"%") T(XML_FMT_INT_MOD) T("d\"")
    554              T(" nbytes=\"%d\"")
    555              T(" line=\"%") T(XML_FMT_INT_MOD) T("u\"")
    556              T(" col=\"%") T(XML_FMT_INT_MOD) T("u\""),
    557            XML_GetCurrentByteIndex(parser),
    558            XML_GetCurrentByteCount(parser),
    559            XML_GetCurrentLineNumber(parser),
    560            XML_GetCurrentColumnNumber(parser));
    561 }
    562 
    563 static void
    564 metaStartDocument(void *userData)
    565 {
    566   fputts(T("<document>\n"),
    567          ((XmlwfUserData *)XML_GetUserData((XML_Parser) userData))->fp);
    568 }
    569 
    570 static void
    571 metaEndDocument(void *userData)
    572 {
    573   fputts(T("</document>\n"),
    574          ((XmlwfUserData *)XML_GetUserData((XML_Parser) userData))->fp);
    575 }
    576 
    577 static void XMLCALL
    578 metaStartElement(void *userData, const XML_Char *name,
    579                  const XML_Char **atts)
    580 {
    581   XML_Parser parser = (XML_Parser) userData;
    582   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
    583   FILE *fp = data->fp;
    584   const XML_Char **specifiedAttsEnd
    585     = atts + XML_GetSpecifiedAttributeCount(parser);
    586   const XML_Char **idAttPtr;
    587   int idAttIndex = XML_GetIdAttributeIndex(parser);
    588   if (idAttIndex < 0)
    589     idAttPtr = 0;
    590   else
    591     idAttPtr = atts + idAttIndex;
    592 
    593   ftprintf(fp, T("<starttag name=\"%s\""), name);
    594   metaLocation(parser);
    595   if (*atts) {
    596     fputts(T(">\n"), fp);
    597     do {
    598       ftprintf(fp, T("<attribute name=\"%s\" value=\""), atts[0]);
    599       characterData(data, atts[1], (int)tcslen(atts[1]));
    600       if (atts >= specifiedAttsEnd)
    601         fputts(T("\" defaulted=\"yes\"/>\n"), fp);
    602       else if (atts == idAttPtr)
    603         fputts(T("\" id=\"yes\"/>\n"), fp);
    604       else
    605         fputts(T("\"/>\n"), fp);
    606     } while (*(atts += 2));
    607     fputts(T("</starttag>\n"), fp);
    608   }
    609   else
    610     fputts(T("/>\n"), fp);
    611 }
    612 
    613 static void XMLCALL
    614 metaEndElement(void *userData, const XML_Char *name)
    615 {
    616   XML_Parser parser = (XML_Parser) userData;
    617   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
    618   FILE *fp = data->fp;
    619   ftprintf(fp, T("<endtag name=\"%s\""), name);
    620   metaLocation(parser);
    621   fputts(T("/>\n"), fp);
    622 }
    623 
    624 static void XMLCALL
    625 metaProcessingInstruction(void *userData, const XML_Char *target,
    626                           const XML_Char *data)
    627 {
    628   XML_Parser parser = (XML_Parser) userData;
    629   XmlwfUserData *usrData = (XmlwfUserData *)XML_GetUserData(parser);
    630   FILE *fp = usrData->fp;
    631   ftprintf(fp, T("<pi target=\"%s\" data=\""), target);
    632   characterData(usrData, data, (int)tcslen(data));
    633   puttc(T('"'), fp);
    634   metaLocation(parser);
    635   fputts(T("/>\n"), fp);
    636 }
    637 
    638 static void XMLCALL
    639 metaComment(void *userData, const XML_Char *data)
    640 {
    641   XML_Parser parser = (XML_Parser) userData;
    642   XmlwfUserData *usrData = (XmlwfUserData *)XML_GetUserData(parser);
    643   FILE *fp = usrData->fp;
    644   fputts(T("<comment data=\""), fp);
    645   characterData(usrData, data, (int)tcslen(data));
    646   puttc(T('"'), fp);
    647   metaLocation(parser);
    648   fputts(T("/>\n"), fp);
    649 }
    650 
    651 static void XMLCALL
    652 metaStartCdataSection(void *userData)
    653 {
    654   XML_Parser parser = (XML_Parser) userData;
    655   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
    656   FILE *fp = data->fp;
    657   fputts(T("<startcdata"), fp);
    658   metaLocation(parser);
    659   fputts(T("/>\n"), fp);
    660 }
    661 
    662 static void XMLCALL
    663 metaEndCdataSection(void *userData)
    664 {
    665   XML_Parser parser = (XML_Parser) userData;
    666   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
    667   FILE *fp = data->fp;
    668   fputts(T("<endcdata"), fp);
    669   metaLocation(parser);
    670   fputts(T("/>\n"), fp);
    671 }
    672 
    673 static void XMLCALL
    674 metaCharacterData(void *userData, const XML_Char *s, int len)
    675 {
    676   XML_Parser parser = (XML_Parser) userData;
    677   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
    678   FILE *fp = data->fp;
    679   fputts(T("<chars str=\""), fp);
    680   characterData(data, s, len);
    681   puttc(T('"'), fp);
    682   metaLocation(parser);
    683   fputts(T("/>\n"), fp);
    684 }
    685 
    686 static void XMLCALL
    687 metaStartDoctypeDecl(void *userData,
    688                      const XML_Char *doctypeName,
    689                      const XML_Char *UNUSED_P(sysid),
    690                      const XML_Char *UNUSED_P(pubid),
    691                      int UNUSED_P(has_internal_subset))
    692 {
    693   XML_Parser parser = (XML_Parser) userData;
    694   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
    695   FILE *fp = data->fp;
    696   ftprintf(fp, T("<startdoctype name=\"%s\""), doctypeName);
    697   metaLocation(parser);
    698   fputts(T("/>\n"), fp);
    699 }
    700 
    701 static void XMLCALL
    702 metaEndDoctypeDecl(void *userData)
    703 {
    704   XML_Parser parser = (XML_Parser) userData;
    705   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
    706   FILE *fp = data->fp;
    707   fputts(T("<enddoctype"), fp);
    708   metaLocation(parser);
    709   fputts(T("/>\n"), fp);
    710 }
    711 
    712 static void XMLCALL
    713 metaNotationDecl(void *userData,
    714                  const XML_Char *notationName,
    715                  const XML_Char *UNUSED_P(base),
    716                  const XML_Char *systemId,
    717                  const XML_Char *publicId)
    718 {
    719   XML_Parser parser = (XML_Parser) userData;
    720   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
    721   FILE *fp = data->fp;
    722   ftprintf(fp, T("<notation name=\"%s\""), notationName);
    723   if (publicId)
    724     ftprintf(fp, T(" public=\"%s\""), publicId);
    725   if (systemId) {
    726     fputts(T(" system=\""), fp);
    727     characterData(data, systemId, (int)tcslen(systemId));
    728     puttc(T('"'), fp);
    729   }
    730   metaLocation(parser);
    731   fputts(T("/>\n"), fp);
    732 }
    733 
    734 
    735 static void XMLCALL
    736 metaEntityDecl(void *userData,
    737                const XML_Char *entityName,
    738                int  UNUSED_P(is_param),
    739                const XML_Char *value,
    740                int  value_length,
    741                const XML_Char *UNUSED_P(base),
    742                const XML_Char *systemId,
    743                const XML_Char *publicId,
    744                const XML_Char *notationName)
    745 {
    746   XML_Parser parser = (XML_Parser) userData;
    747   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
    748   FILE *fp = data->fp;
    749 
    750   if (value) {
    751     ftprintf(fp, T("<entity name=\"%s\""), entityName);
    752     metaLocation(parser);
    753     puttc(T('>'), fp);
    754     characterData(data, value, value_length);
    755     fputts(T("</entity/>\n"), fp);
    756   }
    757   else if (notationName) {
    758     ftprintf(fp, T("<entity name=\"%s\""), entityName);
    759     if (publicId)
    760       ftprintf(fp, T(" public=\"%s\""), publicId);
    761     fputts(T(" system=\""), fp);
    762     characterData(data, systemId, (int)tcslen(systemId));
    763     puttc(T('"'), fp);
    764     ftprintf(fp, T(" notation=\"%s\""), notationName);
    765     metaLocation(parser);
    766     fputts(T("/>\n"), fp);
    767   }
    768   else {
    769     ftprintf(fp, T("<entity name=\"%s\""), entityName);
    770     if (publicId)
    771       ftprintf(fp, T(" public=\"%s\""), publicId);
    772     fputts(T(" system=\""), fp);
    773     characterData(data, systemId, (int)tcslen(systemId));
    774     puttc(T('"'), fp);
    775     metaLocation(parser);
    776     fputts(T("/>\n"), fp);
    777   }
    778 }
    779 
    780 static void XMLCALL
    781 metaStartNamespaceDecl(void *userData,
    782                        const XML_Char *prefix,
    783                        const XML_Char *uri)
    784 {
    785   XML_Parser parser = (XML_Parser) userData;
    786   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
    787   FILE *fp = data->fp;
    788   fputts(T("<startns"), fp);
    789   if (prefix)
    790     ftprintf(fp, T(" prefix=\"%s\""), prefix);
    791   if (uri) {
    792     fputts(T(" ns=\""), fp);
    793     characterData(data, uri, (int)tcslen(uri));
    794     fputts(T("\"/>\n"), fp);
    795   }
    796   else
    797     fputts(T("/>\n"), fp);
    798 }
    799 
    800 static void XMLCALL
    801 metaEndNamespaceDecl(void *userData, const XML_Char *prefix)
    802 {
    803   XML_Parser parser = (XML_Parser) userData;
    804   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
    805   FILE *fp = data->fp;
    806   if (!prefix)
    807     fputts(T("<endns/>\n"), fp);
    808   else
    809     ftprintf(fp, T("<endns prefix=\"%s\"/>\n"), prefix);
    810 }
    811 
    812 static int XMLCALL
    813 unknownEncodingConvert(void *data, const char *p)
    814 {
    815   return codepageConvert(*(int *)data, p);
    816 }
    817 
    818 static int XMLCALL
    819 unknownEncoding(void *UNUSED_P(userData), const XML_Char *name, XML_Encoding *info)
    820 {
    821   int cp;
    822   static const XML_Char prefixL[] = T("windows-");
    823   static const XML_Char prefixU[] = T("WINDOWS-");
    824   int i;
    825 
    826   for (i = 0; prefixU[i]; i++)
    827     if (name[i] != prefixU[i] && name[i] != prefixL[i])
    828       return 0;
    829 
    830   cp = 0;
    831   for (; name[i]; i++) {
    832     static const XML_Char digits[] = T("0123456789");
    833     const XML_Char *s = tcschr(digits, name[i]);
    834     if (!s)
    835       return 0;
    836     cp *= 10;
    837     cp += (int)(s - digits);
    838     if (cp >= 0x10000)
    839       return 0;
    840   }
    841   if (!codepageMap(cp, info->map))
    842     return 0;
    843   info->convert = unknownEncodingConvert;
    844   /* We could just cast the code page integer to a void *,
    845   and avoid the use of release. */
    846   info->release = free;
    847   info->data = malloc(sizeof(int));
    848   if (!info->data)
    849     return 0;
    850   *(int *)info->data = cp;
    851   return 1;
    852 }
    853 
    854 static int XMLCALL
    855 notStandalone(void *UNUSED_P(userData))
    856 {
    857   return 0;
    858 }
    859 
    860 static void
    861 showVersion(XML_Char *prog)
    862 {
    863   XML_Char *s = prog;
    864   XML_Char ch;
    865   const XML_Feature *features = XML_GetFeatureList();
    866   while ((ch = *s) != 0) {
    867     if (ch == '/'
    868 #if defined(_WIN32)
    869         || ch == '\\'
    870 #endif
    871         )
    872       prog = s + 1;
    873     ++s;
    874   }
    875   ftprintf(stdout, T("%s using %s\n"), prog, XML_ExpatVersion());
    876   if (features != NULL && features[0].feature != XML_FEATURE_END) {
    877     int i = 1;
    878     ftprintf(stdout, T("%s"), features[0].name);
    879     if (features[0].value)
    880       ftprintf(stdout, T("=%ld"), features[0].value);
    881     while (features[i].feature != XML_FEATURE_END) {
    882       ftprintf(stdout, T(", %s"), features[i].name);
    883       if (features[i].value)
    884         ftprintf(stdout, T("=%ld"), features[i].value);
    885       ++i;
    886     }
    887     ftprintf(stdout, T("\n"));
    888   }
    889 }
    890 
    891 static void
    892 usage(const XML_Char *prog, int rc)
    893 {
    894   ftprintf(stderr,
    895            T("usage: %s [-s] [-n] [-p] [-x] [-e encoding] [-w] [-d output-dir] [-c] [-m] [-r] [-t] [-N] [file ...]\n"), prog);
    896   exit(rc);
    897 }
    898 
    899 #if defined(__MINGW32__) && defined(XML_UNICODE)
    900 /* Silence warning about missing prototype */
    901 int wmain(int argc, XML_Char **argv);
    902 #endif
    903 
    904 int
    905 tmain(int argc, XML_Char **argv)
    906 {
    907   int i, j;
    908   const XML_Char *outputDir = NULL;
    909   const XML_Char *encoding = NULL;
    910   unsigned processFlags = XML_MAP_FILE;
    911   int windowsCodePages = 0;
    912   int outputType = 0;
    913   int useNamespaces = 0;
    914   int requireStandalone = 0;
    915   int requiresNotations = 0;
    916   enum XML_ParamEntityParsing paramEntityParsing =
    917     XML_PARAM_ENTITY_PARSING_NEVER;
    918   int useStdin = 0;
    919   XmlwfUserData userData = { NULL, NULL, NULL };
    920 
    921 #ifdef _MSC_VER
    922   _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_LEAK_CHECK_DF);
    923 #endif
    924 
    925   i = 1;
    926   j = 0;
    927   while (i < argc) {
    928     if (j == 0) {
    929       if (argv[i][0] != T('-'))
    930         break;
    931       if (argv[i][1] == T('-') && argv[i][2] == T('\0')) {
    932         i++;
    933         break;
    934       }
    935       j++;
    936     }
    937     switch (argv[i][j]) {
    938     case T('r'):
    939       processFlags &= ~XML_MAP_FILE;
    940       j++;
    941       break;
    942     case T('s'):
    943       requireStandalone = 1;
    944       j++;
    945       break;
    946     case T('n'):
    947       useNamespaces = 1;
    948       j++;
    949       break;
    950     case T('p'):
    951       paramEntityParsing = XML_PARAM_ENTITY_PARSING_ALWAYS;
    952       /* fall through */
    953     case T('x'):
    954       processFlags |= XML_EXTERNAL_ENTITIES;
    955       j++;
    956       break;
    957     case T('w'):
    958       windowsCodePages = 1;
    959       j++;
    960       break;
    961     case T('m'):
    962       outputType = 'm';
    963       j++;
    964       break;
    965     case T('c'):
    966       outputType = 'c';
    967       useNamespaces = 0;
    968       j++;
    969       break;
    970     case T('t'):
    971       outputType = 't';
    972       j++;
    973       break;
    974     case T('N'):
    975       requiresNotations = 1;
    976       j++;
    977       break;
    978     case T('d'):
    979       if (argv[i][j + 1] == T('\0')) {
    980         if (++i == argc)
    981           usage(argv[0], 2);
    982         outputDir = argv[i];
    983       }
    984       else
    985         outputDir = argv[i] + j + 1;
    986       i++;
    987       j = 0;
    988       break;
    989     case T('e'):
    990       if (argv[i][j + 1] == T('\0')) {
    991         if (++i == argc)
    992           usage(argv[0], 2);
    993         encoding = argv[i];
    994       }
    995       else
    996         encoding = argv[i] + j + 1;
    997       i++;
    998       j = 0;
    999       break;
   1000     case T('h'):
   1001       usage(argv[0], 0);
   1002       return 0;
   1003     case T('v'):
   1004       showVersion(argv[0]);
   1005       return 0;
   1006     case T('\0'):
   1007       if (j > 1) {
   1008         i++;
   1009         j = 0;
   1010         break;
   1011       }
   1012       /* fall through */
   1013     default:
   1014       usage(argv[0], 2);
   1015     }
   1016   }
   1017   if (i == argc) {
   1018     useStdin = 1;
   1019     processFlags &= ~XML_MAP_FILE;
   1020     i--;
   1021   }
   1022   for (; i < argc; i++) {
   1023     XML_Char *outName = 0;
   1024     int result;
   1025     XML_Parser parser;
   1026     if (useNamespaces)
   1027       parser = XML_ParserCreateNS(encoding, NSSEP);
   1028     else
   1029       parser = XML_ParserCreate(encoding);
   1030 
   1031     if (! parser) {
   1032       tperror(T("Could not instantiate parser"));
   1033       exit(1);
   1034     }
   1035 
   1036     if (requireStandalone)
   1037       XML_SetNotStandaloneHandler(parser, notStandalone);
   1038     XML_SetParamEntityParsing(parser, paramEntityParsing);
   1039     if (outputType == 't') {
   1040       /* This is for doing timings; this gives a more realistic estimate of
   1041          the parsing time. */
   1042       outputDir = 0;
   1043       XML_SetElementHandler(parser, nopStartElement, nopEndElement);
   1044       XML_SetCharacterDataHandler(parser, nopCharacterData);
   1045       XML_SetProcessingInstructionHandler(parser, nopProcessingInstruction);
   1046     }
   1047     else if (outputDir) {
   1048       const XML_Char * delim = T("/");
   1049       const XML_Char *file = useStdin ? T("STDIN") : argv[i];
   1050       if (!useStdin) {
   1051         /* Jump after last (back)slash */
   1052         const XML_Char * lastDelim = tcsrchr(file, delim[0]);
   1053         if (lastDelim)
   1054           file = lastDelim + 1;
   1055 #if defined(_WIN32)
   1056         else {
   1057           const XML_Char * winDelim = T("\\");
   1058           lastDelim = tcsrchr(file, winDelim[0]);
   1059           if (lastDelim) {
   1060             file = lastDelim + 1;
   1061             delim = winDelim;
   1062           }
   1063         }
   1064 #endif
   1065       }
   1066       outName = (XML_Char *)malloc((tcslen(outputDir) + tcslen(file) + 2)
   1067                        * sizeof(XML_Char));
   1068       tcscpy(outName, outputDir);
   1069       tcscat(outName, delim);
   1070       tcscat(outName, file);
   1071       userData.fp = tfopen(outName, T("wb"));
   1072       if (!userData.fp) {
   1073         tperror(outName);
   1074         exit(1);
   1075       }
   1076       setvbuf(userData.fp, NULL, _IOFBF, 16384);
   1077 #ifdef XML_UNICODE
   1078       puttc(0xFEFF, userData.fp);
   1079 #endif
   1080       XML_SetUserData(parser, &userData);
   1081       switch (outputType) {
   1082       case 'm':
   1083         XML_UseParserAsHandlerArg(parser);
   1084         XML_SetElementHandler(parser, metaStartElement, metaEndElement);
   1085         XML_SetProcessingInstructionHandler(parser, metaProcessingInstruction);
   1086         XML_SetCommentHandler(parser, metaComment);
   1087         XML_SetCdataSectionHandler(parser, metaStartCdataSection,
   1088                                    metaEndCdataSection);
   1089         XML_SetCharacterDataHandler(parser, metaCharacterData);
   1090         XML_SetDoctypeDeclHandler(parser, metaStartDoctypeDecl,
   1091                                   metaEndDoctypeDecl);
   1092         XML_SetEntityDeclHandler(parser, metaEntityDecl);
   1093         XML_SetNotationDeclHandler(parser, metaNotationDecl);
   1094         XML_SetNamespaceDeclHandler(parser, metaStartNamespaceDecl,
   1095                                     metaEndNamespaceDecl);
   1096         metaStartDocument(parser);
   1097         break;
   1098       case 'c':
   1099         XML_UseParserAsHandlerArg(parser);
   1100         XML_SetDefaultHandler(parser, markup);
   1101         XML_SetElementHandler(parser, defaultStartElement, defaultEndElement);
   1102         XML_SetCharacterDataHandler(parser, defaultCharacterData);
   1103         XML_SetProcessingInstructionHandler(parser,
   1104                                             defaultProcessingInstruction);
   1105         break;
   1106       default:
   1107         if (useNamespaces)
   1108           XML_SetElementHandler(parser, startElementNS, endElementNS);
   1109         else
   1110           XML_SetElementHandler(parser, startElement, endElement);
   1111         XML_SetCharacterDataHandler(parser, characterData);
   1112 #ifndef W3C14N
   1113         XML_SetProcessingInstructionHandler(parser, processingInstruction);
   1114         if (requiresNotations) {
   1115           XML_SetDoctypeDeclHandler(parser, startDoctypeDecl, endDoctypeDecl);
   1116           XML_SetNotationDeclHandler(parser, notationDecl);
   1117         }
   1118 #endif /* not W3C14N */
   1119         break;
   1120       }
   1121     }
   1122     if (windowsCodePages)
   1123       XML_SetUnknownEncodingHandler(parser, unknownEncoding, 0);
   1124     result = XML_ProcessFile(parser, useStdin ? NULL : argv[i], processFlags);
   1125     if (outputDir) {
   1126       if (outputType == 'm')
   1127         metaEndDocument(parser);
   1128       fclose(userData.fp);
   1129       if (!result) {
   1130         tremove(outName);
   1131         exit(2);
   1132       }
   1133       free(outName);
   1134     }
   1135     XML_ParserFree(parser);
   1136   }
   1137   return 0;
   1138 }
   1139