sax_parser.hpp

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#ifndef INCLUDED_ORCUS_SAX_PARSER_HPP
#define INCLUDED_ORCUS_SAX_PARSER_HPP
 
#include "sax_parser_base.hpp"
 
#include <string_view>
#include <cstdint>
 
namespace orcus {
 
struct sax_parser_default_config
{
    static constexpr uint8_t baseline_version = 10;
};
 
class sax_handler
{
public:
    void doctype(const orcus::sax::doctype_declaration& dtd)
    {
        (void)dtd;
    }

    void start_declaration(std::string_view decl)
    {
        (void)decl;
    }

    void end_declaration(std::string_view decl)
    {
        (void)decl;
    }

    void start_element(const orcus::sax::parser_element& elem)
    {
        (void)elem;
    }

    void end_element(const orcus::sax::parser_element& elem)
    {
        (void)elem;
    }

    void characters(std::string_view val, bool transient)
    {
        (void)val; (void)transient;
    }

    void attribute(const orcus::sax::parser_attribute& attr)
    {
        (void)attr;
    }
};

template<typename HandlerT, typename ConfigT = sax_parser_default_config>
class sax_parser : public sax::parser_base
{
public:
    typedef HandlerT handler_type;
    typedef ConfigT config_type;
 
    sax_parser(std::string_view content, handler_type& handler);
    ~sax_parser() = default;
 
    void parse();
 
private:

    void header();
    void body();
    void element();
    void element_open(std::ptrdiff_t begin_pos);
    void element_close(std::ptrdiff_t begin_pos);
    void special_tag();
    void declaration(const char* name_check);
    void cdata();
    void doctype();
    void characters();
    void attribute();
 
private:
    handler_type& m_handler;
};
 
template<typename HandlerT, typename ConfigT>
sax_parser<HandlerT,ConfigT>::sax_parser(std::string_view content, handler_type& handler) :
    sax::parser_base(content.data(), content.size()),
    m_handler(handler)
{
}
 
template<typename HandlerT, typename ConfigT>
void sax_parser<HandlerT,ConfigT>::parse()
{
    m_nest_level = 0;
    mp_char = mp_begin;
    header();
    skip_space_and_control();
    body();
 
    assert(m_buffer_pos == 0);
}
 
template<typename HandlerT, typename ConfigT>
void sax_parser<HandlerT,ConfigT>::header()
{
    // we don't handle multi byte encodings so we can just skip bom entry if exists.
    skip_bom();
 
    // Allow leading whitespace in the XML stream.
    // TODO : Make this configurable since strictly speaking such an XML
    // sttream is invalid.
    skip_space_and_control();
 
    if (!has_char() || cur_char() != '<')
        throw malformed_xml_error("xml file must begin with '<'.", offset());
 
    if (config_type::baseline_version >= 11)
    {
        // XML version 1.1 requires a header declaration whereas in 1.0 it's
        // optional.
        if (next_char_checked() != '?')
            throw malformed_xml_error("xml file must begin with '<?'.", offset());
 
        declaration("xml");
    }
}
 
template<typename HandlerT, typename ConfigT>
void sax_parser<HandlerT,ConfigT>::body()
{
    while (has_char())
    {
        if (cur_char() == '<')
        {
            element();
            if (!m_root_elem_open)
                // Root element closed.  Stop parsing.
                return;
        }
        else if (m_nest_level)
            // Call characters only when in xml hierarchy.
            characters();
        else
            next();
    }
}
 
template<typename HandlerT, typename ConfigT>
void sax_parser<HandlerT,ConfigT>::element()
{
    assert(cur_char() == '<');
    std::ptrdiff_t pos = offset();
    char c = next_char_checked();
    switch (c)
    {
        case '/':
            element_close(pos);
            return;
        case '!':
            special_tag();
            return;
        case '?':
            declaration(nullptr);
            return;
    }
 
    element_open(pos);
}
 
template<typename HandlerT, typename ConfigT>
void sax_parser<HandlerT,ConfigT>::element_open(std::ptrdiff_t begin_pos)
{
    sax::parser_element elem;
    element_name(elem, begin_pos);
 
    while (true)
    {
        skip_space_and_control();
        char c = cur_char_checked();
        if (c == '/')
        {
            // Self-closing element: <element/>
            if (next_and_char() != '>')
                throw malformed_xml_error("expected '/>' to self-close the element.", offset());
            next();
            elem.end_pos = offset();
            m_handler.start_element(elem);
            reset_buffer_pos();
            m_handler.end_element(elem);
            if (!m_nest_level)
                m_root_elem_open = false;
#if ORCUS_DEBUG_SAX_PARSER
            cout << "element_open: ns='" << elem.ns << "', name='" << elem.name << "' (self-closing)" << endl;
#endif
            return;
        }
        else if (c == '>')
        {
            // End of opening element: <element>
            next();
            elem.end_pos = offset();
            nest_up();
            m_handler.start_element(elem);
            reset_buffer_pos();
#if ORCUS_DEBUG_SAX_PARSER
            cout << "element_open: ns='" << elem.ns << "', name='" << elem.name << "'" << endl;
#endif
            return;
        }
        else
            attribute();
    }
}
 
template<typename HandlerT, typename ConfigT>
void sax_parser<HandlerT,ConfigT>::element_close(std::ptrdiff_t begin_pos)
{
    assert(cur_char() == '/');
    nest_down();
    next_check();
    sax::parser_element elem;
    element_name(elem, begin_pos);
 
    if (cur_char() != '>')
        throw malformed_xml_error("expected '>' to close the element.", offset());
    next();
    elem.end_pos = offset();
 
    m_handler.end_element(elem);
#if ORCUS_DEBUG_SAX_PARSER
    cout << "element_close: ns='" << elem.ns << "', name='" << elem.name << "'" << endl;
#endif
    if (!m_nest_level)
        m_root_elem_open = false;
}
 
template<typename HandlerT, typename ConfigT>
void sax_parser<HandlerT,ConfigT>::special_tag()
{
    assert(cur_char() == '!');
    // This can be either <![CDATA, <!--, or <!DOCTYPE.
    size_t len = available_size();
    if (len < 2)
        throw malformed_xml_error("special tag too short.", offset());
 
    switch (next_and_char())
    {
        case '-':
        {
            // Possibly comment.
            if (next_and_char() != '-')
                throw malformed_xml_error("comment expected.", offset());
 
            len -= 2;
            if (len < 3)
                throw malformed_xml_error("malformed comment.", offset());
 
            next();
            comment();
        }
        break;
        case '[':
        {
            // Possibly a CDATA.
            expects_next("CDATA[", 6);
            if (has_char())
                cdata();
        }
        break;
        case 'D':
        {
            // check if this is a DOCTYPE.
            expects_next("OCTYPE", 6);
            skip_space_and_control();
            if (has_char())
                doctype();
        }
        break;
        default:
            throw malformed_xml_error("failed to parse special tag.", offset());
    }
}
 
template<typename HandlerT, typename ConfigT>
void sax_parser<HandlerT,ConfigT>::declaration(const char* name_check)
{
    assert(cur_char() == '?');
    next_check();
 
    // Get the declaration name first.
    std::string_view decl_name;
    name(decl_name);
#if ORCUS_DEBUG_SAX_PARSER
    cout << "sax_parser::declaration: start name='" << decl_name << "'" << endl;
#endif
 
    if (name_check && decl_name != name_check)
    {
        std::ostringstream os;
        os << "declaration name of '" << name_check << "' was expected, but '" << decl_name << "' was found instead.";
        throw malformed_xml_error(os.str(), offset());
    }
 
    m_handler.start_declaration(decl_name);
    skip_space_and_control();
 
    // Parse the attributes.
    while (cur_char_checked() != '?')
    {
        attribute();
        skip_space_and_control();
    }
    if (next_char_checked() != '>')
        throw malformed_xml_error("declaration must end with '?>'.", offset());
 
    m_handler.end_declaration(decl_name);
    reset_buffer_pos();
    next();
#if ORCUS_DEBUG_SAX_PARSER
    cout << "sax_parser::declaration: end name='" << decl_name << "'" << endl;
#endif
}
 
template<typename HandlerT, typename ConfigT>
void sax_parser<HandlerT,ConfigT>::cdata()
{
    size_t len = available_size();
    assert(len > 3);
 
    // Parse until we reach ']]>'.
    const char* p0 = mp_char;
    size_t i = 0, match = 0;
    for (char c = cur_char(); i < len; ++i, c = next_and_char())
    {
        if (c == ']')
        {
            // Be aware that we may encounter a series of more than two ']'
            // characters, in which case we'll only count the last two.
 
            if (match == 0)
                // First ']'
                ++match;
            else if (match == 1)
                // Second ']'
                ++match;
        }
        else if (c == '>' && match == 2)
        {
            // Found ']]>'.
            size_t cdata_len = i - 2;
            m_handler.characters(std::string_view(p0, cdata_len), false);
            next();
            return;
        }
        else
            match = 0;
    }
    throw malformed_xml_error("malformed CDATA section.", offset());
}
 
template<typename HandlerT, typename ConfigT>
void sax_parser<HandlerT,ConfigT>::doctype()
{
    // Parse the root element first.
    sax::doctype_declaration param;
    name(param.root_element);
    skip_space_and_control();
 
    // Either PUBLIC or SYSTEM.
    size_t len = available_size();
    if (len < 6)
        throw malformed_xml_error("DOCTYPE section too short.", offset());
 
    param.keyword = sax::doctype_declaration::keyword_type::dtd_private;
    char c = cur_char();
    if (c == 'P')
    {
        if (next_and_char() != 'U' || next_and_char() != 'B' || next_and_char() != 'L' || next_and_char() != 'I' || next_and_char() != 'C')
            throw malformed_xml_error("malformed DOCTYPE section.", offset());
 
        param.keyword = sax::doctype_declaration::keyword_type::dtd_public;
    }
    else if (c == 'S')
    {
        if (next_and_char() != 'Y' || next_and_char() != 'S' || next_and_char() != 'T' || next_and_char() != 'E' || next_and_char() != 'M')
            throw malformed_xml_error("malformed DOCTYPE section.", offset());
    }
 
    next_check();
    skip_space_and_control();
 
    // Parse FPI.
    value(param.fpi, false);
 
    has_char_throw("DOCTYPE section too short.");
    skip_space_and_control();
    has_char_throw("DOCTYPE section too short.");
 
    if (cur_char() == '>')
    {
        // Optional URI not given. Exit.
#if ORCUS_DEBUG_SAX_PARSER
        cout << "sax_parser::doctype: root='" << param.root_element << "', fpi='" << param.fpi << "'" << endl;
#endif
        m_handler.doctype(param);
        next();
        return;
    }
 
    // Parse optional URI.
    value(param.uri, false);
 
    has_char_throw("DOCTYPE section too short.");
    skip_space_and_control();
    has_char_throw("DOCTYPE section too short.");
 
    if (cur_char() != '>')
        throw malformed_xml_error("malformed DOCTYPE section - closing '>' expected but not found.", offset());
 
#if ORCUS_DEBUG_SAX_PARSER
    cout << "sax_parser::doctype: root='" << param.root_element << "', fpi='" << param.fpi << "' uri='" << param.uri << "'" << endl;
#endif
    m_handler.doctype(param);
    next();
}
 
template<typename HandlerT, typename ConfigT>
void sax_parser<HandlerT,ConfigT>::characters()
{
    const char* p0 = mp_char;
    for (; has_char(); next())
    {
        if (cur_char() == '<')
            break;
 
        if (cur_char() == '&')
        {
            // Text span with one or more encoded characters. Parse using cell buffer.
            cell_buffer& buf = get_cell_buffer();
            buf.reset();
            buf.append(p0, mp_char-p0);
            characters_with_encoded_char(buf);
            if (buf.empty())
                m_handler.characters(std::string_view{}, false);
            else
                m_handler.characters(buf.str(), true);
            return;
        }
    }
 
    if (mp_char > p0)
    {
        std::string_view val(p0, mp_char-p0);
        m_handler.characters(val, false);
    }
}
 
template<typename HandlerT, typename ConfigT>
void sax_parser<HandlerT,ConfigT>::attribute()
{
    sax::parser_attribute attr;
    attribute_name(attr.ns, attr.name);
 
#if ORCUS_DEBUG_SAX_PARSER
    cout << "sax_parser::attribute: ns='" << attr.ns << "', name='" << attr.name << "'" << endl;
#endif
 
    skip_space_and_control();
 
    char c = cur_char_checked();
    if (c != '=')
    {
        std::ostringstream os;
        os << "Attribute must begin with 'name=..'. (ns='" << attr.ns << "', name='" << attr.name << "')";
        throw malformed_xml_error(os.str(), offset());
    }
 
    next_check(); // skip the '='.
    skip_space_and_control();
 
    attr.transient = value(attr.value, true);
    if (attr.transient)
        // Value is stored in a temporary buffer. Push a new buffer.
        inc_buffer_pos();
 
#if ORCUS_DEBUG_SAX_PARSER
    cout << "sax_parser::attribute: value='" << attr.value << "'" << endl;
#endif
 
    m_handler.attribute(attr);
}
 
}
 
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */