mirror of
https://github.com/tfussell/xlnt.git
synced 2024-03-22 13:11:17 +08:00
938 lines
22 KiB
C++
938 lines
22 KiB
C++
// file : xml/parser.cxx
|
|
// copyright : Copyright (c) 2013-2017 Code Synthesis Tools CC
|
|
// license : MIT; see accompanying LICENSE file
|
|
|
|
#include <new> // std::bad_alloc
|
|
#include <cassert>
|
|
#include <cstring> // std::strchr
|
|
#include <istream>
|
|
#include <ostream>
|
|
#include <sstream>
|
|
|
|
#include <xml/parser>
|
|
|
|
using namespace std;
|
|
|
|
namespace xml
|
|
{
|
|
// parsing
|
|
//
|
|
void parsing::
|
|
init ()
|
|
{
|
|
ostringstream os;
|
|
if (!name_.empty ())
|
|
os << name_ << ':';
|
|
os << line_ << ':' << column_ << ": error: " << description_;
|
|
what_ = os.str ();
|
|
}
|
|
|
|
// parser::event_type
|
|
//
|
|
static const char* parser_event_str[] =
|
|
{
|
|
"start element",
|
|
"end element",
|
|
"start attribute",
|
|
"end attribute",
|
|
"characters",
|
|
"start namespace declaration",
|
|
"end namespace declaration",
|
|
"end of file"
|
|
};
|
|
|
|
ostream&
|
|
operator<< (ostream& os, parser::event_type e)
|
|
{
|
|
return os << parser_event_str[e];
|
|
}
|
|
|
|
// parser
|
|
//
|
|
parser::
|
|
~parser ()
|
|
{
|
|
if (p_ != 0)
|
|
XML_ParserFree (p_);
|
|
}
|
|
|
|
void parser::
|
|
init ()
|
|
{
|
|
depth_ = 0;
|
|
state_ = state_next;
|
|
event_ = eof;
|
|
queue_ = eof;
|
|
|
|
pqname_ = &qname_;
|
|
pvalue_ = &value_;
|
|
|
|
line_ = 0;
|
|
column_ = 0;
|
|
|
|
attr_i_ = 0;
|
|
start_ns_i_ = 0;
|
|
end_ns_i_ = 0;
|
|
|
|
if ((feature_ & receive_attributes_map) != 0 &&
|
|
(feature_ & receive_attributes_event) != 0)
|
|
feature_ &= ~receive_attributes_map;
|
|
|
|
// Allocate the parser. Make sure nothing else can throw after
|
|
// this call since otherwise we will leak it.
|
|
//
|
|
p_ = XML_ParserCreateNS (0, XML_Char (' '));
|
|
|
|
if (p_ == 0)
|
|
throw bad_alloc ();
|
|
|
|
// Get prefixes in addition to namespaces and local names.
|
|
//
|
|
XML_SetReturnNSTriplet (p_, true);
|
|
|
|
// Set handlers.
|
|
//
|
|
XML_SetUserData(p_, this);
|
|
|
|
if ((feature_ & receive_elements) != 0)
|
|
{
|
|
XML_SetStartElementHandler (p_, &start_element_);
|
|
XML_SetEndElementHandler (p_, &end_element_);
|
|
}
|
|
|
|
if ((feature_ & receive_characters) != 0)
|
|
XML_SetCharacterDataHandler (p_, &characters_);
|
|
|
|
if ((feature_ & receive_namespace_decls) != 0)
|
|
XML_SetNamespaceDeclHandler (p_,
|
|
&start_namespace_decl_,
|
|
&end_namespace_decl_);
|
|
}
|
|
|
|
void parser::
|
|
handle_error ()
|
|
{
|
|
XML_Error e (XML_GetErrorCode (p_));
|
|
|
|
if (e == XML_ERROR_ABORTED)
|
|
{
|
|
// For now we only abort the parser in the characters_() and
|
|
// start_element_() handlers.
|
|
//
|
|
switch (content ())
|
|
{
|
|
case content_type::empty:
|
|
throw parsing (*this, "characters in empty content");
|
|
case content_type::simple:
|
|
throw parsing (*this, "element in simple content");
|
|
case content_type::complex:
|
|
throw parsing (*this, "characters in complex content");
|
|
default:
|
|
assert (false);
|
|
}
|
|
}
|
|
else
|
|
throw parsing (iname_,
|
|
XML_GetCurrentLineNumber (p_),
|
|
XML_GetCurrentColumnNumber (p_),
|
|
XML_ErrorString (e));
|
|
}
|
|
|
|
struct stream_exception_controller
|
|
{
|
|
~stream_exception_controller ()
|
|
{
|
|
istream::iostate s = is_.rdstate ();
|
|
s &= ~istream::failbit;
|
|
|
|
// If our error state (sans failbit) intersects with the
|
|
// exception state then that means we have an active
|
|
// exception and changing error/exception state will
|
|
// cause another to be thrown.
|
|
//
|
|
if (!(old_state_ & s))
|
|
{
|
|
// Clear failbit if it was caused by eof.
|
|
//
|
|
if (is_.fail () && is_.eof ())
|
|
is_.clear (s);
|
|
|
|
is_.exceptions (old_state_);
|
|
}
|
|
}
|
|
|
|
stream_exception_controller (istream& is)
|
|
: is_ (is), old_state_ (is_.exceptions ())
|
|
{
|
|
is_.exceptions (old_state_ & ~istream::failbit);
|
|
}
|
|
|
|
private:
|
|
stream_exception_controller (const stream_exception_controller&);
|
|
|
|
stream_exception_controller&
|
|
operator= (const stream_exception_controller&);
|
|
|
|
private:
|
|
istream& is_;
|
|
istream::iostate old_state_;
|
|
};
|
|
|
|
parser::event_type parser::
|
|
next ()
|
|
{
|
|
if (state_ == state_next)
|
|
return next_ (false);
|
|
else
|
|
{
|
|
// If we previously peeked at start/end_element, then adjust
|
|
// state accordingly.
|
|
//
|
|
switch (event_)
|
|
{
|
|
case end_element:
|
|
{
|
|
if (!element_state_.empty () &&
|
|
element_state_.back ().depth == depth_)
|
|
pop_element ();
|
|
|
|
depth_--;
|
|
break;
|
|
}
|
|
case start_element:
|
|
{
|
|
depth_++;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
state_ = state_next;
|
|
return event_;
|
|
}
|
|
}
|
|
|
|
const string& parser::
|
|
attribute (const qname_type& qn) const
|
|
{
|
|
if (const element_entry* e = get_element ())
|
|
{
|
|
attribute_map_type::const_iterator i (e->attr_map_.find (qn));
|
|
|
|
if (i != e->attr_map_.end ())
|
|
{
|
|
if (!i->second.handled)
|
|
{
|
|
i->second.handled = true;
|
|
e->attr_unhandled_--;
|
|
}
|
|
return i->second.value;
|
|
}
|
|
}
|
|
|
|
throw parsing (*this, "attribute '" + qn.string () + "' expected");
|
|
}
|
|
|
|
string parser::
|
|
attribute (const qname_type& qn, const string& dv) const
|
|
{
|
|
if (const element_entry* e = get_element ())
|
|
{
|
|
attribute_map_type::const_iterator i (e->attr_map_.find (qn));
|
|
|
|
if (i != e->attr_map_.end ())
|
|
{
|
|
if (!i->second.handled)
|
|
{
|
|
i->second.handled = true;
|
|
e->attr_unhandled_--;
|
|
}
|
|
return i->second.value;
|
|
}
|
|
}
|
|
|
|
return dv;
|
|
}
|
|
|
|
bool parser::
|
|
attribute_present (const qname_type& qn) const
|
|
{
|
|
if (const element_entry* e = get_element ())
|
|
{
|
|
attribute_map_type::const_iterator i (e->attr_map_.find (qn));
|
|
|
|
if (i != e->attr_map_.end ())
|
|
{
|
|
if (!i->second.handled)
|
|
{
|
|
i->second.handled = true;
|
|
e->attr_unhandled_--;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void parser::
|
|
next_expect (event_type e)
|
|
{
|
|
if (next () != e)
|
|
throw parsing (*this, string (parser_event_str[e]) + " expected");
|
|
}
|
|
|
|
void parser::
|
|
next_expect (event_type e, const string& ns, const string& n)
|
|
{
|
|
if (next () != e || namespace_ () != ns || name () != n)
|
|
throw parsing (*this,
|
|
string (parser_event_str[e]) + " '" +
|
|
qname_type (ns, n).string () + "' expected");
|
|
}
|
|
|
|
string parser::
|
|
element ()
|
|
{
|
|
content (content_type::simple);
|
|
string r;
|
|
|
|
// The content of the element can be empty in which case there
|
|
// will be no characters event.
|
|
//
|
|
event_type e (next ());
|
|
if (e == characters)
|
|
{
|
|
r.swap (value ());
|
|
e = next ();
|
|
}
|
|
|
|
// We cannot really get anything other than end_element since
|
|
// the simple content validation won't allow it.
|
|
//
|
|
assert (e == end_element);
|
|
|
|
return r;
|
|
}
|
|
|
|
string parser::
|
|
element (const qname_type& qn, const string& dv)
|
|
{
|
|
if (peek () == start_element && qname () == qn)
|
|
{
|
|
next ();
|
|
return element ();
|
|
}
|
|
|
|
return dv;
|
|
}
|
|
|
|
const parser::element_entry* parser::
|
|
get_element_ () const
|
|
{
|
|
// The start_element_() Expat handler may have already provisioned
|
|
// an entry in the element stack. In this case, we need to get the
|
|
// one before it, if any.
|
|
//
|
|
const element_entry* r (0);
|
|
element_state::size_type n (element_state_.size () - 1);
|
|
|
|
if (element_state_[n].depth == depth_)
|
|
r = &element_state_[n];
|
|
else if (n != 0 && element_state_[n].depth > depth_)
|
|
{
|
|
n--;
|
|
if (element_state_[n].depth == depth_)
|
|
r = &element_state_[n];
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
void parser::
|
|
pop_element ()
|
|
{
|
|
// Make sure there are no unhandled attributes left.
|
|
//
|
|
const element_entry& e (element_state_.back ());
|
|
if (e.attr_unhandled_ != 0)
|
|
{
|
|
// Find the first unhandled attribute and report it.
|
|
//
|
|
for (attribute_map_type::const_iterator i (e.attr_map_.begin ());
|
|
i != e.attr_map_.end (); ++i)
|
|
{
|
|
if (!i->second.handled)
|
|
throw parsing (
|
|
*this, "unexpected attribute '" + i->first.string () + "'");
|
|
}
|
|
assert (false);
|
|
}
|
|
|
|
element_state_.pop_back ();
|
|
}
|
|
|
|
parser::event_type parser::
|
|
next_ (bool peek)
|
|
{
|
|
event_type e (next_body ());
|
|
|
|
// Content-specific processing. Note that we handle characters in the
|
|
// characters_() Expat handler for two reasons. Firstly, it is faster
|
|
// to ignore the whitespaces at the source. Secondly, this allows us
|
|
// to distinguish between element and attribute characters. We can
|
|
// move this processing to the handler because the characters event
|
|
// is never queued.
|
|
//
|
|
switch (e)
|
|
{
|
|
case end_element:
|
|
{
|
|
// If this is a peek, then avoid popping the stack just yet.
|
|
// This way, the attribute map will still be valid until we
|
|
// call next().
|
|
//
|
|
if (!peek)
|
|
{
|
|
if (!element_state_.empty () &&
|
|
element_state_.back ().depth == depth_)
|
|
pop_element ();
|
|
|
|
depth_--;
|
|
}
|
|
break;
|
|
}
|
|
case start_element:
|
|
{
|
|
if (const element_entry* e = get_element ())
|
|
{
|
|
switch (e->content)
|
|
{
|
|
case content_type::empty:
|
|
throw parsing (*this, "element in empty content");
|
|
case content_type::simple:
|
|
throw parsing (*this, "element in simple content");
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If this is a peek, then delay adjusting the depth.
|
|
//
|
|
if (!peek)
|
|
depth_++;
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return e;
|
|
}
|
|
|
|
parser::event_type parser::
|
|
next_body ()
|
|
{
|
|
// See if we have any start namespace declarations we need to return.
|
|
//
|
|
if (start_ns_i_ < start_ns_.size ())
|
|
{
|
|
// Based on the previous event determine what's the next one must be.
|
|
//
|
|
switch (event_)
|
|
{
|
|
case start_namespace_decl:
|
|
{
|
|
if (++start_ns_i_ == start_ns_.size ())
|
|
{
|
|
start_ns_i_ = 0;
|
|
start_ns_.clear ();
|
|
pqname_ = &qname_;
|
|
break; // No more declarations.
|
|
}
|
|
// Fall through.
|
|
}
|
|
case start_element:
|
|
{
|
|
event_ = start_namespace_decl;
|
|
pqname_ = &start_ns_[start_ns_i_];
|
|
return event_;
|
|
}
|
|
default:
|
|
{
|
|
assert (false);
|
|
return event_ = eof;
|
|
}
|
|
}
|
|
}
|
|
|
|
// See if we have any attributes we need to return as events.
|
|
//
|
|
if (attr_i_ < attr_.size ())
|
|
{
|
|
// Based on the previous event determine what's the next one must be.
|
|
//
|
|
switch (event_)
|
|
{
|
|
case start_attribute:
|
|
{
|
|
event_ = characters;
|
|
pvalue_ = &attr_[attr_i_].value;
|
|
return event_;
|
|
}
|
|
case characters:
|
|
{
|
|
event_ = end_attribute; // Name is already set.
|
|
return event_;
|
|
}
|
|
case end_attribute:
|
|
{
|
|
if (++attr_i_ == attr_.size ())
|
|
{
|
|
attr_i_ = 0;
|
|
attr_.clear ();
|
|
pqname_ = &qname_;
|
|
pvalue_ = &value_;
|
|
break; // No more attributes.
|
|
}
|
|
// Fall through.
|
|
}
|
|
case start_element:
|
|
case start_namespace_decl:
|
|
{
|
|
event_ = start_attribute;
|
|
pqname_ = &attr_[attr_i_].qname;
|
|
return event_;
|
|
}
|
|
default:
|
|
{
|
|
assert (false);
|
|
return event_ = eof;
|
|
}
|
|
}
|
|
}
|
|
|
|
// See if we have any end namespace declarations we need to return.
|
|
//
|
|
if (end_ns_i_ < end_ns_.size ())
|
|
{
|
|
// Based on the previous event determine what's the next one must be.
|
|
//
|
|
switch (event_)
|
|
{
|
|
case end_namespace_decl:
|
|
{
|
|
if (++end_ns_i_ == end_ns_.size ())
|
|
{
|
|
end_ns_i_ = 0;
|
|
end_ns_.clear ();
|
|
pqname_ = &qname_;
|
|
break; // No more declarations.
|
|
}
|
|
// Fall through.
|
|
}
|
|
// The end namespace declaration comes before the end element
|
|
// which means it can follow pretty much any other event.
|
|
//
|
|
default:
|
|
{
|
|
event_ = end_namespace_decl;
|
|
pqname_ = &end_ns_[end_ns_i_];
|
|
return event_;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check the queue.
|
|
//
|
|
if (queue_ != eof)
|
|
{
|
|
event_ = queue_;
|
|
queue_ = eof;
|
|
|
|
line_ = XML_GetCurrentLineNumber (p_);
|
|
column_ = XML_GetCurrentColumnNumber (p_);
|
|
|
|
return event_;
|
|
}
|
|
|
|
// Reset the character accumulation flag.
|
|
//
|
|
accumulate_ = false;
|
|
|
|
XML_ParsingStatus ps;
|
|
XML_GetParsingStatus (p_, &ps);
|
|
|
|
switch (ps.parsing)
|
|
{
|
|
case XML_INITIALIZED:
|
|
{
|
|
// As if we finished the previous chunk.
|
|
break;
|
|
}
|
|
case XML_PARSING:
|
|
{
|
|
assert (false);
|
|
return event_ = eof;
|
|
}
|
|
case XML_FINISHED:
|
|
{
|
|
return event_ = eof;
|
|
}
|
|
case XML_SUSPENDED:
|
|
{
|
|
switch (XML_ResumeParser (p_))
|
|
{
|
|
case XML_STATUS_SUSPENDED:
|
|
{
|
|
// If the parser is again in the suspended state, then
|
|
// that means we have the next event.
|
|
//
|
|
return event_;
|
|
}
|
|
case XML_STATUS_OK:
|
|
{
|
|
// Otherwise, we need to get and parse the next chunk of data
|
|
// unless this was the last chunk, in which case this is eof.
|
|
//
|
|
if (ps.finalBuffer)
|
|
return event_ = eof;
|
|
|
|
break;
|
|
}
|
|
case XML_STATUS_ERROR:
|
|
handle_error ();
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Get and parse the next chunk of data until we get the next event
|
|
// or reach eof.
|
|
//
|
|
if (!accumulate_)
|
|
event_ = eof;
|
|
|
|
XML_Status s;
|
|
do
|
|
{
|
|
if (size_ != 0)
|
|
{
|
|
s = XML_Parse (p_,
|
|
static_cast <const char*> (data_.buf),
|
|
static_cast <int> (size_),
|
|
true);
|
|
|
|
if (s == XML_STATUS_ERROR)
|
|
handle_error ();
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
const size_t cap (4096);
|
|
|
|
char* b (static_cast<char*> (XML_GetBuffer (p_, cap)));
|
|
if (b == 0)
|
|
throw bad_alloc ();
|
|
|
|
// Temporarily unset the exception failbit. Also clear the fail bit
|
|
// when we reset the old state if it was caused by eof.
|
|
//
|
|
istream& is (*data_.is);
|
|
{
|
|
stream_exception_controller sec (is);
|
|
is.read (b, static_cast<streamsize> (cap));
|
|
}
|
|
|
|
// If the caller hasn't configured the stream to use exceptions,
|
|
// then use the parsing exception to report an error.
|
|
//
|
|
if (is.bad () || (is.fail () && !is.eof ()))
|
|
throw parsing (*this, "io failure");
|
|
|
|
bool eof (is.eof ());
|
|
|
|
s = XML_ParseBuffer (p_, static_cast<int> (is.gcount ()), eof);
|
|
|
|
if (s == XML_STATUS_ERROR)
|
|
handle_error ();
|
|
|
|
if (eof)
|
|
break;
|
|
}
|
|
} while (s != XML_STATUS_SUSPENDED);
|
|
|
|
return event_;
|
|
}
|
|
|
|
static void
|
|
split_name (const XML_Char* s, qname& qn)
|
|
{
|
|
string& ns (qn.namespace_ ());
|
|
string& name (qn.name ());
|
|
string& prefix (qn.prefix ());
|
|
|
|
const char* p (strchr (s, ' '));
|
|
|
|
if (p == 0)
|
|
{
|
|
ns.clear ();
|
|
name = s;
|
|
prefix.clear ();
|
|
}
|
|
else
|
|
{
|
|
ns.assign (s, 0, p - s);
|
|
|
|
s = p + 1;
|
|
p = strchr (s, ' ');
|
|
|
|
if (p == 0)
|
|
{
|
|
name = s;
|
|
prefix.clear ();
|
|
}
|
|
else
|
|
{
|
|
name.assign (s, 0, p - s);
|
|
prefix = p + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
void XMLCALL parser::
|
|
start_element_ (void* v, const XML_Char* name, const XML_Char** atts)
|
|
{
|
|
parser& p (*static_cast<parser*> (v));
|
|
|
|
XML_ParsingStatus ps;
|
|
XML_GetParsingStatus (p.p_, &ps);
|
|
|
|
// Expat has a (mis)-feature of a possibily calling handlers even
|
|
// after the non-resumable XML_StopParser call.
|
|
//
|
|
if (ps.parsing == XML_FINISHED)
|
|
return;
|
|
|
|
// Cannot be a followup event.
|
|
//
|
|
assert (ps.parsing == XML_PARSING);
|
|
|
|
// When accumulating characters in simple content, we expect to
|
|
// see more characters or end element. Seeing start element is
|
|
// possible but means violation of the content model.
|
|
//
|
|
if (p.accumulate_)
|
|
{
|
|
// It would have been easier to throw the exception directly,
|
|
// however, the Expat code is most likely not exception safe.
|
|
//
|
|
p.line_ = XML_GetCurrentLineNumber (p.p_);
|
|
p.column_ = XML_GetCurrentColumnNumber (p.p_);
|
|
XML_StopParser (p.p_, false);
|
|
return;
|
|
}
|
|
|
|
p.event_ = start_element;
|
|
split_name (name, p.qname_);
|
|
|
|
p.line_ = XML_GetCurrentLineNumber (p.p_);
|
|
p.column_ = XML_GetCurrentColumnNumber (p.p_);
|
|
|
|
// Handle attributes.
|
|
//
|
|
if (*atts != 0)
|
|
{
|
|
bool am ((p.feature_ & receive_attributes_map) != 0);
|
|
bool ae ((p.feature_ & receive_attributes_event) != 0);
|
|
|
|
// Provision an entry for this element.
|
|
//
|
|
element_entry* pe (0);
|
|
if (am)
|
|
{
|
|
p.element_state_.push_back (element_entry (p.depth_ + 1));
|
|
pe = &p.element_state_.back ();
|
|
}
|
|
|
|
if (am || ae)
|
|
{
|
|
for (; *atts != 0; atts += 2)
|
|
{
|
|
if (am)
|
|
{
|
|
qname_type qn;
|
|
split_name (*atts, qn);
|
|
attribute_map_type::value_type v (qn, attribute_value_type ());
|
|
v.second.value = *(atts + 1);
|
|
v.second.handled = false;
|
|
pe->attr_map_.insert (v);
|
|
}
|
|
else
|
|
{
|
|
p.attr_.push_back (attribute_type ());
|
|
split_name (*atts, p.attr_.back ().qname);
|
|
p.attr_.back ().value = *(atts + 1);
|
|
}
|
|
}
|
|
|
|
if (am)
|
|
pe->attr_unhandled_ = pe->attr_map_.size ();
|
|
}
|
|
}
|
|
|
|
XML_StopParser (p.p_, true);
|
|
}
|
|
|
|
void XMLCALL parser::
|
|
end_element_ (void* v, const XML_Char* name)
|
|
{
|
|
parser& p (*static_cast<parser*> (v));
|
|
|
|
XML_ParsingStatus ps;
|
|
XML_GetParsingStatus (p.p_, &ps);
|
|
|
|
// Expat has a (mis)-feature of a possibily calling handlers even
|
|
// after the non-resumable XML_StopParser call.
|
|
//
|
|
if (ps.parsing == XML_FINISHED)
|
|
return;
|
|
|
|
// This can be a followup event for empty elements (<foo/>). In this
|
|
// case the element name is already set.
|
|
//
|
|
if (ps.parsing != XML_PARSING)
|
|
p.queue_ = end_element;
|
|
else
|
|
{
|
|
split_name (name, p.qname_);
|
|
|
|
// If we are accumulating characters, then queue this event.
|
|
//
|
|
if (p.accumulate_)
|
|
p.queue_ = end_element;
|
|
else
|
|
{
|
|
p.event_ = end_element;
|
|
|
|
p.line_ = XML_GetCurrentLineNumber (p.p_);
|
|
p.column_ = XML_GetCurrentColumnNumber (p.p_);
|
|
}
|
|
|
|
XML_StopParser (p.p_, true);
|
|
}
|
|
}
|
|
|
|
void XMLCALL parser::
|
|
characters_ (void* v, const XML_Char* s, int n)
|
|
{
|
|
parser& p (*static_cast<parser*> (v));
|
|
|
|
XML_ParsingStatus ps;
|
|
XML_GetParsingStatus (p.p_, &ps);
|
|
|
|
// Expat has a (mis)-feature of a possibily calling handlers even
|
|
// after the non-resumable XML_StopParser call.
|
|
//
|
|
if (ps.parsing == XML_FINISHED)
|
|
return;
|
|
|
|
content_type cont (p.content ());
|
|
|
|
// If this is empty or complex content, see if these are whitespaces.
|
|
//
|
|
switch (cont)
|
|
{
|
|
case content_type::empty:
|
|
case content_type::complex:
|
|
{
|
|
for (int i (0); i != n; ++i)
|
|
{
|
|
char c (s[i]);
|
|
if (c == 0x20 || c == 0x0A || c == 0x0D || c == 0x09)
|
|
continue;
|
|
|
|
// It would have been easier to throw the exception directly,
|
|
// however, the Expat code is most likely not exception safe.
|
|
//
|
|
p.line_ = XML_GetCurrentLineNumber (p.p_);
|
|
p.column_ = XML_GetCurrentColumnNumber (p.p_);
|
|
XML_StopParser (p.p_, false);
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// Append the characters if we are accumulating. This can also be a
|
|
// followup event for another character event. In this case also
|
|
// append the data.
|
|
//
|
|
if (p.accumulate_ || ps.parsing != XML_PARSING)
|
|
{
|
|
assert (p.event_ == characters);
|
|
p.value_.append (s, n);
|
|
}
|
|
else
|
|
{
|
|
p.event_ = characters;
|
|
p.value_.assign (s, n);
|
|
|
|
p.line_ = XML_GetCurrentLineNumber (p.p_);
|
|
p.column_ = XML_GetCurrentColumnNumber (p.p_);
|
|
|
|
// In simple content we need to accumulate all the characters
|
|
// into a single event. To do this we will let the parser run
|
|
// until we reach the end of the element.
|
|
//
|
|
if (cont == content_type::simple)
|
|
p.accumulate_ = true;
|
|
else
|
|
XML_StopParser (p.p_, true);
|
|
}
|
|
}
|
|
|
|
void XMLCALL parser::
|
|
start_namespace_decl_ (void* v, const XML_Char* prefix, const XML_Char* ns)
|
|
{
|
|
parser& p (*static_cast<parser*> (v));
|
|
|
|
XML_ParsingStatus ps;
|
|
XML_GetParsingStatus (p.p_, &ps);
|
|
|
|
// Expat has a (mis)-feature of a possibily calling handlers even
|
|
// after the non-resumable XML_StopParser call.
|
|
//
|
|
if (ps.parsing == XML_FINISHED)
|
|
return;
|
|
|
|
p.start_ns_.push_back (qname_type ());
|
|
p.start_ns_.back ().prefix () = (prefix != 0 ? prefix : "");
|
|
p.start_ns_.back ().namespace_ () = (ns != 0 ? ns : "");
|
|
}
|
|
|
|
void XMLCALL parser::
|
|
end_namespace_decl_ (void* v, const XML_Char* prefix)
|
|
{
|
|
parser& p (*static_cast<parser*> (v));
|
|
|
|
XML_ParsingStatus ps;
|
|
XML_GetParsingStatus (p.p_, &ps);
|
|
|
|
// Expat has a (mis)-feature of a possibily calling handlers even
|
|
// after the non-resumable XML_StopParser call.
|
|
//
|
|
if (ps.parsing == XML_FINISHED)
|
|
return;
|
|
|
|
p.end_ns_.push_back (qname_type ());
|
|
p.end_ns_.back ().prefix () = (prefix != 0 ? prefix : "");
|
|
}
|
|
}
|