src/expat/xmlwf/xmlwf.c

/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
   See the file COPYING for copying permission.
*/

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>

#include "expat.h"
#include "codepage.h"
#include "xmlfile.h"
#include "xmltchar.h"

#ifdef _MSC_VER
#include <crtdbg.h>
#endif

/* This ensures proper sorting. */

#define NSSEP T('\001')

static void
characterData(void *userData, const XML_Char *s, int len)
{
  FILE *fp = userData;
  for (; len > 0; --len, ++s) {
    switch (*s) {
    case T('&'):
      fputts(T("&amp;"), fp);
      break;
    case T('<'):
      fputts(T("&lt;"), fp);
      break;
    case T('>'):
      fputts(T("&gt;"), fp);
      break;
#ifdef W3C14N
    case 13:
      fputts(T("&#xD;"), fp);
      break;
#else
    case T('"'):
      fputts(T("&quot;"), fp);
      break;
    case 9:
    case 10:
    case 13:
      ftprintf(fp, T("&#%d;"), *s);
      break;
#endif
    default:
      puttc(*s, fp);
      break;
    }
  }
}

static void
attributeValue(FILE *fp, const XML_Char *s)
{
  puttc(T('='), fp);
  puttc(T('"'), fp);
  for (;;) {
    switch (*s) {
    case 0:
    case NSSEP:
      puttc(T('"'), fp);
      return;
    case T('&'):
      fputts(T("&amp;"), fp);
      break;
    case T('<'):
      fputts(T("&lt;"), fp);
      break;
    case T('"'):
      fputts(T("&quot;"), fp);
      break;
#ifdef W3C14N
    case 9:
      fputts(T("&#x9;"), fp);
      break;
    case 10:
      fputts(T("&#xA;"), fp);
      break;
    case 13:
      fputts(T("&#xD;"), fp);
      break;
#else
    case T('>'):
      fputts(T("&gt;"), fp);
      break;
    case 9:
    case 10:
    case 13:
      ftprintf(fp, T("&#%d;"), *s);
      break;
#endif
    default:
      puttc(*s, fp);
      break;
    }
    s++;
  }
}

/* Lexicographically comparing UTF-8 encoded attribute values,
is equivalent to lexicographically comparing based on the character number. */

static int
attcmp(const void *att1, const void *att2)
{
  return tcscmp(*(const XML_Char **)att1, *(const XML_Char **)att2);
}

static void
startElement(void *userData, const XML_Char *name, const XML_Char **atts)
{
  int nAtts;
  const XML_Char **p;
  FILE *fp = userData;
  puttc(T('<'), fp);
  fputts(name, fp);

  p = atts;
  while (*p)
    ++p;
  nAtts = (p - atts) >> 1;
  if (nAtts > 1)
    qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, attcmp);
  while (*atts) {
    puttc(T(' '), fp);
    fputts(*atts++, fp);
    attributeValue(fp, *atts);
    atts++;
  }
  puttc(T('>'), fp);
}

static void
endElement(void *userData, const XML_Char *name)
{
  FILE *fp = userData;
  puttc(T('<'), fp);
  puttc(T('/'), fp);
  fputts(name, fp);
  puttc(T('>'), fp);
}

static int
nsattcmp(const void *p1, const void *p2)
{
  const XML_Char *att1 = *(const XML_Char **)p1;
  const XML_Char *att2 = *(const XML_Char **)p2;
  int sep1 = (tcsrchr(att1, NSSEP) != 0);
  int sep2 = (tcsrchr(att1, NSSEP) != 0);
  if (sep1 != sep2)
    return sep1 - sep2;
  return tcscmp(att1, att2);
}

static void
startElementNS(void *userData, const XML_Char *name, const XML_Char **atts)
{
  int nAtts;
  int nsi;
  const XML_Char **p;
  FILE *fp = userData;
  const XML_Char *sep;
  puttc(T('<'), fp);

  sep = tcsrchr(name, NSSEP);
  if (sep) {
    fputts(T("n1:"), fp);
    fputts(sep + 1, fp);
    fputts(T(" xmlns:n1"), fp);
    attributeValue(fp, name);
    nsi = 2;
  }
  else {
    fputts(name, fp);
    nsi = 1;
  }

  p = atts;
  while (*p)
    ++p;
  nAtts = (p - atts) >> 1;
  if (nAtts > 1)
    qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, nsattcmp);
  while (*atts) {
    name = *atts++;
    sep = tcsrchr(name, NSSEP);
    puttc(T(' '), fp);
    if (sep) {
      ftprintf(fp, T("n%d:"), nsi);
      fputts(sep + 1, fp);
    }
    else
      fputts(name, fp);
    attributeValue(fp, *atts);
    if (sep) {
      ftprintf(fp, T(" xmlns:n%d"), nsi++);
      attributeValue(fp, name);
    }
    atts++;
  }
  puttc(T('>'), fp);
}

static void
endElementNS(void *userData, const XML_Char *name)
{
  FILE *fp = userData;
  const XML_Char *sep;
  puttc(T('<'), fp);
  puttc(T('/'), fp);
  sep = tcsrchr(name, NSSEP);
  if (sep) {
    fputts(T("n1:"), fp);
    fputts(sep + 1, fp);
  }
  else
    fputts(name, fp);
  puttc(T('>'), fp);
}

#ifndef W3C14N

static void
processingInstruction(void *userData, const XML_Char *target,
                      const XML_Char *data)
{
  FILE *fp = userData;
  puttc(T('<'), fp);
  puttc(T('?'), fp);
  fputts(target, fp);
  puttc(T(' '), fp);
  fputts(data, fp);
  puttc(T('?'), fp);
  puttc(T('>'), fp);
}

#endif /* not W3C14N */

static void
defaultCharacterData(void *userData, const XML_Char *s, int len)
{
  XML_DefaultCurrent((XML_Parser) userData);
}

static void
defaultStartElement(void *userData, const XML_Char *name,
                    const XML_Char **atts)
{
  XML_DefaultCurrent((XML_Parser) userData);
}

static void
defaultEndElement(void *userData, const XML_Char *name)
{
  XML_DefaultCurrent((XML_Parser) userData);
}

static void
defaultProcessingInstruction(void *userData, const XML_Char *target,
                             const XML_Char *data)
{
  XML_DefaultCurrent((XML_Parser) userData);
}

static void
nopCharacterData(void *userData, const XML_Char *s, int len)
{
}

static void
nopStartElement(void *userData, const XML_Char *name, const XML_Char **atts)
{
}

static void
nopEndElement(void *userData, const XML_Char *name)
{
}

static void
nopProcessingInstruction(void *userData, const XML_Char *target,
                         const XML_Char *data)
{
}

static void
markup(void *userData, const XML_Char *s, int len)
{
  FILE *fp = XML_GetUserData((XML_Parser) userData);
  for (; len > 0; --len, ++s)
    puttc(*s, fp);
}

static void
metaLocation(XML_Parser parser)
{
  const XML_Char *uri = XML_GetBase(parser);
  if (uri)
    ftprintf(XML_GetUserData(parser), T(" uri=\"%s\""), uri);
  ftprintf(XML_GetUserData(parser),
           T(" byte=\"%ld\" nbytes=\"%d\" line=\"%d\" col=\"%d\""),
           XML_GetCurrentByteIndex(parser),
           XML_GetCurrentByteCount(parser),
           XML_GetCurrentLineNumber(parser),
           XML_GetCurrentColumnNumber(parser));
}

static void
metaStartDocument(void *userData)
{
  fputts(T("<document>\n"), XML_GetUserData((XML_Parser) userData));
}

static void
metaEndDocument(void *userData)
{
  fputts(T("</document>\n"), XML_GetUserData((XML_Parser) userData));
}

static void
metaStartElement(void *userData, const XML_Char *name,
                 const XML_Char **atts)
{
  XML_Parser parser = (XML_Parser) userData;
  FILE *fp = XML_GetUserData(parser);
  const XML_Char **specifiedAttsEnd
    = atts + XML_GetSpecifiedAttributeCount(parser);
  const XML_Char **idAttPtr;
  int idAttIndex = XML_GetIdAttributeIndex(parser);
  if (idAttIndex < 0)
    idAttPtr = 0;
  else
    idAttPtr = atts + idAttIndex;

  ftprintf(fp, T("<starttag name=\"%s\""), name);
  metaLocation(parser);
  if (*atts) {
    fputts(T(">\n"), fp);
    do {
      ftprintf(fp, T("<attribute name=\"%s\" value=\""), atts[0]);
      characterData(fp, atts[1], tcslen(atts[1]));
      if (atts >= specifiedAttsEnd)
        fputts(T("\" defaulted=\"yes\"/>\n"), fp);
      else if (atts == idAttPtr)
        fputts(T("\" id=\"yes\"/>\n"), fp);
      else
        fputts(T("\"/>\n"), fp);
    } while (*(atts += 2));
    fputts(T("</starttag>\n"), fp);
  }
  else
    fputts(T("/>\n"), fp);
}

static void
metaEndElement(void *userData, const XML_Char *name)
{
  XML_Parser parser = (XML_Parser) userData;
  FILE *fp = XML_GetUserData(parser);
  ftprintf(fp, T("<endtag name=\"%s\""), name);
  metaLocation(parser);
  fputts(T("/>\n"), fp);
}

static void
metaProcessingInstruction(void *userData, const XML_Char *target,
                          const XML_Char *data)
{
  XML_Parser parser = (XML_Parser) userData;
  FILE *fp = XML_GetUserData(parser);
  ftprintf(fp, T("<pi target=\"%s\" data=\""), target);
  characterData(fp, data, tcslen(data));
  puttc(T('"'), fp);
  metaLocation(parser);
  fputts(T("/>\n"), fp);
}

static void
metaComment(void *userData, const XML_Char *data)
{
  XML_Parser parser = (XML_Parser) userData;
  FILE *fp = XML_GetUserData(parser);
  fputts(T("<comment data=\""), fp);
  characterData(fp, data, tcslen(data));
  puttc(T('"'), fp);
  metaLocation(parser);
  fputts(T("/>\n"), fp);
}

static void
metaStartCdataSection(void *userData)
{
  XML_Parser parser = (XML_Parser) userData;
  FILE *fp = XML_GetUserData(parser);
  fputts(T("<startcdata"), fp);
  metaLocation(parser);
  fputts(T("/>\n"), fp);
}

static void
metaEndCdataSection(void *userData)
{
  XML_Parser parser = (XML_Parser) userData;
  FILE *fp = XML_GetUserData(parser);
  fputts(T("<endcdata"), fp);
  metaLocation(parser);
  fputts(T("/>\n"), fp);
}

static void
metaCharacterData(void *userData, const XML_Char *s, int len)
{
  XML_Parser parser = (XML_Parser) userData;
  FILE *fp = XML_GetUserData(parser);
  fputts(T("<chars str=\""), fp);
  characterData(fp, s, len);
  puttc(T('"'), fp);
  metaLocation(parser);
  fputts(T("/>\n"), fp);
}

static void
metaStartDoctypeDecl(void *userData,
                     const XML_Char *doctypeName,
                     const XML_Char *sysid,
                     const XML_Char *pubid,
                     int has_internal_subset)
{
  XML_Parser parser = (XML_Parser) userData;
  FILE *fp = XML_GetUserData(parser);
  ftprintf(fp, T("<startdoctype name=\"%s\""), doctypeName);
  metaLocation(parser);
  fputts(T("/>\n"), fp);
}

static void
metaEndDoctypeDecl(void *userData)
{
  XML_Parser parser = (XML_Parser) userData;
  FILE *fp = XML_GetUserData(parser);
  fputts(T("<enddoctype"), fp);
  metaLocation(parser);
  fputts(T("/>\n"), fp);
}

static void
metaNotationDecl(void *userData,
                 const XML_Char *notationName,
                 const XML_Char *base,
                 const XML_Char *systemId,
                 const XML_Char *publicId)
{
  XML_Parser parser = (XML_Parser) userData;
  FILE *fp = XML_GetUserData(parser);
  ftprintf(fp, T("<notation name=\"%s\""), notationName);
  if (publicId)
    ftprintf(fp, T(" public=\"%s\""), publicId);
  if (systemId) {
    fputts(T(" system=\""), fp);
    characterData(fp, systemId, tcslen(systemId));
    puttc(T('"'), fp);
  }
  metaLocation(parser);
  fputts(T("/>\n"), fp);
}


static void
metaEntityDecl(void *userData,
               const XML_Char *entityName,
               int  is_param,
               const XML_Char *value,
               int  value_length,
               const XML_Char *base,
               const XML_Char *systemId,
               const XML_Char *publicId,
               const XML_Char *notationName)
{
  XML_Parser parser = (XML_Parser) userData;
  FILE *fp = XML_GetUserData(parser);

  if (value) {
    ftprintf(fp, T("<entity name=\"%s\""), entityName);
    metaLocation(parser);
    puttc(T('>'), fp);
    characterData(fp, value, value_length);
    fputts(T("</entity/>\n"), fp);
  }
  else if (notationName) {
    ftprintf(fp, T("<entity name=\"%s\""), entityName);
    if (publicId)
      ftprintf(fp, T(" public=\"%s\""), publicId);
    fputts(T(" system=\""), fp);
    characterData(fp, systemId, tcslen(systemId));
    puttc(T('"'), fp);
    ftprintf(fp, T(" notation=\"%s\""), notationName);
    metaLocation(parser);
    fputts(T("/>\n"), fp);
  }
  else {
    ftprintf(fp, T("<entity name=\"%s\""), entityName);
    if (publicId)
      ftprintf(fp, T(" public=\"%s\""), publicId);
    fputts(T(" system=\""), fp);
    characterData(fp, systemId, tcslen(systemId));
    puttc(T('"'), fp);
    metaLocation(parser);
    fputts(T("/>\n"), fp);
  }
}

static void
metaStartNamespaceDecl(void *userData,
                       const XML_Char *prefix,
                       const XML_Char *uri)
{
  XML_Parser parser = (XML_Parser) userData;
  FILE *fp = XML_GetUserData(parser);
  fputts(T("<startns"), fp);
  if (prefix)
    ftprintf(fp, T(" prefix=\"%s\""), prefix);
  if (uri) {
    fputts(T(" ns=\""), fp);
    characterData(fp, uri, tcslen(uri));
    fputts(T("\"/>\n"), fp);
  }
  else
    fputts(T("/>\n"), fp);
}

static void
metaEndNamespaceDecl(void *userData, const XML_Char *prefix)
{
  XML_Parser parser = (XML_Parser) userData;
  FILE *fp = XML_GetUserData(parser);
  if (!prefix)
    fputts(T("<endns/>\n"), fp);
  else
    ftprintf(fp, T("<endns prefix=\"%s\"/>\n"), prefix);
}

static int
unknownEncodingConvert(void *data, const char *p)
{
  return codepageConvert(*(int *)data, p);
}

static int
unknownEncoding(void *userData, const XML_Char *name, XML_Encoding *info)
{
  int cp;
  static const XML_Char prefixL[] = T("windows-");
  static const XML_Char prefixU[] = T("WINDOWS-");
  int i;

  for (i = 0; prefixU[i]; i++)
    if (name[i] != prefixU[i] && name[i] != prefixL[i])
      return 0;

  cp = 0;
  for (; name[i]; i++) {
    static const XML_Char digits[] = T("0123456789");
    const XML_Char *s = tcschr(digits, name[i]);
    if (!s)
      return 0;
    cp *= 10;
    cp += s - digits;
    if (cp >= 0x10000)
      return 0;
  }
  if (!codepageMap(cp, info->map))
    return 0;
  info->convert = unknownEncodingConvert;
  /* We could just cast the code page integer to a void *,
  and avoid the use of release. */
  info->release = free;
  info->data = malloc(sizeof(int));
  if (!info->data)
    return 0;
  *(int *)info->data = cp;
  return 1;
}

static int
notStandalone(void *userData)
{
  return 0;
}

static void
showVersion(XML_Char *prog)
{
  XML_Char *s = prog;
  XML_Char ch;
  const XML_Feature *features = XML_GetFeatureList();
  while ((ch = *s) != 0) {
    if (ch == '/'
#ifdef WIN32
        || ch == '\\'
#endif
        )
      prog = s + 1;
    ++s;
  }
  ftprintf(stdout, T("%s using %s\n"), prog, XML_ExpatVersion());
  if (features != NULL && features[0].feature != XML_FEATURE_END) {
    int i = 1;
    ftprintf(stdout, T("%s"), features[0].name);
    if (features[0].value)
      ftprintf(stdout, T("=%ld"), features[0].value);
    while (features[i].feature != XML_FEATURE_END) {
      ftprintf(stdout, T(", %s"), features[i].name);
      if (features[i].value)
        ftprintf(stdout, T("=%ld"), features[i].value);
      ++i;
    }
    ftprintf(stdout, T("\n"));
  }
}

static void
usage(const XML_Char *prog, int rc)
{
  ftprintf(stderr,
           T("usage: %s [-n] [-p] [-r] [-s] [-w] [-x] [-d output-dir] "
             "[-e encoding] file ...\n"), prog);
  exit(rc);
}

int
tmain(int argc, XML_Char **argv)
{
  int i, j;
  const XML_Char *outputDir = NULL;
  const XML_Char *encoding = NULL;
  unsigned processFlags = XML_MAP_FILE;
  int windowsCodePages = 0;
  int outputType = 0;
  int useNamespaces = 0;
  int requireStandalone = 0;
  int paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
  int useStdin = 0;

#ifdef _MSC_VER
  _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_LEAK_CHECK_DF);
#endif

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