FormatterToXML.hpp

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the  "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#if !defined(FORMATTERTOXML_HEADER_GUARD_1357924680)
#define FORMATTERTOXML_HEADER_GUARD_1357924680
 
 
 
 
// Base include file.  Must be first.
#include <xalanc/XMLSupport/XMLSupportDefinitions.hpp>
 
 
 
#include <xalanc/Include/XalanVector.hpp>
 
 
 
#include <xalanc/XalanDOM/XalanDOMString.hpp>
 
 
 
#include <xalanc/PlatformSupport/DOMStringHelper.hpp>
#include <xalanc/PlatformSupport/XalanUnicode.hpp>
 
 
 
// Base class header file.
#include <xalanc/PlatformSupport/FormatterListener.hpp>
 
 
 
namespace XALAN_CPP_NAMESPACE {
 
 
 
class Writer;
class XalanOutputStream;
 
 
 
/**
 * FormatterToXML formats SAX-style events into XML.
 */
class XALAN_XMLSUPPORT_EXPORT FormatterToXML : public FormatterListener 
{
public:
 
    enum eDummy
    {
        eDefaultIndentAmount = 0
    };
 
    /**
     * Constructor for customized encoding and doctype.
     *
     * @param writer            character output stream to use
     * @param version           version of the output method
     * @param doIndent          true if output is to be indented
     * @param indent            number of spaces to indent at each nesting level
     * @param encoding          character encoding in use by <VAR>writer</VAR>
     * @param mediaType         media type (MIME content type) of the data
     * @param doctypeSystem     system identifier to be used in the document
     *                          type declaration
     * @param doctypePublic     public identifier to be used in the document
     *                          type declaration
     * @param xmlDecl           true if the XSLT processor should output an XML
     *                          declaration
     * @param standalone        true if the XSLT processor should output a
     *                          standalone document declaration
     *
     * @param format            should be used only by derived classes.
     * @param fBufferData       If true, data will be buffered in the formatter
     */
    FormatterToXML(
            Writer&                 writer,
            const XalanDOMString&   version = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            bool                    doIndent = false,
            int                     indent = eDefaultIndentAmount,
            const XalanDOMString&   encoding = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            const XalanDOMString&   mediaType = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            const XalanDOMString&   doctypeSystem = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            const XalanDOMString&   doctypePublic = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            bool                    xmlDecl = true,
            const XalanDOMString&   standalone = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            eFormat                 format = OUTPUT_METHOD_XML,
            bool                    fBufferData = true,
            MemoryManager&      theManager XALAN_DEFAULT_MEMMGR);
    
    static FormatterToXML*
    create(
            MemoryManager&      theManager,
            Writer&                 writer,
            const XalanDOMString&   version = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            bool                    doIndent = false,
            int                     indent = eDefaultIndentAmount,
            const XalanDOMString&   encoding = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            const XalanDOMString&   mediaType = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            const XalanDOMString&   doctypeSystem = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            const XalanDOMString&   doctypePublic = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            bool                    xmlDecl = true,
            const XalanDOMString&   standalone = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            eFormat                 format = OUTPUT_METHOD_XML,
            bool                    fBufferData = true);
 
    virtual
    ~FormatterToXML();
 
    MemoryManager&
    getMemoryManager()
    {
        return m_stringBuffer.getMemoryManager();
    }
 
    // These methods are inherited from FormatterListener ...
 
    virtual void
    setDocumentLocator(const Locator* const         locator);
 
    virtual void
    startDocument();
 
    virtual void
    endDocument();
 
    virtual void
    startElement(
            const XMLCh* const  name,
            AttributeListType&  attrs);
 
    virtual void
    endElement(const XMLCh* const   name);
 
    virtual void
    characters(
            const XMLCh* const  chars,
            const size_type     length);
 
    virtual void
    charactersRaw(
            const XMLCh* const  chars,
            const size_type     length);
 
    virtual void
    entityReference(const XMLCh* const  name);
 
    virtual void
    ignorableWhitespace(
            const XMLCh* const  chars,
            const size_type     length);
 
    virtual void
    processingInstruction(
            const XMLCh* const  target,
            const XMLCh* const  data);
 
 
    virtual void
    resetDocument();
 
    virtual void
    comment(const XMLCh* const  data);
 
    virtual void
    cdata(
            const XMLCh* const  ch,
            const size_type     length);
 
    virtual Writer*
    getWriter() const;
 
    virtual const XalanDOMString&
    getDoctypeSystem() const;
 
    virtual const XalanDOMString&
    getDoctypePublic() const;
 
    virtual const XalanDOMString&
    getEncoding() const;
 
    virtual const XalanDOMString&
    getMediaType() const;
 
    virtual int
    getIndent() const;
 
    const XalanDOMString&
    getVersion() const
    {
        return m_version;
    }
 
    const XalanDOMString&
    getStandalone() const
    {
        return m_standalone;
    }
 
    bool
    getShouldWriteXMLHeader() const
    {
        return m_shouldWriteXMLHeader;
    }
 
    void
    setShouldWriteXMLHeader(bool    b)
    {
        m_shouldWriteXMLHeader = b;
    }
 
    bool
    getStripCData() const
    {
        return m_stripCData;
    }
 
    void
    setStripCData(bool  b)
    {
        m_stripCData = b;
    }
 
    bool
    getEscapeCData() const
    {
        return m_escapeCData;
    }
 
    void
    setEscapeCData(bool b)
    {
        m_escapeCData = b;
    }
 
    bool
    getDoIndent() const
    {
        return m_doIndent;
    }
 
    void
    setDoIndent(bool    value)
    {
        m_doIndent = value;
    }
 
    void
    setIndent(int   value)
    {
        m_indent = value;
    }
 
 
    typedef XalanVector<bool>           BoolStackType;
    typedef XalanVector<XalanDOMChar>   DOMCharBufferType;
    typedef XalanVector<char>           ByteBufferType;
 
 
protected:
 
    /** 
     * The writer where the XML will be written.
     */
    Writer* const               m_writer;
 
    /** 
     * The stream where the XML will be written.
     */
    XalanOutputStream* const    m_stream;
 
    /**
     * Output a line break.
     */
    void
    outputLineSep();
 
    typedef void (FormatterToXML::*AccumCharFunctionType)(XalanDOMChar);
 
    typedef void (FormatterToXML::*AccumStringFunctionType)(const XalanDOMChar*);
 
    typedef void (FormatterToXML::*AccumDOMStringFunctionType)(const XalanDOMString&);
 
    typedef void (FormatterToXML::*AccumArrayFunctionType)(
                        const XalanDOMChar[],
                        size_type,
                        size_type);
 
    typedef void (FormatterToXML::*FlushFunctionType)();
 
    /**
     * Append a wide character to the buffer.
     *
     * Characters that are not representable
     * in the encoding are not written as
     * entities.
     *
     * @ch the character to append.
     */
    void
    accumName(XalanDOMChar  ch)
    {
        assert(m_accumNameCharFunction != 0);
 
        (this->*m_accumNameCharFunction)(ch);
    }
 
    /**
     * Append a wide character to the buffer.
     *
     * @ch the character to append.
     */
    void
    accumContent(XalanDOMChar   ch)
    {
        assert(m_accumContentCharFunction != 0);
 
        (this->*m_accumContentCharFunction)(ch);
    }
 
    /**
     * Append a null-terminated array of wide characters to
     * the buffer.
     *
     * Characters that are not representable
     * in the encoding are not written as
     * entities.
     *
     * @chars the array to append
     */
    void
    accumName(const XalanDOMChar*   chars)
    {
        assert(m_accumNameStringFunction != 0);
 
        (this->*m_accumNameStringFunction)(chars);
    }
 
    /**
     * Append a null-terminated array of wide characters to
     * the buffer.
     *
     * @chars the array to append
     */
    void
    accumContent(const XalanDOMChar*    chars)
    {
        assert(m_accumContentStringFunction != 0);
 
        (this->*m_accumContentStringFunction)(chars);
    }
 
    /**
     * Append an array of wide character to the buffer.
     *
     * Characters that are not representable
     * in the encoding are not written as
     * entities.
     *
     * @chars the array to append
     * @start the offset into the array to start from
     * @length the number of characters to append
     */
    void
    accumName(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length)
    {
        assert(m_accumNameArrayFunction != 0);
 
        (this->*m_accumNameArrayFunction)(chars, start, length);
    }
 
    /**
     * Append an array of wide character to the buffer.
     *
     * @chars the array to append
     * @start the offset into the array to start from
     * @length the number of characters to append
     */
    void
    accumContent(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length)
    {
        assert(m_accumContentArrayFunction != 0);
 
        (this->*m_accumContentArrayFunction)(chars, start, length);
    }
 
    /**
     * Append a string to the buffer.
     *
     * Characters that are not representable
     * in the encoding are not written as
     * entities.
     *
     * @param str the string to append
     */
    void
    accumName(const XalanDOMString&     str)
    {
        assert(m_accumNameDOMStringFunction != 0);
 
        (this->*m_accumNameDOMStringFunction)(str);
    }
 
    /**
     * Append a string to the buffer.
     *
     * @param str the string to append
     */
    void
    accumContent(const XalanDOMString&  str)
    {
        assert(m_accumContentDOMStringFunction != 0);
 
        (this->*m_accumContentDOMStringFunction)(str);
    }
 
    /**
     * Escape and accum a character.
     */
    size_type
    accumDefaultEscape(
            XalanDOMChar        ch,
            size_type           i,
            const XalanDOMChar  chars[],
            size_type           len,
            bool                escLF);
 
    /**
     * Handle one of the default entities, return false if it 
     * is not a default entity.
     */
    virtual bool
    accumDefaultEntity(
            XalanDOMChar    ch,
            bool            escLF);
 
    /**
     * Set the attribute characters what will require special mapping.
     */
    void
    initAttrCharsMap();
 
    /**
     * Set the output characters what will require special mapping.
     */
    void
    initCharsMap();
 
    /**
     * Flush the char buffer.
     */
    void
    flushChars();
 
    /**
     * Flush the byte buffer.
     */
    void
    flushBytes();
 
    void
    flushWriter();
 
    void
    openElementForChildren();
 
    bool
    childNodesWereAdded();
 
    bool
    shouldIndent() const
    {
        return m_doIndent && (!m_ispreserve && !m_isprevtext);
    }
 
    /**
     * Check to see if a parent's ">" has been written, and, if 
     * it has not, write it.
     */
    void
    writeParentTagEnd();
 
    /**
     * Prints a newline character and <var>n</var> spaces.
     * @param n         Number of spaces to print.
     */
    void
    indent(int  n);
 
    /**
     * Write normalized characters to the writer.
     * @param ch the string to write.
     * @param start the start offset into the string.
     * @param length the length of the string.
     * @param isCData true if writing CDATA.
     */
    virtual void
    writeNormalizedChars(
            const XalanDOMChar  ch[],
            size_type           start,
            size_type           length,
            bool                isCData);
 
    /**
     * Write a number into the buffer as an entity
     * reference.
     * @param theNumber the number to write.
     */
    void
    writeNumberedEntityReference(XalanUnicodeChar   theNumber);
 
    /**
     * Write an attribute string.
     *
     * @param theString The string to write.
     * @param theStringLength The length of the string.
     */
    virtual void
    writeAttrString(
            const XalanDOMChar*     theString,
            size_type               theStringLength);
 
    /**
     * Write the data for a comment
     * @param data The comment's data.
     */
    virtual void
    accumCommentData(const XalanDOMChar*    data);
 
    /**
     * Throw an exception when an invalid
     * surrogate is encountered.
     * @param ch The first character in the surrogate
     * @param theManager The MemoryManager instance to use
     */
    static void
    throwInvalidUTF16SurrogateException(
            XalanDOMChar        ch,
            MemoryManager&  theManager);
 
    /**
     * Throw an exception when an invalid
     * surrogate is encountered.
     * @param ch The first character in the surrogate
     * @param next The next character in the surrogate
     * @param theManager The MemoryManager instance to use
     */
    static void
    throwInvalidUTF16SurrogateException(
            XalanDOMChar        ch,
            XalanDOMChar        next,
            MemoryManager& theManager);
 
 
    /**
     * Throw an exception when an invalid
     * XML character is encountered.
     * @param ch The first character in the surrogate
     * @param next The next character in the surrogate
     */
    static void
    throwInvalidCharacterException( 
            XalanUnicodeChar    ch,
            MemoryManager&  theManager);
 
    static bool
    isUTF16Surrogate(XalanDOMChar   ch)
    {
        return (ch & 0xFC00) == 0xD800 ? true : false;
    }
 
    enum eDummyTwo { SPECIALSSIZE = 256};
 
    /**
     * The maximum character size before we have to resort 
     * to escaping.
     */
    XalanDOMChar            m_maxCharacter;
 
    XalanDOMChar            m_attrCharsMap[SPECIALSSIZE];
 
    XalanDOMChar            m_charsMap[SPECIALSSIZE];
 
    /**
     * If true, XML header should be written to output.
     */
    bool        m_shouldWriteXMLHeader;
 
    /**
     * State flag to tell if preservation of whitespace 
     * is important.
     */
    bool        m_ispreserve;
 
    /**
     * Flag to tell if indenting (pretty-printing) is on.
     */
    bool        m_doIndent;
 
    /**
     * Flag to signal that a newline should be added.
     */
    bool        m_startNewLine;
  
    /**
     * Flag to tell that we need to add the doctype decl, 
     * which we can't do until the first element is 
     * encountered.
     */
    bool        m_needToOutputDocTypeDecl;
  
    /**
     * State flag that tells if the previous node processed 
     * was text, so we can tell if we should preserve whitespace.
     */
    bool        m_isprevtext;
 
    /**
     * If true, cdata sections are simply stripped of their 
     * CDATA brackets, without escaping.
     */
    bool        m_stripCData;
 
    /**
     * Tell if the next text should be raw.
     */
    bool        m_nextIsRaw;
 
    /**
     * Tells if we're in CData section.
     */
    bool        m_inCData;
 
    /**
     * Flag to quickly tell if the encoding is capable of full
     * Unicode support.
     */
    bool        m_encodingIsUTF;
 
    /**
     * The System ID for the doc type.
     */
    const XalanDOMString    m_doctypeSystem;
 
    /**
     * The public ID for the doc type.
     */
    const XalanDOMString    m_doctypePublic;
 
    /**
     * The character encoding.
     */
    XalanDOMString  m_encoding;
 
    /**
     * Flag to keep track of the indent amount.
     */
    int     m_currentIndent;
  
    /**
     * Amount to indent.
     */
    int     m_indent;
 
    /**
     * Stack to keep track of whether or not we need to 
     * preserve whitespace.
     */
    BoolStackType   m_preserves;
 
    // A text buffer.  We use it mostly for converting
    // to string values.  See uses of UnsignedLongToString()
    // and UnsignedLongToHexString().
    XalanDOMString  m_stringBuffer;
 
private:
 
    // These are not implemented.
    FormatterToXML(const FormatterToXML&);
 
    FormatterToXML&
    operator=(const FormatterToXML&);
 
    bool
    operator==(const FormatterToXML&) const;
 
    /**
     * Append a wide character to the buffer.
     * Characters that are not representable
     * in the encoding are not written as
     * entities.
     *
     * @ch the character to append.
     */
    void
    accumNameAsByte(XalanDOMChar    ch);
 
    /**
     * Append a wide character to the buffer.
     * Characters that are not representable
     * in the encoding are not written as
     * entities.
     *
     * @ch the character to append.
     */
    void
    accumNameAsByteDirect(XalanDOMChar  ch);
 
    /**
     * Append a wide character to the buffer.
     * Characters that are not representable
     * in the encoding are written as entities.
     *
     * @ch the character to append.
     */
    void
    accumContentAsByte(XalanDOMChar     ch);
 
    /**
     * Append a wide character to the output.
     * Characters that are not representable
     * in the encoding are written as entities.
     *
     * @ch the character to append.
     */
    void
    accumContentAsByteDirect(XalanDOMChar   ch);
 
    /**
     * Append a wide character to the buffer.
     * Characters that are not representable
     * in the encoding are not written as
     * entities.
     *
     * @ch the character to append.
     */
    void
    accumNameAsChar(XalanDOMChar    ch);
 
    /**
     * Append a wide character to the buffer.
     * Characters that are not representable
     * in the encoding are not written as
     * entities.
     *
     * @ch the character to append.
     */
    void
    accumNameAsCharDirect(XalanDOMChar  ch);
 
    /**
     * Append a wide character to the buffer.
     *
     * @ch the character to append.
     */
    void
    accumContentAsChar(XalanDOMChar     ch);
 
    /**
     * Append a wide character to the stream without buffering.
     *
     * @ch the character to append.
     */
    void
    accumContentAsCharDirect(XalanDOMChar   ch);
 
    /**
     * Append a wide character to the buffer.
     * All characters are representable,
     * so no checks or escapes are needed.
     *
     * @ch the character to append.
     */
    void
    accumCharUTF(XalanDOMChar   ch);
 
    /**
     * Append a wide character to the output.
     * All characters are representable,
     * so no checks or escapes are needed.
     *
     * @ch the character to append.
     */
    void
    accumCharUTFDirect(XalanDOMChar ch);
 
    /**
     * Append a string to the buffer.
     * Characters that are not representable
     * in the encoding are not written as
     * entities.
     *
     * @chars the string to append.
     */
    void
    accumNameString(const XalanDOMChar* chars);
 
    /**
     * Append a wide character to the buffer.
     * All characters are representable,
     * so no checks or escapes are needed.
     *
     * @chars the string to append.
     */
    void
    accumStringUTF(const XalanDOMChar*  chars);
 
    /**
     * Append a wide character to the output.
     * All characters are representable,
     * so no checks or escapes are needed.
     *
     * @chars the string to append.
     */
    void
    accumStringUTFDirect(const XalanDOMChar*    chars);
 
    /**
     * Append a string to the buffer.
     * Characters that are not representable
     * in the encoding are written as entities.
     *
     * @chars the string to append.
     */
    void
    accumContentString(const XalanDOMChar*  chars);
 
    /**
     * Append an array of wide character to the buffer.
     * Characters that are not representable in the
     * encoding are not written as entities.
     *
     * @chars the array to append
     * @start the offset into the array to start from
     * @length the number of characters to append
     */
    void
    accumNameArray(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length);
 
    /**
     * Append an array of wide character to the buffer.
     * Characters that are not representable in the
     * encoding are written as entities.
     *
     * @chars the array to append
     * @start the offset into the array to start from
     * @length the number of characters to append
     */
    void
    accumContentArray(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length);
 
    /**
     * Append an array of wide character to the buffer.
     * All characters are representable,
     * so no checks or escapes are needed.
     *
     * @chars the array to append
     * @start the offset into the array to start from
     * @length the number of characters to append
     */
    void
    accumArrayUTF(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length);
 
    /**
     * Append an array of wide character to the output.
     * All characters are representable,
     * so no checks or escapes are needed.
     *
     * @chars the array to append
     * @start the offset into the array to start from
     * @length the number of characters to append
     */
    void
    accumArrayUTFDirect(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length);
 
    /**
     * Append a string to the buffer.
     * Characters that are not representable in the
     * encoding are not written as entities.
     *
     * @str the string to append
     */
    void
    accumNameDOMString(const XalanDOMString&    str);
 
    /**
     * Append a string to the buffer.
     * Characters that are not representable in the
     * encoding are written as entities.
     *
     * @str the string to append
     */
    void
    accumContentDOMString(const XalanDOMString& str);
 
    /**
     * Append a string to the buffer.
     * All characters are representable,
     * so no checks or escapes are needed.
     *
     * @str the string to append
     */
    void
    accumDOMStringUTF(const XalanDOMString& str);
 
    /**
     * Append a string to the output.
     * All characters are representable,
     * so no checks or escapes are needed.
     *
     * @str the string to append
     */
    void
    accumDOMStringUTFDirect(const XalanDOMString&   str);
 
    /**
     * Output the doc type declaration.
     *
     * @param name the name of the doctype.
     */
    void
    outputDocTypeDecl(const XalanDOMChar*   name);
 
    /**
     * Process an attribute.
     * @param name The name of the attribute.
     * @param value The value of the attribute.
     */
    void
    processAttribute(
            const XalanDOMChar*     name,
            const XalanDOMChar*     value);
 
    /**
     * Prints <var>n</var> spaces.
     * @param n         Number of spaces to print.
     */
    void
    printSpace(int n);
 
    /**
     * Normalize the data in a PI, to replace any
     * "?>" pairs with "? >"
     * @param theData the data to normalize.
     */
    void
    accumNormalizedPIData(
            const XalanDOMChar*     theData,
            size_type               theLength);
 
 
    // Data members...
    /**
     * True if an encoding is only has only values from 0 - 255
     */
    bool        m_bytesEqualChars;
 
    bool        m_shouldFlush;
 
    /**
     * Add space before '/>' for XHTML.
     */
    bool        m_spaceBeforeClose;
 
    /**
     * If true, characters in cdata sections are 
     * escaped, instead of being writted out as 
     * cdata sections.
     */
    bool        m_escapeCData;
 
    /**
     * Tells the XML version, for writing out to the XML decl.
     */
    const XalanDOMString    m_version;
 
    /**
     * Text for standalone part of header.
     */
    const XalanDOMString    m_standalone;
 
    /**
     * The media type.  Not used right now.
     */
    const XalanDOMString    m_mediaType;
 
    /**
     * These are characters that will be escaped in the output.
     */
    const XalanDOMString    m_attrSpecialChars;
 
    //typedef XalanDOMString::size_type   size_type;
 
    /**
     * The string "<!DOCTYPE ".
     */
    static const XalanDOMChar   s_doctypeHeaderStartString[];
 
    static const size_type      s_doctypeHeaderStartStringLength;
 
    /**
     * The string " PUBLIC \"".
     */
    static const XalanDOMChar   s_doctypeHeaderPublicString[];
 
    static const size_type      s_doctypeHeaderPublicStringLength;
 
    /**
     * The string " SYSTEM \"".
     */
    static const XalanDOMChar   s_doctypeHeaderSystemString[];
 
    static const size_type      s_doctypeHeaderSystemStringLength;
 
    /**
     * The string "<?xml version=\"".
     */
    static const XalanDOMChar   s_xmlHeaderStartString[];
 
    static const size_type      s_xmlHeaderStartStringLength;
 
    /**
     * The string "\" encoding=\"".
     */
    static const XalanDOMChar   s_xmlHeaderEncodingString[];
 
    static const size_type      s_xmlHeaderEncodingStringLength;
 
    /**
     * The string "\" standalone=\"".
     */
    static const XalanDOMChar   s_xmlHeaderStandaloneString[];
 
    static const size_type      s_xmlHeaderStandaloneStringLength;
 
    /**
     * The string "\"?>".
     */
    static const XalanDOMChar   s_xmlHeaderEndString[];
 
    static const size_type      s_xmlHeaderEndStringLength;
 
    /**
     * The string "1.0".
     */
    static const XalanDOMChar   s_defaultVersionString[];
 
    static const size_type      s_defaultVersionStringLength;
 
    /**
     * The string "-//W3C//DTD XHTML".
     */
    static const XalanDOMChar   s_xhtmlDocTypeString[];
 
    static const size_type      s_xhtmlDocTypeStringLength;
 
    /**
     * The string "]]>".
     */
    static const XalanDOMChar   s_dtdCDATACloseString[];
 
    static const size_type      s_dtdCDATACloseStringLength;
 
    DOMCharBufferType                           m_charBuf;
 
    XalanDOMString::size_type                   m_pos;
 
    ByteBufferType                              m_byteBuf;
 
    static const XalanDOMString::size_type      s_maxBufferSize;
 
    /**
     * A stack of Boolean objects that tell if the given element 
     * has children.
     */
    BoolStackType   m_elemStack;
 
    /**
     * A pointer to a member function that will do accumulating
     * for names.
     */
    AccumCharFunctionType       m_accumNameCharFunction;
 
    /**
     * A pointer to a member function that will do accumulating
     * for names.
     */
    AccumStringFunctionType     m_accumNameStringFunction;
 
    /**
     * A pointer to a member function that will do accumulating
     * for names.
     */
    AccumDOMStringFunctionType  m_accumNameDOMStringFunction;
 
    /**
     * A pointer to a member function that will do accumulating
     * for names.
     */
    AccumArrayFunctionType      m_accumNameArrayFunction;
 
    /**
     * A pointer to a member function that will do accumulating
     * for content.
     */
    AccumCharFunctionType       m_accumContentCharFunction;
 
    /**
     * A pointer to a member function that will do accumulating
     * for content.
     */
    AccumStringFunctionType     m_accumContentStringFunction;
 
    /**
     * A pointer to a member function that will do accumulating
     * for content.
     */
    AccumDOMStringFunctionType  m_accumContentDOMStringFunction;
 
    /**
     * A pointer to a member function that will do accumulating
     * for names.
     */
    AccumArrayFunctionType      m_accumContentArrayFunction;
 
    /**
     * A pointer to the member function that will flush the buffer.
     */
    FlushFunctionType           m_flushFunction;
 
    /**
     * The string of characters that represents the newline
     */
    const XalanDOMChar*         m_newlineString;
 
    /**
     * The length of the the string of characters that represents the newline
     */
    XalanDOMString::size_type   m_newlineStringLength;
 
    bool                        m_isXML1_1;
};
 
 
 
}
 
 
 
#endif  // FORMATTERTOXML_HEADER_GUARD_1357924680