mirror of
https://github.com/VCMP-SqMod/SqMod.git
synced 2025-02-23 05:07:13 +01:00
4a6bfc086c
Switched to POCO library for unified platform/library interface. Deprecated the external module API. It was creating more problems than solving. Removed most built-in libraries in favor of system libraries for easier maintenance. Cleaned and secured code with help from static analyzers.
635 lines
16 KiB
C++
635 lines
16 KiB
C++
//
|
|
// XMLStreamParser.h
|
|
//
|
|
// Library: XML
|
|
// Package: XML
|
|
// Module: XMLStreamParser
|
|
//
|
|
// Definition of the XMLStreamParser class.
|
|
//
|
|
// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
|
|
// and Contributors.
|
|
//
|
|
// Based on libstudxml (http://www.codesynthesis.com/projects/libstudxml/).
|
|
// Copyright (c) 2009-2013 Code Synthesis Tools CC.
|
|
//
|
|
// SPDX-License-Identifier: BSL-1.0
|
|
//
|
|
|
|
|
|
#ifndef XML_XMLStreamParser_INCLUDED
|
|
#define XML_XMLStreamParser_INCLUDED
|
|
|
|
|
|
// We only support UTF-8 expat.
|
|
#ifdef XML_UNICODE
|
|
#error UTF-16 expat (XML_UNICODE defined) is not supported
|
|
#endif
|
|
|
|
|
|
#include "Poco/XML/QName.h"
|
|
#include "Poco/XML/ValueTraits.h"
|
|
#include "Poco/XML/Content.h"
|
|
#if defined(POCO_UNBUNDLED)
|
|
#include <expat.h>
|
|
#else
|
|
#include "Poco/XML/expat.h"
|
|
#endif
|
|
#include <map>
|
|
#include <vector>
|
|
#include <string>
|
|
#include <iosfwd>
|
|
#include <cstddef>
|
|
|
|
|
|
namespace Poco {
|
|
namespace XML {
|
|
|
|
|
|
class XML_API XMLStreamParser
|
|
/// The streaming XML pull parser and streaming XML serializer. The parser
|
|
/// is a conforming, non-validating XML 1.0 implementation (see Implementation Notes
|
|
/// for details). The application character encoding (that is, the encoding used
|
|
/// in the application's memory) for both parser and serializer is UTF-8.
|
|
/// The output encoding of the serializer is UTF-8 as well. The parser supports
|
|
/// UTF-8, UTF-16, ISO-8859-1, and US-ASCII input encodings.
|
|
///
|
|
/// Attribute map:
|
|
///
|
|
/// Attribute map lookup. If attribute is not found, then the version
|
|
/// without the default value throws an appropriate parsing exception
|
|
/// while the version with the default value returns that value.
|
|
///
|
|
/// Note also that there is no attribute(ns, name) version since it
|
|
/// would conflict with attribute(name, dv) (qualified attributes
|
|
/// are not very common).
|
|
///
|
|
/// Attribute map is valid throughout at the "element level" until
|
|
/// end_element and not just during EV_START_ELEMENT. As a special case,
|
|
/// the map is still valid after peek() that returned end_element until
|
|
/// this end_element event is retrieved with next().
|
|
///
|
|
/// Using parser:
|
|
///
|
|
/// XMLStreamParser p(ifs, argv[1]);
|
|
/// for (XMLStreamParser::EventType e: p)
|
|
/// {
|
|
/// switch (e)
|
|
/// {
|
|
/// case XMLStreamParser::EV_START_ELEMENT:
|
|
/// cerr << p.line () << ':' << p.column () << ": start " << p.name () << endl;
|
|
/// break;
|
|
/// case XMLStreamParser::EV_END_ELEMENT:
|
|
/// cerr << p.line () << ':' << p.column () << ": end " << p.name () << endl;
|
|
/// break;
|
|
/// case XMLStreamParser::EV_START_ATTRIBUTE:
|
|
/// ...
|
|
/// case XMLStreamParser::EV_END_ATTRIBUTE:
|
|
/// ...
|
|
/// case XMLStreamParser::EV_CHARACTERS:
|
|
/// ...
|
|
/// }
|
|
/// }
|
|
{
|
|
public:
|
|
enum EventType
|
|
/// Parsing events.
|
|
{
|
|
EV_START_ELEMENT,
|
|
EV_END_ELEMENT,
|
|
EV_START_ATTRIBUTE,
|
|
EV_END_ATTRIBUTE,
|
|
EV_CHARACTERS,
|
|
EV_START_NAMESPACE_DECL,
|
|
EV_END_NAMESPACE_DECL,
|
|
EV_EOF
|
|
};
|
|
|
|
using FeatureType = unsigned short;
|
|
/// If both receive_attributes_event and RECEIVE_ATTRIBUTE_MAP are
|
|
/// specified, then RECEIVE_ATTRIBUTES_EVENT is assumed.
|
|
|
|
static const FeatureType RECEIVE_ELEMENTS = 0x0001;
|
|
static const FeatureType RECEIVE_CHARACTERS = 0x0002;
|
|
static const FeatureType RECEIVE_ATTRIBUTE_MAP = 0x0004;
|
|
static const FeatureType RECEIVE_ATTRIBUTES_EVENT = 0x0008;
|
|
static const FeatureType RECEIVE_NAMESPACE_DECLS = 0x0010;
|
|
static const FeatureType RECEIVE_DEFAULT = RECEIVE_ELEMENTS | RECEIVE_CHARACTERS | RECEIVE_ATTRIBUTE_MAP;
|
|
|
|
struct AttributeValueType
|
|
{
|
|
std::string value;
|
|
mutable bool handled;
|
|
};
|
|
|
|
using AttributeMapType = std::map<QName, AttributeValueType>;
|
|
|
|
struct XML_API Iterator
|
|
// C++11 range-based for support. Generally, the iterator interface
|
|
// doesn't make much sense for the XMLStreamParser so for now we have an
|
|
// implementation that is just enough to the range-based for.
|
|
{
|
|
using value_type = EventType;
|
|
|
|
Iterator(XMLStreamParser* p = 0, EventType e = EV_EOF):
|
|
_parser(p),
|
|
_e(e)
|
|
{
|
|
}
|
|
|
|
value_type operator * () const
|
|
{
|
|
return _e;
|
|
}
|
|
|
|
Iterator& operator ++ ()
|
|
{
|
|
_e = _parser->next();
|
|
return *this;
|
|
}
|
|
|
|
bool operator == (Iterator y) const
|
|
/// Comparison only makes sense when comparing to end (eof).
|
|
{
|
|
return _e == EV_EOF && y._e == EV_EOF;
|
|
}
|
|
|
|
bool operator != (Iterator y) const
|
|
/// Comparison only makes sense when comparing to end (eof).
|
|
{
|
|
return !(*this == y);
|
|
}
|
|
|
|
private:
|
|
XMLStreamParser* _parser;
|
|
EventType _e;
|
|
};
|
|
|
|
Iterator begin()
|
|
{
|
|
return Iterator(this, next());
|
|
}
|
|
|
|
Iterator end()
|
|
{
|
|
return Iterator(this, EV_EOF);
|
|
}
|
|
|
|
XMLStreamParser(std::istream&, const std::string& inputName, FeatureType = RECEIVE_DEFAULT);
|
|
/// The parser constructor takes three arguments: the stream to parse,
|
|
/// input name that is used in diagnostics to identify the document being
|
|
/// parsed, and the list of events we want the parser to report.
|
|
///
|
|
/// Parse std::istream. Input name is used in diagnostics to identify
|
|
/// the document being parsed.
|
|
///
|
|
/// If stream exceptions are enabled then std::ios_base::failure
|
|
/// exception is used to report io errors (badbit and failbit).
|
|
/// Otherwise, those are reported as the parsing exception.
|
|
|
|
XMLStreamParser(const void* data, std::size_t size, const std::string& inputName, FeatureType = RECEIVE_DEFAULT);
|
|
/// Parse memory buffer that contains the whole document. Input name
|
|
/// is used in diagnostics to identify the document being parsed.
|
|
|
|
~XMLStreamParser();
|
|
/// Destroys the XMLStreamParser.
|
|
|
|
EventType next();
|
|
/// Call the next() function when we are ready to handle the next piece of XML.
|
|
|
|
void nextExpect(EventType);
|
|
/// Get the next event and make sure that it's what's expected. If it
|
|
/// is not, then throw an appropriate parsing exception.
|
|
|
|
void nextExpect(EventType, const std::string& name);
|
|
void nextExpect(EventType, const QName& qname);
|
|
void nextExpect(EventType, const std::string& ns, const std::string& name);
|
|
|
|
EventType peek();
|
|
EventType event();
|
|
/// Return the event that was last returned by the call to next() or peek().
|
|
|
|
const std::string& inputName() const;
|
|
const QName& getQName() const;
|
|
const std::string& namespaceURI() const;
|
|
const std::string& localName() const;
|
|
const std::string& prefix() const;
|
|
std::string& value();
|
|
const std::string& value() const;
|
|
template <typename T> T value() const;
|
|
Poco::UInt64 line() const;
|
|
Poco::UInt64 column() const;
|
|
const std::string& attribute(const std::string& name) const;
|
|
template <typename T>
|
|
T attribute(const std::string& name) const;
|
|
std::string attribute(const std::string& name, const std::string& deflt) const;
|
|
template <typename T>
|
|
T attribute(const std::string& name, const T& deflt) const;
|
|
const std::string& attribute(const QName& qname) const;
|
|
template <typename T>
|
|
T attribute(const QName& qname) const;
|
|
std::string attribute(const QName& qname, const std::string& deflt) const;
|
|
template <typename T>
|
|
T attribute(const QName& qname, const T& deflt) const;
|
|
bool attributePresent(const std::string& name) const;
|
|
bool attributePresent(const QName& qname) const;
|
|
const AttributeMapType& attributeMap() const;
|
|
|
|
void content(Content);
|
|
Content content() const;
|
|
|
|
void nextExpect(EventType, const std::string& name, Content);
|
|
void nextExpect(EventType, const QName& qname, Content);
|
|
void nextExpect(EventType, const std::string& ns, const std::string& name, Content);
|
|
|
|
// Helpers for parsing elements with simple content. The first two
|
|
// functions assume that EV_START_ELEMENT has already been parsed. The
|
|
// rest parse the complete element, from start to end.
|
|
//
|
|
// Note also that as with attribute(), there is no (namespace,name)
|
|
// overload since it would conflicts with (namespace,deflt).
|
|
std::string element();
|
|
|
|
template <typename T>
|
|
T element();
|
|
std::string element(const std::string& name);
|
|
std::string element(const QName& qname);
|
|
template <typename T>
|
|
T element(const std::string& name);
|
|
template <typename T>
|
|
T element(const QName& qname);
|
|
std::string element(const std::string& name, const std::string& deflt);
|
|
std::string element(const QName& qname, const std::string& deflt);
|
|
template <typename T>
|
|
T element(const std::string& name, const T& deflt);
|
|
template <typename T>
|
|
T element(const QName& qname, const T& deflt);
|
|
|
|
private:
|
|
XMLStreamParser(const XMLStreamParser&);
|
|
XMLStreamParser& operator = (const XMLStreamParser&);
|
|
|
|
static void XMLCALL handleStartElement(void*, const XML_Char*, const XML_Char**);
|
|
static void XMLCALL handleEndElement(void*, const XML_Char*);
|
|
static void XMLCALL handleCharacters(void*, const XML_Char*, int);
|
|
static void XMLCALL handleStartNamespaceDecl(void*, const XML_Char*, const XML_Char*);
|
|
static void XMLCALL handleEndNamespaceDecl(void*, const XML_Char*);
|
|
|
|
void init();
|
|
EventType nextImpl(bool peek);
|
|
EventType nextBody();
|
|
void handleError();
|
|
|
|
// If _size is 0, then data is std::istream. Otherwise, it is a buffer.
|
|
union
|
|
{
|
|
std::istream* is;
|
|
const void* buf;
|
|
}
|
|
_data;
|
|
|
|
std::size_t _size;
|
|
const std::string _inputName;
|
|
FeatureType _feature;
|
|
XML_Parser _parser;
|
|
std::size_t _depth;
|
|
bool _accumulateContent; // Whether we are accumulating character content.
|
|
enum { state_next, state_peek } _parserState;
|
|
EventType _currentEvent;
|
|
EventType _queue;
|
|
QName _qname;
|
|
std::string _value;
|
|
const QName* _qualifiedName;
|
|
std::string* _pvalue;
|
|
Poco::UInt64 _line;
|
|
Poco::UInt64 _column;
|
|
|
|
struct AttributeType
|
|
{
|
|
QName qname;
|
|
std::string value;
|
|
};
|
|
|
|
typedef std::vector<AttributeType> attributes;
|
|
attributes _attributes;
|
|
attributes::size_type _currentAttributeIndex; // Index of the current attribute.
|
|
|
|
typedef std::vector<QName> NamespaceDecls;
|
|
NamespaceDecls _startNamespace;
|
|
NamespaceDecls::size_type _startNamespaceIndex;// Index of the current decl.
|
|
NamespaceDecls _endNamespace;
|
|
NamespaceDecls::size_type _endNamespaceIndex;// Index of the current decl.
|
|
|
|
struct ElementEntry
|
|
{
|
|
ElementEntry(std::size_t d, Content c = Content::Mixed):
|
|
depth(d),
|
|
content(c),
|
|
attributesUnhandled(0)
|
|
{
|
|
}
|
|
|
|
std::size_t depth;
|
|
Content content;
|
|
AttributeMapType attributeMap;
|
|
mutable AttributeMapType::size_type attributesUnhandled;
|
|
};
|
|
|
|
typedef std::vector<ElementEntry> ElementState;
|
|
std::vector<ElementEntry> _elementState;
|
|
|
|
const AttributeMapType _emptyAttrMap;
|
|
|
|
const ElementEntry* getElement() const;
|
|
const ElementEntry* getElementImpl() const;
|
|
void popElement();
|
|
};
|
|
|
|
|
|
XML_API std::ostream& operator << (std::ostream&, XMLStreamParser::EventType);
|
|
|
|
|
|
//
|
|
// inlines
|
|
//
|
|
inline XMLStreamParser::EventType XMLStreamParser::event()
|
|
// Return the even that was last returned by the call to next() or peek().
|
|
{
|
|
return _currentEvent;
|
|
}
|
|
|
|
|
|
inline const std::string& XMLStreamParser::inputName() const
|
|
{
|
|
return _inputName;
|
|
}
|
|
|
|
|
|
inline const QName& XMLStreamParser::getQName() const
|
|
{
|
|
return *_qualifiedName;
|
|
}
|
|
|
|
|
|
inline const std::string& XMLStreamParser::namespaceURI() const
|
|
{
|
|
return _qualifiedName->namespaceURI();
|
|
}
|
|
|
|
|
|
inline const std::string& XMLStreamParser::localName() const
|
|
{
|
|
return _qualifiedName->localName();
|
|
}
|
|
|
|
|
|
inline const std::string& XMLStreamParser::prefix() const
|
|
{
|
|
return _qualifiedName->prefix();
|
|
}
|
|
|
|
|
|
inline std::string& XMLStreamParser::value()
|
|
{
|
|
return *_pvalue;
|
|
}
|
|
|
|
|
|
inline const std::string& XMLStreamParser::value() const
|
|
{
|
|
return *_pvalue;
|
|
}
|
|
|
|
|
|
inline Poco::UInt64 XMLStreamParser::line() const
|
|
{
|
|
return _line;
|
|
}
|
|
|
|
|
|
inline Poco::UInt64 XMLStreamParser::column() const
|
|
{
|
|
return _column;
|
|
}
|
|
|
|
|
|
inline XMLStreamParser::EventType XMLStreamParser::peek()
|
|
{
|
|
if (_parserState == state_peek)
|
|
return _currentEvent;
|
|
else
|
|
{
|
|
EventType e(nextImpl(true));
|
|
_parserState = state_peek; // Set it after the call to nextImpl().
|
|
return e;
|
|
}
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
inline T XMLStreamParser::value() const
|
|
{
|
|
return ValueTraits < T > ::parse(value(), *this);
|
|
}
|
|
|
|
|
|
inline const std::string& XMLStreamParser::attribute(const std::string& n) const
|
|
{
|
|
return attribute(QName(n));
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
inline T XMLStreamParser::attribute(const std::string& n) const
|
|
{
|
|
return attribute < T > (QName(n));
|
|
}
|
|
|
|
|
|
inline std::string XMLStreamParser::attribute(const std::string& n, const std::string& dv) const
|
|
{
|
|
return attribute(QName(n), dv);
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
inline T XMLStreamParser::attribute(const std::string& n, const T& dv) const
|
|
{
|
|
return attribute < T > (QName(n), dv);
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
inline T XMLStreamParser::attribute(const QName& qn) const
|
|
{
|
|
return ValueTraits < T > ::parse(attribute(qn), *this);
|
|
}
|
|
|
|
|
|
inline bool XMLStreamParser::attributePresent(const std::string& n) const
|
|
{
|
|
return attributePresent(QName(n));
|
|
}
|
|
|
|
|
|
inline const XMLStreamParser::AttributeMapType& XMLStreamParser::attributeMap() const
|
|
{
|
|
if (const ElementEntry* e = getElement())
|
|
{
|
|
e->attributesUnhandled = 0; // Assume all handled.
|
|
return e->attributeMap;
|
|
}
|
|
|
|
return _emptyAttrMap;
|
|
}
|
|
|
|
|
|
inline void XMLStreamParser::nextExpect(EventType e, const QName& qn)
|
|
{
|
|
nextExpect(e, qn.namespaceURI(), qn.localName());
|
|
}
|
|
|
|
|
|
inline void XMLStreamParser::nextExpect(EventType e, const std::string& n)
|
|
{
|
|
nextExpect(e, std::string(), n);
|
|
}
|
|
|
|
|
|
inline void XMLStreamParser::nextExpect(EventType e, const QName& qn, Content c)
|
|
{
|
|
nextExpect(e, qn);
|
|
poco_assert(e == EV_START_ELEMENT);
|
|
content(c);
|
|
}
|
|
|
|
|
|
inline void XMLStreamParser::nextExpect(EventType e, const std::string& n, Content c)
|
|
{
|
|
nextExpect(e, std::string(), n);
|
|
poco_assert(e == EV_START_ELEMENT);
|
|
content(c);
|
|
}
|
|
|
|
|
|
inline void XMLStreamParser::nextExpect(EventType e, const std::string& ns, const std::string& n, Content c)
|
|
{
|
|
nextExpect(e, ns, n);
|
|
poco_assert(e == EV_START_ELEMENT);
|
|
content(c);
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
inline T XMLStreamParser::element()
|
|
{
|
|
return ValueTraits < T > ::parse(element(), *this);
|
|
}
|
|
|
|
|
|
inline std::string XMLStreamParser::element(const std::string& n)
|
|
{
|
|
nextExpect(EV_START_ELEMENT, n);
|
|
return element();
|
|
}
|
|
|
|
|
|
inline std::string XMLStreamParser::element(const QName& qn)
|
|
{
|
|
nextExpect(EV_START_ELEMENT, qn);
|
|
return element();
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
inline T XMLStreamParser::element(const std::string& n)
|
|
{
|
|
return ValueTraits < T > ::parse(element(n), *this);
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
inline T XMLStreamParser::element(const QName& qn)
|
|
{
|
|
return ValueTraits < T > ::parse(element(qn), *this);
|
|
}
|
|
|
|
|
|
inline std::string XMLStreamParser::element(const std::string& n, const std::string& dv)
|
|
{
|
|
return element(QName(n), dv);
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
inline T XMLStreamParser::element(const std::string& n, const T& dv)
|
|
{
|
|
return element < T > (QName(n), dv);
|
|
}
|
|
|
|
|
|
inline void XMLStreamParser::content(Content c)
|
|
{
|
|
poco_assert(_parserState == state_next);
|
|
|
|
if (!_elementState.empty() && _elementState.back().depth == _depth)
|
|
_elementState.back().content = c;
|
|
else
|
|
_elementState.emplace_back(_depth, c);
|
|
}
|
|
|
|
|
|
inline Content XMLStreamParser::content() const
|
|
{
|
|
poco_assert(_parserState == state_next);
|
|
|
|
return !_elementState.empty() && _elementState.back().depth == _depth ? _elementState.back().content : Content(Content::Mixed);
|
|
}
|
|
|
|
|
|
inline const XMLStreamParser::ElementEntry* XMLStreamParser::getElement() const
|
|
{
|
|
return _elementState.empty() ? 0 : getElementImpl();
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
T XMLStreamParser::attribute(const QName& qn, const T& dv) const
|
|
{
|
|
if (const ElementEntry* e = getElement())
|
|
{
|
|
AttributeMapType::const_iterator i(e->attributeMap.find(qn));
|
|
|
|
if (i != e->attributeMap.end())
|
|
{
|
|
if (!i->second.handled)
|
|
{
|
|
i->second.handled = true;
|
|
e->attributesUnhandled--;
|
|
}
|
|
return ValueTraits < T > ::parse(i->second.value, *this);
|
|
}
|
|
}
|
|
|
|
return dv;
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
T XMLStreamParser::element(const QName& qn, const T& dv)
|
|
{
|
|
if (peek() == EV_START_ELEMENT && getQName() == qn)
|
|
{
|
|
next();
|
|
return element<T>();
|
|
}
|
|
|
|
return dv;
|
|
}
|
|
|
|
|
|
} } // namespace Poco::XML
|
|
|
|
|
|
#endif // XML_XMLStreamParser_INCLUDED
|