XMLParser.cpp

Go to the documentation of this file.

#include <dcl/XMLParser.h>
#include <dcl/Charset.h>

 
#if !__DCL_WINDOWS && defined(XML_UNICODE_WCHAR_T)
    #error "You must not define XML_UNICODE_WCHAR_T for UNIX Operating System"
#endif
 
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/XmlParser.cpp");
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(XmlException, Exception)
 
XmlException::XmlException(XML_Parser _parser)
{
    const XML_LChar* psz = XML_ErrorString(XML_GetErrorCode(_parser));
    const wchar_t* wpsz = NULL;
#ifdef XML_UNICODE_WCHAR_T
    wpsz = psz;
#else
    UTF8Decoder decoder;
    String str = decoder.decode(psz);
    wpsz = str.data();
#endif
    __message = String::format(
        __T("%ls at line %d"),
        wpsz,
        XML_GetCurrentLineNumber(_parser)
        );
}
 
String XmlException::toString() const
{
    return __message;
}
 
IMPLEMENT_CLASSINFO(XmlDefaultHandler, Object)
 
void XmlDefaultHandler::startElement(
        void* _userData, const XML_Char* _name, const XML_Char** _attrs)
{
#ifdef XML_UNICODE_WCHAR_T
    String name = _name;
    StringStringArray attrs;
    while (*_attrs) {
        String key = *_attrs++;
        String value = *_attrs++;
        attrs.add(StringString(key, value));
    }
#else
    UTF8Decoder decoder;
    String name = decoder.decode(_name);
    StringStringArray attrs;
    while (*_attrs) {
        String key = decoder.decode(*_attrs++);
        String value = decoder.decode(*_attrs++);
        attrs.add(StringString(key, value));
    }
#endif
    XmlDefaultHandler* pHandler = (XmlDefaultHandler*) _userData;
    pHandler->startElement(name, attrs);
}
 
void XmlDefaultHandler::endElement(
        void* _userData, const XML_Char* _name)
{
#ifdef XML_UNICODE_WCHAR_T
    String name = _name;
#else
    UTF8Decoder decoder;
    String name = decoder.decode(_name);
#endif
    XmlDefaultHandler* pHandler = (XmlDefaultHandler*) _userData;
    pHandler->endElement(name);
}
 
void XmlDefaultHandler::characters(
        void* _userData, const XML_Char* _chars, int _len)
{
#ifdef XML_UNICODE_WCHAR_T
    String chars(_chars, _len);
#else
    UTF8Decoder decoder;
    String chars = decoder.decode(_chars, _len);
#endif
    // startElement, endElement 사이에서 LF를 구별하여
    XmlDefaultHandler* pHandler = (XmlDefaultHandler*) _userData;
    pHandler->characters(chars);
}
 
void XmlDefaultHandler::startElement(
        const String& _name, const StringStringArray& _attrs)
{
    __DCL_TRACE2(__T("startElement[%ls], attrs[%ls]\n"), _name.data(), _attrs.toString().data());
}
 
void XmlDefaultHandler::endElement(
        const String& _name)
{
    __DCL_TRACE1(__T("endElement[%ls]\n"), _name.data());
}
 
void XmlDefaultHandler::characters(
        const String& _chars)
{
    __DCL_TRACE1(__T("characters[%ls]\n"), _chars.data());
}
 
IMPLEMENT_CLASSINFO(XmlParser, Object)
 
XmlParser::XmlParser()
{
    __parser = XML_ParserCreate(NULL);
}
 
XmlParser::~XmlParser()
{
    XML_ParserFree(__parser);
}
 
void XmlParser::parse(
        const ByteString& _data, XmlDefaultHandler& _handler)
        __DCL_THROWS1(XmlException*)
{
    XML_SetElementHandler(
        __parser,
        XmlDefaultHandler::startElement,
        XmlDefaultHandler::endElement
        );
        XML_SetCharacterDataHandler(
            __parser,
            XmlDefaultHandler::characters
        );
 
        XML_SetUserData(__parser, &_handler);
 
        XML_Status status = XML_Parse(
            __parser,
            _data,
            (int)_data.length(),
            1   // done
        );
 
        if (status == XML_STATUS_ERROR)
            throw new XmlException(__parser);
 
}
 
/*
    References
        http://www.w3.org/DOM/DOMTR#dom2
*/
 
IMPLEMENT_CLASSINFO(XmlNode, Object)
 
IMPLEMENT_CLASSINFO(XmlCharsNode, XmlNode)
 
String XmlCharsNode::toString() const
{
    return __chars;
}
 
XmlCharsNode::XmlCharsNode(XmlNode* _pParentNode, const String& _chars)
    : XmlNode(_pParentNode)
{
    __chars = _chars;
}
 
IMPLEMENT_CLASSINFO(XmlElement, XmlNode)
 
String XmlElement::toString() const
{
    StringBuilder r;
 
    r.append(__T("<")).append(__name);
 
    for (StringStringArray::ConstIterator it = __attrs.begin();
        it != __attrs.end(); it++) {
        r.append(__T(" ")).append((*it).key).append(__T("=\""))
            .append(String::escape((*it).value, (*it).value.length(), String::ESCAPE_XML))
            .append(__T("\""));
    }
 
    if (__children.isEmpty()) {
        r.append(__T(" >"));
    }
    else {
        r.append(__T(">"))
            .append(innerXml())
            .append(__T("</")).append(__name).append(__T(">"));
    }
 
    return r;
}
 
 
XmlElement::XmlElement(XmlNode* _pParentNode,
    const String& _name, const StringStringArray& _attrs)
    : XmlNode(_pParentNode)
{
    __name = _name;
    __attrs = _attrs;
}
 
XmlElement::~XmlElement()
{
    for (PointerArray::Iterator it = __children.begin();
        it != __children.end(); it++) {
        delete ((XmlNode*)(*it));
    }
}
 
void XmlElement::addChildNode(XmlNode* pNode)
{
    __children.add(pNode);
}
 
const String XmlElement::innerText() const
{
    StringBuilder r;
 
    for (PointerArray::ConstIterator it = __children.begin();
            it != __children.end(); it++) {
        XmlNode* p = (XmlNode*)(*it);
        if (p->isInstanceOf(CLASSINFO(XmlElement))) {
            r.append(((XmlElement*) p)->innerText());
        }
        else {
            r.append(p->toString());
        }
    }
 
    return r;
}
 
const String XmlElement::innerXml() const
{
    StringBuilder r;
 
    for (PointerArray::ConstIterator it = __children.begin();
            it != __children.end(); it++) {
        XmlNode* p = (XmlNode*)(*it);
        if (p->isInstanceOf(CLASSINFO(XmlCharsNode))) {
            String s = p->toString();
            r.append(String::escape(s, s.length(), String::ESCAPE_XML));
        }
        else {
            r.append(((XmlNode*)(*it))->toString());
        }
    }
    return r;
}
 
IMPLEMENT_CLASSINFO(XmlDocument, XmlDefaultHandler)
 
String XmlDocument::toString() const
{
    String s;
    if (__pTopElement)
        s = __pTopElement->toString();
    return s; 
}
 
 
XmlDocument::XmlDocument()
{
    __pCurrentElement = NULL;
    __pTopElement = NULL;
}
 
XmlDocument::~XmlDocument()
{
    if (__pTopElement) {
        delete __pTopElement;
#if __DCL_DEBUG
        __pTopElement = NULL;
#endif
    }
}
 
void XmlDocument::startElement(const String& _name, const StringStringArray& _attrs)
{
    XmlElement* pElement = new XmlElement(__pCurrentElement, _name, _attrs);
    if (!__pTopElement)
        __pTopElement = pElement;
    else
        __pCurrentElement->addChildNode(pElement);
 
    __pCurrentElement = pElement;
}
 
void XmlDocument::endElement(const String& _name)
{
    __DCL_ASSERT(__pCurrentElement != NULL && __pCurrentElement->name() == _name);
 
    XmlNode* pParentNode = __pCurrentElement->parentNode();
#if __DCL_DEBUG
    if (__pCurrentElement != __pTopElement) {
        __DCL_ASSERT(pParentNode != NULL
            && pParentNode->isInstanceOf(CLASSINFO(XmlElement)));
    }
#endif
    __pCurrentElement = (XmlElement*) pParentNode;
}
 
void XmlDocument::characters(const String& _chars)
{
    XmlCharsNode* pCharsNode = new XmlCharsNode(__pCurrentElement, _chars);
    __pCurrentElement->addChildNode(pCharsNode);
}
 
__DCL_END_NAMESPACE