home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 3 / AACD03.BIN / AACD / Programming / sofa / archive / exml.lha / exml / expat / xmlwf / xmlwf.c < prev   
C/C++ Source or Header  |  1999-04-13  |  16KB  |  654 lines
  1. /*
  2. The contents of this file are subject to the Mozilla Public License
  3. Version 1.0 (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
  16. James Clark. All Rights Reserved.
  17.  
  18. Contributor(s):
  19. */
  20.  
  21. #include "xmlparse.h"
  22. #include "filemap.h"
  23. #include "codepage.h"
  24.  
  25. #include <stdio.h>
  26. #include <stdlib.h>
  27. #include <stddef.h>
  28. #include <string.h>
  29. #include <fcntl.h>
  30.  
  31. #ifdef _MSC_VER
  32. #include <io.h>
  33. #endif
  34.  
  35. #ifdef _POSIX_SOURCE
  36. #include <unistd.h>
  37. #endif
  38.  
  39. #ifndef O_BINARY
  40. #ifdef _O_BINARY
  41. #define O_BINARY _O_BINARY
  42. #else
  43. #define O_BINARY 0
  44. #endif
  45. #endif
  46.  
  47. #ifdef _MSC_VER
  48. #include <crtdbg.h>
  49. #endif
  50.  
  51. #ifdef _DEBUG
  52. #define READ_SIZE 16
  53. #else
  54. #define READ_SIZE (1024*8)
  55. #endif
  56.  
  57. #ifdef XML_UNICODE
  58. #ifndef XML_UNICODE_WCHAR_T
  59. #error xmlwf requires a 16-bit Unicode-compatible wchar_t 
  60. #endif
  61. #define T(x) L ## x
  62. #define ftprintf fwprintf
  63. #define tfopen _wfopen
  64. #define fputts fputws
  65. #define puttc putwc
  66. #define tcscmp wcscmp
  67. #define tcscpy wcscpy
  68. #define tcscat wcscat
  69. #define tcschr wcschr
  70. #define tcsrchr wcsrchr
  71. #define tcslen wcslen
  72. #define tperror _wperror
  73. #define topen _wopen
  74. #define tmain wmain
  75. #define tremove _wremove
  76. #else /* not XML_UNICODE */
  77. #define T(x) x
  78. #define ftprintf fprintf
  79. #define tfopen fopen
  80. #define fputts fputs
  81. #define puttc putc
  82. #define tcscmp strcmp
  83. #define tcscpy strcpy
  84. #define tcscat strcat
  85. #define tcschr strchr
  86. #define tcsrchr strrchr
  87. #define tcslen strlen
  88. #define tperror perror
  89. #define topen open
  90. #define tmain main
  91. #define tremove remove
  92. #endif /* not XML_UNICODE */
  93.  
  94. static void characterData(void *userData, const XML_Char *s, int len)
  95. {
  96.   FILE *fp = userData;
  97.   for (; len > 0; --len, ++s) {
  98.     switch (*s) {
  99.     case T('&'):
  100.       fputts(T("&"), fp);
  101.       break;
  102.     case T('<'):
  103.       fputts(T("<"), fp);
  104.       break;
  105.     case T('>'):
  106.       fputts(T(">"), fp);
  107.       break;
  108.     case T('"'):
  109.       fputts(T("""), fp);
  110.       break;
  111.     case 9:
  112.     case 10:
  113.     case 13:
  114.       ftprintf(fp, T("&#%d;"), *s);
  115.       break;
  116.     default:
  117.       puttc(*s, fp);
  118.       break;
  119.     }
  120.   }
  121. }
  122.  
  123. /* Lexicographically comparing UTF-8 encoded attribute values,
  124. is equivalent to lexicographically comparing based on the character number. */
  125.  
  126. static int attcmp(const void *att1, const void *att2)
  127. {
  128.   return tcscmp(*(const XML_Char **)att1, *(const XML_Char **)att2);
  129. }
  130.  
  131. static void startElement(void *userData, const XML_Char *name, const XML_Char **atts)
  132. {
  133.   int nAtts;
  134.   const XML_Char **p;
  135.   FILE *fp = userData;
  136.   puttc(T('<'), fp);
  137.   fputts(name, fp);
  138.  
  139.   p = atts;
  140.   while (*p)
  141.     ++p;
  142.   nAtts = (p - atts) >> 1;
  143.   if (nAtts > 1)
  144.     qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, attcmp);
  145.   while (*atts) {
  146.     puttc(T(' '), fp);
  147.     fputts(*atts++, fp);
  148.     puttc(T('='), fp);
  149.     puttc(T('"'), fp);
  150.     characterData(userData, *atts, tcslen(*atts));
  151.     puttc(T('"'), fp);
  152.     atts++;
  153.   }
  154.   puttc(T('>'), fp);
  155. }
  156.  
  157. static void endElement(void *userData, const XML_Char *name)
  158. {
  159.   FILE *fp = userData;
  160.   puttc(T('<'), fp);
  161.   puttc(T('/'), fp);
  162.   fputts(name, fp);
  163.   puttc(T('>'), fp);
  164. }
  165.  
  166. static void processingInstruction(void *userData, const XML_Char *target, const XML_Char *data)
  167. {
  168.   FILE *fp = userData;
  169.   puttc(T('<'), fp);
  170.   puttc(T('?'), fp);
  171.   fputts(target, fp);
  172.   puttc(T(' '), fp);
  173.   fputts(data, fp);
  174.   puttc(T('?'), fp);
  175.   puttc(T('>'), fp);
  176. }
  177.  
  178. static void defaultCharacterData(XML_Parser parser, const XML_Char *s, int len)
  179. {
  180.   XML_DefaultCurrent(parser);
  181. }
  182.  
  183. static void defaultStartElement(XML_Parser parser, const XML_Char *name, const XML_Char **atts)
  184. {
  185.   XML_DefaultCurrent(parser);
  186. }
  187.  
  188. static void defaultEndElement(XML_Parser parser, const XML_Char *name)
  189. {
  190.   XML_DefaultCurrent(parser);
  191. }
  192.  
  193. static void defaultProcessingInstruction(XML_Parser parser, const XML_Char *target, const XML_Char *data)
  194. {
  195.   XML_DefaultCurrent(parser);
  196. }
  197.  
  198. static void markup(XML_Parser parser, const XML_Char *s, int len)
  199. {
  200.   FILE *fp = XML_GetUserData(parser);
  201.   for (; len > 0; --len, ++s)
  202.     puttc(*s, fp);
  203. }
  204.  
  205. static
  206. void metaLocation(XML_Parser parser)
  207. {
  208.   const XML_Char *uri = XML_GetBase(parser);
  209.   if (uri)
  210.     ftprintf(XML_GetUserData(parser), T(" uri=\"%s\""), uri);
  211.   ftprintf(XML_GetUserData(parser),
  212.            T(" byte=\"%ld\" line=\"%d\" col=\"%d\""),
  213.        XML_GetCurrentByteIndex(parser),
  214.        XML_GetCurrentLineNumber(parser),
  215.        XML_GetCurrentColumnNumber(parser));
  216. }
  217.  
  218. static
  219. void metaStartElement(XML_Parser parser, const XML_Char *name, const XML_Char **atts)
  220. {
  221.   FILE *fp = XML_GetUserData(parser);
  222.   ftprintf(fp, T("<starttag name=\"%s\""), name);
  223.   metaLocation(parser);
  224.   if (*atts) {
  225.     fputts(T(">\n"), fp);
  226.     do {
  227.       ftprintf(fp, T("<attribute name=\"%s\" value=\""), atts[0]);
  228.       characterData(fp, atts[1], tcslen(atts[1]));
  229.       fputts(T("\"/>\n"), fp);
  230.     } while (*(atts += 2));
  231.     fputts(T("</starttag>\n"), fp);
  232.   }
  233.   else
  234.     fputts(T("/>\n"), fp);
  235. }
  236.  
  237. static
  238. void metaEndElement(XML_Parser parser, const XML_Char *name)
  239. {
  240.   FILE *fp = XML_GetUserData(parser);
  241.   ftprintf(fp, T("<endtag name=\"%s\""), name);
  242.   metaLocation(parser);
  243.   fputts(T("/>\n"), fp);
  244. }
  245.  
  246. static
  247. void metaProcessingInstruction(XML_Parser parser, const XML_Char *target, const XML_Char *data)
  248. {
  249.   FILE *fp = XML_GetUserData(parser);
  250.   ftprintf(fp, T("<pi target=\"%s\" data=\""), target);
  251.   characterData(fp, data, tcslen(data));
  252.   puttc(T('"'), fp);
  253.   metaLocation(parser);
  254.   fputts(T("/>\n"), fp);
  255. }
  256.  
  257. static
  258. void metaCharacterData(XML_Parser parser, const XML_Char *s, int len)
  259. {
  260.   FILE *fp = XML_GetUserData(parser);
  261.   fputts(T("<chars str=\""), fp);
  262.   characterData(fp, s, len);
  263.   puttc(T('"'), fp);
  264.   metaLocation(parser);
  265.   fputts(T("/>\n"), fp);
  266. }
  267.  
  268. static
  269. void metaUnparsedEntityDecl(XML_Parser parser,
  270.                    const XML_Char *entityName,
  271.                    const XML_Char *base,
  272.                    const XML_Char *systemId,
  273.                    const XML_Char *publicId,
  274.                    const XML_Char *notationName)
  275. {
  276.   FILE *fp = XML_GetUserData(parser);
  277.   ftprintf(fp, T("<entity name=\"%s\""), entityName);
  278.   if (publicId)
  279.     ftprintf(fp, T(" public=\"%s\""), publicId);
  280.   fputts(T(" system=\""), fp);
  281.   characterData(fp, systemId, tcslen(systemId));
  282.   puttc(T('"'), fp);
  283.   ftprintf(fp, T(" notation=\"%s\""), notationName);
  284.   metaLocation(parser);
  285.   fputts(T("/>\n"), fp);
  286. }
  287.  
  288. static
  289. void metaNotationDecl(XML_Parser parser,
  290.               const XML_Char *notationName,
  291.               const XML_Char *base,
  292.               const XML_Char *systemId,
  293.               const XML_Char *publicId)
  294. {
  295.   FILE *fp = XML_GetUserData(parser);
  296.   ftprintf(fp, T("<notation name=\"%s\""), notationName);
  297.   if (publicId)
  298.     ftprintf(fp, T(" public=\"%s\""), publicId);
  299.   if (systemId) {
  300.     fputts(T(" system=\""), fp);
  301.     characterData(fp, systemId, tcslen(systemId));
  302.     puttc(T('"'), fp);
  303.   }
  304.   metaLocation(parser);
  305.   fputts(T("/>\n"), fp);
  306. }
  307.  
  308. typedef struct {
  309.   XML_Parser parser;
  310.   int *retPtr;
  311. } PROCESS_ARGS;
  312.  
  313. static
  314. void reportError(XML_Parser parser, const XML_Char *filename)
  315. {
  316.   int code = XML_GetErrorCode(parser);
  317.   const XML_Char *message = XML_ErrorString(code);
  318.   if (message)
  319.     ftprintf(stdout, T("%s:%d:%ld: %s\n"),
  320.          filename,
  321.          XML_GetErrorLineNumber(parser),
  322.          XML_GetErrorColumnNumber(parser),
  323.          message);
  324.   else
  325.     ftprintf(stderr, T("%s: (unknown message %d)\n"), filename, code);
  326. }
  327.  
  328. static
  329. void processFile(const void *data, size_t size, const XML_Char *filename, void *args)
  330. {
  331.   XML_Parser parser = ((PROCESS_ARGS *)args)->parser;
  332.   int *retPtr = ((PROCESS_ARGS *)args)->retPtr;
  333.   if (!XML_Parse(parser, data, size, 1)) {
  334.     reportError(parser, filename);
  335.     *retPtr = 0;
  336.   }
  337.   else
  338.     *retPtr = 1;
  339. }
  340.  
  341. static
  342. int isAsciiLetter(XML_Char c)
  343. {
  344.   return (T('a') <= c && c <= T('z')) || (T('A') <= c && c <= T('Z'));
  345. }
  346.  
  347. static
  348. const XML_Char *resolveSystemId(const XML_Char *base, const XML_Char *systemId, XML_Char **toFree)
  349. {
  350.   XML_Char *s;
  351.   *toFree = 0;
  352.   if (!base
  353.       || *systemId == T('/')
  354. #ifdef WIN32
  355.       || *systemId == T('\\')
  356.       || (isAsciiLetter(systemId[0]) && systemId[1] == T(':'))
  357. #endif
  358.      )
  359.     return systemId;
  360.   *toFree = (XML_Char *)malloc((tcslen(base) + tcslen(systemId) + 2)*sizeof(XML_Char));
  361.   if (!*toFree)
  362.     return systemId;
  363.   tcscpy(*toFree, base);
  364.   s = *toFree;
  365.   if (tcsrchr(s, T('/')))
  366.     s = tcsrchr(s, T('/')) + 1;
  367. #ifdef WIN32
  368.   if (tcsrchr(s, T('\\')))
  369.     s = tcsrchr(s, T('\\')) + 1;
  370. #endif
  371.   tcscpy(s, systemId);
  372.   return *toFree;
  373. }
  374.  
  375. static
  376. int externalEntityRefFilemap(XML_Parser parser,
  377.                  const XML_Char *openEntityNames,
  378.                  const XML_Char *base,
  379.                  const XML_Char *systemId,
  380.                  const XML_Char *publicId)
  381. {
  382.   int result;
  383.   XML_Char *s;
  384.   const XML_Char *filename;
  385.   XML_Parser entParser = XML_ExternalEntityParserCreate(parser, openEntityNames, 0);
  386.   PROCESS_ARGS args;
  387.   args.retPtr = &result;
  388.   args.parser = entParser;
  389.   filename = resolveSystemId(base, systemId, &s);
  390.   XML_SetBase(entParser, filename);
  391.   if (!filemap(filename, processFile, &args))
  392.     result = 0;
  393.   free(s);
  394.   XML_ParserFree(entParser);
  395.   return result;
  396. }
  397.  
  398. static
  399. int processStream(const XML_Char *filename, XML_Parser parser)
  400. {
  401.   int fd = topen(filename, O_BINARY|O_RDONLY);
  402.   if (fd < 0) {
  403.     tperror(filename);
  404.     return 0;
  405.   }
  406.   for (;;) {
  407.     int nread;
  408.     char *buf = XML_GetBuffer(parser, READ_SIZE);
  409.     if (!buf) {
  410.       close(fd);
  411.       ftprintf(stderr, T("%s: out of memory\n"), filename);
  412.       return 0;
  413.     }
  414.     nread = read(fd, buf, READ_SIZE);
  415.     if (nread < 0) {
  416.       tperror(filename);
  417.       close(fd);
  418.       return 0;
  419.     }
  420.     if (!XML_ParseBuffer(parser, nread, nread == 0)) {
  421.       reportError(parser, filename);
  422.       close(fd);
  423.       return 0;
  424.     }
  425.     if (nread == 0) {
  426.       close(fd);
  427.       break;;
  428.     }
  429.   }
  430.   return 1;
  431. }
  432.  
  433. static
  434. int externalEntityRefStream(XML_Parser parser,
  435.                 const XML_Char *openEntityNames,
  436.                 const XML_Char *base,
  437.                 const XML_Char *systemId,
  438.                 const XML_Char *publicId)
  439. {
  440.   XML_Char *s;
  441.   const XML_Char *filename;
  442.   int ret;
  443.   XML_Parser entParser = XML_ExternalEntityParserCreate(parser, openEntityNames, 0);
  444.   filename = resolveSystemId(base, systemId, &s);
  445.   XML_SetBase(entParser, filename);
  446.   ret = processStream(filename, entParser);
  447.   free(s);
  448.   XML_ParserFree(entParser);
  449.   return ret;
  450. }
  451.  
  452. static
  453. int unknownEncodingConvert(void *data, const char *p)
  454. {
  455.   return codepageConvert(*(int *)data, p);
  456. }
  457.  
  458. static
  459. int unknownEncoding(void *userData,
  460.             const XML_Char *name,
  461.             XML_Encoding *info)
  462. {
  463.   int cp;
  464.   static const XML_Char prefixL[] = T("windows-");
  465.   static const XML_Char prefixU[] = T("WINDOWS-");
  466.   int i;
  467.  
  468.   for (i = 0; prefixU[i]; i++)
  469.     if (name[i] != prefixU[i] && name[i] != prefixL[i])
  470.       return 0;
  471.   
  472.   cp = 0;
  473.   for (; name[i]; i++) {
  474.     static const XML_Char digits[] = T("0123456789");
  475.     const XML_Char *s = tcschr(digits, name[i]);
  476.     if (!s)
  477.       return 0;
  478.     cp *= 10;
  479.     cp += s - digits;
  480.     if (cp >= 0x10000)
  481.       return 0;
  482.   }
  483.   if (!codepageMap(cp, info->map))
  484.     return 0;
  485.   info->convert = unknownEncodingConvert;
  486.   /* We could just cast the code page integer to a void *,
  487.   and avoid the use of release. */
  488.   info->release = free;
  489.   info->data = malloc(sizeof(int));
  490.   if (!info->data)
  491.     return 0;
  492.   *(int *)info->data = cp;
  493.   return 1;
  494. }
  495.  
  496. static
  497. void usage(const XML_Char *prog)
  498. {
  499.   ftprintf(stderr, T("usage: %s [-r] [-w] [-x] [-d output-dir] [-e encoding] file ...\n"), prog);
  500.   exit(1);
  501. }
  502.  
  503. int tmain(int argc, XML_Char **argv)
  504. {
  505.   int i;
  506.   const XML_Char *outputDir = 0;
  507.   const XML_Char *encoding = 0;
  508.   int useFilemap = 1;
  509.   int processExternalEntities = 0;
  510.   int windowsCodePages = 0;
  511.   int outputType = 0;
  512.  
  513. #ifdef _MSC_VER
  514.   _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_LEAK_CHECK_DF);
  515. #endif
  516.  
  517.   i = 1;
  518.   while (i < argc && argv[i][0] == T('-')) {
  519.     int j;
  520.     if (argv[i][1] == T('-') && argv[i][2] == T('\0')) {
  521.       i++;
  522.       break;
  523.     }
  524.     j = 1;
  525.     if (argv[i][j] == T('r')) {
  526.       useFilemap = 0;
  527.       j++;
  528.     }
  529.     if (argv[i][j] == T('x')) {
  530.       processExternalEntities = 1;
  531.       j++;
  532.     }
  533.     if (argv[i][j] == T('w')) {
  534.       windowsCodePages = 1;
  535.       j++;
  536.     }
  537.     if (argv[i][j] == T('m')) {
  538.       outputType = 'm';
  539.       j++;
  540.     }
  541.     if (argv[i][j] == T('c')) {
  542.       outputType = 'c';
  543.       j++;
  544.     }
  545.     if (argv[i][j] == T('d')) {
  546.       if (argv[i][j + 1] == T('\0')) {
  547.     if (++i == argc)
  548.       usage(argv[0]);
  549.     outputDir = argv[i];
  550.       }
  551.       else
  552.     outputDir = argv[i] + j + 1;
  553.       i++;
  554.     }
  555.     else if (argv[i][j] == T('e')) {
  556.       if (argv[i][j + 1] == T('\0')) {
  557.     if (++i == argc)
  558.       usage(argv[0]);
  559.     encoding = argv[i];
  560.       }
  561.       else
  562.     encoding = argv[i] + j + 1;
  563.       i++;
  564.     }
  565.     else if (argv[i][j] == T('\0') && j > 1)
  566.       i++;
  567.     else
  568.       usage(argv[0]);
  569.   }
  570.   if (i == argc)
  571.     usage(argv[0]);
  572.   for (; i < argc; i++) {
  573.     FILE *fp = 0;
  574.     XML_Char *outName = 0;
  575.     int result;
  576.     XML_Parser parser = XML_ParserCreate(encoding);
  577.     if (outputDir) {
  578.       const XML_Char *file = argv[i];
  579.       if (tcsrchr(file, T('/')))
  580.     file = tcsrchr(file, T('/')) + 1;
  581. #ifdef WIN32
  582.       if (tcsrchr(file, T('\\')))
  583.     file = tcsrchr(file, T('\\')) + 1;
  584. #endif
  585.       outName = malloc((tcslen(outputDir) + tcslen(file) + 2) * sizeof(XML_Char));
  586.       tcscpy(outName, outputDir);
  587.       tcscat(outName, T("/"));
  588.       tcscat(outName, file);
  589.       fp = tfopen(outName, T("wb"));
  590.       if (!fp) {
  591.     tperror(outName);
  592.     exit(1);
  593.       }
  594. #ifdef XML_UNICODE
  595.       puttc(0xFEFF, fp);
  596. #endif
  597.       XML_SetUserData(parser, fp);
  598.       switch (outputType) {
  599.       case 'm':
  600.     XML_UseParserAsHandlerArg(parser);
  601.     fputts(T("<document>\n"), fp);
  602.     XML_SetElementHandler(parser, metaStartElement, metaEndElement);
  603.     XML_SetProcessingInstructionHandler(parser, metaProcessingInstruction);
  604.     XML_SetCharacterDataHandler(parser, metaCharacterData);
  605.     XML_SetUnparsedEntityDeclHandler(parser, metaUnparsedEntityDecl);
  606.     XML_SetNotationDeclHandler(parser, metaNotationDecl);
  607.     break;
  608.       case 'c':
  609.     XML_UseParserAsHandlerArg(parser);
  610.     XML_SetDefaultHandler(parser, markup);
  611.     XML_SetElementHandler(parser, defaultStartElement, defaultEndElement);
  612.     XML_SetCharacterDataHandler(parser, defaultCharacterData);
  613.     XML_SetProcessingInstructionHandler(parser, defaultProcessingInstruction);
  614.     break;
  615.       default:
  616.     XML_SetElementHandler(parser, startElement, endElement);
  617.     XML_SetCharacterDataHandler(parser, characterData);
  618.     XML_SetProcessingInstructionHandler(parser, processingInstruction);
  619.     break;
  620.       }
  621.     }
  622.     if (windowsCodePages)
  623.       XML_SetUnknownEncodingHandler(parser, unknownEncoding, 0);
  624.     if (!XML_SetBase(parser, argv[i])) {
  625.       ftprintf(stderr, T("%s: out of memory"), argv[0]);
  626.       exit(1);
  627.     }
  628.     if (processExternalEntities)
  629.       XML_SetExternalEntityRefHandler(parser,
  630.                                   useFilemap
  631.                       ? externalEntityRefFilemap
  632.                       : externalEntityRefStream);
  633.     if (useFilemap) {
  634.       PROCESS_ARGS args;
  635.       args.retPtr = &result;
  636.       args.parser = parser;
  637.       if (!filemap(argv[i], processFile, &args))
  638.     result = 0;
  639.     }
  640.     else
  641.       result = processStream(argv[i], parser);
  642.     if (outputDir) {
  643.       if (outputType == 'm')
  644.     fputts(T("</document>\n"), fp);
  645.       fclose(fp);
  646.       if (!result)
  647.     tremove(outName);
  648.       free(outName);
  649.     }
  650.     XML_ParserFree(parser);
  651.   }
  652.   return 0;
  653. }
  654.