xml_parser.hpp

Go to the documentation of this file.

/*
    Copyright 2013 Adobe
    Distributed under the Boost Software License, Version 1.0.
    (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
/**************************************************************************************************/
 
#ifndef ADOBE_XML_PARSER_HPP
#define ADOBE_XML_PARSER_HPP
 
/**************************************************************************************************/
 
#include <adobe/config.hpp>
 
#include <adobe/algorithm/set.hpp>
#include <adobe/any_regular.hpp>
#include <adobe/array.hpp>
#include <adobe/copy_on_write.hpp>
#include <adobe/dictionary.hpp>
#include <adobe/implementation/parser_shared.hpp>
#include <adobe/implementation/xml_lex.hpp>
#include <adobe/implementation/xml_token.hpp>
#include <adobe/istream.hpp>
#include <adobe/name.hpp>
#include <adobe/string.hpp>
 
#include <boost/iterator/iterator_facade.hpp>
#include <boost/noncopyable.hpp>
#include <boost/operators.hpp>
 
#include <cassert>
#include <functional>
#include <utility>
 
/**************************************************************************************************/
 
namespace adobe {
 
/**************************************************************************************************/
 
// NOTE (fbrereto) : Class declaration for the documentation is in xml_parser.dox
struct attribute_set_t : public boost::equality_comparable<attribute_set_t> {
    typedef token_range_t key_type;
    typedef token_range_t mapped_type;
    typedef std::pair<key_type, mapped_type> value_type;
    typedef std::vector<value_type> set_type;
    typedef set_type::size_type size_type;
    typedef set_type::const_iterator const_iterator;
    typedef const_iterator iterator;

    struct less_t {
        bool operator()(const value_type& x, const value_type& y) const {
            return token_range_less(x.first, y.first) ||
                   (!token_range_less(y.first, x.first) && token_range_less(x.second, y.second));
        }
    };

    struct less_key_only_t {
        bool operator()(const value_type& x, const value_type& y) const {
            return token_range_less(x.first, y.first);
        }
    };

    bool lower_bound(const value_type& attribute, set_type::iterator& result) {
        result = adobe::lower_bound(set_m.write(), attribute, less_key_only_t());
 
        return result != set_m.write().end() && token_range_equal(result->first, attribute.first);
    }

    bool lower_bound(const key_type& key, set_type::iterator& result) {
        return lower_bound(value_type(key, mapped_type()), result);
    }

    bool lower_bound(const value_type& attribute, set_type::const_iterator& result) const {
        result = adobe::lower_bound(*set_m, attribute, less_key_only_t());
 
        return result != set_m->end() && token_range_equal(result->first, attribute.first);
    }

    bool lower_bound(const key_type& key, set_type::const_iterator& result) const {
        return lower_bound(value_type(key, mapped_type()), result);
    }

    mapped_type operator[](const key_type& key) const {
        set_type::const_iterator result;
 
        if (lower_bound(key, result))
            return result->second;
 
        return mapped_type();
    }

    attribute_set_t merge(const attribute_set_t& other_set) const {
 
        attribute_set_t merged;
 
        adobe::set_union(*set_m, *other_set.set_m, std::back_inserter(merged.set_m.write()),
                         less_key_only_t());
 
        return merged;
    }

    void insert(const value_type& attribute) {
        set_type::iterator result;
 
        if (lower_bound(attribute, result))
            result->second = attribute.second;
        else
            set_m.write().insert(result, attribute);
    }

    template <typename I> // I models InputIterator
    inline void insert(I first, I last) {
        for (; first != last; ++first)
            insert(*first);
    }

    inline void insert(const key_type& key, const mapped_type& value) {
        insert(value_type(key, value));
    }

    std::size_t count_same(const attribute_set_t& other_set, bool mapped_matters = true) const;

    bool has_collisions(const attribute_set_t& other_set) const;

    std::size_t count_collisions(const attribute_set_t& other_set) const;

    inline bool empty() const { return set_m->empty(); }

    inline size_type size() const { return set_m->size(); }

    const_iterator begin() const { return set_m->begin(); }

    const_iterator end() const { return set_m->end(); }

    void clear() { set_m.write().clear(); }
 
private:
    friend bool operator==(const attribute_set_t& x, const attribute_set_t& y);
    friend std::ostream& operator<<(std::ostream& s, const attribute_set_t& attribute_set);
 
    copy_on_write<set_type> set_m;
};
 
/**************************************************************************************************/

inline bool operator==(const attribute_set_t& x, const attribute_set_t& y) {
    return x.set_m->size() == y.set_m->size() && x.count_same(y) == x.set_m->size();
}
 
/**************************************************************************************************/

inline std::ostream& operator<<(std::ostream& s, const attribute_set_t& attribute_set) {
    attribute_set_t::set_type::const_iterator first(attribute_set.set_m->begin());
    attribute_set_t::set_type::const_iterator last(attribute_set.set_m->end());
    bool not_first(false);
 
    for (; first != last; ++first) {
        if (not_first)
            s << " ";
        else
            not_first = true;
 
        adobe::copy(first->first, std::ostream_iterator<char>(s));
 
        s << "='";
 
        adobe::copy(first->second, std::ostream_iterator<char>(s));
 
        s << "'";
    }
 
    return s;
}
 
/**************************************************************************************************/
 
inline std::size_t attribute_set_t::count_same(const attribute_set_t& other_set,
                                               bool mapped_matters) const {
    std::size_t result(0);
 
    if (mapped_matters)
        result =
            adobe::set_intersection(*set_m, *other_set.set_m, counting_output_iterator(), less_t())
                .count();
    else
        result = adobe::set_intersection(*set_m, *other_set.set_m, counting_output_iterator(),
                                         less_key_only_t())
                     .count();
 
#if 0
        std::cerr   << "    count_same:\n"
                    << "          orig: " << *this << "\n"
                    << "          test: " << other_set << "\n"
                    << "        result: " << result << std::endl;
#endif
 
    return result;
}
 
/**************************************************************************************************/
 
inline bool attribute_set_t::has_collisions(const attribute_set_t& other_set) const {
    attribute_set_t::set_type::const_iterator first(set_m->begin());
    attribute_set_t::set_type::const_iterator last(set_m->end());
 
    for (; first != last; ++first) {
        set_type::const_iterator result;
 
        if (other_set.lower_bound(*first, result) &&
            !token_range_equal(result->second, first->second))
            return true;
    }
 
    return false;
}
 
/**************************************************************************************************/
 
inline std::size_t attribute_set_t::count_collisions(const attribute_set_t& other_set) const {
    attribute_set_t::set_type::const_iterator first(set_m->begin());
    attribute_set_t::set_type::const_iterator last(set_m->end());
    std::size_t collision_count(0);
 
    for (; first != last; ++first) {
        set_type::const_iterator result;
 
        if (other_set.lower_bound(*first, result) && result->second != first->second)
            ++collision_count;
    }
 
    return collision_count;
}
 
/**************************************************************************************************/
 
// REVISIT (sparent) : Extra typedef just for the doxygen tool.
 
typedef token_range_t(implementation_xml_element_proc_t)(const token_range_t& entire_element_range,
                                                         const token_range_t& name,
                                                         const attribute_set_t& attribute_set,
                                                         const token_range_t& value);
 
using xml_element_proc_t = std::function<implementation_xml_element_proc_t>;
 
/**************************************************************************************************/
 
// NOTE (fbrereto) : Class declaration for the documentation is in xml_parser.dox
template <typename O> // O models OutputIterator
class xml_parser_t : public boost::noncopyable {
public:
    using callback_proc_t = xml_element_proc_t;
    using preorder_predicate_t = std::function<bool(const token_range_t&)>;
    using token_type = xml_lex_t::token_type;
 
    xml_parser_t(uchar_ptr_t first, uchar_ptr_t last, const line_position_t& position,
                 preorder_predicate_t predicate, callback_proc_t callback, O output)
        : pred_m(predicate), callback_m(callback), output_m(output),
          token_stream_m(first, last, position), preorder_mode_m(false) {}
 
    xml_parser_t(const xml_parser_t& rhs)
        : pred_m(rhs.pred_m), callback_m(rhs.callback_m), output_m(rhs.output_m),
          token_stream_m(rhs.token_stream_m), preorder_mode_m(rhs.preorder_mode_m) {}
 
    xml_parser_t& operator=(const xml_parser_t& rhs) {
        pred_m = rhs.pred_m;
        callback_m = rhs.callback_m;
        output_m = rhs.output_m;
        token_stream_m = rhs.token_stream_m;
        preorder_mode_m = rhs.preorder_mode_m;
 
        return *this;
    }
 
    virtual ~xml_parser_t() {}
 
    const line_position_t& next_position() { return token_stream_m.next_position(); }

    void set_preorder_predicate(preorder_predicate_t pred) { pred_m = pred; }

    void parse_element_sequence();

    void parse_content();

    void parse_document();
 
    /*
        REVISIT (sparent) : We should provide a protected call to get the token stream and allow
        subclasses to access it directly - but for now we'll stick with the law of Demiter.
    */
 
protected:
    const token_type& get_token() { return token_stream_m.get(); }
    void putback() { token_stream_m.putback(); }
 
    bool is_token(xml_lex_token_set_t name, token_range_t& value);
    bool is_token(xml_lex_token_set_t name);
    void require_token(xml_lex_token_set_t name, token_range_t& value);
    void require_token(xml_lex_token_set_t name);
 
    /* REVISIT (sparent) : Should these be const? And is there a way to specify the class to throw?
     */
 
    void throw_exception(const char* error_string) {
        throw_parser_exception(error_string, next_position());
    }
    void throw_exception(xml_lex_token_set_t found, xml_lex_token_set_t expected) {
        throw_parser_exception(token_to_string(found), token_to_string(expected), next_position());
    }
 
    bool is_element(token_range_t& element);
    bool is_content(token_range_t& element);
    bool is_e_tag(token_range_t& name, token_range_t& close_tag);
    bool is_attribute_set(attribute_set_t& attribute_set);
    bool is_attribute(token_range_t& name, token_range_t& value);
    bool is_prolog();
    bool is_bom(token_range_t& bom);
    bool is_xml_decl(token_range_t& xml_decl);
 
    void content_callback(token_range_t& result_element, const token_range_t& old_element,
                          const token_range_t& start_tag, const attribute_set_t attribute_set,
                          const token_range_t& content, bool preorder_parent);
 
    preorder_predicate_t pred_m;
    callback_proc_t callback_m;
    O output_m;
 
private:
    xml_lex_t token_stream_m;
    bool preorder_mode_m;
};
 
/**************************************************************************************************/
 
inline token_range_t xml_element_echo(const token_range_t& entire_element_range,
                                      const token_range_t& /*name*/,
                                      const attribute_set_t& /*attribute_set*/,
                                      const token_range_t& /*value*/) {
    return entire_element_range;
}
 
/**************************************************************************************************/
 
inline token_range_t xml_element_strip(const token_range_t& /*entire_element_range*/,
                                       const token_range_t& /*name*/,
                                       const attribute_set_t& /*attribute_set*/,
                                       const token_range_t& value) {
    return value;
}
 
/**************************************************************************************************/
 
inline token_range_t xml_element_linefeed(const token_range_t& /*entire_element_range*/,
                                          const token_range_t& name,
                                          const attribute_set_t& attribute_set,
                                          const token_range_t& value) {
    if (token_range_equal(name, static_token_range("br")) && attribute_set.empty() &&
        adobe::token_range_size(value) == 0) {
#if ADOBE_PLATFORM_WIN
        return static_token_range("&cr;&lf;");
#elif ADOBE_PLATFORM_MAC
        return static_token_range("&cr;");
#elif ADOBE_PLATFORM_UNIX || ADOBE_PLATFORM_LINUX || ADOBE_PLATFORM_BSD ||                         \
    ADOBE_PLATFORM_SOLARIS || ADOBE_PLATFORM_IRIX || ADOBE_PLATFORM_HPUX ||                        \
    ADOBE_PLATFORM_CYGWIN || ADOBE_PLATFORM_AIX
        return static_token_range("&lf;");
#else
#error                                                                                             \
    "Line ending for platform unknown - please configure and report the results to stlab.adobe.com"
#endif
    }
 
    return value;
}
 
/**************************************************************************************************/
 
namespace implementation {
 
/**************************************************************************************************/
 
token_range_t transform_reference(const token_range_t& reference);
 
/**************************************************************************************************/
 
} // namespace implementation
 
/**************************************************************************************************/
 
template <typename O> // O models OutputIterator
bool xml_parser_t<O>::is_token(xml_lex_token_set_t token_name, token_range_t& token_range) {
    const token_type& result(get_token());
 
    if (result.enum_m == token_name) {
        token_range = result.range_m;
 
        return true;
    }
 
    putback();
 
    return false;
}
 
/**************************************************************************************************/
 
template <typename O> // O models OutputIterator
bool xml_parser_t<O>::is_token(xml_lex_token_set_t token_name) {
    const token_type& result(get_token());
 
    if (result.enum_m == token_name)
        return true;
 
    putback();
 
    return false;
}
 
/**************************************************************************************************/
 
template <typename O> // O models OutputIterator
void xml_parser_t<O>::require_token(xml_lex_token_set_t token_name, token_range_t& token_range) {
    const token_type& result(get_token());
 
    if (result.enum_m != token_name)
        throw_exception(result.enum_m, token_name);
 
    token_range = result.range_m;
}
 
/**************************************************************************************************/
 
template <typename O> // O models OutputIterator
void xml_parser_t<O>::require_token(xml_lex_token_set_t token_name) {
    const token_type& result(get_token());
 
    if (result.enum_m != token_name)
        throw_exception(result.enum_m, token_name);
}
 
/**************************************************************************************************/
 
template <typename O> // O models OutputIterator
void xml_parser_t<O>::content_callback(token_range_t& result_element,
                                       const token_range_t& old_element,
                                       const token_range_t& start_tag,
                                       const attribute_set_t attribute_set,
                                       const token_range_t& content, bool preorder_parent) {
    if (preorder_parent) {
        // if we are in preorder mode and we are the preorder_parent,
        // we send the content to the client callback function.
        // We get back a single token_range, which we then parse all
        // over again in a content parser all its own.
 
        token_range_t new_content(callback_m(old_element, start_tag, attribute_set, content));
 
        if (old_element == new_content) {
            // In the case when the new content is the same as the old element,
            // the user has opted to echo the element to the output unchanged.
 
            adobe::copy(old_element, output_m);
        } else {
            // otherwise we need to parse the new content before we can move on to
            // the rest of the parse. The new parser has the same predicate and
            // output iterator as this one
 
            xml_parser_t<O>(new_content.first, new_content.second, next_position(), pred_m,
                            callback_m, output_m)
                .parse_content();
        }
 
        // once the token_range from the client has been parsed, we can turn off
        // preorder mode and resume parsing the original token stream from where we
        // left off.
 
        preorder_mode_m = false; // only the preorder_parent can turn off preorder mode
    } else {
        // in the case we are in preorder mode but we are not the initiator of
        // the mode, we are within the context of another preorder parse. In
        // this case we use the entire contents of the element as the token range
        // and hand it back as the return value of this function.
 
        result_element = old_element;
    }
}
 
/**************************************************************************************************/
 
template <typename O> // O models OutputIterator
bool xml_parser_t<O>::is_element(token_range_t& element) {
    element = token_range_t();
 
    attribute_set_t attribute_set;
 
    token_range_t open_tag;
    token_range_t close_tag;
 
    if (!is_token(xml_token_open_tag_k, open_tag))
        return false;
 
    token_range_t start_tag;
    token_range_t end_tag;
 
    require_token(xml_token_name_k, start_tag);
 
    bool preorder_parent(false); // explained below
 
    // Preorder mode is a state for the entire parser. In this state the
    // client processing callback is never called until the end of the
    // current element is found. This precludes the processing of elements
    // and other entities nested within this element from being handled until
    // this containing element is processed. This is useful in the case when
    // the content of the element could potentially be replaced, in which
    // case processing the nested elements first would be a moot point.
 
    if (!preorder_mode_m && pred_m) {
        // preorder mode is only set when the predicate is defined and
        // returns true for the start_tag of this element.
 
        preorder_mode_m = pred_m(start_tag);
 
 
        // preorder_parent is used to denote which frame in the stack began
        // the preorder traversal, as it is this frame alone that can turn
        // it back off again.
 
        preorder_parent = preorder_mode_m;
    }
 
    is_attribute_set(attribute_set);
 
    if (is_token(xml_token_slash_close_tag_k, close_tag)) {
        if (preorder_mode_m) {
            content_callback(element, token_range_t(open_tag.first, close_tag.second), start_tag,
                             attribute_set, token_range_t(), preorder_parent);
        } else {
            // in the case when we are not in preorder mode at all, we pass the element
            // to the client callback and output the token_range we receive back.
 
            token_range_t result(callback_m(token_range_t(open_tag.first, close_tag.second),
                                            start_tag, attribute_set, token_range_t()));
 
            adobe::copy(result, output_m);
        }
 
        return true;
    }
 
    token_range_t close_of_open_tag;
 
    require_token(xml_token_close_tag_k, close_of_open_tag);
 
    token_range_t content;
 
    // In the case of inorder parsing we want to output the tags
    // as we see them; in this case we need to output the opening
    // tag before we can go on to the content parsing.
 
    if (!preorder_mode_m)
        std::copy(open_tag.first, close_of_open_tag.second, output_m);
 
    if (!is_content(content))
        throw std::runtime_error("Content expected but not found.");
 
    if (!is_e_tag(end_tag, close_tag))
        throw std::runtime_error("End tag expected but not found.");
 
    if (!token_range_equal(start_tag, end_tag))
        throw std::runtime_error("Start tag and end tag do not have the same name.");
 
    if (!preorder_mode_m) {
        // in the case when we are not in preorder mode
        // we output the content we have immediately,
        // then we need to output the closing tag before
        // we can go on to the rest of the parse.
 
        adobe::copy(content, output_m);
        adobe::copy(token_range_t(end_tag.first - 2, end_tag.second + 1), output_m);
    } else {
        // In this instance we are continuing a preorder parse...
 
        content_callback(element, token_range_t(open_tag.first, close_tag.second), start_tag,
                         attribute_set, content, preorder_parent);
    }
 
    return true;
}
 
/**************************************************************************************************/
 
template <typename O> // O models OutputIterator
bool xml_parser_t<O>::is_content(token_range_t& content) {
    content = token_range_t();
 
    token_range_t char_data;
 
    // NOTE (fbrereto) :    The content parser can never initiate a preorder mode.
    //                      It can only be initiated by the parsing of a preorder
    //                      element, which isn't handled here. So for the content
    //                      parse we are either in preorder mode or not; we need
    //                      not worry about managing it.
 
    if (is_token(xml_token_char_data_k, char_data)) {
        // in the case when we are in preorder mode, we are part of a nested
        // content, and we want to use this beginning char_data token as the
        // start of the overall content token_range.
 
        if (preorder_mode_m) {
            content = char_data;
        }
 
        // in the case when we are not in preorder mode this range of char_data
        // needs to be sent directly to the output.
        else {
            adobe::copy(char_data, output_m);
        }
    }
 
    while (true) {
        token_range_t result;
 
        if (is_token(xml_token_reference_k, result)) {
            if (adobe::token_range_size(result)) {
                if (preorder_mode_m) {
                    // Again, if we're in preorder mode we're not outputting
                    // but extending (possibly even starting, too) the token_range
                    // for the preorder element.
 
                    if (!content.first)
                        content.first = result.first;
 
                    content.second = result.second;
                } else {
                    // if we're not in preorder mode, we pass the element's
                    // reference-transformed token_range result directly to
                    // the output.
 
                    adobe::copy(implementation::transform_reference(result), output_m);
                }
            }
        } else if (is_element(result)) {
            if (adobe::token_range_size(result)) {
                if (preorder_mode_m) {
                    // Again, if we're in preorder mode we're not outputting
                    // but extending (possibly even starting, too) the token_range
                    // for the preorder element.
 
                    if (!content.first)
                        content.first = result.first;
 
                    content.second = result.second;
                } else {
                    // if we're not in preorder mode, we pass the element's
                    // token_range result directly to the output.
 
                    adobe::copy(result, output_m);
                }
            }
        } else if (is_token(xml_token_comment_k, result)) {
            // Comments are not parsed by any client functions.
            // They are merely ignored by the parser.
 
            // REVISIT eberdahl - Because some clients may want to
            // handle comments, we may want to extend the client
            // callback system to permit a comment callback.
        } else {
            break;
        }
 
        if (is_token(xml_token_char_data_k, char_data)) {
            // if we find more char_data at the end of the content, we
            // either extent the preorder content data or we output
            // the contents of the char_data directly to the output (in
            // fullorder mode).
 
            if (preorder_mode_m) {
                content.second = char_data.second;
            } else {
                adobe::copy(char_data, output_m);
            }
        }
    }
 
    return true;
}
 
/**************************************************************************************************/
 
template <typename O> // O models OutputIterator
bool xml_parser_t<O>::is_e_tag(token_range_t& name, token_range_t& close_tag) {
    if (!is_token(xml_token_open_slash_tag_k))
        return false;
 
    require_token(xml_token_name_k, name);
 
    require_token(xml_token_close_tag_k, close_tag);
 
    return true;
}
 
/**************************************************************************************************/
 
template <typename O> // O models OutputIterator
bool xml_parser_t<O>::is_attribute_set(attribute_set_t& attribute_set) {
    token_range_t att_name;
    token_range_t att_value;
 
    while (is_attribute(att_name, att_value))
        attribute_set.insert(att_name, att_value);
 
    return true;
}
 
/**************************************************************************************************/
 
template <typename O> // O models OutputIterator
bool xml_parser_t<O>::is_prolog() {
    token_range_t bom;
    token_range_t xml_decl;
 
    if (is_bom(bom)) {
        // REVISIT eberdahl 2006 Jun 18 - sanity check the bom
    }
 
    if (is_xml_decl(xml_decl)) {
        // REVISIT eberdahl 2006 Jun 18 - sanity check the encoding
        // of the XMLDecl
 
        return true;
    }
 
    return false;
}
 
/**************************************************************************************************/
 
template <typename O> // O models OutputIterator
bool xml_parser_t<O>::is_bom(token_range_t& bom) {
    const token_range_t utf8_bom = static_token_range("\xEF\xBB\xBF");
    const token_range_t utf16_be_bom = static_token_range("\xFE\xFF");
    const token_range_t utf16_le_bom = static_token_range("\xFF\xFE");
 
    bool result = false;
 
    // whitespace skipping should be off when sniffing for a bom
    token_stream_m.set_skip_white_space(false);
 
    if (is_token(xml_token_char_data_k, bom)) {
        if (adobe::token_range_size(utf8_bom) <= adobe::token_range_size(bom) &&
            adobe::equal(utf8_bom, bom.first)) {
            bom.second = bom.first;
            std::advance(bom.second, adobe::token_range_size(utf8_bom));
 
            result = true;
        } else if (adobe::token_range_size(utf16_be_bom) <= adobe::token_range_size(bom) &&
                   adobe::equal(utf16_be_bom, bom.first)) {
            // it's a bom, but it's not a format the parser supports
            throw_exception("utf16be bom encountered; xml_parser_t only supports utf8 encoding");
        } else if (adobe::token_range_size(utf16_le_bom) <= adobe::token_range_size(bom) &&
                   adobe::equal(utf16_le_bom, bom.first)) {
            // it's a bom, but it's not a format the parser supports
            throw_exception("utf16le bom encountered; xml_parser_t only supports utf8 encoding");
        }
    }
 
    token_stream_m.set_skip_white_space(true);
 
    return result;
}
 
/**************************************************************************************************/
 
template <typename O> // O models OutputIterator
bool xml_parser_t<O>::is_xml_decl(token_range_t& xml_decl) {
    if (is_token(xml_token_processing_instruction_k, xml_decl)) {
        // REVISIT eberdahl 2006 Jun 18 - sanity check that the PI
        // encountered is, in fact, targeted at the xml application
 
        return true;
    }
 
    return false;
}
 
/**************************************************************************************************/
 
template <typename O> // O models OutputIterator
bool xml_parser_t<O>::is_attribute(token_range_t& name, token_range_t& value) {
    if (is_token(xml_token_name_k, name)) {
        require_token(xml_token_equals_k);
 
        require_token(xml_token_att_value_k, value);
 
        return true;
    }
 
    return false;
}
 
/**************************************************************************************************/
 
template <typename O> // O models OutputIterator
void xml_parser_t<O>::parse_element_sequence() {
    assert(callback_m);
 
    token_range_t dummy;
 
    token_stream_m.set_skip_white_space(false);
 
    while (is_element(dummy))
        is_token(xml_token_char_data_k);
}
 
/**************************************************************************************************/
 
template <typename O> // O models OutputIterator
void xml_parser_t<O>::parse_content() {
    token_range_t content;
 
    token_stream_m.set_skip_white_space(false);
 
    while (true) {
        // always returns true; have to test results
        is_content(content);
 
        if (adobe::token_range_size(content)) {
            token_range_t result(
                this->callback_m(content, token_range_t(), attribute_set_t(), content));
 
            adobe::copy(result, this->output_m);
        } else {
            break;
        }
    }
}
 
/**************************************************************************************************/
 
template <typename O> // O models OutputIterator
void xml_parser_t<O>::parse_document() {
    token_range_t dummy;
 
    token_stream_m.set_skip_white_space(true);
 
    is_prolog();
    is_element(dummy);
}
 
/**************************************************************************************************/

template <typename O> // O models OutputIterator
inline xml_parser_t<O>
make_xml_parser(uchar_ptr_t first, uchar_ptr_t last, const line_position_t& position,
                typename xml_parser_t<O>::preorder_predicate_t predicate,
                typename xml_parser_t<O>::callback_proc_t callback, O output) {
    return xml_parser_t<O>(first, last, position, predicate, callback, output);
}
 
/**************************************************************************************************/
template <typename Result, typename InputIterator>
InputIterator xatoi(InputIterator first, InputIterator last, Result& result) {
    result = 0;
 
    while (first != last && std::isxdigit(*first)) {
        typename std::iterator_traits<InputIterator>::value_type c(*first);
 
        result <<= 4;
 
        if (std::isdigit(c)) {
            result += c - '0';
        } else {
            c = std::use_facet<std::ctype<char>>(std::locale()).tolower(c);
 
            result += c - 'a' + 10;
        }
 
        ++first;
    }
 
    return first;
}
 
/**************************************************************************************************/
template <typename Result, typename InputIterator>
InputIterator datoi(InputIterator first, InputIterator last, Result& result) {
    result = 0;
 
    while (first != last && std::isdigit(*first)) {
        result *= 10;
 
        result += *first - '0';
 
        ++first;
    }
 
    return first;
}
 
/**************************************************************************************************/
 
} // namespace adobe
 
/**************************************************************************************************/
 
#endif
 
/**************************************************************************************************/