XMLParser.cpp

Go to the documentation of this file.

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

 
#if !defined(__WINNT__) && defined(XML_UNICODE_WCHAR_T)
    #error "You must not define XML_UNICODE_WCHAR_T for UNIX Operating System"
#endif
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/XmlParser.cpp");
#endif
 
__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* _parentNode, const String& _chars)
    : XmlNode(_parentNode)
{
    __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* _parentNode,
const String& _name, const StringStringArray& _attrs
) : XmlNode(_parentNode)
{
    __name = _name;
    __attrs = _attrs;
}
 
XmlElement::~XmlElement()
{
    for (PointerArray::Iterator it = __children.begin();
        it != __children.end(); it++) {
        delete ((XmlNode*)(*it));
    }
}
 
void XmlElement::addChildNode(XmlNode* _node)
{
    __children.add(_node);
}
 
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 (__topElement)
        s = __topElement->toString();
    return s; 
}
 
XmlDocument::XmlDocument()
{
    __currentElement = NULL;
    __topElement = NULL;
}
 
XmlDocument::~XmlDocument()
{
    if (__topElement) {
        delete __topElement;
#ifdef __DCL_DEBUG
        __topElement = NULL;
#endif
    }
}
 
void XmlDocument::startElement(const String& _name, const StringStringArray& _attrs)
{
    XmlElement* pElement = new XmlElement(__currentElement, _name, _attrs);
    if (!__topElement)
        __topElement = pElement;
    else
        __currentElement->addChildNode(pElement);
 
    __currentElement = pElement;
}
 
void XmlDocument::endElement(const String& _name)
{
    __DCL_ASSERT(__currentElement != NULL && __currentElement->name() == _name);
 
    XmlNode* pParentNode = __currentElement->parentNode();
#ifdef __DCL_DEBUG
    if (__currentElement != __topElement) {
        __DCL_ASSERT(pParentNode != NULL
            && pParentNode->isInstanceOf(CLASSINFO(XmlElement)));
    }
#endif
    __currentElement = (XmlElement*) pParentNode;
}
 
void XmlDocument::characters(const String& _chars)
{
    XmlCharsNode* charsNode = new XmlCharsNode(__currentElement, _chars);
    __currentElement->addChildNode(charsNode);
}
 
__DCL_END_NAMESPACE