mirror of
https://github.com/jezhiggins/arabica
synced 2024-12-29 22:23:27 +01:00
395 lines
11 KiB
C++
395 lines
11 KiB
C++
#ifndef ARABICA_XSLT_OUTPUT_HPP
|
|
#define ARABICA_XSLT_OUTPUT_HPP
|
|
|
|
#include <XML/escaper.hpp>
|
|
#include <SAX/ext/LexicalHandler.hpp>
|
|
#include "xslt_namespace_stack.hpp"
|
|
#include "xslt_qname.hpp"
|
|
#include "handler/xslt_constants.hpp"
|
|
|
|
namespace Arabica
|
|
{
|
|
namespace XSLT
|
|
{
|
|
|
|
template<class string_type, class string_adaptor>
|
|
class Output
|
|
{
|
|
typedef StylesheetConstant<string_type, string_adaptor> SC;
|
|
public:
|
|
typedef std::map<string_type, string_type> Settings;
|
|
typedef std::set<QName<string_type, string_adaptor> > CDATAElements;
|
|
|
|
protected:
|
|
Output() :
|
|
buffering_(0),
|
|
pending_element_(false),
|
|
pending_text_(false),
|
|
pending_attribute_(-1),
|
|
text_mode_(false),
|
|
warning_sink_(0)
|
|
{
|
|
} // Output
|
|
~Output()
|
|
{
|
|
} // ~Output
|
|
|
|
public:
|
|
void start_document(const Settings& settings, const CDATAElements& cdataElements)
|
|
{
|
|
typename Settings::const_iterator method = settings.find(SC::method);
|
|
text_mode_ = (method != settings.end() && method->second == SC::text);
|
|
if(text_mode_)
|
|
do_disableOutputEscaping(true);
|
|
|
|
cdataElements_ = cdataElements;
|
|
do_start_document(settings);
|
|
} // start_document
|
|
|
|
void end_document()
|
|
{
|
|
do_end_document();
|
|
} // end_document
|
|
|
|
bool start_element(const string_type& qName, const string_type& namespaceURI)
|
|
{
|
|
QName<string_type, string_adaptor> en = QName<string_type, string_adaptor>::create(qName, namespaceURI);
|
|
return start_element(en.prefix, en.localName, en.namespaceURI);
|
|
} // start_element
|
|
|
|
bool start_element(const string_type& prefix, const string_type& localName, const string_type& namespaceURI)
|
|
{
|
|
if(is_buffering())
|
|
return false;
|
|
|
|
flush_current();
|
|
|
|
namespaceStack_.pushScope();
|
|
if(!string_adaptor::empty(namespaceURI))
|
|
namespaceStack_.declareNamespace(prefix, namespaceURI);
|
|
|
|
string_type mapped_prefix = namespaceStack_.findPrefix(namespaceURI);
|
|
|
|
element_stack_.push(QName<string_type, string_adaptor>(mapped_prefix, localName, namespaceURI));
|
|
|
|
atts_.clear();
|
|
pending_element_ = true;
|
|
|
|
namespaceStack_.pushScope();
|
|
return true;
|
|
} // start_element
|
|
|
|
void end_element(const string_type& qName, const string_type& namespaceURI)
|
|
{
|
|
QName<string_type, string_adaptor> en = QName<string_type, string_adaptor>::create(qName, namespaceURI);
|
|
end_element(en.prefix, en.localName, en.namespaceURI);
|
|
} // end_element
|
|
|
|
void end_element(const string_type& /* prefix */, const string_type& localName, const string_type& namespaceURI)
|
|
{
|
|
if(pop_if_buffering())
|
|
return;
|
|
|
|
flush_current();
|
|
|
|
if(!text_mode_)
|
|
{
|
|
string_type mapped_prefix = namespaceStack_.findPrefix(namespaceURI);
|
|
do_end_element((!string_adaptor::empty(mapped_prefix)) ? makeName(mapped_prefix, localName) : localName, namespaceURI);
|
|
element_stack_.pop();
|
|
} // end_element
|
|
|
|
namespaceStack_.popScope();
|
|
} // end_element
|
|
|
|
string_type makeName(const string_type& prefix, const string_type& localName) const
|
|
{
|
|
string_type n = prefix;
|
|
string_adaptor::append(n, SC::COLON);
|
|
string_adaptor::append(n, localName);
|
|
return n;
|
|
} // makeName
|
|
|
|
void start_attribute(const string_type& qName, const string_type& namespaceURI)
|
|
{
|
|
QName<string_type, string_adaptor> qn = QName<string_type, string_adaptor>::create(qName, namespaceURI);
|
|
start_attribute(qn.prefix, qn.localName, qn.namespaceURI);
|
|
} // start_attribute
|
|
|
|
void start_attribute(const string_type& prefix, const string_type& localName, const string_type& namespaceURI)
|
|
{
|
|
if(push_buffering())
|
|
return;
|
|
|
|
if(!pending_element_)
|
|
{
|
|
warning(string_adaptor::construct_from_utf8("WARNING: Cannot write attribute, no open element"));
|
|
return;
|
|
} // if ...
|
|
|
|
if(!string_adaptor::empty(namespaceURI))
|
|
namespaceStack_.declareNamespace(prefix, namespaceURI, true);
|
|
|
|
string_type mapped_prefix = namespaceStack_.findPrefix(namespaceURI);
|
|
string_type qName = (!string_adaptor::empty(mapped_prefix)) ? makeName(mapped_prefix, localName) : localName;
|
|
|
|
atts_.addOrReplaceAttribute(namespaceURI,
|
|
localName,
|
|
qName,
|
|
string_adaptor::empty_string(),
|
|
string_adaptor::empty_string());
|
|
pending_attribute_ = atts_.getIndex(qName);
|
|
} // start_attribute
|
|
|
|
void end_attribute()
|
|
{
|
|
if(pop_buffering())
|
|
return;
|
|
|
|
if(pending_attribute_ == -1)
|
|
return;
|
|
|
|
|
|
pending_attribute_ = -1;
|
|
} // end_attribute
|
|
|
|
void add_attribute(const string_type& uri,
|
|
const string_type& localName,
|
|
const string_type& qName,
|
|
const string_type& value)
|
|
{
|
|
if(!pending_element_)
|
|
{
|
|
warning(string_adaptor::construct_from_utf8("WARNING: Cannot write attribute, no open element"));
|
|
return;
|
|
} // if ...
|
|
|
|
atts_.addAttribute(uri, localName, qName, string_adaptor::empty_string(), value);
|
|
} // add_attribute
|
|
|
|
void characters(const string_type& ch)
|
|
{
|
|
if(buffering_)
|
|
{
|
|
if(buffering_ == 1)
|
|
buffer_ << ch;
|
|
return;
|
|
} // if ...
|
|
|
|
flush_element();
|
|
|
|
if(pending_attribute_ != -1)
|
|
{
|
|
atts_.setValue(pending_attribute_, string_adaptor::concat(atts_.getValue(pending_attribute_), ch));
|
|
return;
|
|
} // if ...
|
|
|
|
if(buffering_)
|
|
return;
|
|
|
|
if(!pending_text_)
|
|
{
|
|
pending_text_ = true;
|
|
if(isCDATA())
|
|
do_start_CDATA();
|
|
} // if ...
|
|
do_characters(ch);
|
|
} // characters
|
|
|
|
void start_comment()
|
|
{
|
|
if(push_buffering())
|
|
return;
|
|
|
|
flush_current();
|
|
} // start_comment
|
|
|
|
void end_comment()
|
|
{
|
|
if(pop_buffering())
|
|
return;
|
|
|
|
if(!text_mode_)
|
|
{
|
|
string_type comment = escape(string_adaptor::construct(buffer_.str()), SC::double_hyphen, SC::escaped_double_hyphen);
|
|
if(string_adaptor::length(comment) && *(string_adaptor::rbegin(comment)) == SC::HYPHEN_MINUS)
|
|
string_adaptor::append(comment, SC::SPACE);
|
|
do_comment(comment);
|
|
} // if ...
|
|
} // end_comment
|
|
|
|
void start_processing_instruction(const string_type& target)
|
|
{
|
|
if(push_buffering())
|
|
return;
|
|
|
|
flush_current();
|
|
|
|
target_ = target;
|
|
} // start_processing_instruction
|
|
|
|
void end_processing_instruction()
|
|
{
|
|
if(pop_buffering())
|
|
return;
|
|
|
|
if(!text_mode_)
|
|
{
|
|
string_type data = escape(string_adaptor::construct(buffer_.str()), SC::PIEnd, SC::escaped_pi_end);
|
|
do_processing_instruction(target_, data);
|
|
} // if ...
|
|
} // end_processing_instruction
|
|
|
|
void disableOutputEscaping(bool disable)
|
|
{
|
|
if(!text_mode_)
|
|
do_disableOutputEscaping(disable);
|
|
} // disableOutputEscaping
|
|
|
|
void set_warning_sink(Output& warning_sink)
|
|
{
|
|
warning_sink_ = &warning_sink;
|
|
} // set_warning_sink
|
|
|
|
protected:
|
|
virtual void do_start_document(const Settings& settings) = 0;
|
|
virtual void do_end_document() = 0;
|
|
virtual void do_start_element(const string_type& qName, const string_type& namespaceURI, const SAX::Attributes<string_type, string_adaptor>& atts) = 0;
|
|
virtual void do_end_element(const string_type& qName, const string_type& namespaceURI) = 0;
|
|
virtual void do_characters(const string_type& ch) = 0;
|
|
virtual void do_start_CDATA() = 0;
|
|
virtual void do_end_CDATA() = 0;
|
|
virtual void do_comment(const string_type& ch) = 0;
|
|
virtual void do_processing_instruction(const string_type& target, const string_type& data) = 0;
|
|
virtual void do_disableOutputEscaping(bool disable) = 0;
|
|
virtual bool want_namespace_declarations() const = 0;
|
|
|
|
private:
|
|
string_type escape(string_type str, const string_type& t, const string_type& r) const
|
|
{
|
|
typename string_adaptor::size_type naughty = string_adaptor::find(str, t);
|
|
while(naughty != string_adaptor::npos())
|
|
{
|
|
string_type newstr = string_adaptor::substr(str, 0, naughty);
|
|
string_adaptor::append(newstr, r);
|
|
string_adaptor::append(newstr, string_adaptor::substr(str, naughty + string_adaptor::length(t)));
|
|
str = newstr;
|
|
naughty = string_adaptor::find(str, t, naughty);
|
|
} // while
|
|
return str;
|
|
} // escape
|
|
|
|
bool push_buffering()
|
|
{
|
|
bool is_buf = is_buffering();
|
|
++buffering_;
|
|
|
|
if(is_buf)
|
|
return true;
|
|
|
|
buffer_.str(std::basic_string<typename string_adaptor::value_type>());
|
|
return false;
|
|
} // push_buffering
|
|
|
|
bool is_buffering()
|
|
{
|
|
if(!buffering_)
|
|
return false;
|
|
warning(string_adaptor::construct_from_utf8("WARNING: non-text ignored when creating processing instruction, comment or attribute"));
|
|
return true;
|
|
} // is_buffering
|
|
|
|
bool pop_if_buffering()
|
|
{
|
|
if(!buffering_)
|
|
return false;
|
|
--buffering_;
|
|
return true;
|
|
} // pop_if_buffering
|
|
|
|
bool pop_buffering()
|
|
{
|
|
--buffering_;
|
|
return (buffering_ != 0); // oh, Visual Studio how I curse you warning C4800
|
|
} // pop_buffering
|
|
|
|
void flush_current()
|
|
{
|
|
if(pending_text_)
|
|
{
|
|
if(isCDATA())
|
|
do_end_CDATA();
|
|
pending_text_ = false;
|
|
} // if ...
|
|
|
|
flush_element();
|
|
} // flush_current
|
|
|
|
void flush_element()
|
|
{
|
|
if((!pending_element_) || (pending_attribute_ != -1))
|
|
return;
|
|
|
|
if(text_mode_)
|
|
return;
|
|
|
|
bool want_decs = want_namespace_declarations();
|
|
if(want_decs)
|
|
addNamespaceDeclarations();
|
|
namespaceStack_.popScope();
|
|
if(want_decs)
|
|
addNamespaceDeclarations();
|
|
|
|
do_start_element(element_stack_.top().qname, element_stack_.top().namespaceURI, atts_);
|
|
pending_element_ = false;
|
|
} // flush_element
|
|
|
|
bool isCDATA()
|
|
{
|
|
if(element_stack_.empty())
|
|
return false;
|
|
QName<string_type, string_adaptor> currentElement = element_stack_.top();
|
|
return cdataElements_.find(currentElement) != cdataElements_.end();
|
|
} // isCDATA
|
|
|
|
void addNamespaceDeclarations()
|
|
{
|
|
for(typename NamespaceStack<string_type, string_adaptor>::Scope::const_iterator n = namespaceStack_.begin(), ne = namespaceStack_.end(); n != ne; ++n)
|
|
{
|
|
if(n->first == SC::xml)
|
|
continue;
|
|
|
|
string_type qName = (string_adaptor::empty(n->first)) ? SC::xmlns : string_adaptor::concat(SC::xmlns_colon, n->first);
|
|
atts_.addAttribute(SC::xmlns_uri,
|
|
n->first,
|
|
qName,
|
|
string_adaptor::empty_string(),
|
|
n->second);
|
|
}
|
|
} // addNamespaceDeclarations
|
|
|
|
void warning(const string_type& warning_message)
|
|
{
|
|
warning_sink_->characters(warning_message);
|
|
warning_sink_->characters(SC::newline);
|
|
} // warning
|
|
|
|
int buffering_;
|
|
bool pending_element_;
|
|
bool pending_text_;
|
|
int pending_attribute_;
|
|
bool text_mode_;
|
|
Output* warning_sink_;
|
|
CDATAElements cdataElements_;
|
|
std::stack<QName<string_type, string_adaptor> > element_stack_;
|
|
string_type target_;
|
|
SAX::AttributesImpl<string_type, string_adaptor> atts_;
|
|
std::basic_stringstream<typename string_adaptor::value_type> buffer_;
|
|
NamespaceStack<string_type, string_adaptor> namespaceStack_;
|
|
}; // class Output
|
|
|
|
} // namespace XSLT
|
|
} // namespace Arabica
|
|
|
|
#endif // ARABICA_XSLT_OUTPUT_HPP
|
|
|