home *** CD-ROM | disk | FTP | other *** search
/ Chip 2000 May / Chip_2000-05_cd1.bin / zkuste / Perl / ActivePerl-5.6.0.613.msi / 䆊䌷䈹䈙䏵-䞅䞆䞀㡆䞃䄦䠥 / _884155581891a697b11ec32f823b5173 < prev    next >
Text File  |  2000-03-15  |  19KB  |  748 lines
  1. /*
  2. The contents of this file are subject to the Mozilla Public License
  3. Version 1.1 (the "License"); you may not use this file except in
  4. compliance with the License. You may obtain a copy of the License at
  5. http://www.mozilla.org/MPL/
  6.  
  7. Software distributed under the License is distributed on an "AS IS"
  8. basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
  9. License for the specific language governing rights and limitations
  10. under the License.
  11.  
  12. The Original Code is expat.
  13.  
  14. The Initial Developer of the Original Code is James Clark.
  15. Portions created by James Clark are Copyright (C) 1998, 1999
  16. James Clark. All Rights Reserved.
  17.  
  18. Contributor(s):
  19.  
  20. Alternatively, the contents of this file may be used under the terms
  21. of the GNU General Public License (the "GPL"), in which case the
  22. provisions of the GPL are applicable instead of those above.  If you
  23. wish to allow use of your version of this file only under the terms of
  24. the GPL and not to allow others to use your version of this file under
  25. the MPL, indicate your decision by deleting the provisions above and
  26. replace them with the notice and other provisions required by the
  27. GPL. If you do not delete the provisions above, a recipient may use
  28. your version of this file under either the MPL or the GPL.
  29. */
  30.  
  31. #include <stdio.h>
  32. #include <stdlib.h>
  33. #include <stddef.h>
  34. #include <string.h>
  35.  
  36. #include "xmlparse.h"
  37. #include "codepage.h"
  38. #include "xmlfile.h"
  39. #include "xmltchar.h"
  40.  
  41. #ifdef _MSC_VER
  42. #include <crtdbg.h>
  43. #endif
  44.  
  45. /* This ensures proper sorting. */
  46.  
  47. #define NSSEP T('\001')
  48.  
  49. static void characterData(void *userData, const XML_Char *s, int len)
  50. {
  51.   FILE *fp = userData;
  52.   for (; len > 0; --len, ++s) {
  53.     switch (*s) {
  54.     case T('&'):
  55.       fputts(T("&"), fp);
  56.       break;
  57.     case T('<'):
  58.       fputts(T("<"), fp);
  59.       break;
  60.     case T('>'):
  61.       fputts(T(">"), fp);
  62.       break;
  63. #ifdef W3C14N
  64.     case 13:
  65.       fputts(T(" "), fp);
  66.       break;
  67. #else
  68.     case T('"'):
  69.       fputts(T("""), fp);
  70.       break;
  71.     case 9:
  72.     case 10:
  73.     case 13:
  74.       ftprintf(fp, T("&#%d;"), *s);
  75.       break;
  76. #endif
  77.     default:
  78.       puttc(*s, fp);
  79.       break;
  80.     }
  81.   }
  82. }
  83.  
  84. static void attributeValue(FILE *fp, const XML_Char *s)
  85. {
  86.   puttc(T('='), fp);
  87.   puttc(T('"'), fp);
  88.   for (;;) {
  89.     switch (*s) {
  90.     case 0:
  91.     case NSSEP:
  92.       puttc(T('"'), fp);
  93.       return;
  94.     case T('&'):
  95.       fputts(T("&"), fp);
  96.       break;
  97.     case T('<'):
  98.       fputts(T("<"), fp);
  99.       break;
  100.     case T('"'):
  101.       fputts(T("""), fp);
  102.       break;
  103. #ifdef W3C14N
  104.     case 9:
  105.       fputts(T(" "), fp);
  106.       break;
  107.     case 10:
  108.       fputts(T(" "), fp);
  109.       break;
  110.     case 13:
  111.       fputts(T(" "), fp);
  112.       break;
  113. #else
  114.     case T('>'):
  115.       fputts(T(">"), fp);
  116.       break;
  117.     case 9:
  118.     case 10:
  119.     case 13:
  120.       ftprintf(fp, T("&#%d;"), *s);
  121.       break;
  122. #endif
  123.     default:
  124.       puttc(*s, fp);
  125.       break;
  126.     }
  127.     s++;
  128.   }
  129. }
  130.  
  131. /* Lexicographically comparing UTF-8 encoded attribute values,
  132. is equivalent to lexicographically comparing based on the character number. */
  133.  
  134. static int attcmp(const void *att1, const void *att2)
  135. {
  136.   return tcscmp(*(const XML_Char **)att1, *(const XML_Char **)att2);
  137. }
  138.  
  139. static void startElement(void *userData, const XML_Char *name, const XML_Char **atts)
  140. {
  141.   int nAtts;
  142.   const XML_Char **p;
  143.   FILE *fp = userData;
  144.   puttc(T('<'), fp);
  145.   fputts(name, fp);
  146.  
  147.   p = atts;
  148.   while (*p)
  149.     ++p;
  150.   nAtts = (p - atts) >> 1;
  151.   if (nAtts > 1)
  152.     qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, attcmp);
  153.   while (*atts) {
  154.     puttc(T(' '), fp);
  155.     fputts(*atts++, fp);
  156.     attributeValue(fp, *atts);
  157.     atts++;
  158.   }
  159.   puttc(T('>'), fp);
  160. }
  161.  
  162. static void endElement(void *userData, const XML_Char *name)
  163. {
  164.   FILE *fp = userData;
  165.   puttc(T('<'), fp);
  166.   puttc(T('/'), fp);
  167.   fputts(name, fp);
  168.   puttc(T('>'), fp);
  169. }
  170.  
  171. static int nsattcmp(const void *p1, const void *p2)
  172. {
  173.   const XML_Char *att1 = *(const XML_Char **)p1;
  174.   const XML_Char *att2 = *(const XML_Char **)p2;
  175.   int sep1 = (tcsrchr(att1, NSSEP) != 0);
  176.   int sep2 = (tcsrchr(att1, NSSEP) != 0);
  177.   if (sep1 != sep2)
  178.     return sep1 - sep2;
  179.   return tcscmp(att1, att2);
  180. }
  181.  
  182. static void startElementNS(void *userData, const XML_Char *name, const XML_Char **atts)
  183. {
  184.   int nAtts;
  185.   int nsi;
  186.   const XML_Char **p;
  187.   FILE *fp = userData;
  188.   const XML_Char *sep;
  189.   puttc(T('<'), fp);
  190.  
  191.   sep = tcsrchr(name, NSSEP);
  192.   if (sep) {
  193.     fputts(T("n1:"), fp);
  194.     fputts(sep + 1, fp);
  195.     fputts(T(" xmlns:n1"), fp);
  196.     attributeValue(fp, name);
  197.     nsi = 2;
  198.   }
  199.   else {
  200.     fputts(name, fp);
  201.     nsi = 1;
  202.   }
  203.  
  204.   p = atts;
  205.   while (*p)
  206.     ++p;
  207.   nAtts = (p - atts) >> 1;
  208.   if (nAtts > 1)
  209.     qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, nsattcmp);
  210.   while (*atts) {
  211.     name = *atts++;
  212.     sep = tcsrchr(name, NSSEP);
  213.     puttc(T(' '), fp);
  214.     if (sep) {
  215.       ftprintf(fp, T("n%d:"), nsi);
  216.       fputts(sep + 1, fp);
  217.     }
  218.     else
  219.       fputts(name, fp);
  220.     attributeValue(fp, *atts);
  221.     if (sep) {
  222.       ftprintf(fp, T(" xmlns:n%d"), nsi++);
  223.       attributeValue(fp, name);
  224.     }
  225.     atts++;
  226.   }
  227.   puttc(T('>'), fp);
  228. }
  229.  
  230. static void endElementNS(void *userData, const XML_Char *name)
  231. {
  232.   FILE *fp = userData;
  233.   const XML_Char *sep;
  234.   puttc(T('<'), fp);
  235.   puttc(T('/'), fp);
  236.   sep = tcsrchr(name, NSSEP);
  237.   if (sep) {
  238.     fputts(T("n1:"), fp);
  239.     fputts(sep + 1, fp);
  240.   }
  241.   else
  242.     fputts(name, fp);
  243.   puttc(T('>'), fp);
  244. }
  245.  
  246. #ifndef W3C14N
  247.  
  248. static void processingInstruction(void *userData, const XML_Char *target, const XML_Char *data)
  249. {
  250.   FILE *fp = userData;
  251.   puttc(T('<'), fp);
  252.   puttc(T('?'), fp);
  253.   fputts(target, fp);
  254.   puttc(T(' '), fp);
  255.   fputts(data, fp);
  256.   puttc(T('?'), fp);
  257.   puttc(T('>'), fp);
  258. }
  259.  
  260. #endif /* not W3C14N */
  261.  
  262. static void defaultCharacterData(XML_Parser parser, const XML_Char *s, int len)
  263. {
  264.   XML_DefaultCurrent(parser);
  265. }
  266.  
  267. static void defaultStartElement(XML_Parser parser, const XML_Char *name, const XML_Char **atts)
  268. {
  269.   XML_DefaultCurrent(parser);
  270. }
  271.  
  272. static void defaultEndElement(XML_Parser parser, const XML_Char *name)
  273. {
  274.   XML_DefaultCurrent(parser);
  275. }
  276.  
  277. static void defaultProcessingInstruction(XML_Parser parser, const XML_Char *target, const XML_Char *data)
  278. {
  279.   XML_DefaultCurrent(parser);
  280. }
  281.  
  282. static void nopCharacterData(XML_Parser parser, const XML_Char *s, int len)
  283. {
  284. }
  285.  
  286. static void nopStartElement(XML_Parser parser, const XML_Char *name, const XML_Char **atts)
  287. {
  288. }
  289.  
  290. static void nopEndElement(XML_Parser parser, const XML_Char *name)
  291. {
  292. }
  293.  
  294. static void nopProcessingInstruction(XML_Parser parser, const XML_Char *target, const XML_Char *data)
  295. {
  296. }
  297.  
  298. static void markup(XML_Parser parser, const XML_Char *s, int len)
  299. {
  300.   FILE *fp = XML_GetUserData(parser);
  301.   for (; len > 0; --len, ++s)
  302.     puttc(*s, fp);
  303. }
  304.  
  305. static
  306. void metaLocation(XML_Parser parser)
  307. {
  308.   const XML_Char *uri = XML_GetBase(parser);
  309.   if (uri)
  310.     ftprintf(XML_GetUserData(parser), T(" uri=\"%s\""), uri);
  311.   ftprintf(XML_GetUserData(parser),
  312.            T(" byte=\"%ld\" nbytes=\"%d\" line=\"%d\" col=\"%d\""),
  313.        XML_GetCurrentByteIndex(parser),
  314.        XML_GetCurrentByteCount(parser),
  315.        XML_GetCurrentLineNumber(parser),
  316.        XML_GetCurrentColumnNumber(parser));
  317. }
  318.  
  319. static
  320. void metaStartDocument(XML_Parser parser)
  321. {
  322.   fputts(T("<document>\n"), XML_GetUserData(parser));
  323. }
  324.  
  325. static
  326. void metaEndDocument(XML_Parser parser)
  327. {
  328.   fputts(T("</document>\n"), XML_GetUserData(parser));
  329. }
  330.  
  331. static
  332. void metaStartElement(XML_Parser parser, const XML_Char *name, const XML_Char **atts)
  333. {
  334.   FILE *fp = XML_GetUserData(parser);
  335.   const XML_Char **specifiedAttsEnd
  336.     = atts + 2*XML_GetSpecifiedAttributeCount(parser);
  337.   ftprintf(fp, T("<starttag name=\"%s\""), name);
  338.   metaLocation(parser);
  339.   if (*atts) {
  340.     fputts(T(">\n"), fp);
  341.     do {
  342.       ftprintf(fp, T("<attribute name=\"%s\" value=\""), atts[0]);
  343.       characterData(fp, atts[1], tcslen(atts[1]));
  344.       if (atts >= specifiedAttsEnd)
  345.     fputts(T("\" defaulted=\"yes\"/>\n"), fp);
  346.       else
  347.     fputts(T("\"/>\n"), fp);
  348.     } while (*(atts += 2));
  349.     fputts(T("</starttag>\n"), fp);
  350.   }
  351.   else
  352.     fputts(T("/>\n"), fp);
  353. }
  354.  
  355. static
  356. void metaEndElement(XML_Parser parser, const XML_Char *name)
  357. {
  358.   FILE *fp = XML_GetUserData(parser);
  359.   ftprintf(fp, T("<endtag name=\"%s\""), name);
  360.   metaLocation(parser);
  361.   fputts(T("/>\n"), fp);
  362. }
  363.  
  364. static
  365. void metaProcessingInstruction(XML_Parser parser, const XML_Char *target, const XML_Char *data)
  366. {
  367.   FILE *fp = XML_GetUserData(parser);
  368.   ftprintf(fp, T("<pi target=\"%s\" data=\""), target);
  369.   characterData(fp, data, tcslen(data));
  370.   puttc(T('"'), fp);
  371.   metaLocation(parser);
  372.   fputts(T("/>\n"), fp);
  373. }
  374.  
  375. static
  376. void metaComment(XML_Parser parser, const XML_Char *data)
  377. {
  378.   FILE *fp = XML_GetUserData(parser);
  379.   fputts(T("<comment data=\""), fp);
  380.   characterData(fp, data, tcslen(data));
  381.   puttc(T('"'), fp);
  382.   metaLocation(parser);
  383.   fputts(T("/>\n"), fp);
  384. }
  385.  
  386. static
  387. void metaStartCdataSection(XML_Parser parser)
  388. {
  389.   FILE *fp = XML_GetUserData(parser);
  390.   fputts(T("<startcdata"), fp);
  391.   metaLocation(parser);
  392.   fputts(T("/>\n"), fp);
  393. }
  394.  
  395. static
  396. void metaEndCdataSection(XML_Parser parser)
  397. {
  398.   FILE *fp = XML_GetUserData(parser);
  399.   fputts(T("<endcdata"), fp);
  400.   metaLocation(parser);
  401.   fputts(T("/>\n"), fp);
  402. }
  403.  
  404. static
  405. void metaCharacterData(XML_Parser parser, const XML_Char *s, int len)
  406. {
  407.   FILE *fp = XML_GetUserData(parser);
  408.   fputts(T("<chars str=\""), fp);
  409.   characterData(fp, s, len);
  410.   puttc(T('"'), fp);
  411.   metaLocation(parser);
  412.   fputts(T("/>\n"), fp);
  413. }
  414.  
  415. static
  416. void metaStartDoctypeDecl(XML_Parser parser, const XML_Char *doctypeName)
  417. {
  418.   FILE *fp = XML_GetUserData(parser);
  419.   ftprintf(fp, T("<startdoctype name=\"%s\""), doctypeName);
  420.   metaLocation(parser);
  421.   fputts(T("/>\n"), fp);
  422. }
  423.  
  424. static
  425. void metaEndDoctypeDecl(XML_Parser parser)
  426. {
  427.   FILE *fp = XML_GetUserData(parser);
  428.   fputts(T("<enddoctype"), fp);
  429.   metaLocation(parser);
  430.   fputts(T("/>\n"), fp);
  431. }
  432.  
  433. static
  434. void metaUnparsedEntityDecl(XML_Parser parser,
  435.                 const XML_Char *entityName,
  436.                 const XML_Char *base,
  437.                 const XML_Char *systemId,
  438.                 const XML_Char *publicId,
  439.                 const XML_Char *notationName)
  440. {
  441.   FILE *fp = XML_GetUserData(parser);
  442.   ftprintf(fp, T("<entity name=\"%s\""), entityName);
  443.   if (publicId)
  444.     ftprintf(fp, T(" public=\"%s\""), publicId);
  445.   fputts(T(" system=\""), fp);
  446.   characterData(fp, systemId, tcslen(systemId));
  447.   puttc(T('"'), fp);
  448.   ftprintf(fp, T(" notation=\"%s\""), notationName);
  449.   metaLocation(parser);
  450.   fputts(T("/>\n"), fp);
  451. }
  452.  
  453. static
  454. void metaNotationDecl(XML_Parser parser,
  455.               const XML_Char *notationName,
  456.               const XML_Char *base,
  457.               const XML_Char *systemId,
  458.               const XML_Char *publicId)
  459. {
  460.   FILE *fp = XML_GetUserData(parser);
  461.   ftprintf(fp, T("<notation name=\"%s\""), notationName);
  462.   if (publicId)
  463.     ftprintf(fp, T(" public=\"%s\""), publicId);
  464.   if (systemId) {
  465.     fputts(T(" system=\""), fp);
  466.     characterData(fp, systemId, tcslen(systemId));
  467.     puttc(T('"'), fp);
  468.   }
  469.   metaLocation(parser);
  470.   fputts(T("/>\n"), fp);
  471. }
  472.  
  473. static
  474. void metaStartNamespaceDecl(XML_Parser parser,
  475.                 const XML_Char *prefix,
  476.                 const XML_Char *uri)
  477. {
  478.   FILE *fp = XML_GetUserData(parser);
  479.   fputts(T("<startns"), fp);
  480.   if (prefix)
  481.     ftprintf(fp, T(" prefix=\"%s\""), prefix);
  482.   if (uri) {
  483.     fputts(T(" ns=\""), fp);
  484.     characterData(fp, uri, tcslen(uri));
  485.     fputts(T("\"/>\n"), fp);
  486.   }
  487.   else
  488.     fputts(T("/>\n"), fp);
  489. }
  490.  
  491. static
  492. void metaEndNamespaceDecl(XML_Parser parser, const XML_Char *prefix)
  493. {
  494.   FILE *fp = XML_GetUserData(parser);
  495.   if (!prefix)
  496.     fputts(T("<endns/>\n"), fp);
  497.   else
  498.     ftprintf(fp, T("<endns prefix=\"%s\"/>\n"), prefix);
  499. }
  500.  
  501. static
  502. int unknownEncodingConvert(void *data, const char *p)
  503. {
  504.   return codepageConvert(*(int *)data, p);
  505. }
  506.  
  507. static
  508. int unknownEncoding(void *userData,
  509.             const XML_Char *name,
  510.             XML_Encoding *info)
  511. {
  512.   int cp;
  513.   static const XML_Char prefixL[] = T("windows-");
  514.   static const XML_Char prefixU[] = T("WINDOWS-");
  515.   int i;
  516.  
  517.   for (i = 0; prefixU[i]; i++)
  518.     if (name[i] != prefixU[i] && name[i] != prefixL[i])
  519.       return 0;
  520.   
  521.   cp = 0;
  522.   for (; name[i]; i++) {
  523.     static const XML_Char digits[] = T("0123456789");
  524.     const XML_Char *s = tcschr(digits, name[i]);
  525.     if (!s)
  526.       return 0;
  527.     cp *= 10;
  528.     cp += s - digits;
  529.     if (cp >= 0x10000)
  530.       return 0;
  531.   }
  532.   if (!codepageMap(cp, info->map))
  533.     return 0;
  534.   info->convert = unknownEncodingConvert;
  535.   /* We could just cast the code page integer to a void *,
  536.   and avoid the use of release. */
  537.   info->release = free;
  538.   info->data = malloc(sizeof(int));
  539.   if (!info->data)
  540.     return 0;
  541.   *(int *)info->data = cp;
  542.   return 1;
  543. }
  544.  
  545. static
  546. int notStandalone(void *userData)
  547. {
  548.   return 0;
  549. }
  550.  
  551. static
  552. void usage(const XML_Char *prog)
  553. {
  554.   ftprintf(stderr, T("usage: %s [-n] [-p] [-r] [-s] [-w] [-x] [-d output-dir] [-e encoding] file ...\n"), prog);
  555.   exit(1);
  556. }
  557.  
  558. int tmain(int argc, XML_Char **argv)
  559. {
  560.   int i, j;
  561.   const XML_Char *outputDir = 0;
  562.   const XML_Char *encoding = 0;
  563.   unsigned processFlags = XML_MAP_FILE;
  564.   int windowsCodePages = 0;
  565.   int outputType = 0;
  566.   int useNamespaces = 0;
  567.   int requireStandalone = 0;
  568.   int paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
  569.  
  570. #ifdef _MSC_VER
  571.   _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_LEAK_CHECK_DF);
  572. #endif
  573.  
  574.   i = 1;
  575.   j = 0;
  576.   while (i < argc) {
  577.     if (j == 0) {
  578.       if (argv[i][0] != T('-'))
  579.     break;
  580.       if (argv[i][1] == T('-') && argv[i][2] == T('\0')) {
  581.     i++;
  582.     break;
  583.       }
  584.       j++;
  585.     }
  586.     switch (argv[i][j]) {
  587.     case T('r'):
  588.       processFlags &= ~XML_MAP_FILE;
  589.       j++;
  590.       break;
  591.     case T('s'):
  592.       requireStandalone = 1;
  593.       j++;
  594.       break;
  595.     case T('n'):
  596.       useNamespaces = 1;
  597.       j++;
  598.       break;
  599.     case T('p'):
  600.       paramEntityParsing = XML_PARAM_ENTITY_PARSING_ALWAYS;
  601.       /* fall through */
  602.     case T('x'):
  603.       processFlags |= XML_EXTERNAL_ENTITIES;
  604.       j++;
  605.       break;
  606.     case T('w'):
  607.       windowsCodePages = 1;
  608.       j++;
  609.       break;
  610.     case T('m'):
  611.       outputType = 'm';
  612.       j++;
  613.       break;
  614.     case T('c'):
  615.       outputType = 'c';
  616.       useNamespaces = 0;
  617.       j++;
  618.       break;
  619.     case T('t'):
  620.       outputType = 't';
  621.       j++;
  622.       break;
  623.     case T('d'):
  624.       if (argv[i][j + 1] == T('\0')) {
  625.     if (++i == argc)
  626.       usage(argv[0]);
  627.     outputDir = argv[i];
  628.       }
  629.       else
  630.     outputDir = argv[i] + j + 1;
  631.       i++;
  632.       j = 0;
  633.       break;
  634.     case T('e'):
  635.       if (argv[i][j + 1] == T('\0')) {
  636.     if (++i == argc)
  637.       usage(argv[0]);
  638.     encoding = argv[i];
  639.       }
  640.       else
  641.     encoding = argv[i] + j + 1;
  642.       i++;
  643.       j = 0;
  644.       break;
  645.     case T('\0'):
  646.       if (j > 1) {
  647.     i++;
  648.     j = 0;
  649.     break;
  650.       }
  651.       /* fall through */
  652.     default:
  653.       usage(argv[0]);
  654.     }
  655.   }
  656.   if (i == argc)
  657.     usage(argv[0]);
  658.   for (; i < argc; i++) {
  659.     FILE *fp = 0;
  660.     XML_Char *outName = 0;
  661.     int result;
  662.     XML_Parser parser;
  663.     if (useNamespaces)
  664.       parser = XML_ParserCreateNS(encoding, NSSEP);
  665.     else
  666.       parser = XML_ParserCreate(encoding);
  667.     if (requireStandalone)
  668.       XML_SetNotStandaloneHandler(parser, notStandalone);
  669.     XML_SetParamEntityParsing(parser, paramEntityParsing);
  670.     if (outputType == 't') {
  671.       /* This is for doing timings; this gives a more realistic estimate of
  672.      the parsing time. */
  673.       outputDir = 0;
  674.       XML_SetElementHandler(parser, nopStartElement, nopEndElement);
  675.       XML_SetCharacterDataHandler(parser, nopCharacterData);
  676.       XML_SetProcessingInstructionHandler(parser, nopProcessingInstruction);
  677.     }
  678.     else if (outputDir) {
  679.       const XML_Char *file = argv[i];
  680.       if (tcsrchr(file, T('/')))
  681.     file = tcsrchr(file, T('/')) + 1;
  682. #ifdef WIN32
  683.       if (tcsrchr(file, T('\\')))
  684.     file = tcsrchr(file, T('\\')) + 1;
  685. #endif
  686.       outName = malloc((tcslen(outputDir) + tcslen(file) + 2) * sizeof(XML_Char));
  687.       tcscpy(outName, outputDir);
  688.       tcscat(outName, T("/"));
  689.       tcscat(outName, file);
  690.       fp = tfopen(outName, T("wb"));
  691.       if (!fp) {
  692.     tperror(outName);
  693.     exit(1);
  694.       }
  695.       setvbuf(fp, NULL, _IOFBF, 16384);
  696. #ifdef XML_UNICODE
  697.       puttc(0xFEFF, fp);
  698. #endif
  699.       XML_SetUserData(parser, fp);
  700.       switch (outputType) {
  701.       case 'm':
  702.     XML_UseParserAsHandlerArg(parser);
  703.     XML_SetElementHandler(parser, metaStartElement, metaEndElement);
  704.     XML_SetProcessingInstructionHandler(parser, metaProcessingInstruction);
  705.     XML_SetCommentHandler(parser, metaComment);
  706.     XML_SetCdataSectionHandler(parser, metaStartCdataSection, metaEndCdataSection);
  707.     XML_SetCharacterDataHandler(parser, metaCharacterData);
  708.     XML_SetDoctypeDeclHandler(parser, metaStartDoctypeDecl, metaEndDoctypeDecl);
  709.     XML_SetUnparsedEntityDeclHandler(parser, metaUnparsedEntityDecl);
  710.     XML_SetNotationDeclHandler(parser, metaNotationDecl);
  711.     XML_SetNamespaceDeclHandler(parser, metaStartNamespaceDecl, metaEndNamespaceDecl);
  712.     metaStartDocument(parser);
  713.     break;
  714.       case 'c':
  715.     XML_UseParserAsHandlerArg(parser);
  716.     XML_SetDefaultHandler(parser, markup);
  717.     XML_SetElementHandler(parser, defaultStartElement, defaultEndElement);
  718.     XML_SetCharacterDataHandler(parser, defaultCharacterData);
  719.     XML_SetProcessingInstructionHandler(parser, defaultProcessingInstruction);
  720.     break;
  721.       default:
  722.     if (useNamespaces)
  723.       XML_SetElementHandler(parser, startElementNS, endElementNS);
  724.     else
  725.       XML_SetElementHandler(parser, startElement, endElement);
  726.     XML_SetCharacterDataHandler(parser, characterData);
  727. #ifndef W3C14N
  728.     XML_SetProcessingInstructionHandler(parser, processingInstruction);
  729. #endif /* not W3C14N */
  730.     break;
  731.       }
  732.     }
  733.     if (windowsCodePages)
  734.       XML_SetUnknownEncodingHandler(parser, unknownEncoding, 0);
  735.     result = XML_ProcessFile(parser, argv[i], processFlags);
  736.     if (outputDir) {
  737.       if (outputType == 'm')
  738.     metaEndDocument(parser);
  739.       fclose(fp);
  740.       if (!result)
  741.     tremove(outName);
  742.       free(outName);
  743.     }
  744.     XML_ParserFree(parser);
  745.   }
  746.   return 0;
  747. }
  748.