generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2025-10-22 08:02:06 +02:00
Code Issues Projects Releases Wiki Activity

Initial adding of XMLStream API based on libstudxml library

Browse Source
This commit is contained in:
Marian Krivos
2015-08-22 16:32:51 +02:00
parent 5e3258f92e
commit 11211d345d
17 changed files with 5531 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
XML/src/QName.cpp Normal file
View File

@@ -0,0 +1,34 @@
// file : cutl/xml/QName.cxx
// copyright : Copyright (c) 2009-2013 Code Synthesis Tools CC
// license : MIT; see accompanying LICENSE file
#include "QName.h"
#include <ostream>
using namespace std;
namespace Poco
{
namespace XML
{
string QName::string() const
{
std::string r;
if (!ns_.empty())
{
r += ns_;
r += '#';
}
r += name_;
return r;
}
ostream& operator<<(ostream& os, const QName& qn)
{
return os << qn.string();
}
}
}

26
XML/src/ValueTraits.cpp Normal file
View File

@@ -0,0 +1,26 @@
// file : cutl/xml/value-traits.cxx
// copyright : Copyright (c) 2009-2013 Code Synthesis Tools CC
// license : MIT; see accompanying LICENSE file
#include "XMLStreamParser.h"
#include "XMLStreamParserException.h"
using namespace std;
namespace Poco
{
namespace XML
{
bool default_value_traits<bool>::parse(string s, const XMLStreamParser& p)
{
if (s == "true" || s == "1" || s == "True" || s == "TRUE")
return true;
else if (s == "false" || s == "0" || s == "False" || s == "FALSE")
return false;
else
throw XMLStreamParserException(p, "invalid bool value '" + s + "'");
}
}
}

882
XML/src/XMLStreamParser.cpp Normal file
View File

@@ -0,0 +1,882 @@
// file : cutl/xml/XMLStreamParser.cxx
// copyright : Copyright (c) 2009-2013 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 "XMLStreamParser.h"
using namespace std;
namespace Poco
{
namespace XML
{
// XMLStreamParser::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, XMLStreamParser::EventType e)
{
return os << parser_event_str[e];
}
// XMLStreamParser
//
XMLStreamParser::~XMLStreamParser()
{
if (p_ != 0)
XML_ParserFree (p_);
}
void XMLStreamParser::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_ATTRIBUTE_MAP) != 0 && (feature_ & RECEIVE_ATTRIBUTES_EVENT) != 0)
feature_ &= ~RECEIVE_ATTRIBUTE_MAP;
// Allocate the XMLStreamParser. 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 XMLStreamParser::handle_error()
{
XML_Error e(XML_GetErrorCode (p_));
if (e == XML_ERROR_ABORTED)
{
// For now we only abort the XMLStreamParser in the characters_() and
// start_element_() handlers.
//
switch (content())
{
case Content::Empty:
throw XMLStreamParserException(*this, "characters in empty content");
case Content::Simple:
throw XMLStreamParserException(*this, "element in simple content");
case Content::Complex:
throw XMLStreamParserException(*this, "characters in complex content");
default:
assert(false);
}
}
else
throw XMLStreamParserException(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_;
};
XMLStreamParser::EventType XMLStreamParser::next()
{
if (state_ == state_next)
return next_(false);
else
{
// If we previously peeked at start/end_element, then adjust
// state accordingly.
//
switch (event_)
{
case EndElement:
{
if (!element_state_.empty() && element_state_.back().depth == depth_)
pop_element();
depth_--;
break;
}
case StartElement:
{
depth_++;
break;
}
default:
break;
}
state_ = state_next;
return event_;
}
}
const string& XMLStreamParser::attribute(const QName& qn) const
{
if (const ElementEntry* e = getElement())
{
AttributeMapType::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 XMLStreamParserException(*this, "attribute '" + qn.string() + "' expected");
}
string XMLStreamParser::attribute(const QName& qn, const string& dv) const
{
if (const ElementEntry* e = getElement())
{
AttributeMapType::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 XMLStreamParser::attributePresent(const QName& qn) const
{
if (const ElementEntry* e = getElement())
{
AttributeMapType::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 XMLStreamParser::nextExpect(EventType e)
{
if (next() != e)
throw XMLStreamParserException(*this, string(parser_event_str[e]) + " expected");
}
void XMLStreamParser::nextExpect(EventType e, const string& ns, const string& n)
{
if (next() != e || namespace_() != ns || name() != n)
throw XMLStreamParserException(*this, string(parser_event_str[e]) + " '" + QName(ns, n).string() + "' expected");
}
string XMLStreamParser::element()
{
content(Content::Simple);
string r;
// The content of the element can be empty in which case there
// will be no characters event.
//
EventType 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 == EndElement);
return r;
}
string XMLStreamParser::element(const QName& qn, const string& dv)
{
if (peek() == StartElement && qname() == qn)
{
next();
return element();
}
return dv;
}
const XMLStreamParser::ElementEntry* XMLStreamParser::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 ElementEntry* r(0);
ElementState::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 XMLStreamParser::pop_element()
{
// Make sure there are no unhandled attributes left.
//
const ElementEntry& e(element_state_.back());
if (e.attr_unhandled_ != 0)
{
// Find the first unhandled attribute and report it.
//
for (AttributeMapType::const_iterator i(e.attr_map_.begin()); i != e.attr_map_.end(); ++i)
{
if (!i->second.handled)
throw XMLStreamParserException(*this, "unexpected attribute '" + i->first.string() + "'");
}
assert(false);
}
element_state_.pop_back();
}
XMLStreamParser::EventType XMLStreamParser::next_(bool peek)
{
EventType 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 EndElement:
{
// 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 StartElement:
{
if (const ElementEntry* e = getElement())
{
switch (e->content)
{
case Content::Empty:
throw XMLStreamParserException(*this, "element in empty content");
case Content::Simple:
throw XMLStreamParserException(*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;
}
XMLStreamParser::EventType XMLStreamParser::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 StartNamespaceDecl:
{
if (++start_ns_i_ == start_ns_.size())
{
start_ns_i_ = 0;
start_ns_.clear();
pqname_ = &qname_;
break; // No more declarations.
}
// Fall through.
}
case StartElement:
{
event_ = StartNamespaceDecl;
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 StartAttribute:
{
event_ = Characters;
pvalue_ = &attr_[attr_i_].value;
return event_;
}
case Characters:
{
event_ = EndAttribute; // Name is already set.
return event_;
}
case EndAttribute:
{
if (++attr_i_ == attr_.size())
{
attr_i_ = 0;
attr_.clear();
pqname_ = &qname_;
pvalue_ = &value_;
break; // No more attributes.
}
// Fall through.
}
case StartElement:
case StartNamespaceDecl:
{
event_ = StartAttribute;
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 EndNamespaceDecl:
{
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_ = EndNamespaceDecl;
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 XMLStreamParser 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 XMLStreamParserException(*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 splitName(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 XMLStreamParser::start_element_(void* v, const XML_Char* name, const XML_Char** atts)
{
XMLStreamParser& p(*static_cast<XMLStreamParser*>(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_ = StartElement;
splitName(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_ATTRIBUTE_MAP) != 0);
bool ae((p.feature_ & RECEIVE_ATTRIBUTES_EVENT) != 0);
// Provision an entry for this element.
//
ElementEntry* pe(0);
if (am)
{
p.element_state_.push_back(ElementEntry(p.depth_ + 1));
pe = &p.element_state_.back();
}
if (am || ae)
{
for (; *atts != 0; atts += 2)
{
if (am)
{
QName qn;
splitName(*atts, qn);
AttributeMapType::value_type v(qn, AttributeValueType());
v.second.value = *(atts + 1);
v.second.handled = false;
pe->attr_map_.insert(v);
}
else
{
p.attr_.push_back(attribute_type());
splitName(*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 XMLStreamParser::end_element_(void* v, const XML_Char* name)
{
XMLStreamParser& p(*static_cast<XMLStreamParser*>(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_ = EndElement;
else
{
splitName(name, p.qname_);
// If we are accumulating characters, then queue this event.
//
if (p.accumulate_)
p.queue_ = EndElement;
else
{
p.event_ = EndElement;
p.line_ = XML_GetCurrentLineNumber(p.p_);
p.column_ = XML_GetCurrentColumnNumber(p.p_);
}
XML_StopParser(p.p_, true);
}
}
void XMLCALL XMLStreamParser::characters_(void* v, const XML_Char* s, int n)
{
XMLStreamParser& p(*static_cast<XMLStreamParser*>(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 cont(p.content());
// If this is empty or complex content, see if these are whitespaces.
//
switch (cont)
{
case Content::Empty:
case Content::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 XMLStreamParser run
// until we reach the end of the element.
//
if (cont == Content::Simple)
p.accumulate_ = true;
else
XML_StopParser(p.p_, true);
}
}
void XMLCALL XMLStreamParser::start_namespace_decl_(void* v, const XML_Char* prefix, const XML_Char* ns)
{
XMLStreamParser& p(*static_cast<XMLStreamParser*>(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());
p.start_ns_.back().prefix() = (prefix != 0 ? prefix : "");
p.start_ns_.back().namespace_() = (ns != 0 ? ns : "");
}
void XMLCALL XMLStreamParser::end_namespace_decl_(void* v, const XML_Char* prefix)
{
XMLStreamParser& p(*static_cast<XMLStreamParser*>(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());
p.end_ns_.back().prefix() = (prefix != 0 ? prefix : "");
}
}
}

54
XML/src/XMLStreamParserException.cpp Normal file
View File

@@ -0,0 +1,54 @@
///
/// \package metamodel
/// \file XMLStreamException.cpp
///
/// \author Marian Krivos <marian.krivos@rsys.sk>
/// \date Aug 21, 2015 - 6:52:24 PM
/// \brief definicia typu
///
/// (C) Copyright 2015 R-SYS,s.r.o
/// All rights reserved.
///
#include "XMLStreamParserException.h"
#include "XMLStreamParser.h"
using namespace std;
namespace Poco
{
namespace XML
{
XMLStreamParserException::~XMLStreamParserException() throw ()
{
}
XMLStreamParserException::XMLStreamParserException(const string& n, Poco::UInt64 l, Poco::UInt64 c, const string& d)
: name_(n), line_(l), column_(c), description_(d)
{
init();
}
XMLStreamParserException::XMLStreamParserException(const XMLStreamParser& p, const std::string& d)
: name_(p.input_name()), line_(p.line()), column_(p.column()), description_(d)
{
init();
}
void XMLStreamParserException::init()
{
std::ostringstream os;
if (!name_.empty())
os << name_ << ':';
os << line_ << ':' << column_ << ": error: " << description_;
what_ = os.str();
}
char const* XMLStreamParserException::what() const throw ()
{
return what_.c_str();
}
} /* namespace XML */
} /* namespace Poco */

191
XML/src/XMLStreamSerializer.cpp Normal file
View File

@@ -0,0 +1,191 @@
// file : xml/XMLStreamSerializer.cxx
// copyright : Copyright (c) 2013-2014 Code Synthesis Tools CC
// license : MIT; see accompanying LICENSE file
#include "XMLStreamSerializer.h"
#include "XMLStreamSerializerException.h"
#include <new> // std::bad_alloc
#include <cstring> // std::strlen
using namespace std;
namespace Poco
{
namespace XML
{
// XMLStreamSerializer
//
extern "C" genxStatus genx_write(void* p, constUtf8 us)
{
// It would have been easier to throw the exception directly,
// however, the Genx code is most likely not exception safe.
//
ostream* os(static_cast<ostream*>(p));
const char* s(reinterpret_cast<const char*>(us));
os->write(s, static_cast<streamsize>(strlen(s)));
return os->good() ? GENX_SUCCESS : GENX_IO_ERROR;
}
extern "C" genxStatus genx_write_bound(void* p, constUtf8 start, constUtf8 end)
{
ostream* os(static_cast<ostream*>(p));
const char* s(reinterpret_cast<const char*>(start));
streamsize n(static_cast<streamsize>(end - start));
os->write(s, n);
return os->good() ? GENX_SUCCESS : GENX_IO_ERROR;
}
extern "C" genxStatus genx_flush(void* p)
{
ostream* os(static_cast<ostream*>(p));
os->flush();
return os->good() ? GENX_SUCCESS : GENX_IO_ERROR;
}
XMLStreamSerializer::~XMLStreamSerializer()
{
if (s_ != 0)
genxDispose (s_);
}
XMLStreamSerializer::XMLStreamSerializer(ostream& os, const string& oname, unsigned short ind)
: os_(os), os_state_(os.exceptions()), oname_(oname), depth_(0)
{
// Temporarily disable exceptions on the stream.
//
os_.exceptions(ostream::goodbit);
// Allocate the XMLStreamSerializer. Make sure nothing else can throw after
// this call since otherwise we will leak it.
//
s_ = genxNew(0, 0, 0);
if (s_ == 0)
throw bad_alloc();
genxSetUserData(s_, &os_);
if (ind != 0)
genxSetPrettyPrint(s_, ind);
sender_.send = &genx_write;
sender_.sendBounded = &genx_write_bound;
sender_.flush = &genx_flush;
if (genxStatus e = genxStartDocSender(s_, &sender_))
{
string m(genxGetErrorMessage(s_, e));
genxDispose (s_);
throw XMLStreamSerializerException(oname, m);
}
}
void XMLStreamSerializer::handleError(genxStatus e)
{
switch (e)
{
case GENX_ALLOC_FAILED:
throw bad_alloc();
case GENX_IO_ERROR:
// Restoring the original exception state should trigger the
// exception. If it doesn't (e.g., because the user didn't
// configure the stream to throw), then fall back to the
// serialiation exception.
//
os_.exceptions(os_state_);
// Fall through.
default:
throw XMLStreamSerializerException(oname_, genxGetErrorMessage(s_, e));
}
}
void XMLStreamSerializer::startElement(const string& ns, const string& name)
{
if (genxStatus e = genxStartElementLiteral(s_, reinterpret_cast<constUtf8>(ns.empty() ? 0 : ns.c_str()), reinterpret_cast<constUtf8>(name.c_str())))
handleError(e);
depth_++;
}
void XMLStreamSerializer::endElement()
{
if (genxStatus e = genxEndElement(s_))
handleError(e);
// Call EndDocument() if we are past the root element.
//
if (--depth_ == 0)
{
if (genxStatus e = genxEndDocument(s_))
handleError(e);
// Also restore the original exception state on the stream.
//
os_.exceptions(os_state_);
}
}
void XMLStreamSerializer::element(const string& ns, const string& n, const string& v)
{
startElement(ns, n);
element(v);
}
void XMLStreamSerializer::startAttribute(const string& ns, const string& name)
{
if (genxStatus e = genxStartAttributeLiteral(s_, reinterpret_cast<constUtf8>(ns.empty() ? 0 : ns.c_str()), reinterpret_cast<constUtf8>(name.c_str())))
handleError(e);
}
void XMLStreamSerializer::endAttribute()
{
if (genxStatus e = genxEndAttribute(s_))
handleError(e);
}
void XMLStreamSerializer::attribute(const string& ns, const string& name, const string& value)
{
if (genxStatus e = genxAddAttributeLiteral(s_, reinterpret_cast<constUtf8>(ns.empty() ? 0 : ns.c_str()), reinterpret_cast<constUtf8>(name.c_str()),
reinterpret_cast<constUtf8>(value.c_str())))
handleError(e);
}
void XMLStreamSerializer::characters(const string& value)
{
if (genxStatus e = genxAddCountedText(s_, reinterpret_cast<constUtf8>(value.c_str()), value.size()))
handleError(e);
}
void XMLStreamSerializer::namespaceDecl(const string& ns, const string& p)
{
if (genxStatus e =
ns.empty() && p.empty() ?
genxUnsetDefaultNamespace(s_) :
genxAddNamespaceLiteral(s_, reinterpret_cast<constUtf8>(ns.c_str()), reinterpret_cast<constUtf8>(p.c_str())))
handleError(e);
}
void XMLStreamSerializer::xmlDecl(const string& ver, const string& enc, const string& stl)
{
if (genxStatus e = genxXmlDeclaration(s_, reinterpret_cast<constUtf8>(ver.c_str()), (enc.empty() ? 0 : reinterpret_cast<constUtf8>(enc.c_str())),
(stl.empty() ? 0 : reinterpret_cast<constUtf8>(stl.c_str()))))
handleError(e);
}
bool XMLStreamSerializer::lookupNamespacePrefix(const string& ns, string& p)
{
// Currently Genx will create a namespace mapping if one doesn't
// already exist.
//
genxStatus e;
genxNamespace gns(genxDeclareNamespace(s_, reinterpret_cast<constUtf8>(ns.c_str()), 0, &e));
if (e != GENX_SUCCESS)
handleError(e);
p = reinterpret_cast<const char*>(genxGetNamespacePrefix(gns));
return true;
}
}
}

59
XML/src/XMLStreamSerializerException.cpp Normal file
View File

@@ -0,0 +1,59 @@
///
/// \package metamodel
/// \file XMLStreamException.cpp
///
/// \author Marian Krivos <marian.krivos@rsys.sk>
/// \date Aug 21, 2015 - 6:52:24 PM
/// \brief definicia typu
///
/// (C) Copyright 2015 R-SYS,s.r.o
/// All rights reserved.
///
#include "XMLStreamParserException.h"
#include "XMLStreamSerializer.h"
using namespace std;
namespace Poco
{
namespace XML
{
// XMLStreamSerializerException
//
XMLStreamSerializerException::~XMLStreamSerializerException() throw ()
{
}
XMLStreamSerializerException::XMLStreamSerializerException(const string& n, const string& d)
: name_(n), description_(d)
{
init();
}
XMLStreamSerializerException::XMLStreamSerializerException(const XMLStreamSerializer& s, const std::string& d)
: name_(s.outputName()), description_(d)
{
init();
}
void XMLStreamSerializerException::init()
{
if (!name_.empty())
{
what_ += name_;
what_ += ": ";
}
what_ += "error: ";
what_ += description_;
}
char const* XMLStreamSerializerException::what() const throw ()
{
return what_.c_str();
}
} /* namespace XML */
} /* namespace Poco */

394
XML/src/char-props.c Normal file
View File

@@ -0,0 +1,394 @@
/*
* Copyright (c) 2007-2013 Code Synthesis Tools CC.
* Copyright (c) 2004 by Tim Bray and Sun Microsystems.
*
* For copying permission, see the accompanying COPYING file.
*/
/*
* Construct character-properties tables for genx.
* Quite likely there's a better way.
* This version is generated semi-automatically from the source code of the
* XML specification via emacs global replace and keyboard macros
*/
#include "genx.h"
static void charProp(char * p, int c, int prop)
{
p[c] |= prop;
}
static void rangeProp(char * p, size_t start, size_t end, int prop)
{
size_t i;
for (i = start; i <= end; i++)
p[i] |= prop;
}
void genxSetCharProps(char * p)
{
size_t i;
for (i = 0; i < GENX_CHAR_TABLE_SIZE; i++)
p[i] = 0;
/* per XML 1.0 */
charProp(p, 0x9, GENX_XML_CHAR);
charProp(p, 0xa, GENX_XML_CHAR);
charProp(p, 0xd, GENX_XML_CHAR);
rangeProp(p, 0x20, 0xff, GENX_XML_CHAR);
#if GENX_CHAR_TABLE_SIZE == 0x10000
rangeProp(p, 0x0100, 0xd7ff, GENX_XML_CHAR);
rangeProp(p, 0xe000, 0xfffd, GENX_XML_CHAR);
#endif
/* Letter ::= BaseChar | Ideographic */
rangeProp(p, 0x0041, 0x005A, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0061, 0x007A, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x00C0, 0x00D6, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x00D8, 0x00F6, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x00F8, 0x00FF, GENX_LETTER|GENX_NAMECHAR);
#if GENX_CHAR_TABLE_SIZE == 0x10000
rangeProp(p, 0x0100, 0x0131, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0134, 0x013E, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0141, 0x0148, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x014A, 0x017E, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0180, 0x01C3, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x01CD, 0x01F0, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x01F4, 0x01F5, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x01FA, 0x0217, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0250, 0x02A8, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x02BB, 0x02C1, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0386, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0388, 0x038A, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x038C, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x038E, 0x03A1, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x03A3, 0x03CE, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x03D0, 0x03D6, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x03DA, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x03DC, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x03DE, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x03E0, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x03E2, 0x03F3, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0401, 0x040C, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x040E, 0x044F, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0451, 0x045C, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x045E, 0x0481, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0490, 0x04C4, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x04C7, 0x04C8, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x04CB, 0x04CC, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x04D0, 0x04EB, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x04EE, 0x04F5, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x04F8, 0x04F9, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0531, 0x0556, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0559, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0561, 0x0586, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x05D0, 0x05EA, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x05F0, 0x05F2, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0621, 0x063A, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0641, 0x064A, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0671, 0x06B7, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x06BA, 0x06BE, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x06C0, 0x06CE, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x06D0, 0x06D3, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x06D5, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x06E5, 0x06E6, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0905, 0x0939, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x093D, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0958, 0x0961, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0985, 0x098C, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x098F, 0x0990, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0993, 0x09A8, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x09AA, 0x09B0, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x09B2, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x09B6, 0x09B9, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x09DC, 0x09DD, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x09DF, 0x09E1, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x09F0, 0x09F1, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0A05, 0x0A0A, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0A0F, 0x0A10, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0A13, 0x0A28, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0A2A, 0x0A30, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0A32, 0x0A33, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0A35, 0x0A36, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0A38, 0x0A39, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0A59, 0x0A5C, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0A5E, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0A72, 0x0A74, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0A85, 0x0A8B, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0A8D, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0A8F, 0x0A91, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0A93, 0x0AA8, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0AAA, 0x0AB0, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0AB2, 0x0AB3, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0AB5, 0x0AB9, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0ABD, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0AE0, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0B05, 0x0B0C, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0B0F, 0x0B10, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0B13, 0x0B28, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0B2A, 0x0B30, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0B32, 0x0B33, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0B36, 0x0B39, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0B3D, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0B5C, 0x0B5D, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0B5F, 0x0B61, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0B85, 0x0B8A, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0B8E, 0x0B90, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0B92, 0x0B95, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0B99, 0x0B9A, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0B9C, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0B9E, 0x0B9F, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0BA3, 0x0BA4, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0BA8, 0x0BAA, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0BAE, 0x0BB5, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0BB7, 0x0BB9, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0C05, 0x0C0C, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0C0E, 0x0C10, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0C12, 0x0C28, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0C2A, 0x0C33, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0C35, 0x0C39, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0C60, 0x0C61, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0C85, 0x0C8C, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0C8E, 0x0C90, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0C92, 0x0CA8, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0CAA, 0x0CB3, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0CB5, 0x0CB9, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0CDE, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0CE0, 0x0CE1, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0D05, 0x0D0C, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0D0E, 0x0D10, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0D12, 0x0D28, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0D2A, 0x0D39, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0D60, 0x0D61, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0E01, 0x0E2E, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0E30, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0E32, 0x0E33, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0E40, 0x0E45, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0E81, 0x0E82, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0E84, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0E87, 0x0E88, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0E8A, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0E8D, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0E94, 0x0E97, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0E99, 0x0E9F, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0EA1, 0x0EA3, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0EA5, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0EA7, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0EAA, 0x0EAB, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0EAD, 0x0EAE, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0EB0, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0EB2, 0x0EB3, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0EBD, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0EC0, 0x0EC4, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0F40, 0x0F47, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0F49, 0x0F69, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x10A0, 0x10C5, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x10D0, 0x10F6, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x1100, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1102, 0x1103, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1105, 0x1107, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x1109, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x110B, 0x110C, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x110E, 0x1112, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x113C, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x113E, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x1140, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x114C, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x114E, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x1150, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1154, 0x1155, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x1159, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x115F, 0x1161, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x1163, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x1165, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x1167, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x1169, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x116D, 0x116E, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1172, 0x1173, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x1175, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x119E, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x11A8, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x11AB, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x11AE, 0x11AF, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x11B7, 0x11B8, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x11BA, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x11BC, 0x11C2, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x11EB, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x11F0, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x11F9, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1E00, 0x1E9B, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1EA0, 0x1EF9, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1F00, 0x1F15, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1F18, 0x1F1D, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1F20, 0x1F45, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1F48, 0x1F4D, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1F50, 0x1F57, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x1F59, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x1F5B, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x1F5D, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1F5F, 0x1F7D, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1F80, 0x1FB4, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1FB6, 0x1FBC, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x1FBE, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1FC2, 0x1FC4, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1FC6, 0x1FCC, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1FD0, 0x1FD3, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1FD6, 0x1FDB, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1FE0, 0x1FEC, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1FF2, 0x1FF4, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x1FF6, 0x1FFC, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x2126, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x212A, 0x212B, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x212E, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x2180, 0x2182, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x3041, 0x3094, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x30A1, 0x30FA, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x3105, 0x312C, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0xAC00, 0xD7A3, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x4E00, 0x9FA5, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x3007, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x3021, 0x3029, GENX_LETTER|GENX_NAMECHAR);
#endif /* GENX_CHAR_TABLE_SIZE == 0x10000 */
/*
* NameChar ::=
* Letter | Digit | '.' | '-' | '_' | ':' | CombiningChar | Extender
*/
charProp(p, '.', GENX_NAMECHAR);
charProp(p, '-', GENX_NAMECHAR);
charProp(p, '_', GENX_NAMECHAR);
rangeProp(p, 0x0030, 0x0039, GENX_NAMECHAR);
charProp(p, 0x00B7, GENX_LETTER|GENX_NAMECHAR);
#if GENX_CHAR_TABLE_SIZE == 0x10000
rangeProp(p, 0x0660, 0x0669, GENX_NAMECHAR);
rangeProp(p, 0x06F0, 0x06F9, GENX_NAMECHAR);
rangeProp(p, 0x0966, 0x096F, GENX_NAMECHAR);
rangeProp(p, 0x09E6, 0x09EF, GENX_NAMECHAR);
rangeProp(p, 0x0A66, 0x0A6F, GENX_NAMECHAR);
rangeProp(p, 0x0AE6, 0x0AEF, GENX_NAMECHAR);
rangeProp(p, 0x0B66, 0x0B6F, GENX_NAMECHAR);
rangeProp(p, 0x0BE7, 0x0BEF, GENX_NAMECHAR);
rangeProp(p, 0x0C66, 0x0C6F, GENX_NAMECHAR);
rangeProp(p, 0x0CE6, 0x0CEF, GENX_NAMECHAR);
rangeProp(p, 0x0D66, 0x0D6F, GENX_NAMECHAR);
rangeProp(p, 0x0E50, 0x0E59, GENX_NAMECHAR);
rangeProp(p, 0x0ED0, 0x0ED9, GENX_NAMECHAR);
rangeProp(p, 0x0F20, 0x0F29, GENX_NAMECHAR);
rangeProp(p, 0x0300, 0x0345, GENX_NAMECHAR);
rangeProp(p, 0x0360, 0x0361, GENX_NAMECHAR);
rangeProp(p, 0x0483, 0x0486, GENX_NAMECHAR);
rangeProp(p, 0x0591, 0x05A1, GENX_NAMECHAR);
rangeProp(p, 0x05A3, 0x05B9, GENX_NAMECHAR);
rangeProp(p, 0x05BB, 0x05BD, GENX_NAMECHAR);
charProp(p, 0x05BF, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x05C1, 0x05C2, GENX_NAMECHAR);
charProp(p, 0x05C4, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x064B, 0x0652, GENX_NAMECHAR);
charProp(p, 0x0670, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x06D6, 0x06DC, GENX_NAMECHAR);
rangeProp(p, 0x06DD, 0x06DF, GENX_NAMECHAR);
rangeProp(p, 0x06E0, 0x06E4, GENX_NAMECHAR);
rangeProp(p, 0x06E7, 0x06E8, GENX_NAMECHAR);
rangeProp(p, 0x06EA, 0x06ED, GENX_NAMECHAR);
rangeProp(p, 0x0901, 0x0903, GENX_NAMECHAR);
charProp(p, 0x093C, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x093E, 0x094C, GENX_NAMECHAR);
charProp(p, 0x094D, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0951, 0x0954, GENX_NAMECHAR);
rangeProp(p, 0x0962, 0x0963, GENX_NAMECHAR);
rangeProp(p, 0x0981, 0x0983, GENX_NAMECHAR);
charProp(p, 0x09BC, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x09BE, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x09BF, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x09C0, 0x09C4, GENX_NAMECHAR);
rangeProp(p, 0x09C7, 0x09C8, GENX_NAMECHAR);
rangeProp(p, 0x09CB, 0x09CD, GENX_NAMECHAR);
charProp(p, 0x09D7, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x09E2, 0x09E3, GENX_NAMECHAR);
charProp(p, 0x0A02, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0A3C, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0A3E, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0A3F, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0A40, 0x0A42, GENX_NAMECHAR);
rangeProp(p, 0x0A47, 0x0A48, GENX_NAMECHAR);
rangeProp(p, 0x0A4B, 0x0A4D, GENX_NAMECHAR);
rangeProp(p, 0x0A70, 0x0A71, GENX_NAMECHAR);
rangeProp(p, 0x0A81, 0x0A83, GENX_NAMECHAR);
charProp(p, 0x0ABC, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0ABE, 0x0AC5, GENX_NAMECHAR);
rangeProp(p, 0x0AC7, 0x0AC9, GENX_NAMECHAR);
rangeProp(p, 0x0ACB, 0x0ACD, GENX_NAMECHAR);
rangeProp(p, 0x0B01, 0x0B03, GENX_NAMECHAR);
charProp(p, 0x0B3C, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0B3E, 0x0B43, GENX_NAMECHAR);
rangeProp(p, 0x0B47, 0x0B48, GENX_NAMECHAR);
rangeProp(p, 0x0B4B, 0x0B4D, GENX_NAMECHAR);
rangeProp(p, 0x0B56, 0x0B57, GENX_NAMECHAR);
rangeProp(p, 0x0B82, 0x0B83, GENX_NAMECHAR);
rangeProp(p, 0x0BBE, 0x0BC2, GENX_NAMECHAR);
rangeProp(p, 0x0BC6, 0x0BC8, GENX_NAMECHAR);
rangeProp(p, 0x0BCA, 0x0BCD, GENX_NAMECHAR);
charProp(p, 0x0BD7, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0C01, 0x0C03, GENX_NAMECHAR);
rangeProp(p, 0x0C3E, 0x0C44, GENX_NAMECHAR);
rangeProp(p, 0x0C46, 0x0C48, GENX_NAMECHAR);
rangeProp(p, 0x0C4A, 0x0C4D, GENX_NAMECHAR);
rangeProp(p, 0x0C55, 0x0C56, GENX_NAMECHAR);
rangeProp(p, 0x0C82, 0x0C83, GENX_NAMECHAR);
rangeProp(p, 0x0CBE, 0x0CC4, GENX_NAMECHAR);
rangeProp(p, 0x0CC6, 0x0CC8, GENX_NAMECHAR);
rangeProp(p, 0x0CCA, 0x0CCD, GENX_NAMECHAR);
rangeProp(p, 0x0CD5, 0x0CD6, GENX_NAMECHAR);
rangeProp(p, 0x0D02, 0x0D03, GENX_NAMECHAR);
rangeProp(p, 0x0D3E, 0x0D43, GENX_NAMECHAR);
rangeProp(p, 0x0D46, 0x0D48, GENX_NAMECHAR);
rangeProp(p, 0x0D4A, 0x0D4D, GENX_NAMECHAR);
charProp(p, 0x0D57, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0E31, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0E34, 0x0E3A, GENX_NAMECHAR);
rangeProp(p, 0x0E47, 0x0E4E, GENX_NAMECHAR);
charProp(p, 0x0EB1, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0EB4, 0x0EB9, GENX_NAMECHAR);
rangeProp(p, 0x0EBB, 0x0EBC, GENX_NAMECHAR);
rangeProp(p, 0x0EC8, 0x0ECD, GENX_NAMECHAR);
rangeProp(p, 0x0F18, 0x0F19, GENX_NAMECHAR);
charProp(p, 0x0F35, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0F37, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0F39, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0F3E, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0F3F, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0F71, 0x0F84, GENX_NAMECHAR);
rangeProp(p, 0x0F86, 0x0F8B, GENX_NAMECHAR);
rangeProp(p, 0x0F90, 0x0F95, GENX_NAMECHAR);
charProp(p, 0x0F97, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x0F99, 0x0FAD, GENX_NAMECHAR);
rangeProp(p, 0x0FB1, 0x0FB7, GENX_NAMECHAR);
charProp(p, 0x0FB9, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x20D0, 0x20DC, GENX_NAMECHAR);
charProp(p, 0x20E1, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x302A, 0x302F, GENX_NAMECHAR);
charProp(p, 0x3099, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x309A, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x02D0, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x02D1, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0387, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0640, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0E46, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x0EC6, GENX_LETTER|GENX_NAMECHAR);
charProp(p, 0x3005, GENX_LETTER|GENX_NAMECHAR);
rangeProp(p, 0x3031, 0x3035, GENX_NAMECHAR);
rangeProp(p, 0x309D, 0x309E, GENX_NAMECHAR);
rangeProp(p, 0x30FC, 0x30FE, GENX_NAMECHAR);
#endif /* GENX_CHAR_TABLE_SIZE == 0x10000 */
}

2328
XML/src/genx.c Normal file
View File

File diff suppressed because it is too large Load Diff

343
XML/src/genx.h Normal file
View File

@@ -0,0 +1,343 @@
/*
* genx - C-callable library for generating XML documents
*/
/*
* Copyright (c) 2007-2013 Code Synthesis Tools CC.
* Copyright (c) 2004 by Tim Bray and Sun Microsystems.
*
* For copying permission, see the accompanying COPYING file.
*/
#ifndef GENX_H
#define GENX_H
#include <stddef.h> /* size_t */
#ifdef __cplusplus
extern "C" {
#endif
/*
* Note on error handling: genx routines mostly return
* GENX_SUCCESS (guaranteed to be zero) in normal circumstances, one of
* these other GENX_ values on a memory allocation or I/O failure or if the
* call would result in non-well-formed output.
* You can associate an error message with one of these codes explicitly
* or with the most recent error using genxGetErrorMessage() and
* genxLastErrorMessage(); see below.
*/
typedef enum
{
GENX_SUCCESS = 0,
GENX_BAD_UTF8,
GENX_NON_XML_CHARACTER,
GENX_BAD_NAME,
GENX_ALLOC_FAILED,
GENX_BAD_NAMESPACE_NAME,
GENX_INTERNAL_ERROR,
GENX_DUPLICATE_PREFIX,
GENX_SEQUENCE_ERROR,
GENX_NO_START_TAG,
GENX_IO_ERROR,
GENX_MISSING_VALUE,
GENX_MALFORMED_COMMENT,
GENX_XML_PI_TARGET,
GENX_MALFORMED_PI,
GENX_DUPLICATE_ATTRIBUTE,
GENX_ATTRIBUTE_IN_DEFAULT_NAMESPACE,
GENX_DUPLICATE_NAMESPACE,
GENX_BAD_DEFAULT_DECLARATION
} genxStatus;
/* character types */
#define GENX_XML_CHAR 1
#define GENX_LETTER 2
#define GENX_NAMECHAR 4
/* The size of the character table. Valid values are 0x100 (first 255
chars are checked) and 0x10000 (all chars are checked). */
#ifndef GENX_CHAR_TABLE_SIZE
# define GENX_CHAR_TABLE_SIZE 0x100
#endif
/* a UTF-8 string */
typedef unsigned char * utf8;
typedef const unsigned char * constUtf8;
/*
* genx's own types
*/
typedef struct genxWriter_rec * genxWriter;
typedef struct genxNamespace_rec * genxNamespace;
typedef struct genxElement_rec * genxElement;
typedef struct genxAttribute_rec * genxAttribute;
typedef void * (*genxAlloc) (void * userData, size_t bytes);
typedef void (*genxDealloc) (void * userData, void* data);
/*
* Constructors, set/get
*/
/*
* Create a new writer. For generating multiple XML documents, it's most
* efficient to re-use the same genx object. However, you can only write
* one document at a time with a writer.
* Returns NULL if it fails, which can only be due to an allocation failure.
*/
genxWriter genxNew(genxAlloc alloc, genxDealloc dealloc, void * userData);
/*
* Reset the writer object back into usable state after an error or
* interruption.
*/
genxStatus genxReset (genxWriter w);
/*
* Dispose of a writer, freeing all associated memory
*/
void genxDispose(genxWriter w);
/*
* Set/get
*/
/*
* The userdata pointer will be passed to memory-allocation
* and I/O callbacks. If not set, genx will pass NULL
*/
void genxSetUserData(genxWriter w, void * userData);
void * genxGetUserData(genxWriter w);
/*
* Set/get pretty-printing. If indentation is set to 0, then no pretty-
* printing is performed.
*/
genxStatus genxSetPrettyPrint(genxWriter w, int indentation);
int genxGetPrettyPrint(genxWriter w);
/*
* Set/get canonicalization. If true, then output explicit closing
* tags and sort attributes. Default is false.
*/
genxStatus genxSetCanonical(genxWriter w, int flag);
int genxGetCanonical(genxWriter w);
/*
* User-provided memory allocator, if desired. For example, if you were
* in an Apache module, you could arrange for genx to use ap_palloc by
* making the pool accessible via the userData call.
* The "dealloc" is to be used to free memory allocated with "alloc". If
* alloc is provided but dealloc is NULL, genx will not attempt to free
* the memory; this would be appropriate in an Apache context.
* If "alloc" is not provided, genx routines use malloc() to allocate memory
*/
void genxSetAlloc(genxWriter w, genxAlloc alloc);
void genxSetDealloc(genxWriter w, genxDealloc dealloc);
genxAlloc genxGetAlloc(genxWriter w);
genxDealloc genxGetDealloc(genxWriter w);
/*
* Get the prefix associated with a namespace
*/
utf8 genxGetNamespacePrefix(genxNamespace ns);
/*
* Declaration functions
*/
/*
* Declare a namespace. The provided prefix is the default but can be
* overridden by genxAddNamespace. If no default prefiix is provided,
* genx will generate one of the form g-%d.
* On error, returns NULL and signals via statusp
*/
genxNamespace genxDeclareNamespace(genxWriter w,
constUtf8 uri, constUtf8 prefix,
genxStatus * statusP);
/*
* Declare an element
* If something failed, returns NULL and sets the status code via statusP
*/
genxElement genxDeclareElement(genxWriter w,
genxNamespace ns, constUtf8 type,
genxStatus * statusP);
/*
* Declare an attribute
*/
genxAttribute genxDeclareAttribute(genxWriter w,
genxNamespace ns,
constUtf8 name, genxStatus * statusP);
/*
* Writing XML
*/
/*
* Caller-provided I/O package.
* First form is for a null-terminated string.
* for second, if you have s="abcdef" and want to send "abc", you'd call
* sendBounded(userData, s, s + 3)
*/
typedef struct
{
genxStatus (* send)(void * userData, constUtf8 s);
genxStatus (* sendBounded)(void * userData, constUtf8 start, constUtf8 end);
genxStatus (* flush)(void * userData);
} genxSender;
genxStatus genxStartDocSender(genxWriter w, genxSender * sender);
/*
* End a document. Calls "flush"
*/
genxStatus genxEndDocument(genxWriter w);
/*
* Write XML declaration. If encoding or standalone are NULL, then those
* attributes are omitted.
*/
genxStatus genxXmlDeclaration(genxWriter w,
constUtf8 version,
constUtf8 encoding,
constUtf8 standalone);
/*
* Write a comment
*/
genxStatus genxComment(genxWriter w, constUtf8 text);
/*
* Write a PI
*/
genxStatus genxPI(genxWriter w, constUtf8 target, constUtf8 text);
/*
* Start an element
*/
genxStatus genxStartElementLiteral(genxWriter w,
constUtf8 xmlns, constUtf8 type);
/*
* Start a predeclared element
* - element must have been declared
*/
genxStatus genxStartElement(genxElement e);
/*
* Write an attribute
*/
genxStatus genxAddAttributeLiteral(genxWriter w, constUtf8 xmlns,
constUtf8 name, constUtf8 value);
/*
* Start an attribute
*/
genxStatus genxStartAttributeLiteral(genxWriter w,
constUtf8 xmlns, constUtf8 name);
/*
* Write a predeclared attribute
*/
genxStatus genxAddAttribute(genxAttribute a, constUtf8 value);
/*
* Start a predeclared attribute
*/
genxStatus genxStartAttribute(genxAttribute a);
/*
* End an attribute
*/
genxStatus genxEndAttribute(genxWriter w);
/*
* add a namespace declaration
*/
genxStatus genxAddNamespaceLiteral(genxWriter w,
constUtf8 uri, constUtf8 prefix);
/*
* add a predefined namespace declaration
*/
genxStatus genxAddNamespace(genxNamespace ns, constUtf8 prefix);
/*
* Clear default namespace declaration
*/
genxStatus genxUnsetDefaultNamespace(genxWriter w);
/*
* Write an end tag
*/
genxStatus genxEndElement(genxWriter w);
/*
* Write some text
* You can't write any text outside the root element, except with
* genxComment and genxPI.
*/
genxStatus genxAddText(genxWriter w, constUtf8 start);
genxStatus genxAddCountedText(genxWriter w, constUtf8 start, size_t byteCount);
genxStatus genxAddBoundedText(genxWriter w, constUtf8 start, constUtf8 end);
/*
* Write one character. The integer value is the Unicode character
* value, as usually expressed in U+XXXX notation.
*/
genxStatus genxAddCharacter(genxWriter w, int c);
/*
* Utility routines
*/
/*
* Return the Unicode character encoded by the UTF-8 pointed-to by the
* argument, and advance the argument past the encoding of the character.
* Returns -1 if the UTF-8 is malformed, in which case advances the
* argument to point at the first byte past the point past the malformed
* ones.
*/
int genxNextUnicodeChar(constUtf8 * sp);
/*
* Scan a buffer allegedly full of UTF-8 encoded XML characters; return
* one of GENX_SUCCESS, GENX_BAD_UTF8, or GENX_NON_XML_CHARACTER
*/
genxStatus genxCheckText(genxWriter w, constUtf8 s);
/*
* return character status, the OR of GENX_XML_CHAR,
* GENX_LETTER, and GENX_NAMECHAR
*/
int genxCharClass(genxWriter w, int c);
/*
* Silently wipe any non-XML characters out of a chunk of text.
* If you call this on a string before you pass it addText or
* addAttribute, you will never get an error from genx unless
* (a) there's a bug in your software, e.g. a malformed element name, or
* (b) there's a memory allocation or I/O error
* The output can never be longer than the input.
* Returns true if any changes were made.
*/
int genxScrubText(genxWriter w, constUtf8 in, utf8 out);
/*
* return error messages
*/
char * genxGetErrorMessage(genxWriter w, genxStatus status);
char * genxLastErrorMessage(genxWriter w);
/*
* return version
*/
char * genxGetVersion();
#ifdef __cplusplus
}
#endif
#endif /* GENX_H */