[wxWidgets.git] / 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
5e9f2524 VS	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	}