Miroirs/arabica
1
0
Fork 0
mirror of https://github.com/jezhiggins/arabica synced 2024-12-27 21:58:30 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge original jezhiggins/arabica

Browse source
This commit is contained in:
Sebastian Schleussner 2016-07-04 14:22:14 +02:00
commit c796cf458f
17 changed files with 143 additions and 18335 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
.gitignore vendored
View file

@ -1,13 +1,18 @@
*.o *.o
*~ *~
libtool libtool
ltmain.sh
config.log config.log
config.status config.status
configure configure
compile
autom4te.cache autom4te.cache
missing
test-driver
Makefile Makefile
Makefile.in Makefile.in
.deps .deps
.dirstamp
aclocal.m4 aclocal.m4
arabica.pc arabica.pc
include/SAX/ArabicaConfig.hpp include/SAX/ArabicaConfig.hpp
@ -40,6 +45,8 @@ vs10/mangle.sln
*.dll *.dll
spec spec
gmon.out gmon.out
*.log
*.trs
examples/DOM/dom2pyx examples/DOM/dom2pyx
examples/DOM/domwriter examples/DOM/domwriter
examples/SAX/pyx examples/SAX/pyx
@ -56,10 +63,14 @@ tests/DOM/dom_test*
tests/XPath/xpath_test* tests/XPath/xpath_test*
tests/Taggle/taggle_test tests/Taggle/taggle_test
tests/Utils/utils_test* tests/Utils/utils_test*
tests/XSLT/xslt_test tests/XSLT/xslt_test*
bin/mandelbrot-*.html bin/mandelbrot-*.html
doc/html doc/html
m4/lt~obsolete.m4 m4/lt~obsolete.m4
m4/ltversion.m4
m4/ltsugar.m4
m4/ltoptions.m4
m4/libtool.m4
*.vcxproj.filters *.vcxproj.filters
*.vcxproj.user *.vcxproj.user
*.sdf *.sdf
@ -73,3 +84,5 @@ cmake_install.cmake
build/* build/*
*.DS_Store* *.DS_Store*
compile
test-driver

5
HOWTOBUILD
View file

@ -1,6 +1,8 @@
Using autotools Using autotools
--------------- ---------------
If you've pulled the source from GitHub, you'll need to start with autoreconf, otherwise go directly to ... If you've pulled the source from GitHub, you'll need to start with
autoreconf -i
otherwise go directly to ...
./configure ./configure
make make
Optionally make check to run the tests Optionally make check to run the tests
@ -17,4 +19,3 @@ Please see CMake.README
Using Visual Studio Using Visual Studio
------------------- -------------------
See http://www.jezuk.co.uk/arabica/howtobuild See http://www.jezuk.co.uk/arabica/howtobuild

48
autogen.sh
View file

@ -1,48 +0,0 @@
#! /bin/sh
# $Id: autogen.sh,v 1.4 2002/12/02 01:39:49 murrayc Exp $
#
# Copyright (c) 2002 Daniel Elstner <daniel.elstner@gmx.net>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License VERSION 2 as
# published by the Free Software Foundation. You are not allowed to
# use any other version of the license; unless you got the explicit
# permission from the author to do so.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
dir=`echo "$0" | sed 's,[^/]*$,,'`
test "x${dir}" = "x" && dir='.'
if test "x`cd "${dir}" 2>/dev/null && pwd`" != "x`pwd`"
then
echo "This script must be executed directly from the source directory."
exit 1
fi
rm -f config.cache acconfig.h
echo "- libtoolize." && \
libtoolize --force && \
echo "- aclocal." && \
aclocal -I m4 && \
echo "- autoconf." && \
autoconf && \
echo "- autoheader." && \
autoheader && \
echo "- automake." && \
automake --add-missing --gnu && \
echo && \
./configure "$@" && exit 0
exit 1

6
configure.ac
View file

@ -1,11 +1,11 @@
AC_INIT([Arabica], [2013-Sometime], [jez@jezuk.co.uk]) AC_INIT([Arabica],[2016-January],[jez@jezuk.co.uk])
AM_INIT_AUTOMAKE([1.9 tar-ustar dist-bzip2 dist-zip]) AM_INIT_AUTOMAKE([1.9 tar-ustar dist-bzip2 dist-zip subdir-objects])
AC_CONFIG_MACRO_DIR([m4]) AC_CONFIG_MACRO_DIR([m4])
AC_PROG_CXX AC_PROG_CXX
AC_PROG_LIBTOOL LT_INIT
AC_LANG([C++]) AC_LANG([C++])

23
include/DOM/Document.hpp
View file

@ -22,8 +22,6 @@
#include <DOM/Traversal/DocumentTraversal.hpp> #include <DOM/Traversal/DocumentTraversal.hpp>
#include <DOM/Traversal/DocumentTraversalImpl.hpp> #include <DOM/Traversal/DocumentTraversalImpl.hpp>
#include <DOM/Events/DocumentEvent.hpp>
namespace Arabica namespace Arabica
{ {
namespace DOM namespace DOM
@ -31,7 +29,7 @@ namespace DOM
namespace Events { namespace Events {
template<class stringT, class string_adaptorT> class DocumentEvent; template<class stringT, class string_adaptorT> class DocumentEvent;
} // namespace Events } // namespace Events
template<class stringT, class string_adaptorT> class Document_impl; template<class stringT, class string_adaptorT> class Document_impl;
@ -43,7 +41,7 @@ class Document : public Node<stringT, string_adaptorT>
Document() : Node<stringT, string_adaptorT>() { } Document() : Node<stringT, string_adaptorT>() { }
Document(Document_impl<stringT, string_adaptorT>* impl) : Node<stringT, string_adaptorT>(impl) { } Document(Document_impl<stringT, string_adaptorT>* impl) : Node<stringT, string_adaptorT>(impl) { }
Document(const Document& rhs) : Node<stringT, string_adaptorT>(rhs) { } Document(const Document& rhs) : Node<stringT, string_adaptorT>(rhs) { }
explicit Document(const Node<stringT, string_adaptorT>& rhs) : Node<stringT, string_adaptorT>(rhs) explicit Document(const Node<stringT, string_adaptorT>& rhs) : Node<stringT, string_adaptorT>(rhs)
{ {
if(NodeT::impl_ == 0) // null nodes can always be cast if(NodeT::impl_ == 0) // null nodes can always be cast
return; return;
@ -52,7 +50,7 @@ class Document : public Node<stringT, string_adaptorT>
} // Document } // Document
~Document() { } ~Document() { }
Document& operator=(const Document& rhs) Document& operator=(const Document& rhs)
{ {
Node<stringT, string_adaptorT>::operator=(rhs); Node<stringT, string_adaptorT>::operator=(rhs);
return *this; return *this;
@ -76,7 +74,7 @@ class Document : public Node<stringT, string_adaptorT>
ProcessingInstruction<stringT, string_adaptorT> createProcessingInstruction(const stringT& target, const stringT& data) const ProcessingInstruction<stringT, string_adaptorT> createProcessingInstruction(const stringT& target, const stringT& data) const
{ {
return ProcessingInstruction<stringT, string_adaptorT>(dImpl()->createProcessingInstruction(target, data)); return ProcessingInstruction<stringT, string_adaptorT>(dImpl()->createProcessingInstruction(target, data));
} // createProcessingInstruction } // createProcessingInstruction
Attr<stringT, string_adaptorT> createAttribute(const stringT& name) const { return Attr<stringT, string_adaptorT>(dImpl()->createAttribute(name)); } Attr<stringT, string_adaptorT> createAttribute(const stringT& name) const { return Attr<stringT, string_adaptorT>(dImpl()->createAttribute(name)); }
@ -89,12 +87,12 @@ class Document : public Node<stringT, string_adaptorT>
Element<stringT, string_adaptorT> createElementNS(const stringT& namespaceURI, const stringT& qualifiedName) const Element<stringT, string_adaptorT> createElementNS(const stringT& namespaceURI, const stringT& qualifiedName) const
{ {
return Element<stringT, string_adaptorT>(dImpl()->createElementNS(namespaceURI, qualifiedName)); return Element<stringT, string_adaptorT>(dImpl()->createElementNS(namespaceURI, qualifiedName));
} // createElementNS } // createElementNS
Attr<stringT, string_adaptorT> createAttributeNS(const stringT& namespaceURI, const stringT& qualifiedName) const Attr<stringT, string_adaptorT> createAttributeNS(const stringT& namespaceURI, const stringT& qualifiedName) const
{ {
return Attr<stringT, string_adaptorT>(dImpl()->createAttributeNS(namespaceURI, qualifiedName)); return Attr<stringT, string_adaptorT>(dImpl()->createAttributeNS(namespaceURI, qualifiedName));
} // createAttributeNS } // createAttributeNS
NodeList<stringT, string_adaptorT> getElementsByTagNameNS(const stringT& namespaceURI, const stringT& localName) const NodeList<stringT, string_adaptorT> getElementsByTagNameNS(const stringT& namespaceURI, const stringT& localName) const
@ -110,14 +108,6 @@ class Document : public Node<stringT, string_adaptorT>
return docTraversal; return docTraversal;
} // createDocumentTraversal } // createDocumentTraversal
Events::Event_impl<stringT, string_adaptorT>* createEvent(const stringT& eventType)
{
DOM::Events::DocumentEvent_impl<stringT, string_adaptorT>* deImpl = dynamic_cast<DOM::Events::DocumentEvent_impl<stringT, string_adaptorT>* >(dImpl());
if (deImpl)
return deImpl->createEvent(eventType);
return 0;
} // createEvent
private: private:
Document_impl<stringT, string_adaptorT>* dImpl() const { return dynamic_cast<Document_impl<stringT, string_adaptorT>*>(*NodeT::impl_); } Document_impl<stringT, string_adaptorT>* dImpl() const { return dynamic_cast<Document_impl<stringT, string_adaptorT>*>(*NodeT::impl_); }
@ -185,4 +175,3 @@ class Document_impl : virtual public Node_impl<stringT, string_adaptorT>
} // namespace Arabica } // namespace Arabica
#endif #endif

43
include/DOM/Node.hpp
View file

@ -13,13 +13,13 @@
#include <algorithm> #include <algorithm>
namespace Arabica namespace Arabica
{ {
namespace DOM namespace DOM
{ {
namespace Events { namespace Events {
template<class stringT, class string_adaptorT> class EventTarget; template<class stringT, class string_adaptorT> class EventTarget;
} // namespace Events } // namespace Events
template<class stringT, class string_adaptorT> class Document; template<class stringT, class string_adaptorT> class Document;
template<class stringT, class string_adaptorT> class NodeList; template<class stringT, class string_adaptorT> class NodeList;
@ -54,21 +54,16 @@ class Node : public Node_base
Node() : impl_() { } Node() : impl_() { }
Node(Node_impl<stringT, string_adaptorT>* const impl) : impl_(impl) { } Node(Node_impl<stringT, string_adaptorT>* const impl) : impl_(impl) { }
Node(const Node& rhs) : impl_(rhs.impl_) { } Node(const Node& rhs) : impl_(rhs.impl_) { }
explicit Node(const DOM::Events::EventTarget<stringT, string_adaptorT>& rhs): impl_(dynamic_cast<Node_impl<stringT, string_adaptorT>*>(rhs.Impl()))
{
if(dynamic_cast<Node_impl<stringT, string_adaptorT>*>(rhs.Impl()) == 0)
throw DOM::DOMException(DOM::DOMException::NOT_SUPPORTED_ERR);
}
virtual ~Node() { } virtual ~Node() { }
operator bool() const { return impl_; } operator bool() const { return impl_; }
bool operator< (const Node& rhs) const { return impl_ < rhs.impl_; } bool operator< (const Node& rhs) const { return impl_ < rhs.impl_; }
bool operator==(const Node& rhs) const { return impl_ == rhs.impl_; } bool operator==(const Node& rhs) const { return impl_ == rhs.impl_; }
bool operator!=(const Node& rhs) const { return impl_ != rhs.impl_; } bool operator!=(const Node& rhs) const { return impl_ != rhs.impl_; }
bool operator==(int dummy) const { return impl_ == dummy; } bool operator==(int dummy) const { return impl_ == dummy; }
bool operator!=(int dummy) const { return impl_ != dummy; } bool operator!=(int dummy) const { return impl_ != dummy; }
Node& operator=(const Node& rhs) Node& operator=(const Node& rhs)
{ {
impl_ = rhs.impl_; impl_ = rhs.impl_;
return *this; return *this;
@ -80,11 +75,11 @@ class Node : public Node_base
void setNodeValue(const stringT& nodeValue) { impl_->setNodeValue(nodeValue); } void setNodeValue(const stringT& nodeValue) { impl_->setNodeValue(nodeValue); }
Type getNodeType() const { return impl_->getNodeType(); } Type getNodeType() const { return impl_->getNodeType(); }
Node getParentNode() const { return impl_->getParentNode(); } Node getParentNode() const { return impl_->getParentNode(); }
const NodeList<stringT, string_adaptorT> getChildNodes() const { return NodeList<stringT, string_adaptorT>(impl_->getChildNodes()); } const NodeList<stringT, string_adaptorT> getChildNodes() const { return NodeList<stringT, string_adaptorT>(impl_->getChildNodes()); }
Node getFirstChild() const { return impl_->getFirstChild(); } Node getFirstChild() const { return impl_->getFirstChild(); }
Node getLastChild() const { return impl_->getLastChild(); } Node getLastChild() const { return impl_->getLastChild(); }
Node getPreviousSibling() const { return impl_->getPreviousSibling(); } Node getPreviousSibling() const { return impl_->getPreviousSibling(); }
@ -94,17 +89,17 @@ class Node : public Node_base
Document<stringT, string_adaptorT> getOwnerDocument() const { return impl_->getOwnerDocument(); } Document<stringT, string_adaptorT> getOwnerDocument() const { return impl_->getOwnerDocument(); }
Node insertBefore(const Node& newChild, const Node& refChild) { return impl_->insertBefore(*newChild.impl_, *refChild.impl_); } Node insertBefore(const Node& newChild, const Node& refChild) { return impl_->insertBefore(*newChild.impl_, *refChild.impl_); }
Node replaceChild(const Node& newChild, const Node& oldChild) { return impl_->replaceChild(*newChild.impl_, *oldChild.impl_); } Node replaceChild(const Node& newChild, const Node& oldChild) { return impl_->replaceChild(*newChild.impl_, *oldChild.impl_); }
Node removeChild(const Node& oldChild) { return impl_->removeChild(*oldChild.impl_); } Node removeChild(const Node& oldChild) { return impl_->removeChild(*oldChild.impl_); }
Node appendChild(const Node& newChild) { return impl_->appendChild(*newChild.impl_); } Node appendChild(const Node& newChild) { return impl_->appendChild(*newChild.impl_); }
void purgeChild(Node& oldChild) void purgeChild(Node& oldChild)
{ {
Node_impl<stringT, string_adaptorT>* child = *oldChild.impl_; Node_impl<stringT, string_adaptorT>* child = *oldChild.impl_;
oldChild = 0; oldChild = 0;
try { try {
impl_->purgeChild(child); impl_->purgeChild(child);
} }
catch(DOMException&) catch(DOMException&)
{ {
@ -112,7 +107,7 @@ class Node : public Node_base
throw; throw;
} // catch } // catch
} // purge } // purge
bool hasChildNodes() const { return impl_->hasChildNodes(); } bool hasChildNodes() const { return impl_->hasChildNodes(); }
Node cloneNode(bool deep) const { return impl_->cloneNode(deep); } Node cloneNode(bool deep) const { return impl_->cloneNode(deep); }
@ -128,11 +123,11 @@ class Node : public Node_base
// additional three methods - since C++ std::string (and by implication // additional three methods - since C++ std::string (and by implication
// stringT) don't differenciate between a null string and an empty string, // stringT) don't differenciate between a null string and an empty string,
// but the DOM recommendation does, I have to introduce these three methods // but the DOM recommendation does, I have to introduce these three methods
// to disambiguate. If they return false, the corresponding attribute should be // to disambiguate. If they return false, the corresponding attribute should be
// considered null. If they return true, the attribute has been set EVEN IF // considered null. If they return true, the attribute has been set EVEN IF
// it has been set to the empty string // it has been set to the empty string
bool hasNamespaceURI() const { return impl_->hasNamespaceURI(); } bool hasNamespaceURI() const { return impl_->hasNamespaceURI(); }
bool hasPrefix() const { return impl_->hasPrefix(); } bool hasPrefix() const { return impl_->hasPrefix(); }
bool hasAttributes() const { return impl_->hasAttributes(); } bool hasAttributes() const { return impl_->hasAttributes(); }
@ -177,11 +172,11 @@ class Node_impl
virtual void setNodeValue(const stringT& nodeValue) = 0; virtual void setNodeValue(const stringT& nodeValue) = 0;
virtual Node_base::Type getNodeType() const = 0; virtual Node_base::Type getNodeType() const = 0;
virtual Node_impl<stringT, string_adaptorT>* getParentNode() const = 0; virtual Node_impl<stringT, string_adaptorT>* getParentNode() const = 0;
virtual NodeList_impl<stringT, string_adaptorT>* getChildNodes() const = 0; virtual NodeList_impl<stringT, string_adaptorT>* getChildNodes() const = 0;
virtual Node_impl<stringT, string_adaptorT>* getFirstChild() const = 0; virtual Node_impl<stringT, string_adaptorT>* getFirstChild() const = 0;
virtual Node_impl<stringT, string_adaptorT>* getLastChild() const = 0; virtual Node_impl<stringT, string_adaptorT>* getLastChild() const = 0;
@ -213,9 +208,9 @@ class Node_impl
// additional methods - since C++ std::string (and by implication // additional methods - since C++ std::string (and by implication
// stringT) don't differenciate between a null string and an empty string, // stringT) don't differenciate between a null string and an empty string,
// but the DOM recommendation does, I have to introduce these three methods // but the DOM recommendation does, I have to introduce these three methods
// to disambiguate. If they return false, the corresponding attribute should be // to disambiguate. If they return false, the corresponding attribute should be
// considered null. If they return true, the attribute has been set EVEN IF // considered null. If they return true, the attribute has been set EVEN IF
// it has been set to the empty string // it has been set to the empty string
virtual bool hasNamespaceURI() const = 0; virtual bool hasNamespaceURI() const = 0;
virtual bool hasPrefix() const = 0; virtual bool hasPrefix() const = 0;

25
include/DOM/Simple/CharacterDataImpl.hpp
View file

@ -4,12 +4,6 @@
#include <DOM/CharacterData.hpp> #include <DOM/CharacterData.hpp>
#include <DOM/Simple/NodeImpl.hpp> #include <DOM/Simple/NodeImpl.hpp>
#define DISPATCH_DOM_CHARACTERDATA_MODIFIED_EVENT(oldValue, newValue) \
DOM::Events::MutationEvent<stringT, string_adaptorT> mutationEvent(NodeImpl<stringT, string_adaptorT>::ownerDoc_->createEvent("MutationEvent")); \
mutationEvent.initMutationEvent("DOMCharacterDataModified", true, false, Arabica::DOM::Node<stringT, string_adaptorT>(), oldValue, newValue, string_adaptorT::empty_string(), Arabica::DOM::Events::MutationEvent<stringT, string_adaptorT>::MODIFICATION); \
DOM::Events::EventTarget<stringT, string_adaptorT> eventTarget(this); \
eventTarget.dispatchEvent(mutationEvent); \
namespace Arabica namespace Arabica
{ {
namespace SimpleDOM namespace SimpleDOM
@ -21,10 +15,10 @@ class CharacterDataImpl : virtual public DOM::CharacterData_impl<stringT, string
{ {
typedef ChildlessNodeImpl<stringT, string_adaptorT> NodeT; typedef ChildlessNodeImpl<stringT, string_adaptorT> NodeT;
public: public:
CharacterDataImpl(DocumentImpl<stringT, string_adaptorT>* ownerDoc, const stringT& data) : CharacterDataImpl(DocumentImpl<stringT, string_adaptorT>* ownerDoc, const stringT& data) :
ChildlessNodeImpl<stringT, string_adaptorT>(ownerDoc), ChildlessNodeImpl<stringT, string_adaptorT>(ownerDoc),
data_(data) data_(data)
{ {
} // CharacterDataImpl } // CharacterDataImpl
virtual ~CharacterDataImpl() { } virtual ~CharacterDataImpl() { }
@ -39,9 +33,7 @@ class CharacterDataImpl : virtual public DOM::CharacterData_impl<stringT, string
virtual void setData(const stringT& data) virtual void setData(const stringT& data)
{ {
NodeT::throwIfReadOnly(); NodeT::throwIfReadOnly();
stringT oldValue = data_;
setNodeValue(data); setNodeValue(data);
DISPATCH_DOM_CHARACTERDATA_MODIFIED_EVENT(oldValue, data_);
} // setData } // setData
virtual int getLength() const virtual int getLength() const
@ -62,9 +54,7 @@ class CharacterDataImpl : virtual public DOM::CharacterData_impl<stringT, string
virtual void appendData(const stringT& arg) virtual void appendData(const stringT& arg)
{ {
NodeT::throwIfReadOnly(); NodeT::throwIfReadOnly();
stringT oldValue = data_;
string_adaptorT::append(data_, arg); string_adaptorT::append(data_, arg);
DISPATCH_DOM_CHARACTERDATA_MODIFIED_EVENT(oldValue, data_);
} // appendData } // appendData
virtual void insertData(int offset, const stringT& arg) virtual void insertData(int offset, const stringT& arg)
@ -74,9 +64,7 @@ class CharacterDataImpl : virtual public DOM::CharacterData_impl<stringT, string
if((offset < 0) || (offset > static_cast<int>(string_adaptorT::length(data_)))) if((offset < 0) || (offset > static_cast<int>(string_adaptorT::length(data_))))
throw DOM::DOMException(DOM::DOMException::INDEX_SIZE_ERR); throw DOM::DOMException(DOM::DOMException::INDEX_SIZE_ERR);
stringT oldValue = data_;
string_adaptorT::insert(data_, offset, arg); string_adaptorT::insert(data_, offset, arg);
DISPATCH_DOM_CHARACTERDATA_MODIFIED_EVENT(oldValue, data_);
} // insertData } // insertData
virtual void deleteData(int offset, int count) virtual void deleteData(int offset, int count)
@ -88,9 +76,7 @@ class CharacterDataImpl : virtual public DOM::CharacterData_impl<stringT, string
if(count < 0) if(count < 0)
throw DOM::DOMException(DOM::DOMException::INDEX_SIZE_ERR); throw DOM::DOMException(DOM::DOMException::INDEX_SIZE_ERR);
stringT oldValue = data_;
string_adaptorT::replace(data_, offset, count, stringT()); string_adaptorT::replace(data_, offset, count, stringT());
DISPATCH_DOM_CHARACTERDATA_MODIFIED_EVENT(oldValue, data_);
} // deleteData } // deleteData
virtual void replaceData(int offset, int count, const stringT& arg) virtual void replaceData(int offset, int count, const stringT& arg)
@ -102,14 +88,12 @@ class CharacterDataImpl : virtual public DOM::CharacterData_impl<stringT, string
if(count < 0) if(count < 0)
throw DOM::DOMException(DOM::DOMException::INDEX_SIZE_ERR); throw DOM::DOMException(DOM::DOMException::INDEX_SIZE_ERR);
stringT oldValue = data_;
string_adaptorT::replace(data_, offset, count, arg); string_adaptorT::replace(data_, offset, count, arg);
DISPATCH_DOM_CHARACTERDATA_MODIFIED_EVENT(oldValue, data_);
} // replaceData } // replaceData
/////////////////////////////////////////////////////// ///////////////////////////////////////////////////////
// DOM::Node methods // DOM::Node methods
virtual const stringT& getNodeValue() const virtual const stringT& getNodeValue() const
{ {
return data_; return data_;
} // getNodeValue } // getNodeValue
@ -118,9 +102,7 @@ class CharacterDataImpl : virtual public DOM::CharacterData_impl<stringT, string
{ {
NodeT::throwIfReadOnly(); NodeT::throwIfReadOnly();
stringT oldValue = data_;
data_ = data; data_ = data;
DISPATCH_DOM_CHARACTERDATA_MODIFIED_EVENT(oldValue, data_);
} // setNodeValue } // setNodeValue
private: private:
stringT data_; stringT data_;
@ -130,4 +112,3 @@ class CharacterDataImpl : virtual public DOM::CharacterData_impl<stringT, string
} // namespace Arabica } // namespace Arabica
#endif #endif

10
include/DOM/Simple/DOMImplementation.hpp
View file

@ -18,7 +18,7 @@ template<class stringT, class string_adaptorT = Arabica::default_string_adaptor<
class DOMImplementation class DOMImplementation
{ {
public: public:
static DOM::DOMImplementation<stringT, string_adaptorT> getDOMImplementation() static DOM::DOMImplementation<stringT, string_adaptorT> getDOMImplementation()
{ {
static DOMImplementationImpl<stringT, string_adaptorT> domImpl; static DOMImplementationImpl<stringT, string_adaptorT> domImpl;
return DOM::DOMImplementation<stringT, string_adaptorT>(&domImpl); return DOM::DOMImplementation<stringT, string_adaptorT>(&domImpl);
@ -41,15 +41,15 @@ class DOMImplementationImpl : public DOM::DOMImplementation_impl<stringT, string
virtual bool hasFeature(const stringT& feature, const stringT& version) const virtual bool hasFeature(const stringT& feature, const stringT& version) const
{ {
// need a proper case-insensitive compare here eventually // need a proper case-insensitive compare here eventually
const char* names[] = { "Core", "core", "CORE", "XML", "xml", "Events", "MutationEvents", 0 }; const char* names[] = { "Core", "core", "CORE", "XML", "xml", 0 };
for(int n = 0; names[n] != 0; ++n) for(int n = 0; names[n] != 0; ++n)
{ {
if((feature == string_adaptorT::construct_from_utf8(names[n])) && if((feature == string_adaptorT::construct_from_utf8(names[n])) &&
(string_adaptorT::empty(version) || (string_adaptorT::empty(version) ||
version == string_adaptorT::construct_from_utf8("1.0") || version == string_adaptorT::construct_from_utf8("1.0") ||
version == string_adaptorT::construct_from_utf8("2.0"))) version == string_adaptorT::construct_from_utf8("2.0")))
return true; return true;
} // while } // while
return false; return false;
} // hasFeature } // hasFeature

68
include/DOM/Simple/DocumentImpl.hpp
View file

@ -15,7 +15,6 @@
#include <DOM/Simple/NotationImpl.hpp> #include <DOM/Simple/NotationImpl.hpp>
#include <DOM/Simple/ElementByTagImpl.hpp> #include <DOM/Simple/ElementByTagImpl.hpp>
#include <DOM/Simple/NodeImpl.hpp> #include <DOM/Simple/NodeImpl.hpp>
#include <DOM/Simple/DocumentEventImpl.hpp>
#include <set> #include <set>
#include <algorithm> #include <algorithm>
@ -41,8 +40,7 @@ class valueIs : public std::unary_function<AttrImpl<stringT, string_adaptorT>*,
template<class stringT, class string_adaptorT> template<class stringT, class string_adaptorT>
class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>, class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
public NodeImplWithChildren<stringT, string_adaptorT>, public NodeImplWithChildren<stringT, string_adaptorT>
virtual public DocumentEventImpl<stringT, string_adaptorT>
{ {
typedef NodeImpl<stringT, string_adaptorT> NodeImplT; typedef NodeImpl<stringT, string_adaptorT> NodeImplT;
@ -57,21 +55,21 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
typedef DOM::DocumentType_impl<stringT, string_adaptorT> DOMDocumentType_implT; typedef DOM::DocumentType_impl<stringT, string_adaptorT> DOMDocumentType_implT;
typedef DOM::DOMImplementation<stringT, string_adaptorT> DOMDOMImplementationT; typedef DOM::DOMImplementation<stringT, string_adaptorT> DOMDOMImplementationT;
DocumentImpl() : DocumentImpl() :
NodeWithChildrenT(0), NodeWithChildrenT(0),
documentElement_(0), documentElement_(0),
documentType_(0), documentType_(0),
domImplementation_(), domImplementation_(),
namespaceURI_(), namespaceURI_(),
qualifiedName_(), qualifiedName_(),
changesCount_(0), changesCount_(0),
refCount_(0), refCount_(0),
empty_() empty_()
{ {
NodeImplT::setOwnerDoc(this); NodeImplT::setOwnerDoc(this);
} // DocumentBaseImpl } // DocumentBaseImpl
DocumentImpl(DOMDOMImplementationT domImpl) : DocumentImpl(DOMDOMImplementationT domImpl) :
NodeWithChildrenT(0), NodeWithChildrenT(0),
documentElement_(0), documentElement_(0),
documentType_(0), documentType_(0),
@ -80,14 +78,14 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
qualifiedName_(), qualifiedName_(),
changesCount_(0), changesCount_(0),
refCount_(0) refCount_(0)
{ {
NodeImplT::setOwnerDoc(this); NodeImplT::setOwnerDoc(this);
} // DocumentBaseImpl } // DocumentBaseImpl
DocumentImpl(const stringT& namespaceURI, DocumentImpl(const stringT& namespaceURI,
const stringT& qualifiedName, const stringT& qualifiedName,
DOMDocumentType_implT* docType, DOMDocumentType_implT* docType,
DOMDOMImplementationT domImpl) : DOMDOMImplementationT domImpl) :
NodeWithChildrenT(0), NodeWithChildrenT(0),
documentElement_(0), documentElement_(0),
documentType_(0), documentType_(0),
@ -96,7 +94,7 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
qualifiedName_(qualifiedName), qualifiedName_(qualifiedName),
changesCount_(0), changesCount_(0),
refCount_(0) refCount_(0)
{ {
NodeImplT::setOwnerDoc(this); NodeImplT::setOwnerDoc(this);
if(docType) if(docType)
{ {
@ -106,8 +104,8 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
} // if(docType) } // if(docType)
} // DocumentBaseImpl } // DocumentBaseImpl
virtual ~DocumentImpl() virtual ~DocumentImpl()
{ {
for(typename std::set<NodeImplT*>::iterator n = orphans_.begin(); n != orphans_.end(); ++n) for(typename std::set<NodeImplT*>::iterator n = orphans_.begin(); n != orphans_.end(); ++n)
delete *n; delete *n;
} // ~DocumentImpl } // ~DocumentImpl
@ -150,7 +148,7 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
DOMElement_implT* createElement_nocheck(const stringT& tagName) const DOMElement_implT* createElement_nocheck(const stringT& tagName) const
{ {
ElementImplT* n = ElementImplT* n =
new ElementImplT(const_cast<DocumentImpl*>(this), tagName); new ElementImplT(const_cast<DocumentImpl*>(this), tagName);
orphaned(n); orphaned(n);
return n; return n;
@ -192,7 +190,7 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
} // createProcessingInstruction } // createProcessingInstruction
DOM::ProcessingInstruction_impl<stringT, string_adaptorT>* createProcessingInstruction_nocheck(const stringT& target, const stringT& data) const DOM::ProcessingInstruction_impl<stringT, string_adaptorT>* createProcessingInstruction_nocheck(const stringT& target, const stringT& data) const
{ {
ProcessingInstructionImpl<stringT, string_adaptorT>* n = new ProcessingInstructionImpl<stringT, string_adaptorT>(const_cast<DocumentImpl*>(this), target, data); ProcessingInstructionImpl<stringT, string_adaptorT>* n = new ProcessingInstructionImpl<stringT, string_adaptorT>(const_cast<DocumentImpl*>(this), target, data);
orphaned(n); orphaned(n);
return n; return n;
@ -291,7 +289,7 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
entity->getPublicId(), entity->getPublicId(),
entity->getSystemId(), entity->getSystemId(),
entity->getNotationName()); entity->getNotationName());
} }
break; break;
case DOM::Node_base::ENTITY_REFERENCE_NODE: case DOM::Node_base::ENTITY_REFERENCE_NODE:
newNode = createEntityReference_nocheck(importedNode->getNodeName()); newNode = createEntityReference_nocheck(importedNode->getNodeName());
@ -304,7 +302,7 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
entity->getNodeName(), entity->getNodeName(),
entity->getPublicId(), entity->getPublicId(),
entity->getSystemId()); entity->getSystemId());
} }
break; break;
case DOM::Node_base::PROCESSING_INSTRUCTION_NODE: case DOM::Node_base::PROCESSING_INSTRUCTION_NODE:
newNode = createProcessingInstruction_nocheck(importedNode->getNodeName(), importedNode->getNodeValue()); newNode = createProcessingInstruction_nocheck(importedNode->getNodeName(), importedNode->getNodeValue());
@ -343,7 +341,7 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
DOMElement_implT* createElementNS_nocheck(const stringT& namespaceURI, const stringT& qualifiedName) const DOMElement_implT* createElementNS_nocheck(const stringT& namespaceURI, const stringT& qualifiedName) const
{ {
ElementNSImpl<stringT, string_adaptorT>* n = ElementNSImpl<stringT, string_adaptorT>* n =
new ElementNSImpl<stringT, string_adaptorT>(const_cast<DocumentImpl*>(this), namespaceURI, !string_adaptorT::empty(namespaceURI), qualifiedName); new ElementNSImpl<stringT, string_adaptorT>(const_cast<DocumentImpl*>(this), namespaceURI, !string_adaptorT::empty(namespaceURI), qualifiedName);
orphaned(n); orphaned(n);
return n; return n;
@ -378,12 +376,12 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
} // getElementById } // getElementById
//////////////////////////////////////////////////////// ////////////////////////////////////////////////////////
// DOM Node methods // DOM Node methods
virtual typename DOM::Node_base::Type getNodeType() const virtual typename DOM::Node_base::Type getNodeType() const
{ {
return DOM::Node_base::DOCUMENT_NODE; return DOM::Node_base::DOCUMENT_NODE;
} // getNodeType } // getNodeType
virtual DOMNode_implT* getParentNode() const { return 0; } virtual DOMNode_implT* getParentNode() const { return 0; }
virtual DOMDocument_implT* getOwnerDocument() const { return 0; } virtual DOMDocument_implT* getOwnerDocument() const { return 0; }
@ -417,14 +415,14 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
if((newChild->getNodeType() == DOM::Node_base::DOCUMENT_TYPE_NODE) && (documentType_ == oldChild)) if((newChild->getNodeType() == DOM::Node_base::DOCUMENT_TYPE_NODE) && (documentType_ == oldChild))
throw DOM::DOMException(DOM::DOMException::HIERARCHY_REQUEST_ERR); throw DOM::DOMException(DOM::DOMException::HIERARCHY_REQUEST_ERR);
if((newChild->getNodeType() == DOM::Node_base::ELEMENT_NODE) && if((newChild->getNodeType() == DOM::Node_base::ELEMENT_NODE) &&
(documentElement_ != 0) && (documentElement_ != 0) &&
(documentElement_ != oldChild)) (documentElement_ != oldChild))
throw DOM::DOMException(DOM::DOMException::HIERARCHY_REQUEST_ERR); throw DOM::DOMException(DOM::DOMException::HIERARCHY_REQUEST_ERR);
DOMNode_implT* result = NodeWithChildrenT::replaceChild(newChild, oldChild); DOMNode_implT* result = NodeWithChildrenT::replaceChild(newChild, oldChild);
if((newChild->getNodeType() == DOM::Node_base::ELEMENT_NODE) && if((newChild->getNodeType() == DOM::Node_base::ELEMENT_NODE) &&
((documentElement_ == 0) || (documentElement_ == oldChild))) ((documentElement_ == 0) || (documentElement_ == oldChild)))
documentElement_ = dynamic_cast<DOMElement_implT*>(newChild); documentElement_ = dynamic_cast<DOMElement_implT*>(newChild);
@ -433,10 +431,10 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
virtual DOMNode_implT* removeChild(DOMNode_implT* oldChild) virtual DOMNode_implT* removeChild(DOMNode_implT* oldChild)
{ {
if((documentType_ == oldChild)) if(documentType_ == oldChild)
throw DOM::DOMException(DOM::DOMException::HIERARCHY_REQUEST_ERR); throw DOM::DOMException(DOM::DOMException::HIERARCHY_REQUEST_ERR);
DOMNode_implT* result = NodeWithChildrenT::removeChild(oldChild); DOMNode_implT* result = NodeWithChildrenT::removeChild(oldChild);
if(documentElement_ == oldChild) if(documentElement_ == oldChild)
documentElement_ = static_cast<DOMElement_implT*>(0); documentElement_ = static_cast<DOMElement_implT*>(0);
@ -456,7 +454,7 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
DocumentTypeImpl<stringT, string_adaptorT>* dt = dynamic_cast<DocumentTypeImpl<stringT, string_adaptorT>*>(documentType_->cloneNode(true)); DocumentTypeImpl<stringT, string_adaptorT>* dt = dynamic_cast<DocumentTypeImpl<stringT, string_adaptorT>*>(documentType_->cloneNode(true));
dt->setOwnerDoc(clone); dt->setOwnerDoc(clone);
clone->appendChild(dt); clone->appendChild(dt);
} }
if(deep) if(deep)
for(DOMNode_implT* child = NodeWithChildrenT::getFirstChild(); child != 0; child = child->getNextSibling()) for(DOMNode_implT* child = NodeWithChildrenT::getFirstChild(); child != 0; child = child->getNextSibling())
@ -472,8 +470,8 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
unsigned long changes() const { return changesCount_; } unsigned long changes() const { return changesCount_; }
void orphaned(NodeImplT* node) const void orphaned(NodeImplT* node) const
{ {
orphans_.insert(node); orphans_.insert(node);
} // orphaned } // orphaned
bool isOrphaned(NodeImplT* node) const bool isOrphaned(NodeImplT* node) const
@ -481,8 +479,8 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
return orphans_.find(node) != orphans_.end(); return orphans_.find(node) != orphans_.end();
} // isOrphaned } // isOrphaned
void purge(NodeImplT* node) void purge(NodeImplT* node)
{ {
orphans_.erase(node); orphans_.erase(node);
delete node; delete node;
} // purge } // purge
@ -494,7 +492,7 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
orphans_.erase(n); orphans_.erase(n);
} // adopted } // adopted
void setElementId(AttrImplT* attr) void setElementId(AttrImplT* attr)
{ {
idNodes_.insert(attr); idNodes_.insert(attr);
} // setElementId } // setElementId
@ -517,10 +515,10 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
void checkChildType(DOMNode_implT* child) void checkChildType(DOMNode_implT* child)
{ {
typename DOM::Node_base::Type type = child->getNodeType(); typename DOM::Node_base::Type type = child->getNodeType();
if((type != DOM::Node_base::ELEMENT_NODE) && if((type != DOM::Node_base::ELEMENT_NODE) &&
(type != DOM::Node_base::PROCESSING_INSTRUCTION_NODE) && (type != DOM::Node_base::PROCESSING_INSTRUCTION_NODE) &&
(type != DOM::Node_base::COMMENT_NODE) && (type != DOM::Node_base::COMMENT_NODE) &&
(type != DOM::Node_base::DOCUMENT_TYPE_NODE)) (type != DOM::Node_base::DOCUMENT_TYPE_NODE))
throw DOM::DOMException(DOM::DOMException::HIERARCHY_REQUEST_ERR); throw DOM::DOMException(DOM::DOMException::HIERARCHY_REQUEST_ERR);
} // checkChildType } // checkChildType

84
include/DOM/Simple/ElementImpl.hpp
View file

@ -25,21 +25,19 @@ class ElementImpl : public DOM::Element_impl<stringT, string_adaptorT>,
typedef DOM::NodeList_impl<stringT, string_adaptorT> DOMNodeList_implT; typedef DOM::NodeList_impl<stringT, string_adaptorT> DOMNodeList_implT;
typedef DOM::NamedNodeMap_impl<stringT, string_adaptorT> DOMNamedNodeMap_implT; typedef DOM::NamedNodeMap_impl<stringT, string_adaptorT> DOMNamedNodeMap_implT;
typedef DOM::Element_impl<stringT, string_adaptorT> DOMElement_implT; typedef DOM::Element_impl<stringT, string_adaptorT> DOMElement_implT;
typedef DOM::Events::EventTarget<stringT, string_adaptorT> EventTargetT;
typedef DOM::Events::MutationEvent<stringT, string_adaptorT> MutationEventT;
public: public:
ElementImpl(DocumentImplT* ownerDoc, const stringT& tagName) : ElementImpl(DocumentImplT* ownerDoc, const stringT& tagName) :
DOMElement_implT(), DOMElement_implT(),
NodeT(ownerDoc), NodeT(ownerDoc),
attributes_(ownerDoc), attributes_(ownerDoc),
tagName_(ownerDoc->stringPool(tagName)) tagName_(ownerDoc->stringPool(tagName))
{ {
attributes_.setOwnerElement(this); attributes_.setOwnerElement(this);
} // ElementImpl } // ElementImpl
virtual ~ElementImpl() virtual ~ElementImpl()
{ {
} // ~ElementImpl } // ~ElementImpl
///////////////////////////////////////////////////// /////////////////////////////////////////////////////
@ -51,37 +49,20 @@ class ElementImpl : public DOM::Element_impl<stringT, string_adaptorT>,
return attributes_.getAttribute(name); return attributes_.getAttribute(name);
} // getAttribute } // getAttribute
virtual void setAttribute(const stringT& name, const stringT& value) virtual void setAttribute(const stringT& name, const stringT& value)
{ {
this->checkName(name); this->checkName(name);
stringT oldValue = getAttribute(name); stringT oldValue = getAttribute(name);
attributes_.setAttribute(name, value); attributes_.setAttribute(name, value);
MutationEventT mutationEvent(NodeT::ownerDoc_->createEvent("MutationEvent"));
if (!string_adaptorT::empty(oldValue)) {
mutationEvent.initMutationEvent("DOMAttrModified", true, false, Arabica::DOM::Node<stringT, string_adaptorT>(this), string_adaptorT::empty_string(), value, name, MutationEventT::MODIFICATION);
} else {
mutationEvent.initMutationEvent("DOMAttrModified", true, false, Arabica::DOM::Node<stringT, string_adaptorT>(this), oldValue, value, name, MutationEventT::ADDITION);
}
EventTargetT eventTarget(this);
eventTarget.dispatchEvent(mutationEvent);
} // setAttribute } // setAttribute
virtual void removeAttribute(const stringT& name) virtual void removeAttribute(const stringT& name)
{ {
stringT oldValue = getAttribute(name); stringT oldValue = getAttribute(name);
attributes_.removeAttribute(name); attributes_.removeAttribute(name);
// dispatch DOMAttrModified event
MutationEventT mutationEvent(NodeT::ownerDoc_->createEvent("MutationEvent"));
mutationEvent.initMutationEvent("DOMAttrModified", true, false, Arabica::DOM::Node<stringT, string_adaptorT>(this), oldValue, string_adaptorT::empty_string(), name, MutationEventT::REMOVAL);
EventTargetT eventTarget(this);
eventTarget.dispatchEvent(mutationEvent);
} // removeAttribute } // removeAttribute
virtual DOMAttr_implT* getAttributeNode(const stringT& name) const virtual DOMAttr_implT* getAttributeNode(const stringT& name) const
{ {
return attributes_.getAttributeNode(name); return attributes_.getAttributeNode(name);
} // getAttributeNode } // getAttributeNode
@ -91,52 +72,32 @@ class ElementImpl : public DOM::Element_impl<stringT, string_adaptorT>,
return attributes_.setAttributeNode(newAttr); return attributes_.setAttributeNode(newAttr);
} // setAttributeNode } // setAttributeNode
virtual DOMAttr_implT* removeAttributeNode(DOMAttr_implT* oldAttr) virtual DOMAttr_implT* removeAttributeNode(DOMAttr_implT* oldAttr)
{ {
return attributes_.removeAttributeNode(oldAttr); return attributes_.removeAttributeNode(oldAttr);
} // removeAttributeNode } // removeAttributeNode
virtual DOMNodeList_implT* getElementsByTagName(const stringT& tagName) const virtual DOMNodeList_implT* getElementsByTagName(const stringT& tagName) const
{ {
return new ElementByTagListT(NodeT::ownerDoc_, return new ElementByTagListT(NodeT::ownerDoc_,
const_cast<ElementImpl*>(this), const_cast<ElementImpl*>(this),
tagName); tagName);
} // getElementsByTagName } // getElementsByTagName
virtual stringT getAttributeNS(const stringT& namespaceURI, const stringT& localName) const virtual stringT getAttributeNS(const stringT& namespaceURI, const stringT& localName) const
{ {
return attributes_.getAttributeNS(namespaceURI, localName); return attributes_.getAttributeNS(namespaceURI, localName);
} // getAttributeNS } // getAttributeNS
virtual void setAttributeNS(const stringT& namespaceURI, const stringT& qualifiedName, const stringT& value) virtual void setAttributeNS(const stringT& namespaceURI, const stringT& qualifiedName, const stringT& value)
{ {
this->checkName(qualifiedName); this->checkName(qualifiedName);
stringT oldValue = getAttribute(qualifiedName);
attributes_.setAttributeNS(namespaceURI, qualifiedName, value); attributes_.setAttributeNS(namespaceURI, qualifiedName, value);
// dispatch DOMAttrModified event
MutationEventT mutationEvent(NodeT::ownerDoc_->createEvent("MutationEvent"));
if (!string_adaptorT::empty(oldValue)) {
mutationEvent.initMutationEvent("DOMAttrModified", true, false, Arabica::DOM::Node<stringT, string_adaptorT>(this), string_adaptorT::empty_string(), value, qualifiedName, MutationEventT::MODIFICATION);
} else {
mutationEvent.initMutationEvent("DOMAttrModified", true, false, Arabica::DOM::Node<stringT, string_adaptorT>(this), oldValue, value, qualifiedName, MutationEventT::ADDITION);
}
EventTargetT eventTarget(this);
eventTarget.dispatchEvent(mutationEvent);
} // setAttributeNS } // setAttributeNS
virtual void removeAttributeNS(const stringT& namespaceURI, const stringT& localName) virtual void removeAttributeNS(const stringT& namespaceURI, const stringT& localName)
{ {
stringT oldValue = getAttributeNS(namespaceURI, localName);
attributes_.removeAttributeNS(namespaceURI, localName); attributes_.removeAttributeNS(namespaceURI, localName);
// dispatch DOMAttrModified event
MutationEventT mutationEvent(NodeT::ownerDoc_->createEvent("MutationEvent"));
mutationEvent.initMutationEvent("DOMAttrModified", true, false, Arabica::DOM::Node<stringT, string_adaptorT>(this), oldValue, string_adaptorT::empty_string(), localName, MutationEventT::REMOVAL);
EventTargetT eventTarget(this);
eventTarget.dispatchEvent(mutationEvent);
} // removeAttributeNS } // removeAttributeNS
virtual DOMAttr_implT* getAttributeNodeNS(const stringT& namespaceURI, const stringT& localName) const virtual DOMAttr_implT* getAttributeNodeNS(const stringT& namespaceURI, const stringT& localName) const
@ -144,25 +105,25 @@ class ElementImpl : public DOM::Element_impl<stringT, string_adaptorT>,
return attributes_.getAttributeNodeNS(namespaceURI, localName); return attributes_.getAttributeNodeNS(namespaceURI, localName);
} // getAttributeNodeNS } // getAttributeNodeNS
virtual DOMAttr_implT* setAttributeNodeNS(DOMAttr_implT* newAttr) virtual DOMAttr_implT* setAttributeNodeNS(DOMAttr_implT* newAttr)
{ {
return attributes_.setAttributeNodeNS(newAttr); return attributes_.setAttributeNodeNS(newAttr);
} // setAttributeNodeNS } // setAttributeNodeNS
virtual DOMNodeList_implT* getElementsByTagNameNS(const stringT& namespaceURI, const stringT& localName) const virtual DOMNodeList_implT* getElementsByTagNameNS(const stringT& namespaceURI, const stringT& localName) const
{ {
return new ElementByTagListT(NodeT::ownerDoc_, return new ElementByTagListT(NodeT::ownerDoc_,
const_cast<ElementImpl*>(this), const_cast<ElementImpl*>(this),
namespaceURI, namespaceURI,
localName); localName);
} // getElementsByTagNameNS } // getElementsByTagNameNS
virtual bool hasAttribute(const stringT& name) const virtual bool hasAttribute(const stringT& name) const
{ {
return attributes_.hasAttribute(name); return attributes_.hasAttribute(name);
} // hasAttribute } // hasAttribute
virtual bool hasAttributeNS(const stringT& namespaceURI, const stringT& localName) const virtual bool hasAttributeNS(const stringT& namespaceURI, const stringT& localName) const
{ {
return attributes_.hasAttributeNS(namespaceURI, localName); return attributes_.hasAttributeNS(namespaceURI, localName);
} // hasAttributeNS } // hasAttributeNS
@ -233,12 +194,12 @@ class ElementImpl : public DOM::Element_impl<stringT, string_adaptorT>,
virtual void checkChildType(DOMNode_implT* child) virtual void checkChildType(DOMNode_implT* child)
{ {
typename DOM::Node_base::Type type = child->getNodeType(); typename DOM::Node_base::Type type = child->getNodeType();
if((type != DOM::Node_base::ELEMENT_NODE) && if((type != DOM::Node_base::ELEMENT_NODE) &&
(type != DOM::Node_base::TEXT_NODE) && (type != DOM::Node_base::TEXT_NODE) &&
(type != DOM::Node_base::COMMENT_NODE) && (type != DOM::Node_base::COMMENT_NODE) &&
(type != DOM::Node_base::PROCESSING_INSTRUCTION_NODE) && (type != DOM::Node_base::PROCESSING_INSTRUCTION_NODE) &&
(type != DOM::Node_base::CDATA_SECTION_NODE) && (type != DOM::Node_base::CDATA_SECTION_NODE) &&
(type != DOM::Node_base::ENTITY_REFERENCE_NODE)) (type != DOM::Node_base::ENTITY_REFERENCE_NODE))
throw DOM::DOMException(DOM::DOMException::HIERARCHY_REQUEST_ERR); throw DOM::DOMException(DOM::DOMException::HIERARCHY_REQUEST_ERR);
} // checkChildType } // checkChildType
@ -251,4 +212,3 @@ class ElementImpl : public DOM::Element_impl<stringT, string_adaptorT>,
} // namespace Arabica } // namespace Arabica
#endif #endif

123
include/DOM/Simple/NodeImpl.hpp
View file

@ -14,12 +14,7 @@
#include <algorithm> #include <algorithm>
#include <map> #include <map>
#include <DOM/Events/MutationEvent.hpp> namespace Arabica
#include <DOM/Simple/EventTargetImpl.hpp>
//#include <iostream>
namespace Arabica
{ {
namespace SimpleDOM namespace SimpleDOM
{ {
@ -28,8 +23,7 @@ namespace SimpleDOM
template<class stringT, class string_adaptorT> class DocumentImpl; template<class stringT, class string_adaptorT> class DocumentImpl;
template<class stringT, class string_adaptorT> template<class stringT, class string_adaptorT>
class NodeImpl : virtual public DOM::Node_impl<stringT, string_adaptorT>, class NodeImpl : virtual public DOM::Node_impl<stringT, string_adaptorT>
virtual public EventTargetImpl<stringT, string_adaptorT>
{ {
public: public:
typedef NodeImpl<stringT, string_adaptorT> NodeImplT; typedef NodeImpl<stringT, string_adaptorT> NodeImplT;
@ -39,10 +33,6 @@ class NodeImpl : virtual public DOM::Node_impl<stringT, string_adaptorT>,
typedef DOM::Document_impl<stringT, string_adaptorT> DOMDocument_implT; typedef DOM::Document_impl<stringT, string_adaptorT> DOMDocument_implT;
typedef DOM::NamedNodeMap_impl<stringT, string_adaptorT> DOMNamedNodeMap_implT; typedef DOM::NamedNodeMap_impl<stringT, string_adaptorT> DOMNamedNodeMap_implT;
typedef DOM::NodeList_impl<stringT, string_adaptorT> DOMNodeList_implT; typedef DOM::NodeList_impl<stringT, string_adaptorT> DOMNodeList_implT;
typedef DOM::Events::Event<stringT, string_adaptorT> EventT;
typedef DOM::Events::MutationEvent<stringT, string_adaptorT> MutationEventT;
typedef DOM::Events::EventTarget<stringT, string_adaptorT> EventTargetT;
typedef DOM::Events::EventListener<stringT, string_adaptorT> EventListenerT;
NodeImpl(DocumentImplT* ownerDoc) : NodeImpl(DocumentImplT* ownerDoc) :
parentNode_(0), parentNode_(0),
@ -53,9 +43,9 @@ class NodeImpl : virtual public DOM::Node_impl<stringT, string_adaptorT>,
{ {
//std::cout << std::endl << "born " << this << std::endl; //std::cout << std::endl << "born " << this << std::endl;
} // NodeImpl } // NodeImpl
virtual ~NodeImpl() virtual ~NodeImpl()
{ {
//std::cout << std::endl << "die " << this << std::endl; //std::cout << std::endl << "die " << this << std::endl;
} }
@ -66,7 +56,7 @@ class NodeImpl : virtual public DOM::Node_impl<stringT, string_adaptorT>,
if(ownerDoc_) if(ownerDoc_)
ownerDoc_->addRef(); ownerDoc_->addRef();
} // addRef } // addRef
virtual void releaseRef() virtual void releaseRef()
{ {
if(ownerDoc_) if(ownerDoc_)
ownerDoc_->releaseRef(); ownerDoc_->releaseRef();
@ -80,11 +70,11 @@ class NodeImpl : virtual public DOM::Node_impl<stringT, string_adaptorT>,
virtual void setNodeValue(const stringT& /*nodeValue*/) { } virtual void setNodeValue(const stringT& /*nodeValue*/) { }
virtual DOM::Node_base::Type getNodeType() const = 0; virtual DOM::Node_base::Type getNodeType() const = 0;
virtual DOMNode_implT* getParentNode() const { return parentNode_; } virtual DOMNode_implT* getParentNode() const { return parentNode_; }
virtual DOMNodeList_implT* getChildNodes() const = 0; virtual DOMNodeList_implT* getChildNodes() const = 0;
virtual DOMNode_implT* getFirstChild() const = 0; virtual DOMNode_implT* getFirstChild() const = 0;
virtual DOMNode_implT* getLastChild() const = 0; virtual DOMNode_implT* getLastChild() const = 0;
@ -107,7 +97,7 @@ class NodeImpl : virtual public DOM::Node_impl<stringT, string_adaptorT>,
virtual void normalize() virtual void normalize()
{ {
DOMNode_implT*child = getFirstChild(); DOMNode_implT*child = getFirstChild();
while(child != 0) while(child != 0)
{ {
DOMNode_implT*next = child->getNextSibling(); DOMNode_implT*next = child->getNextSibling();
@ -115,21 +105,21 @@ class NodeImpl : virtual public DOM::Node_impl<stringT, string_adaptorT>,
if(child->getNodeType() == DOM::Node_base::TEXT_NODE) if(child->getNodeType() == DOM::Node_base::TEXT_NODE)
{ {
DOMText_implT* textNode = dynamic_cast<DOMText_implT*>(child); DOMText_implT* textNode = dynamic_cast<DOMText_implT*>(child);
while((next != 0) && while((next != 0) &&
(next->getNodeType() == DOM::Node_base::TEXT_NODE)) (next->getNodeType() == DOM::Node_base::TEXT_NODE))
{ {
textNode->appendData(next->getNodeValue()); textNode->appendData(next->getNodeValue());
removeChild(next); removeChild(next);
next = textNode->getNextSibling(); next = textNode->getNextSibling();
} // while } // while
if(string_adaptorT::empty(textNode->getData())) if(string_adaptorT::empty(textNode->getData()))
removeChild(textNode); removeChild(textNode);
} }
else else
child->normalize(); child->normalize();
child = next; child = next;
} // while } // while
DOMNamedNodeMap_implT* attrs = getAttributes(); DOMNamedNodeMap_implT* attrs = getAttributes();
if(attrs) if(attrs)
@ -149,11 +139,11 @@ class NodeImpl : virtual public DOM::Node_impl<stringT, string_adaptorT>,
// additional methods - since C++ std::string (and by implication // additional methods - since C++ std::string (and by implication
// stringT) don't differenciate between a null string and an empty string, // stringT) don't differenciate between a null string and an empty string,
// but the DOM recommendation does, I have to introduce these three methods // but the DOM recommendation does, I have to introduce these three methods
// to disambiguate. If they return false, the corresponding attribute should be // to disambiguate. If they return false, the corresponding attribute should be
// considered null. If they return true, the attribute has been set EVEN IF // considered null. If they return true, the attribute has been set EVEN IF
// it has been set to the empty string // it has been set to the empty string
virtual bool hasNamespaceURI() const { return false; } virtual bool hasNamespaceURI() const { return false; }
virtual bool hasPrefix() const { return false; } virtual bool hasPrefix() const { return false; }
virtual bool hasAttributes() const { return false; } virtual bool hasAttributes() const { return false; }
@ -246,7 +236,7 @@ class NodeImpl : virtual public DOM::Node_impl<stringT, string_adaptorT>,
}; // class NodeImpl }; // class NodeImpl
template<class stringT, class string_adaptorT> template<class stringT, class string_adaptorT>
class ChildlessNodeImpl : public NodeImpl<stringT, string_adaptorT> class ChildlessNodeImpl : public NodeImpl<stringT, string_adaptorT>
{ {
public: public:
typedef DocumentImpl<stringT, string_adaptorT> DocumentImplT; typedef DocumentImpl<stringT, string_adaptorT> DocumentImplT;
@ -256,12 +246,12 @@ class ChildlessNodeImpl : public NodeImpl<stringT, string_adaptorT>
ChildlessNodeImpl(DocumentImplT* ownerDoc) : ChildlessNodeImpl(DocumentImplT* ownerDoc) :
NodeImpl<stringT, string_adaptorT>(ownerDoc) NodeImpl<stringT, string_adaptorT>(ownerDoc)
{ {
} // ChildlessNodeImpl } // ChildlessNodeImpl
/////////////////////////////////////////////////////// ///////////////////////////////////////////////////////
// Node methods // Node methods
virtual DOMNodeList_implT* getChildNodes() const { return 0; } virtual DOMNodeList_implT* getChildNodes() const { return 0; }
virtual DOMNode_implT* getFirstChild() const { return 0; } virtual DOMNode_implT* getFirstChild() const { return 0; }
virtual DOMNode_implT* getLastChild() const { return 0; } virtual DOMNode_implT* getLastChild() const { return 0; }
@ -302,18 +292,14 @@ class NodeImplWithChildren : public NodeImpl<stringT, string_adaptorT>,
typedef DocumentImpl<stringT, string_adaptorT> DocumentImplT; typedef DocumentImpl<stringT, string_adaptorT> DocumentImplT;
typedef DOM::Node_impl<stringT, string_adaptorT> DOMNode_implT; typedef DOM::Node_impl<stringT, string_adaptorT> DOMNode_implT;
typedef DOM::NodeList_impl<stringT, string_adaptorT> DOMNodeList_implT; typedef DOM::NodeList_impl<stringT, string_adaptorT> DOMNodeList_implT;
typedef DOM::Events::Event<stringT, string_adaptorT> EventT;
typedef DOM::Events::MutationEvent<stringT, string_adaptorT> MutationEventT;
typedef DOM::Events::EventTarget<stringT, string_adaptorT> EventTargetT;
typedef DOM::Events::EventListener<stringT, string_adaptorT> EventListenerT;
NodeImplWithChildren(DocumentImplT* ownerDoc) : NodeImplWithChildren(DocumentImplT* ownerDoc) :
NodeImplT(ownerDoc) NodeImplT(ownerDoc)
{ {
} // NodeImplWithChildren } // NodeImplWithChildren
virtual ~NodeImplWithChildren() virtual ~NodeImplWithChildren()
{ {
for(typename NodeListT::iterator i = nodes_.begin(); i != nodes_.end(); ++i) for(typename NodeListT::iterator i = nodes_.begin(); i != nodes_.end(); ++i)
delete (*i); delete (*i);
} // ~NodeImpl } // ~NodeImpl
@ -324,18 +310,18 @@ class NodeImplWithChildren : public NodeImpl<stringT, string_adaptorT>,
{ {
NodeImplT::addRef(); NodeImplT::addRef();
} // addRef } // addRef
virtual void releaseRef() virtual void releaseRef()
{ {
NodeImplT::releaseRef(); NodeImplT::releaseRef();
} // releaseRef } // releaseRef
/////////////////////////////////////////////////////// ///////////////////////////////////////////////////////
// Node methods // Node methods
virtual DOMNodeList_implT* getChildNodes() const virtual DOMNodeList_implT* getChildNodes() const
{ {
return const_cast<DOMNodeList_implT*>(static_cast<const DOMNodeList_implT*>(this)); return const_cast<DOMNodeList_implT*>(static_cast<const DOMNodeList_implT*>(this));
} // getChildNodes } // getChildNodes
virtual DOMNode_implT* getFirstChild() const virtual DOMNode_implT* getFirstChild() const
{ {
if(nodes_.size()) if(nodes_.size())
@ -352,13 +338,13 @@ class NodeImplWithChildren : public NodeImpl<stringT, string_adaptorT>,
virtual DOMNode_implT* insertBefore(DOMNode_implT* newChild, DOMNode_implT* refChild) virtual DOMNode_implT* insertBefore(DOMNode_implT* newChild, DOMNode_implT* refChild)
{ {
return do_insertBefore(dynamic_cast<NodeImplT*>(newChild), return do_insertBefore(dynamic_cast<NodeImplT*>(newChild),
dynamic_cast<NodeImplT*>(refChild)); dynamic_cast<NodeImplT*>(refChild));
} // insertBefore } // insertBefore
virtual DOMNode_implT* replaceChild(DOMNode_implT* newChild, DOMNode_implT* oldChild) virtual DOMNode_implT* replaceChild(DOMNode_implT* newChild, DOMNode_implT* oldChild)
{ {
return do_replaceChild(dynamic_cast<NodeImplT*>(newChild), return do_replaceChild(dynamic_cast<NodeImplT*>(newChild),
dynamic_cast<NodeImplT*>(oldChild)); dynamic_cast<NodeImplT*>(oldChild));
} // replaceChild } // replaceChild
@ -377,8 +363,8 @@ class NodeImplWithChildren : public NodeImpl<stringT, string_adaptorT>,
do_purgeChild(dynamic_cast<NodeImplT*>(oldChild)); do_purgeChild(dynamic_cast<NodeImplT*>(oldChild));
} // purgeChild } // purgeChild
virtual bool hasChildNodes() const virtual bool hasChildNodes() const
{ {
return nodes_.size() != 0; return nodes_.size() != 0;
} // hasChildNodes } // hasChildNodes
@ -423,14 +409,14 @@ class NodeImplWithChildren : public NodeImpl<stringT, string_adaptorT>,
newChild->setPrev(prev); newChild->setPrev(prev);
newChild->setNext(refChild); newChild->setNext(refChild);
refChild->setPrev(newChild); refChild->setPrev(newChild);
} }
else else
{ {
if(!nodes_.empty()) if(!nodes_.empty())
{ {
(*nodes_.rbegin())->setNext(newChild); (*nodes_.rbegin())->setNext(newChild);
newChild->setPrev(*nodes_.rbegin()); newChild->setPrev(*nodes_.rbegin());
} // } //
nodes_.push_back(newChild); nodes_.push_back(newChild);
} }
@ -438,19 +424,6 @@ class NodeImplWithChildren : public NodeImpl<stringT, string_adaptorT>,
markChanged(); markChanged();
// dispatch DOMNodeInserted event
MutationEventT mutationEvent(NodeImplT::ownerDoc_->createEvent("MutationEvent"));
mutationEvent.initMutationEvent("DOMNodeInserted",
true,
false,
Arabica::DOM::Node<stringT, string_adaptorT>(this),
string_adaptorT::empty_string(),
string_adaptorT::empty_string(),
string_adaptorT::empty_string(),
MutationEventT::ADDITION);
EventTargetT eventTarget(newChild);
eventTarget.dispatchEvent(mutationEvent);
return newChild; return newChild;
} // insertBefore } // insertBefore
@ -488,19 +461,6 @@ class NodeImplWithChildren : public NodeImpl<stringT, string_adaptorT>,
markChanged(); markChanged();
// dispatch DOMSubtreeModified event
MutationEventT mutationEvent(NodeImplT::ownerDoc_->createEvent("MutationEvent"));
mutationEvent.initMutationEvent("DOMSubtreeModified",
true,
false,
Arabica::DOM::Node<stringT, string_adaptorT>(),
string_adaptorT::empty_string(),
string_adaptorT::empty_string(),
string_adaptorT::empty_string(),
MutationEventT::MODIFICATION);
EventTargetT eventTarget(this);
eventTarget.dispatchEvent(mutationEvent);
return oldChild; return oldChild;
} // replaceChild } // replaceChild
@ -508,19 +468,6 @@ class NodeImplWithChildren : public NodeImpl<stringT, string_adaptorT>,
{ {
NodeImplT::throwIfReadOnly(); NodeImplT::throwIfReadOnly();
// dispatch DOMNodeRemoved event
MutationEventT mutationEvent(NodeImplT::ownerDoc_->createEvent("MutationEvent"));
mutationEvent.initMutationEvent("DOMNodeRemoved",
true,
false,
Arabica::DOM::Node<stringT, string_adaptorT>(this),
string_adaptorT::empty_string(),
string_adaptorT::empty_string(),
string_adaptorT::empty_string(),
MutationEventT::REMOVAL);
EventTargetT eventTarget(oldChild);
eventTarget.dispatchEvent(mutationEvent);
nodes_.erase(findChild(oldChild)); nodes_.erase(findChild(oldChild));
NodeImplT* prev = oldChild->getPrev(); NodeImplT* prev = oldChild->getPrev();
@ -574,9 +521,9 @@ class NodeImplWithChildren : public NodeImpl<stringT, string_adaptorT>,
{ {
child->setOwnerDoc(NodeImplT::getOwnerDoc()); child->setOwnerDoc(NodeImplT::getOwnerDoc());
return; return;
} // } //
if(child->getNodeType() == DOM::Node_base::DOCUMENT_NODE) if(child->getNodeType() == DOM::Node_base::DOCUMENT_NODE)
{ {
if(childDoc != dynamic_cast<DocumentImplT*>(this)) if(childDoc != dynamic_cast<DocumentImplT*>(this))
throw DOM::DOMException(DOM::DOMException::WRONG_DOCUMENT_ERR); throw DOM::DOMException(DOM::DOMException::WRONG_DOCUMENT_ERR);

9661
ltmain.sh
View file

File diff suppressed because it is too large Load diff

7851
m4/libtool.m4 vendored
View file

File diff suppressed because it is too large Load diff

369
m4/ltoptions.m4 vendored
View file

@ -1,369 +0,0 @@
# Helper functions for option handling. -*- Autoconf -*-
#
# Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation,
# Inc.
# Written by Gary V. Vaughan, 2004
#
# This file is free software; the Free Software Foundation gives
# unlimited permission to copy and/or distribute it, with or without
# modifications, as long as this notice is preserved.
# serial 7 ltoptions.m4
# This is to help aclocal find these macros, as it can't see m4_define.
AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])])
# _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME)
# ------------------------------------------
m4_define([_LT_MANGLE_OPTION],
[[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])])
# _LT_SET_OPTION(MACRO-NAME, OPTION-NAME)
# ---------------------------------------
# Set option OPTION-NAME for macro MACRO-NAME, and if there is a
# matching handler defined, dispatch to it. Other OPTION-NAMEs are
# saved as a flag.
m4_define([_LT_SET_OPTION],
[m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl
m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]),
_LT_MANGLE_DEFUN([$1], [$2]),
[m4_warning([Unknown $1 option `$2'])])[]dnl
])
# _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET])
# ------------------------------------------------------------
# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
m4_define([_LT_IF_OPTION],
[m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])])
# _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET)
# -------------------------------------------------------
# Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME
# are set.
m4_define([_LT_UNLESS_OPTIONS],
[m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
[m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option),
[m4_define([$0_found])])])[]dnl
m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3
])[]dnl
])
# _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST)
# ----------------------------------------
# OPTION-LIST is a space-separated list of Libtool options associated
# with MACRO-NAME. If any OPTION has a matching handler declared with
# LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about
# the unknown option and exit.
m4_defun([_LT_SET_OPTIONS],
[# Set options
m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
[_LT_SET_OPTION([$1], _LT_Option)])
m4_if([$1],[LT_INIT],[
dnl
dnl Simply set some default values (i.e off) if boolean options were not
dnl specified:
_LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no
])
_LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no
])
dnl
dnl If no reference was made to various pairs of opposing options, then
dnl we run the default mode handler for the pair. For example, if neither
dnl `shared' nor `disable-shared' was passed, we enable building of shared
dnl archives by default:
_LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED])
_LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC])
_LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC])
_LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install],
[_LT_ENABLE_FAST_INSTALL])
])
])# _LT_SET_OPTIONS
## --------------------------------- ##
## Macros to handle LT_INIT options. ##
## --------------------------------- ##
# _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME)
# -----------------------------------------
m4_define([_LT_MANGLE_DEFUN],
[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])])
# LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE)
# -----------------------------------------------
m4_define([LT_OPTION_DEFINE],
[m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl
])# LT_OPTION_DEFINE
# dlopen
# ------
LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes
])
AU_DEFUN([AC_LIBTOOL_DLOPEN],
[_LT_SET_OPTION([LT_INIT], [dlopen])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you
put the `dlopen' option into LT_INIT's first parameter.])
])
dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], [])
# win32-dll
# ---------
# Declare package support for building win32 dll's.
LT_OPTION_DEFINE([LT_INIT], [win32-dll],
[enable_win32_dll=yes
case $host in
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*)
AC_CHECK_TOOL(AS, as, false)
AC_CHECK_TOOL(DLLTOOL, dlltool, false)
AC_CHECK_TOOL(OBJDUMP, objdump, false)
;;
esac
test -z "$AS" && AS=as
_LT_DECL([], [AS], [1], [Assembler program])dnl
test -z "$DLLTOOL" && DLLTOOL=dlltool
_LT_DECL([], [DLLTOOL], [1], [DLL creation program])dnl
test -z "$OBJDUMP" && OBJDUMP=objdump
_LT_DECL([], [OBJDUMP], [1], [Object dumper program])dnl
])# win32-dll
AU_DEFUN([AC_LIBTOOL_WIN32_DLL],
[AC_REQUIRE([AC_CANONICAL_HOST])dnl
_LT_SET_OPTION([LT_INIT], [win32-dll])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you
put the `win32-dll' option into LT_INIT's first parameter.])
])
dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], [])
# _LT_ENABLE_SHARED([DEFAULT])
# ----------------------------
# implement the --enable-shared flag, and supports the `shared' and
# `disable-shared' LT_INIT options.
# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'.
m4_define([_LT_ENABLE_SHARED],
[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl
AC_ARG_ENABLE([shared],
[AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@],
[build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])],
[p=${PACKAGE-default}
case $enableval in
yes) enable_shared=yes ;;
no) enable_shared=no ;;
*)
enable_shared=no
# Look at the argument we got. We use all the common list separators.
lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
for pkg in $enableval; do
IFS="$lt_save_ifs"
if test "X$pkg" = "X$p"; then
enable_shared=yes
fi
done
IFS="$lt_save_ifs"
;;
esac],
[enable_shared=]_LT_ENABLE_SHARED_DEFAULT)
_LT_DECL([build_libtool_libs], [enable_shared], [0],
[Whether or not to build shared libraries])
])# _LT_ENABLE_SHARED
LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])])
LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])])
# Old names:
AC_DEFUN([AC_ENABLE_SHARED],
[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared])
])
AC_DEFUN([AC_DISABLE_SHARED],
[_LT_SET_OPTION([LT_INIT], [disable-shared])
])
AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)])
AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)])
dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AM_ENABLE_SHARED], [])
dnl AC_DEFUN([AM_DISABLE_SHARED], [])
# _LT_ENABLE_STATIC([DEFAULT])
# ----------------------------
# implement the --enable-static flag, and support the `static' and
# `disable-static' LT_INIT options.
# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'.
m4_define([_LT_ENABLE_STATIC],
[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl
AC_ARG_ENABLE([static],
[AS_HELP_STRING([--enable-static@<:@=PKGS@:>@],
[build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])],
[p=${PACKAGE-default}
case $enableval in
yes) enable_static=yes ;;
no) enable_static=no ;;
*)
enable_static=no
# Look at the argument we got. We use all the common list separators.
lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
for pkg in $enableval; do
IFS="$lt_save_ifs"
if test "X$pkg" = "X$p"; then
enable_static=yes
fi
done
IFS="$lt_save_ifs"
;;
esac],
[enable_static=]_LT_ENABLE_STATIC_DEFAULT)
_LT_DECL([build_old_libs], [enable_static], [0],
[Whether or not to build static libraries])
])# _LT_ENABLE_STATIC
LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])])
LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])])
# Old names:
AC_DEFUN([AC_ENABLE_STATIC],
[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static])
])
AC_DEFUN([AC_DISABLE_STATIC],
[_LT_SET_OPTION([LT_INIT], [disable-static])
])
AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)])
AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)])
dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AM_ENABLE_STATIC], [])
dnl AC_DEFUN([AM_DISABLE_STATIC], [])
# _LT_ENABLE_FAST_INSTALL([DEFAULT])
# ----------------------------------
# implement the --enable-fast-install flag, and support the `fast-install'
# and `disable-fast-install' LT_INIT options.
# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'.
m4_define([_LT_ENABLE_FAST_INSTALL],
[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl
AC_ARG_ENABLE([fast-install],
[AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],
[optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],
[p=${PACKAGE-default}
case $enableval in
yes) enable_fast_install=yes ;;
no) enable_fast_install=no ;;
*)
enable_fast_install=no
# Look at the argument we got. We use all the common list separators.
lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
for pkg in $enableval; do
IFS="$lt_save_ifs"
if test "X$pkg" = "X$p"; then
enable_fast_install=yes
fi
done
IFS="$lt_save_ifs"
;;
esac],
[enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT)
_LT_DECL([fast_install], [enable_fast_install], [0],
[Whether or not to optimize for fast installation])dnl
])# _LT_ENABLE_FAST_INSTALL
LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])])
LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])])
# Old names:
AU_DEFUN([AC_ENABLE_FAST_INSTALL],
[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you put
the `fast-install' option into LT_INIT's first parameter.])
])
AU_DEFUN([AC_DISABLE_FAST_INSTALL],
[_LT_SET_OPTION([LT_INIT], [disable-fast-install])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you put
the `disable-fast-install' option into LT_INIT's first parameter.])
])
dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], [])
dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], [])
# _LT_WITH_PIC([MODE])
# --------------------
# implement the --with-pic flag, and support the `pic-only' and `no-pic'
# LT_INIT options.
# MODE is either `yes' or `no'. If omitted, it defaults to `both'.
m4_define([_LT_WITH_PIC],
[AC_ARG_WITH([pic],
[AS_HELP_STRING([--with-pic],
[try to use only PIC/non-PIC objects @<:@default=use both@:>@])],
[pic_mode="$withval"],
[pic_mode=default])
test -z "$pic_mode" && pic_mode=m4_default([$1], [default])
_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl
])# _LT_WITH_PIC
LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])])
LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])])
# Old name:
AU_DEFUN([AC_LIBTOOL_PICMODE],
[_LT_SET_OPTION([LT_INIT], [pic-only])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you
put the `pic-only' option into LT_INIT's first parameter.])
])
dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AC_LIBTOOL_PICMODE], [])
## ----------------- ##
## LTDL_INIT Options ##
## ----------------- ##
m4_define([_LTDL_MODE], [])
LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive],
[m4_define([_LTDL_MODE], [nonrecursive])])
LT_OPTION_DEFINE([LTDL_INIT], [recursive],
[m4_define([_LTDL_MODE], [recursive])])
LT_OPTION_DEFINE([LTDL_INIT], [subproject],
[m4_define([_LTDL_MODE], [subproject])])
m4_define([_LTDL_TYPE], [])
LT_OPTION_DEFINE([LTDL_INIT], [installable],
[m4_define([_LTDL_TYPE], [installable])])
LT_OPTION_DEFINE([LTDL_INIT], [convenience],
[m4_define([_LTDL_TYPE], [convenience])])

123
m4/ltsugar.m4 vendored
View file

@ -1,123 +0,0 @@
# ltsugar.m4 -- libtool m4 base layer. -*-Autoconf-*-
#
# Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
# Written by Gary V. Vaughan, 2004
#
# This file is free software; the Free Software Foundation gives
# unlimited permission to copy and/or distribute it, with or without
# modifications, as long as this notice is preserved.
# serial 6 ltsugar.m4
# This is to help aclocal find these macros, as it can't see m4_define.
AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])])
# lt_join(SEP, ARG1, [ARG2...])
# -----------------------------
# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their
# associated separator.
# Needed until we can rely on m4_join from Autoconf 2.62, since all earlier
# versions in m4sugar had bugs.
m4_define([lt_join],
[m4_if([$#], [1], [],
[$#], [2], [[$2]],
[m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])])
m4_define([_lt_join],
[m4_if([$#$2], [2], [],
[m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])])
# lt_car(LIST)
# lt_cdr(LIST)
# ------------
# Manipulate m4 lists.
# These macros are necessary as long as will still need to support
# Autoconf-2.59 which quotes differently.
m4_define([lt_car], [[$1]])
m4_define([lt_cdr],
[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])],
[$#], 1, [],
[m4_dquote(m4_shift($@))])])
m4_define([lt_unquote], $1)
# lt_append(MACRO-NAME, STRING, [SEPARATOR])
# ------------------------------------------
# Redefine MACRO-NAME to hold its former content plus `SEPARATOR'`STRING'.
# Note that neither SEPARATOR nor STRING are expanded; they are appended
# to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked).
# No SEPARATOR is output if MACRO-NAME was previously undefined (different
# than defined and empty).
#
# This macro is needed until we can rely on Autoconf 2.62, since earlier
# versions of m4sugar mistakenly expanded SEPARATOR but not STRING.
m4_define([lt_append],
[m4_define([$1],
m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])])
# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...])
# ----------------------------------------------------------
# Produce a SEP delimited list of all paired combinations of elements of
# PREFIX-LIST with SUFFIX1 through SUFFIXn. Each element of the list
# has the form PREFIXmINFIXSUFFIXn.
# Needed until we can rely on m4_combine added in Autoconf 2.62.
m4_define([lt_combine],
[m4_if(m4_eval([$# > 3]), [1],
[m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl
[[m4_foreach([_Lt_prefix], [$2],
[m4_foreach([_Lt_suffix],
]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[,
[_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])])
# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ])
# -----------------------------------------------------------------------
# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited
# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ.
m4_define([lt_if_append_uniq],
[m4_ifdef([$1],
[m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1],
[lt_append([$1], [$2], [$3])$4],
[$5])],
[lt_append([$1], [$2], [$3])$4])])
# lt_dict_add(DICT, KEY, VALUE)
# -----------------------------
m4_define([lt_dict_add],
[m4_define([$1($2)], [$3])])
# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE)
# --------------------------------------------
m4_define([lt_dict_add_subkey],
[m4_define([$1($2:$3)], [$4])])
# lt_dict_fetch(DICT, KEY, [SUBKEY])
# ----------------------------------
m4_define([lt_dict_fetch],
[m4_ifval([$3],
m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]),
m4_ifdef([$1($2)], [m4_defn([$1($2)])]))])
# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE])
# -----------------------------------------------------------------
m4_define([lt_if_dict_fetch],
[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4],
[$5],
[$6])])
# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...])
# --------------------------------------------------------------
m4_define([lt_dict_filter],
[m4_if([$5], [], [],
[lt_join(m4_quote(m4_default([$4], [[, ]])),
lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]),
[lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl
])

23
m4/ltversion.m4 vendored
View file

@ -1,23 +0,0 @@
# ltversion.m4 -- version numbers -*- Autoconf -*-
#
# Copyright (C) 2004 Free Software Foundation, Inc.
# Written by Scott James Remnant, 2004
#
# This file is free software; the Free Software Foundation gives
# unlimited permission to copy and/or distribute it, with or without
# modifications, as long as this notice is preserved.
# @configure_input@
# serial 3337 ltversion.m4
# This file is part of GNU Libtool
m4_define([LT_PACKAGE_VERSION], [2.4.2])
m4_define([LT_PACKAGE_REVISION], [1.3337])
AC_DEFUN([LTVERSION_VERSION],
[macro_version='2.4.2'
macro_revision='1.3337'
_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?])
_LT_DECL(, macro_revision, 0)
])

1
missing
View file

@ -1 +0,0 @@
/usr/share/automake-1.11/missing