parse.cpp

Go to the documentation of this file.

// See ../../license.txt for license information.
//
// parse.cpp
//
// NOTES
//              XML Parser for the persistence framework.
//
// 30-Jun-2003  phamilton  Created
//

#define PERSIST_IN_LIBRARY_SOURCE

#include "parse.hpp"
#include <iostream>
#include <fstream>
#include "expat-1.95.5/lib/expat.h"
#include "boost/lexical_cast.hpp"
#include "boost/format.hpp"

using namespace ph::persist::xml;

// format strings.
const char XMLFmt_error[] = "file: %s %s at line %d";
const char XMLFmt_expected[] = "expected %s=\"string\"";

// common possible error messages.
const char XMLErr_mismatched_end_tag[] = "mismatched end element tag.";

#define PROGRESS_UNIT   512
#define BUFFER_SIZE     1024

bool parse::parse_xml(std::istream *stream, const std::string &streampath, parse *parser, parse_progress *progress)
{

        if (progress)
        {
                stream->seekg(0, std::ios_base::end);
                long len = stream->tellg();
                long count = len / PROGRESS_UNIT;
                progress->total(count > 0 ? count : 1);
        }

        if (progress)
                progress->progress(0);

        parser->startparse(streampath);
        int done = 0;
        long total = 0;
        bool parseresult = true;
        while (!done)
        {
                char buf[BUFFER_SIZE];
                stream->read(buf, sizeof(buf));
                long len = stream->gcount();
                done = len < (long)sizeof(buf);
                int error = parser->doparse(buf, len, done);
                if (error != PARSE_SUCCESS)
                {
                        parseresult =  false;
                        done = 1;
                }
                total += len;
                if (progress)
                {
                        long p = total / PROGRESS_UNIT;
                        progress->progress(p);
                }
        }
        parser->endparse();

        return parseresult;
}

void parse::startparse(const std::string &streamname)
/*
        Called at the start of a parse. Set's to the expat
        data structures.
*/
{
        assert(_parser == NULL);
        _parser = XML_ParserCreate(NULL);
        _filename = streamname; // for error messages.
        _error = PARSE_SUCCESS;
        
        XML_SetUserData(_parser, this);
        XML_SetElementHandler(_parser, sstartelement_handler, sendelement_handler);
        XML_SetCharacterDataHandler(_parser, scdata_handler);
        XML_SetCommentHandler(_parser, scomment_handler);
        XML_SetDefaultHandler(_parser, sdefault_handler);
}

int parse::doparse(char *buf, long len, int done)
/*
        Called in the middle of a parse. Feed more XML into the
        parser.
*/
{
        try
        {
                if (XML_Parse(_parser, buf, len, done))
                        return PARSE_SUCCESS;
        }
        catch (...)
        {
                // the only thrown exception is to end the parse.
                _error = PARSE_BADXMLTYPE;
                return _error;
        }

        // for some reason, the string returned is not actually UNICODE! So we convert it to unicode here.
/* TBD
        CWStr m;
        m.Convert(string);

        XMLError(m.c_str());
*/
        return _error;
}

void parse::endparse()
/*
        Called at the end of a parse, or to abort a parse.
*/
{
        finish_handler();
        XML_ParserFree(_parser);
        _parser = NULL;
}

int parse::parsestream(std::istream *stream, const std::string &streamname)
/*
        Wrapper function to parse a file of XML.
*/
{
        startparse(streamname);

        int done = 0;
        while (!done)
        {
                char buf[BUFFER_SIZE];
                stream->read(buf, sizeof(buf));
                long len = stream->gcount();
                done = len < (long)sizeof(buf);
                int error = doparse(buf, len, done);
                if (error != PARSE_SUCCESS)
                        return _error;
        }
        endparse();

        return _error;
}

int parse::doparsefile(const std::string &filename)
/*
        Parse a file given a filename of a file on disk.
*/
{
        int result = PARSE_NOFILE;
        std::ifstream f(filename.c_str());
        if (f.is_open())
        {
                result = parsestream(&f, filename);
                f.close();
        }
        return result;
}

void parse::sstartelement_handler(void *userData, const XML_Char *name, const XML_Char **atts)
{
        parse *me = reinterpret_cast<parse *>(userData);
        
        // push this element.
        me->_elementstack.push_back(name);

        xmlstring n(name);
        std::vector<xmlstring> a;
        if (atts)
                for (int i=0; atts[i]; i++)
                        a.push_back(atts[i]);
        me->startelement_handler(n, a);
}

void parse::sendelement_handler(void *userData, const XML_Char *name)
{
        parse *me = reinterpret_cast<parse *>(userData);

        me->endelement_handler(name);

        // pop the element.
        if (me->_elementstack.back() == name)
                me->_elementstack.pop_back();
        else
                me->error(XMLErr_mismatched_end_tag);
}

void parse::scdata_handler(void *userData, const XML_Char *s, int len)
{
        parse *me = reinterpret_cast<parse *>(userData);

        // use the length in conversion.
        xmlstring ws(s, len);

        me->cdata_handler(ws, len);
}

void parse::scomment_handler(void *userData, const XML_Char *data)
{
        parse *me = reinterpret_cast<parse *>(userData);

        // use the length in conversion.
        xmlstring ws(data);

        me->comment_handler(data);
}

void parse::sdefault_handler(void *userData,  const XML_Char *s,  int len)
{
        parse *me = reinterpret_cast<parse *>(userData);

        // use the length in conversion.
        xmlstring ws(s, len);

        me->default_handler(ws, len);
}

xmlstring parse::attr(const std::vector<xmlstring> &attrs, int index)
{
        if ((int)attrs.size() > (index * 2))
                return attrs[index * 2];
        return S("");
}

xmlstring parse::attrval(const std::vector<xmlstring> &attrs, int index)
{
        if ((int)attrs.size() > ((index * 2) + 1))
                return attrs[(index * 2) + 1];
        return S("");
}

xmlstring parse::attr(const std::vector<xmlstring> &attrs, const xmlstring &token)
{
        // these are processed in pairs. So a simple for() is best here.
        for (int i=0; i < (int)attrs.size(); i++)
        {
                if (token == attrs[i])
                        return attrs[i+1];
                i++;
        }
                
        return S("");
}

xmlstring parse::expectedattr(const std::vector<xmlstring> &attrs, const xmlstring &token)
{
        xmlstring a = attr(attrs, token);
        if (!a.empty())
                return a;

        expected_error(token);
        return S("");
}

void parse::expected_error(const xmlstring &token)
{
        error(boost::io::str(boost::format(XMLFmt_expected) % boost::lexical_cast<std::string>(token)));
}

void parse::error(const std::string &s, bool detail)
/*
        Default error does a message box.
*/
{
        if (!_silent)
        {
                if (_errorhandler)
                {
                        if (detail)
                        {
                                // on debian, the direct version of this that uses a stream doesn't seem to work, so just cast to a string
                                // for now.
                                *_errorhandler << boost::io::str(boost::format(XMLFmt_error) % _filename % s % XML_GetCurrentLineNumber(_parser)) << std::endl;
                        }
                        else
                                *_errorhandler << s << std::endl;
                }
        }

        _error = PARSE_XMLERROR;
}

void parse::error(const std::string &format, const std::string &s1, bool detail)
{
        error(boost::io::str(boost::format(format) % s1), detail);
}

void parse::error(const std::string &format, const std::string &s1, const std::string &s2, bool detail)
{
        error(boost::io::str(boost::format(format) % s1 % s2), detail);
}

// we escape all data with 2 sets of this char...
const char kEscapeChar = '\\';

// and here are the things that we escape.
static struct { char c; const char *s; } gXMLEncodingTable[] = 
{
        { '<', S("lt") },
        { '>', S("gt") },
        { '&', S("amp") },
        { 0, 0 }
};

// some helper strings. The short header is used as a way of telling whether a particular
// string contains XML or not.
const xmlstring kXMLShortHeader = S("<?xml version=\"1.0\"");
const xmlstring kXMLLongHeader = S("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");

bool parse::encodexmldata(const xmlstring &s, xmlstring *news)
{
        *news = S("");
        for (xmlstring::const_iterator i = s.begin(); i != s.end(); i++)
        {
                if (*i == kEscapeChar)
                {
                        *news += kEscapeChar;
                        *news += kEscapeChar;

                }
                else
                {
                        int j=0;
                        while (gXMLEncodingTable[j].c && gXMLEncodingTable[j].c != *i)
                                j++;
                        if (gXMLEncodingTable[j].c)
                        {
                                *news += kEscapeChar;
                                *news += gXMLEncodingTable[j].s;
                                *news += kEscapeChar;
                        }
                        else
                                *news += *i;
                }
        }

        return s.length() != news->length();
}

bool parse::decodexmldata(const xmlstring &s, xmlstring *news)
{
        // if the string is actually a chunk of XML, then we don't decode (we are already
        // decoded).
        if (s.substr(0, kXMLShortHeader.length()) == kXMLShortHeader)
                return false;

        bool escape = false;
        xmlstring escdata;
        *news = S("");
        for (xmlstring::const_iterator i = s.begin(); i != s.end(); i++)
        {
                if (escape)
                {
                        if (*i == kEscapeChar)
                        {
                                if (escdata == S(""))
                                        *news += kEscapeChar;
                                else
                                {
                                        // finished escaping.
                                        int j=0;
                                        while (gXMLEncodingTable[j].c && gXMLEncodingTable[j].s != escdata)
                                                j++;
                                        if (gXMLEncodingTable[j].c)
                                                *news += gXMLEncodingTable[j].c;
                                        else
                                                *news += escdata;
                                }
                                escape = false;
                        }
                        else
                                escdata += *i;
                }
                else if (*i == kEscapeChar)
                {
                        escdata = S("");
                        escape = true;
                }
                else
                        *news += *i;
        }

        if (escape)
                *news += escdata;

        return s.length() != news->length();
}

---