/* 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

#ifdef AMIGA_SHARED_LIB

#include <proto/expat.h>

#endif

/* This ensures proper sorting. */

#define NSSEP T('\001')

static void XMLCALL

characterData(void *userData, const XML_Char *s, int len)

{

  FILE *fp = (FILE *)userData;

  for (; len > 0; --len, ++s) {

    switch (*s) {

    case T('&'):

      fputts(T("&"), fp);

      break;

    case T('<'):

      fputts(T("<"), fp);

      break;

    case T('>'):

      fputts(T(">"), fp);

      break;

#ifdef W3C14N

    case 13:

      fputts(T("
"), fp);

      break;

#else

    case T('"'):

      fputts(T("""), 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("&"), fp);

      break;

    case T('<'):

      fputts(T("<"), fp);

      break;

    case T('"'):

      fputts(T("""), fp);

      break;

#ifdef W3C14N

    case 9:

      fputts(T("	"), fp);

      break;

    case 10:

      fputts(T("
"), fp);

      break;

    case 13:

      fputts(T("
"), fp);

      break;

#else

    case T('>'):

      fputts(T(">"), 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 XMLCALL

startElement(void *userData, const XML_Char *name, const XML_Char **atts)

{

  int nAtts;

  const XML_Char **p;

  FILE *fp = (FILE *)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 XMLCALL

endElement(void *userData, const XML_Char *name)

{

  FILE *fp = (FILE *)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 XMLCALL

startElementNS(void *userData, const XML_Char *name, const XML_Char **atts)

{

  int nAtts;

  int nsi;

  const XML_Char **p;

  FILE *fp = (FILE *)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 XMLCALL

endElementNS(void *userData, const XML_Char *name)

{

  FILE *fp = (FILE *)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 XMLCALL

processingInstruction(void *userData, const XML_Char *target,

                      const XML_Char *data)

{

  FILE *fp = (FILE *)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 XMLCALL

defaultCharacterData(void *userData, const XML_Char *s, int len)

{

  XML_DefaultCurrent((XML_Parser) userData);

}

static void XMLCALL

defaultStartElement(void *userData, const XML_Char *name,

                    const XML_Char **atts)

{

  XML_DefaultCurrent((XML_Parser) userData);

}

static void XMLCALL

defaultEndElement(void *userData, const XML_Char *name)

{

  XML_DefaultCurrent((XML_Parser) userData);

}

static void XMLCALL

defaultProcessingInstruction(void *userData, const XML_Char *target,

                             const XML_Char *data)

{

  XML_DefaultCurrent((XML_Parser) userData);

}

static void XMLCALL

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

{

}

static void XMLCALL

nopStartElement(void *userData, const XML_Char *name, const XML_Char **atts)

{

}

static void XMLCALL

nopEndElement(void *userData, const XML_Char *name)

{

}

static void XMLCALL

nopProcessingInstruction(void *userData, const XML_Char *target,

                         const XML_Char *data)

{

}

static void XMLCALL

markup(void *userData, const XML_Char *s, int len)

{

  FILE *fp = (FILE *)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((FILE *)XML_GetUserData(parser), T(" uri=\"%s\""), uri);

  ftprintf((FILE *)XML_GetUserData(parser),

           T(" byte=\"%" XML_FMT_INT_MOD "d\" nbytes=\"%d\" \

			 line=\"%" XML_FMT_INT_MOD "u\" col=\"%" XML_FMT_INT_MOD "u\""),

           XML_GetCurrentByteIndex(parser),

           XML_GetCurrentByteCount(parser),

           XML_GetCurrentLineNumber(parser),

           XML_GetCurrentColumnNumber(parser));

}

static void

metaStartDocument(void *userData)

{

  fputts(T("<document>\n"), (FILE *)XML_GetUserData((XML_Parser) userData));

}

static void

metaEndDocument(void *userData)

{

  fputts(T("</document>\n"), (FILE *)XML_GetUserData((XML_Parser) userData));

}

static void XMLCALL

metaStartElement(void *userData, const XML_Char *name,

                 const XML_Char **atts)

{

  XML_Parser parser = (XML_Parser) userData;

  FILE *fp = (FILE *)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 XMLCALL

metaEndElement(void *userData, const XML_Char *name)

{

  XML_Parser parser = (XML_Parser) userData;

  FILE *fp = (FILE *)XML_GetUserData(parser);

  ftprintf(fp, T("<endtag name=\"%s\""), name);

  metaLocation(parser);

  fputts(T("/>\n"), fp);

}

static void XMLCALL

metaProcessingInstruction(void *userData, const XML_Char *target,

                          const XML_Char *data)

{

  XML_Parser parser = (XML_Parser) userData;

  FILE *fp = (FILE *)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 XMLCALL

metaComment(void *userData, const XML_Char *data)

{

  XML_Parser parser = (XML_Parser) userData;

  FILE *fp = (FILE *)XML_GetUserData(parser);

  fputts(T("<comment data=\""), fp);

  characterData(fp, data, tcslen(data));

  puttc(T('"'), fp);

  metaLocation(parser);

  fputts(T("/>\n"), fp);

}

static void XMLCALL

metaStartCdataSection(void *userData)

{

  XML_Parser parser = (XML_Parser) userData;

  FILE *fp = (FILE *)XML_GetUserData(parser);

  fputts(T("<startcdata"), fp);

  metaLocation(parser);

  fputts(T("/>\n"), fp);

}

static void XMLCALL

metaEndCdataSection(void *userData)

{

  XML_Parser parser = (XML_Parser) userData;

  FILE *fp = (FILE *)XML_GetUserData(parser);

  fputts(T("<endcdata"), fp);

  metaLocation(parser);

  fputts(T("/>\n"), fp);

}

static void XMLCALL

metaCharacterData(void *userData, const XML_Char *s, int len)

{

  XML_Parser parser = (XML_Parser) userData;

  FILE *fp = (FILE *)XML_GetUserData(parser);

  fputts(T("<chars str=\""), fp);

  characterData(fp, s, len);

  puttc(T('"'), fp);

  metaLocation(parser);

  fputts(T("/>\n"), fp);

}

static void XMLCALL

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 = (FILE *)XML_GetUserData(parser);

  ftprintf(fp, T("<startdoctype name=\"%s\""), doctypeName);

  metaLocation(parser);

  fputts(T("/>\n"), fp);

}

static void XMLCALL

metaEndDoctypeDecl(void *userData)

{

  XML_Parser parser = (XML_Parser) userData;

  FILE *fp = (FILE *)XML_GetUserData(parser);

  fputts(T("<enddoctype"), fp);

  metaLocation(parser);

  fputts(T("/>\n"), fp);

}

static void XMLCALL

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 = (FILE *)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 XMLCALL

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 = (FILE *)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 XMLCALL

metaStartNamespaceDecl(void *userData,

                       const XML_Char *prefix,

                       const XML_Char *uri)

{