/**********************************************************************

Filename    :   GFxXML.cpp
Content     :   DOM support
Created     :   December 13, 2007
Authors     :   Prasad Silva
Copyright   :   (c) 2005-2008 Scaleform Corp. All Rights Reserved.

Licensees may use this file in accordance with the valid Scaleform
Commercial License Agreement provided with the software.

This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING 
THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR ANY PURPOSE.

**********************************************************************/

#include "GConfig.h"

#ifndef GFC_NO_XML_SUPPORT

#include <GFxXML.h>


// 
// Debug trace/dump helper functions
//
#ifdef GFC_BUILD_DEBUG

//
// Trace the document builder's DOM tree construction in debug output
//
// #define GFC_XML_DOCBUILDER_TRACE
//

//
// Dump all constructed DOM trees to standard out
// if provided to the document builder
// (Warning: Avoid this for large files)
//
// #define GFC_XML_DOCBUILDER_DOM_TREE_DUMP
//


// Maximum size of strings used for debug printing
#define MAX_DEBUG_STRING_LENGTH 256
// 
// Helper to copy strings for debugging
//
void SafeStringCopyWithSentinel(const char* src, UPInt srcLen, 
                                char* dest, UPInt destSz)
{
    UPInt len = 0;
    if (srcLen  < destSz)
        len = srcLen;
    else
        len = (destSz - 1);
    G_strncpy(dest, len + 1, src, len);
    // explicit sentinel just in case
    dest[len] = '\0';
}

#ifdef GFC_XML_DOCBUILDER_DOM_TREE_DUMP
//
// Prints the DOM tree to stdout
//
char printDOMBuffer[128];
void PrintDOMTree(GFxXMLNode* proot, UPInt level = 0)
{
    for (UPInt i=0; i < level; i++)
        printf("  ");
    switch (proot->Type)
    {
    case GFxXMLElementNodeType: 
        {
            GFxXMLElementNode* pnode = static_cast<GFxXMLElementNode*>(proot);
            if (pnode->Prefix.GetSize() > 0)
            {
                printf("ELEM - '%.16s:%.16s' ns:'%.16s' prefix:'%.16s'"
                    " localname: '%.16s'",
                    pnode->Prefix.ToCStr(),
                    pnode->Value.ToCStr(),
                    pnode->Namespace.ToCStr(),
                    pnode->Prefix.ToCStr(),
                    pnode->Value.ToCStr());
            }
            else
            {
                printf("ELEM - '%.16s' ns:'%.16s' prefix:''"
                    " localname: '%.16s'",
                    pnode->Value.ToCStr(), 
                    pnode->Namespace.ToCStr(), 
                    pnode->Value.ToCStr());
            }
            for (GFxXMLAttribute* attr = pnode->FirstAttribute; 
                attr != NULL; attr = attr->Next)
            {
                printf(" {%.16s,%.16s}", attr->Name.ToCStr(), 
                attr->Value.ToCStr());
            }
            printf("\n");
            for (GFxXMLNode* child = pnode->FirstChild; child != NULL; 
                child = child->NextSibling)
                PrintDOMTree(child, level+1);
            break;
        }
    case GFxXMLTextNodeType: 
        {
            printf("TEXT - '%.16s'\n", proot->Value.ToCStr());
            break;
        }
    default: 
        {
            printf("UNKN\n");
        }
    }
}

#endif  // #ifdef GFC_XML_DOCBUILDER_DOM_TREE_DUMP

#endif  // #ifdef GFC_BUILD_DEBUG


// 
// Constructor
//
GFxXMLDOMBuilder::GFxXMLDOMBuilder(GPtr<GFxXMLSupportBase> pxmlParser, 
                                           bool ignorews)
    : pXMLParserState(pxmlParser), pLocator(NULL), pDoc(NULL), 
      bIgnoreWhitespace(ignorews), bError(false)
{
#ifdef GFC_XML_DOCBUILDER_TRACE
    GFC_DEBUG_MESSAGE(1, "GFxXMLDocumentBuilder::GFxXMLDocumentBuilder");
#endif
}


// 
// Parse an XML file and build a DOM tree out of it
//
GPtr<GFxXMLDocument> GFxXMLDOMBuilder::ParseFile(const char* pfilename, 
                                                      GFxFileOpenerBase* pfo, 
                                                      GPtr<GFxXMLObjectManager> objMgr /* = NULL */)
{
    // reset internal vars
    bError = false;
    TotalBytesToLoad = 0;
    LoadedBytes = 0;

    if (NULL == objMgr.GetPtr())
        objMgr = *new GFxXMLObjectManager;

    // create new document
    pDoc = *objMgr->CreateDocument();

    // commence parsing
    if (pXMLParserState)
        bError = !pXMLParserState->ParseFile(pfilename, pfo, this);
    // NOTE: The locator could be invalid at this point
    
    // Release internal reference to document
    GPtr<GFxXMLDocument> pret = pDoc;
    pDoc = 0;

    if (pret.GetPtr() && bIgnoreWhitespace)
        DropWhiteSpaceNodes(pret);

    return pret;
}

// 
// Parse an XML string and build a DOM tree out of it
//
GPtr<GFxXMLDocument> GFxXMLDOMBuilder::ParseString(const char* pdata, UPInt len, 
                                                        GPtr<GFxXMLObjectManager> objMgr /* = NULL */)
{
    // Reset internal vars
    bError = false;
    TotalBytesToLoad = 0;
    LoadedBytes = 0;

    if (NULL == objMgr.GetPtr())
        objMgr = *new GFxXMLObjectManager;

    // Create new document
    pDoc = *objMgr->CreateDocument();

    // Commence parsing
    if (pXMLParserState)
        bError = !pXMLParserState->ParseString(pdata, len, this);
    // NOTE: The locator could be invalid at this point

    // Release internal reference to document
    GPtr<GFxXMLDocument> pret = pDoc;
    pDoc = 0;

    if (pret.GetPtr() && bIgnoreWhitespace)
        DropWhiteSpaceNodes(pret);

    return pret;
}

// 
// Document begin reported by XML parser
//
void GFxXMLDOMBuilder::StartDocument()
{
#ifdef GFC_XML_DOCBUILDER_TRACE
    GFC_DEBUG_ASSERT(pLocator, "Locator not set!");
    GFC_DEBUG_MESSAGE(1, "GFxXMLDocumentBuilder::StartDocument");
#endif

    // Create a parse stack      
    ParseStack.PushBack(pDoc);

    // Copy the total number of bytes to load
    TotalBytesToLoad = pLocator->TotalBytesToLoad;
}


// 
// Document end reported by XML parser
//
void GFxXMLDOMBuilder::EndDocument()
{
#ifdef GFC_XML_DOCBUILDER_TRACE
    GFC_DEBUG_ASSERT(pLocator, "Locator not set!");
    char db0[MAX_DEBUG_STRING_LENGTH];
    char db1[MAX_DEBUG_STRING_LENGTH];
    SafeStringCopyWithSentinel(pLocator->XMLVersion.ToCStr(), 
        pLocator->XMLVersion.GetSize(),
        db0, MAX_DEBUG_STRING_LENGTH);
    SafeStringCopyWithSentinel(pLocator->Encoding.ToCStr(), 
        pLocator->Encoding.GetSize(),
        db1, MAX_DEBUG_STRING_LENGTH);
    GFC_DEBUG_MESSAGE3(1, 
        "GFxXMLDocumentBuilder::EndDocument('%.16s', '%.16s', %d)",
        db0, db1, pLocator->StandAlone);
#endif

    // Copy the number of bytes loaded
    LoadedBytes = pLocator->LoadedBytes;

    // Check parse stack
    GASSERT(ParseStack.GetSize() == 1);
    GASSERT(ParseStack[0].GetPtr() == pDoc.GetPtr());

    // Drop reference to document
    ParseStack.Clear();

    // Check prefix ownership stacks
    GASSERT(PrefixNamespaceStack.GetSize() == 0);
    GASSERT(DefaultNamespaceStack.GetSize() == 0);

    // Set the xml declaration values
    GPtr<GFxXMLObjectManager> memMgr = pDoc->MemoryManager;
    pDoc->XMLVersion = memMgr->CreateString(pLocator->XMLVersion.ToCStr(),
        pLocator->XMLVersion.GetSize());
    pDoc->Encoding = memMgr->CreateString(pLocator->Encoding.ToCStr(),
        pLocator->Encoding.GetSize());
    pDoc->Standalone = (SByte)pLocator->StandAlone;

#ifdef GFC_XML_DOCBUILDER_DOM_TREE_DUMP
    PrintDOMTree(pDoc);
#endif
}


// 
// Tag element begin reported by XML parser
//
void GFxXMLDOMBuilder::StartElement(const GFxXMLStringRef& prefix,
                                  const GFxXMLStringRef& localname,
                                  const GFxXMLParserAttributes& atts)
{
#ifdef GFC_XML_DOCBUILDER_TRACE
    GFC_DEBUG_ASSERT(pLocator, "Locator not set!");
    char db0[MAX_DEBUG_STRING_LENGTH];
    char db1[MAX_DEBUG_STRING_LENGTH];
    SafeStringCopyWithSentinel(prefix.ToCStr(), prefix.GetSize(), 
        db0, MAX_DEBUG_STRING_LENGTH);
    SafeStringCopyWithSentinel(localname.ToCStr(), localname.GetSize(), 
        db1, MAX_DEBUG_STRING_LENGTH);
    GFC_DEBUG_MESSAGE4(1, 
        "[%d, %d] GFxXMLDocumentBuilder::StartElement('%.16s', '%.16s')", 
        pLocator->Line, pLocator->Column, db0, db1);
    for (UPInt i=0; i < atts.Length; i++)
    {
        GFxXMLParserAttribute& att = atts.Attributes[i];
        SafeStringCopyWithSentinel(att.Name.ToCStr(), att.Name.GetSize(), 
            db0, MAX_DEBUG_STRING_LENGTH);
        SafeStringCopyWithSentinel(att.Value.ToCStr(), att.Value.GetSize(), 
            db1, MAX_DEBUG_STRING_LENGTH);
        GFC_DEBUG_MESSAGE2(1, "\tATTR: '%.16s' -> '%.16s'", db0, db1);
    }
#endif

    // Copy the number of bytes loaded
    LoadedBytes = pLocator->LoadedBytes;

    // Must have at least root node in stack
    GASSERT(ParseStack.GetSize() > 0);

    GPtr<GFxXMLObjectManager> memMgr = pDoc->MemoryManager;

    // If appending required, consolidate it
    if (pAppendChainRoot.GetPtr() != NULL)
    {
        GPtr<GFxXMLElementNode> pnode = ParseStack.Back();
        pnode->AppendChild(pAppendChainRoot);
        pAppendChainRoot->Value = memMgr->CreateString(AppendText.ToCStr(), AppendText.GetSize());
        // Reset append chain
        pAppendChainRoot = NULL;
        AppendText.Clear();
    }

    // Create new node
    GPtr<GFxXMLElementNode> elemNode = *memMgr->CreateElementNode(
        memMgr->CreateString(localname.ToCStr(), localname.GetSize()));

    // Add attributes
    for (UPInt i=0; i < atts.Length; i++)
    {
        GFxXMLParserAttribute& att = atts.Attributes[i];
        GFxXMLAttribute* patt = memMgr->CreateAttribute(
            memMgr->CreateString(att.Name.ToCStr(), att.Name.GetSize()),
            memMgr->CreateString(att.Value.ToCStr(), att.Value.GetSize()));
        elemNode->AddAttribute(patt);
    }

    // Assign ownership to any floating namespaces
    if (PrefixNamespaceStack.GetSize() > 0)
    {
        UPInt len = PrefixNamespaceStack.GetSize();
        for (SInt i=(SInt)len-1; i >= 0; i--)
        {
            PrefixOwnership& po = PrefixNamespaceStack[i];
            if (NULL != po.Owner.GetPtr())
                break;
            po.Owner = elemNode;
        }
    }
    if (DefaultNamespaceStack.GetSize() > 0)
    {
        PrefixOwnership& po = DefaultNamespaceStack.Back();
        if (NULL == po.Owner.GetPtr())
            po.Owner = elemNode;
    }

    // Assign appropriate namespace to node
    if (prefix.GetSize() > 0)
    {
        bool found = false;
        // Assign prefix namespace - it has higher precedence
        // TODO: change to hash lookup?
        if (PrefixNamespaceStack.GetSize() > 0)
        {
            UPInt len = PrefixNamespaceStack.GetSize();
            for (SInt i=(SInt)len-1; i >= 0; i--)
            {
                PrefixOwnership po = PrefixNamespaceStack[i];
                if (po.Prefix->Name == 
                    GFxXMLDOMStringCompareWrapper(prefix.ToCStr(), prefix.GetSize()))
                {
                    found = true;
                    elemNode->Prefix = po.Prefix->Name;
                    elemNode->Namespace = po.Prefix->Value;
                    break;
                }
            }
        }
        if (!found)
        {
            // Prefix was not found. create a dummy one.
            elemNode->Prefix = memMgr->CreateString(prefix.ToCStr(), 
                prefix.GetSize());
            elemNode->Namespace = memMgr->EmptyString();
        }
    }
    else if (DefaultNamespaceStack.GetSize() > 0)
    {
        // Assign default namespace
        PrefixOwnership os = DefaultNamespaceStack.Back();
        elemNode->Prefix = os.Prefix->Name;
        elemNode->Namespace = os.Prefix->Value;
    }

    // Attach to parent
    GPtr<GFxXMLElementNode> parentNode = ParseStack.Back();
    parentNode->AppendChild(elemNode);

    // Push to parse stack
    ParseStack.PushBack(elemNode);
}


// 
// Tag element end reported by XML parser
//
void GFxXMLDOMBuilder::EndElement(const GFxXMLStringRef& prefix,
                                const GFxXMLStringRef& localname)
{
    GUNUSED2(prefix, localname);

#ifdef GFC_XML_DOCBUILDER_TRACE
    GFC_DEBUG_ASSERT(pLocator, "Locator not set!");
    char db0[MAX_DEBUG_STRING_LENGTH];
    char db1[MAX_DEBUG_STRING_LENGTH];
    SafeStringCopyWithSentinel(prefix.ToCStr(), prefix.GetSize(), db0, 
        MAX_DEBUG_STRING_LENGTH);
    SafeStringCopyWithSentinel(localname.ToCStr(), localname.GetSize(), 
        db1, MAX_DEBUG_STRING_LENGTH);
    GFC_DEBUG_MESSAGE4(1, 
        "[%d, %d] GFxXMLDocumentBuilder::EndElement('%.16s', '%.16s')", 
        pLocator->Line, pLocator->Column, db0, db1);
#endif

    // Copy the number of bytes loaded
    LoadedBytes = pLocator->LoadedBytes;

    GASSERT(ParseStack.GetSize() > 1); // must be at least root node + 1

    GPtr<GFxXMLElementNode> pnode = ParseStack.Back();
    GASSERT(pnode.GetPtr() != pDoc.GetPtr());    // must not be root node    
   
    // If appending required, consolidate it
    if (pAppendChainRoot.GetPtr() != NULL)
    {
        GPtr<GFxXMLObjectManager> memMgr = pDoc->MemoryManager;
        pnode->AppendChild(pAppendChainRoot);
        // Accumulate append text while removing the nodes
        pAppendChainRoot->Value = memMgr->CreateString(AppendText.ToCStr(), AppendText.GetSize());
        // Reset append chain
        pAppendChainRoot = NULL;
        AppendText.Clear();
    }
    
    // Remove namespace ownership
    // A top-down traversal of the namespace stacks is guaranteed to 
    // return any owned namespaces. if not found, no ownership.
    if (PrefixNamespaceStack.GetSize() > 0)
    {
        UPInt len = PrefixNamespaceStack.GetSize();
        for (SInt i=(SInt)len-1; i >= 0; i--)
        {
            PrefixOwnership po = PrefixNamespaceStack[i];
            if (po.Owner != pnode)
                break;
            PrefixNamespaceStack.PopBack();
        }
    }
    if (DefaultNamespaceStack.GetSize() > 0)
    {
        PrefixOwnership po = DefaultNamespaceStack.Back();
        if (po.Owner == pnode)
            DefaultNamespaceStack.PopBack();
    }

    // Pop stack
    ParseStack.PopBack();
}


// 
// Namespace mapping reported by XML parser
//
// Next tag element will define the namespace scope.
//
void GFxXMLDOMBuilder::PrefixMapping(const GFxXMLStringRef& prefix, 
                                          const GFxXMLStringRef& uri)
{
#ifdef GFC_XML_DOCBUILDER_TRACE
    GFC_DEBUG_ASSERT(pLocator, "Locator not set!");
    char db0[MAX_DEBUG_STRING_LENGTH];
    char db1[MAX_DEBUG_STRING_LENGTH];
    SafeStringCopyWithSentinel(prefix.ToCStr(), prefix.GetSize(), 
        db0, MAX_DEBUG_STRING_LENGTH);
    SafeStringCopyWithSentinel(uri.ToCStr(), uri.GetSize(), db1, 
        MAX_DEBUG_STRING_LENGTH);
    GFC_DEBUG_MESSAGE4(1, 
        "[%d, %d] GFxXMLDocumentBuilder::StartPrefixMapping('%.16s', '%.16s')", 
        pLocator->Line, pLocator->Column, db0, db1);
#endif

    // Copy the number of bytes loaded
    LoadedBytes = pLocator->LoadedBytes;

    GPtr<GFxXMLObjectManager> memMgr = pDoc->MemoryManager;

    GPtr<GFxXMLPrefix> pPfxObj = *memMgr->CreatePrefix(
        memMgr->CreateString(prefix.ToCStr(), prefix.GetSize()),
        memMgr->CreateString(uri.ToCStr(), uri.GetSize()));

    // Add prefix namespaces to prefix stack
    if (prefix.GetSize() > 0)
    {
        // Owner will be set when next start element is encountered.
        PrefixNamespaceStack.PushBack(PrefixOwnership(pPfxObj, NULL));
    }
    // Add default namespaces to dns stack
    else
    {
        // Why is this in a separate stack?
        // Elements without a prefix may inherit a default namespace
        // from any of its ancestors. keeping it in a separate stack
        // makes lookup Theta(1).
        // Owner will be set when next start element is encountered.
        DefaultNamespaceStack.PushBack(PrefixOwnership(pPfxObj, NULL));
    }
}


// 
// Text data reported by XML parser
//
void GFxXMLDOMBuilder::Characters(const GFxXMLStringRef& text)
{
#ifdef GFC_XML_DOCBUILDER_TRACE
    GFC_DEBUG_ASSERT(pLocator, "Locator not set!");
    char db0[MAX_DEBUG_STRING_LENGTH];
    SafeStringCopyWithSentinel(text.ToCStr(), text.GetSize(), db0, 
        MAX_DEBUG_STRING_LENGTH);
    GFC_DEBUG_MESSAGE3(1, 
        "[%d, %d] GFxXMLDocumentBuilder::Characters('%.16s')", 
        pLocator->Line, pLocator->Column, db0);
#endif

    // Copy the number of bytes loaded
    LoadedBytes = pLocator->LoadedBytes;

    GASSERT(ParseStack.GetSize() > 0);

    GPtr<GFxXMLObjectManager> memMgr = pDoc->MemoryManager;

    if (pAppendChainRoot.GetPtr() == NULL)
    {
        pAppendChainRoot = *memMgr->CreateTextNode(memMgr->EmptyString());
        AppendText.AppendString(text.ToCStr(), text.GetSize());
    }
    else
    {
        AppendText.AppendString(text.ToCStr(), text.GetSize());
    }
}


// 
// Ignored whitespace reported by XML parser
//
void GFxXMLDOMBuilder::IgnorableWhitespace(const GFxXMLStringRef& ws)
{
    GUNUSED(ws);
#ifdef GFC_XML_DOCBUILDER_TRACE
    GFC_DEBUG_ASSERT(pLocator, "Locator not set!");
    char db0[MAX_DEBUG_STRING_LENGTH];
    SafeStringCopyWithSentinel(ws.ToCStr(), ws.GetSize(), db0, 
        MAX_DEBUG_STRING_LENGTH);
    GFC_DEBUG_MESSAGE3(1, 
        "[%d, %d] GFxXMLDocumentBuilder::IgnorableWhitespace('%.16s')", 
        pLocator->Line, pLocator->Column, db0);
#endif

    // copy the number of bytes loaded
    LoadedBytes = pLocator->LoadedBytes;

    // Do nothing
}


// 
// Skipped entity reported by XML parser
//
void GFxXMLDOMBuilder::SkippedEntity(const GFxXMLStringRef& name)
{
    GUNUSED(name);
#ifdef GFC_XML_DOCBUILDER_TRACE
    GFC_DEBUG_ASSERT(pLocator, "Locator not set!");
    char db0[MAX_DEBUG_STRING_LENGTH];
    SafeStringCopyWithSentinel(name.ToCStr(), name.GetSize(), 
        db0, MAX_DEBUG_STRING_LENGTH);
    GFC_DEBUG_MESSAGE3(1, 
        "[%d, %d] GFxXMLDocumentBuilder::SkippedEntity('%.16s')", 
        pLocator->Line, pLocator->Column, db0);
#endif

    // Copy the number of bytes loaded
    LoadedBytes = pLocator->LoadedBytes;

    // Do nothing
}


// 
// Document locater registration
//
void GFxXMLDOMBuilder::SetDocumentLocator(const GFxXMLParserLocator* plocator)
{
#ifdef GFC_XML_DOCBUILDER_TRACE
    GFC_DEBUG_MESSAGE(1, "GFxXMLDocumentBuilder::SetDocumentLocator");
#endif

    pLocator = plocator;
}


// 
// Comment found by XML parser
//
void GFxXMLDOMBuilder::Comment(const GFxXMLStringRef& text)
{
    GUNUSED(text);
#ifdef GFC_XML_DOCBUILDER_TRACE
    GFC_DEBUG_ASSERT(pLocator, "Locator not set!");
    char db0[MAX_DEBUG_STRING_LENGTH];
    SafeStringCopyWithSentinel(text.ToCStr(), text.GetSize(), db0, 
        MAX_DEBUG_STRING_LENGTH);
    GFC_DEBUG_MESSAGE3(1, "[%d, %d] GFxXMLDocumentBuilder::Comment('%.16s')", 
        pLocator->Line, pLocator->Column, db0);
#endif

    // Copy the number of bytes loaded
    LoadedBytes = pLocator->LoadedBytes;

    // Do nothing
}


// 
// Error reported by XML parser
//
void GFxXMLDOMBuilder::Error(const GFxXMLParserException& exception)
{
    GUNUSED(exception);
#ifdef GFC_XML_DOCBUILDER_TRACE
    GFC_DEBUG_ASSERT(pLocator, "Locator not set!");
    char db0[MAX_DEBUG_STRING_LENGTH];
    SafeStringCopyWithSentinel(exception.ErrorMessage.ToCStr(), 
        exception.ErrorMessage.GetSize(), db0, MAX_DEBUG_STRING_LENGTH);
    GFC_DEBUG_MESSAGE3(1, "[%d, %d] GFxXMLDocumentBuilder::Error('%.64s')",
        pLocator->Line, pLocator->Column, db0);
#endif

    // Copy the number of bytes loaded
    LoadedBytes = pLocator->LoadedBytes;

    GFC_DEBUG_ERROR3(1, "Document builder @ line:%d col:%d - %.64s\n",
        pLocator->Line,
        pLocator->Column,
        exception.ErrorMessage.ToCStr());

    bError = true;
}


// 
// Fatal error reported by XML parser
//
void GFxXMLDOMBuilder::FatalError(const GFxXMLParserException& exception)
{
    GUNUSED(exception);
#ifdef GFC_XML_DOCBUILDER_TRACE
    GFC_DEBUG_ASSERT(pLocator, "Locator not set!");
    char db0[MAX_DEBUG_STRING_LENGTH];
    SafeStringCopyWithSentinel(exception.ErrorMessage.ToCStr(), 
        exception.ErrorMessage.GetSize(), db0, MAX_DEBUG_STRING_LENGTH);
    GFC_DEBUG_MESSAGE3(1, "[%d, %d] GFxXMLDocumentBuilder::FatalError('%.64s')",
        pLocator->Line, pLocator->Column, db0);
#endif

    // Copy the number of bytes loaded
    LoadedBytes = pLocator->LoadedBytes;

    GFC_DEBUG_ERROR3(1, "Document builder @ line:%d col:%d - %.64s\n",
        pLocator->Line,
        pLocator->Column,
        exception.ErrorMessage.ToCStr());

    bError = true;
}


// 
// Warning reported by XML parser
//
void GFxXMLDOMBuilder::Warning(const GFxXMLParserException& exception)
{
    GUNUSED(exception);
#ifdef GFC_XML_DOCBUILDER_TRACE
    GFC_DEBUG_ASSERT(pLocator, "Locator not set!");
    char db0[MAX_DEBUG_STRING_LENGTH];
    SafeStringCopyWithSentinel(exception.ErrorMessage.ToCStr(), 
        exception.ErrorMessage.GetSize(), db0, MAX_DEBUG_STRING_LENGTH);
    GFC_DEBUG_MESSAGE3(1, "[%d, %d] GFxXMLDocumentBuilder::Warning('%.64s')",
        pLocator->Line, pLocator->Column, db0);
#endif

    // Copy the number of bytes loaded
    LoadedBytes = pLocator->LoadedBytes;

    GFC_DEBUG_WARNING3(1, "Document builder @ line:%d col:%d - %.64s\n",
        pLocator->Line,
        pLocator->Column,
        exception.ErrorMessage.ToCStr());
}


//
// Return true if the text node only contains whitespace
//
bool CheckWhiteSpaceNode(GFxXMLTextNode* textNode)
{
    const char* buffer = textNode->Value.GetBuffer();
    bool allws = true;
    UInt32 utf8char;
    while ( (utf8char = GUTF8Util::DecodeNextChar(&buffer)) != 0 )
    {
        if (!G_iswspace((wchar_t)utf8char))
        {
            allws = false;
            break;
        }
    }
    return allws;
}

//
// Helper function for DOM traversal
//
void DropWhiteSpaceNodesHelper(GFxXMLElementNode* elemNode) 
{
    GFxXMLNode* child = elemNode->FirstChild;
    GFxXMLNode* temp = child;
    while (child != NULL)
    {
        temp = child->NextSibling;
        if (child->Type == GFxXMLElementNodeType)
            DropWhiteSpaceNodesHelper((GFxXMLElementNode*)child);
        else if (child->Type == GFxXMLTextNodeType)
        {
            if (CheckWhiteSpaceNode((GFxXMLTextNode*)child))
            {
                // Remove it
                elemNode->RemoveChild(child);
            }
        }
        child = temp;
    }
}


// 
// Drop all text nodes containing only whitespace from the DOM tree.
// This emulates the behavior of not processing unnecessary whitespace 
// in the XML document.
//
void GFxXMLDOMBuilder::DropWhiteSpaceNodes(GFxXMLDocument* document)
{
    for (GFxXMLNode* child = document->FirstChild; child != NULL; 
        child = child->NextSibling)
    {
        if (child->Type == GFxXMLElementNodeType)
            DropWhiteSpaceNodesHelper((GFxXMLElementNode*)child);
    }
}


#endif // #ifndef GFC_NO_XML_SUPPORT