---

outputsaxreceptor.cpp

Go to the documentation of this file.

/***************************************************************************
    outputsaxreceptor.cpp  -  Definition of OutputSAXReceptor class methods
                             -------------------
    begin                : October 24 2002
    copyright            : (C) 2003 by Vojtìch Toman
    email                : vtoman@lit.cz
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifdef __GNUG__
# pragma implementation
#endif


#include "outputsaxreceptor.h"


#define ENSURE_TEXT_CODEC_EXISTS        \
{                                       \
  if (!textCodec)                       \
    createDefaultTextCodec();           \
}



#define OUTPUT_TO_DEVICE(str)                                                   \
{                                                                               \
  ENSURE_TEXT_CODEC_EXISTS;                                                     \
  if (outputDevice)                                                             \
    textCodec->output(outputDevice, str,                                        \
                      (Encodings::MIB)ExaltOptions::getOption(ExaltOptions::Encoding)); \
}



#define OUTPUT_TO_DEVICE_LENGTH(str, length)                                    \
{                                                                               \
  ENSURE_TEXT_CODEC_EXISTS;                                                     \
  if (outputDevice)                                                             \
    textCodec->output(outputDevice, str, length,                                \
                      (Encodings::MIB)ExaltOptions::getOption(ExaltOptions::Encoding)); \
}


#define OUTPUT_TO_DEVICE_CHAR(c)                                                \
{                                                                               \
  ENSURE_TEXT_CODEC_EXISTS;                                                     \
  if (outputDevice)                                                             \
    textCodec->output(outputDevice, c,                                          \
                      (Encodings::MIB)ExaltOptions::getOption(ExaltOptions::Encoding)); \
}




OutputSAXReceptor::OutputSAXReceptor(void)
  : SAXReceptor(), UserOfTextCodec()
{
  outputDevice = 0;
  init();
}



OutputSAXReceptor::OutputSAXReceptor(IODevice *outDevice)
  : SAXReceptor(), UserOfTextCodec()
{
  outputDevice = outDevice;
  init();
}


OutputSAXReceptor::~OutputSAXReceptor(void)
{
  deleteDefaultTextCodec();
}


void OutputSAXReceptor::init(void)
{
  dtdHasInternalSubset = false;
  inCDATA = false;
}



void OutputSAXReceptor::setOutputDevice(IODevice *outDevice)
{
  outputDevice = outDevice;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++



void OutputSAXReceptor::reportError(void)
{
  FATAL("Output SAX receptor error!");
}



void OutputSAXReceptor::startElement(void *userData, const XmlChar *name, const XmlChar **attr)
{
  OUTPUT_TO_DEVICE("<");
  OUTPUT_TO_DEVICE(name);

//   DBG("<" << name << ">");
  if (attr)
    if (attr[0])
      {
        for (int i = 0; attr[i]; i += 2)
          {
            OUTPUT_TO_DEVICE(" ");
            OUTPUT_TO_DEVICE(attr[i]);
            OUTPUT_TO_DEVICE("=\"");
            OUTPUT_TO_DEVICE(attr[i + 1]);
            OUTPUT_TO_DEVICE("\"");

//          DBG(attr[i] << " = " << attr[i + 1]);
          }
      }

  OUTPUT_TO_DEVICE(">");
}



void OutputSAXReceptor::endElement(void *userData,
                                   const XmlChar *name)
{
  OUTPUT_TO_DEVICE("</");
  OUTPUT_TO_DEVICE(name);
  OUTPUT_TO_DEVICE(">");
}




void OutputSAXReceptor::characterData(void *userData,
                                      const XmlChar *data,
                                      int length)
{
  if (!inCDATA)
    {
      //output character data and substitute XML's reserved entites
      for (int i = 0; i < length; i++)
        {
          switch (data[i])
            {
            case AMP_REPLACEMENT:
              //&gt;
              OUTPUT_TO_DEVICE("&");
              break;
          
            case '>':
              //&gt;
              OUTPUT_TO_DEVICE(ENT_GT);
              break;
          
            case '<':
              //&lt;
              OUTPUT_TO_DEVICE(ENT_LT);
              break;
          
            case '&':
              //&amp;
              OUTPUT_TO_DEVICE(ENT_AMP);
              break;
          
            case '\'':
              //&apos;
              OUTPUT_TO_DEVICE(ENT_APOS);
              break;
          
            case '\"':
              //&quot;
              OUTPUT_TO_DEVICE(ENT_QUOT);
              break;
          
          
          
            default:
              OUTPUT_TO_DEVICE_CHAR(data[i]);
            }
        }
    }
  else
    //we are in CDATA --> no substitutions
    OUTPUT_TO_DEVICE_LENGTH(data, length);
}



void OutputSAXReceptor::processingInstruction(void *userData,
                                              const XmlChar *target,
                                              const XmlChar *data)
{
  OUTPUT_TO_DEVICE("<?");
  OUTPUT_TO_DEVICE(target);

  if (xmlchar_strlen(data))
    {
      OUTPUT_TO_DEVICE(" ");
      OUTPUT_TO_DEVICE(data);
    }
  OUTPUT_TO_DEVICE("?>");
}



void OutputSAXReceptor::comment(void *userData,
                                const XmlChar *data)
{
  OUTPUT_TO_DEVICE("<!--");
  OUTPUT_TO_DEVICE(data);
  OUTPUT_TO_DEVICE("-->");
}



void OutputSAXReceptor::startCDATASection(void *userData)
{
  OUTPUT_TO_DEVICE("<![CDATA[");
  inCDATA = true;
}



void OutputSAXReceptor::endCDATASection(void *userData)
{
  OUTPUT_TO_DEVICE("]]>");
  inCDATA = false;
}



void OutputSAXReceptor::defaultHandler(void *userData,
                                       const XmlChar *data,
                                       int length)
{
  OUTPUT_TO_DEVICE_LENGTH(data, length);
}



int OutputSAXReceptor::unknownEncoding(void *unknownEncodingData,
                                       const XmlChar *name,
                                       XML_Encoding *info)
{
  return 1;
}



void OutputSAXReceptor::xmlDecl(void *userData,
                                const XmlChar *version,
                                const XmlChar *encoding,
                                int standalone)
{
  OUTPUT_TO_DEVICE("<?xml");
  if (version)
    {
      OUTPUT_TO_DEVICE(" version=\"");
      OUTPUT_TO_DEVICE(version);
      OUTPUT_TO_DEVICE("\"");
    }

  if (encoding)
    {
      OUTPUT_TO_DEVICE(" encoding=\"");
      OUTPUT_TO_DEVICE(encoding);
      OUTPUT_TO_DEVICE("\"");
    }

  if (standalone != -1)
    {
      OUTPUT_TO_DEVICE(" standalone=\"");
      if (standalone)
        {
          OUTPUT_TO_DEVICE("yes");
        }
      else
        {
          OUTPUT_TO_DEVICE("no");
        }

      OUTPUT_TO_DEVICE("\"");
    }

  OUTPUT_TO_DEVICE("?>");
}



void OutputSAXReceptor::startDoctypeDecl(void *userData,
                                         const XmlChar *doctypeName,
                                         const XmlChar *systemId,
                                         const XmlChar *publicId,
                                         int hasInternalSubset)
{
  OUTPUT_TO_DEVICE("<!DOCTYPE ");
  OUTPUT_TO_DEVICE(doctypeName);

  if (publicId)
    {
      OUTPUT_TO_DEVICE(" PUBLIC \"");
      OUTPUT_TO_DEVICE(publicId);
      OUTPUT_TO_DEVICE("\"");
    }

  if (systemId)
    {
      if (!publicId)
        OUTPUT_TO_DEVICE(" SYSTEM");

      OUTPUT_TO_DEVICE(" \"");
      OUTPUT_TO_DEVICE(systemId);
      OUTPUT_TO_DEVICE("\"");
    }

  if (hasInternalSubset)
    {
      OUTPUT_TO_DEVICE(" [");
      dtdHasInternalSubset = true;
    }
  else
    dtdHasInternalSubset = false;

}



void OutputSAXReceptor::endDoctypeDecl(void *userData)
{
  if (dtdHasInternalSubset)
    {
      OUTPUT_TO_DEVICE("]");
      dtdHasInternalSubset = false;
    }

  OUTPUT_TO_DEVICE(">");
}




void OutputSAXReceptor::entityDecl(void *userData,
                                   const XmlChar *entityName,
                                   int isParameterEntity,
                                   const XmlChar *value,
                                   int valueLength,
                                   const XmlChar *base,
                                   const XmlChar *systemId,
                                   const XmlChar *publicId,
                                   const XmlChar *notationName)
{
  OUTPUT_TO_DEVICE("<!ENTITY ");

  if (isParameterEntity)
    OUTPUT_TO_DEVICE("% ");

  OUTPUT_TO_DEVICE(entityName);

  if (value)
    {
      OUTPUT_TO_DEVICE(" \"");
      OUTPUT_TO_DEVICE_LENGTH(value, valueLength);
      OUTPUT_TO_DEVICE("\"");
    }

  if (publicId)
    {
      OUTPUT_TO_DEVICE(" PUBLIC \"");
      OUTPUT_TO_DEVICE(publicId);
      OUTPUT_TO_DEVICE("\"");
    }

  if (systemId)
    {
      if (!publicId)
        OUTPUT_TO_DEVICE(" SYSTEM");

      OUTPUT_TO_DEVICE(" \"");
      OUTPUT_TO_DEVICE(systemId);
      OUTPUT_TO_DEVICE("\"");
    }

  if (notationName)
    {
      OUTPUT_TO_DEVICE(" NDATA ");
      OUTPUT_TO_DEVICE(notationName);
    }

  OUTPUT_TO_DEVICE(">");
}



void OutputSAXReceptor::notationDecl(void *userData,
                                     const XmlChar *notationName,
                                     const XmlChar *base,
                                     const XmlChar *systemId,
                                     const XmlChar *publicId)
{
  OUTPUT_TO_DEVICE("<!NOTATION ");

  OUTPUT_TO_DEVICE(notationName);

  if (publicId)
    {
      OUTPUT_TO_DEVICE(" PUBLIC \"");
      OUTPUT_TO_DEVICE(publicId);
      OUTPUT_TO_DEVICE("\"");
    }

  if (systemId)
    {
      if (!publicId)
        OUTPUT_TO_DEVICE(" SYSTEM");

      OUTPUT_TO_DEVICE(" \"");
      OUTPUT_TO_DEVICE(systemId);
      OUTPUT_TO_DEVICE("\"");
    }

  OUTPUT_TO_DEVICE(">");
}

---