mirror of
https://github.com/jezhiggins/arabica
synced 2024-12-26 21:58:39 +01:00
Merge original jezhiggins/arabica
This commit is contained in:
Sebastian Schleussner
commit
c796cf458f
17 changed files with 143 additions and 18335 deletions
15
.gitignore
vendored
15
.gitignore
vendored
|
|
@ -1,13 +1,18 @@
|
|||
*.o
|
||||
*~
|
||||
libtool
|
||||
ltmain.sh
|
||||
config.log
|
||||
config.status
|
||||
configure
|
||||
compile
|
||||
autom4te.cache
|
||||
missing
|
||||
test-driver
|
||||
Makefile
|
||||
Makefile.in
|
||||
.deps
|
||||
.dirstamp
|
||||
aclocal.m4
|
||||
arabica.pc
|
||||
include/SAX/ArabicaConfig.hpp
|
||||
|
|
@ -40,6 +45,8 @@ vs10/mangle.sln
|
|||
*.dll
|
||||
spec
|
||||
gmon.out
|
||||
*.log
|
||||
*.trs
|
||||
examples/DOM/dom2pyx
|
||||
examples/DOM/domwriter
|
||||
examples/SAX/pyx
|
||||
|
|
@ -56,10 +63,14 @@ tests/DOM/dom_test*
|
|||
tests/XPath/xpath_test*
|
||||
tests/Taggle/taggle_test
|
||||
tests/Utils/utils_test*
|
||||
tests/XSLT/xslt_test
|
||||
tests/XSLT/xslt_test*
|
||||
bin/mandelbrot-*.html
|
||||
doc/html
|
||||
m4/lt~obsolete.m4
|
||||
m4/ltversion.m4
|
||||
m4/ltsugar.m4
|
||||
m4/ltoptions.m4
|
||||
m4/libtool.m4
|
||||
*.vcxproj.filters
|
||||
*.vcxproj.user
|
||||
*.sdf
|
||||
|
|
@ -73,3 +84,5 @@ cmake_install.cmake
|
|||
|
||||
build/*
|
||||
*.DS_Store*
|
||||
compile
|
||||
test-driver
|
||||
|
|
|
|||
|
|
@ -1,6 +1,8 @@
|
|||
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
|
||||
make
|
||||
Optionally make check to run the tests
|
||||
|
|
@ -17,4 +19,3 @@ Please see CMake.README
|
|||
Using Visual Studio
|
||||
-------------------
|
||||
See http://www.jezuk.co.uk/arabica/howtobuild
|
||||
|
||||
|
|
|
|||
48
autogen.sh
48
autogen.sh
|
|
@ -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
|
||||
|
||||
|
|
@ -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_PROG_CXX
|
||||
AC_PROG_LIBTOOL
|
||||
LT_INIT
|
||||
|
||||
AC_LANG([C++])
|
||||
|
||||
|
|
|
|||
|
|
@ -22,8 +22,6 @@
|
|||
#include <DOM/Traversal/DocumentTraversal.hpp>
|
||||
#include <DOM/Traversal/DocumentTraversalImpl.hpp>
|
||||
|
||||
#include <DOM/Events/DocumentEvent.hpp>
|
||||
|
||||
namespace Arabica
|
||||
{
|
||||
namespace DOM
|
||||
|
|
@ -31,7 +29,7 @@ namespace DOM
|
|||
|
||||
namespace Events {
|
||||
template<class stringT, class string_adaptorT> class DocumentEvent;
|
||||
} // namespace Events
|
||||
} // namespace Events
|
||||
|
||||
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(Document_impl<stringT, string_adaptorT>* impl) : Node<stringT, string_adaptorT>(impl) { }
|
||||
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
|
||||
return;
|
||||
|
|
@ -52,7 +50,7 @@ class Document : public Node<stringT, string_adaptorT>
|
|||
} // Document
|
||||
~Document() { }
|
||||
|
||||
Document& operator=(const Document& rhs)
|
||||
Document& operator=(const Document& rhs)
|
||||
{
|
||||
Node<stringT, string_adaptorT>::operator=(rhs);
|
||||
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
|
||||
{
|
||||
return ProcessingInstruction<stringT, string_adaptorT>(dImpl()->createProcessingInstruction(target, data));
|
||||
return ProcessingInstruction<stringT, string_adaptorT>(dImpl()->createProcessingInstruction(target, data));
|
||||
} // createProcessingInstruction
|
||||
|
||||
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
|
||||
{
|
||||
return Element<stringT, string_adaptorT>(dImpl()->createElementNS(namespaceURI, qualifiedName));
|
||||
return Element<stringT, string_adaptorT>(dImpl()->createElementNS(namespaceURI, qualifiedName));
|
||||
} // createElementNS
|
||||
|
||||
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
|
||||
|
||||
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;
|
||||
} // 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:
|
||||
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
|
||||
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -13,13 +13,13 @@
|
|||
#include <algorithm>
|
||||
|
||||
namespace Arabica
|
||||
{
|
||||
{
|
||||
namespace DOM
|
||||
{
|
||||
|
||||
namespace Events {
|
||||
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 NodeList;
|
||||
|
|
@ -54,21 +54,16 @@ class Node : public Node_base
|
|||
Node() : impl_() { }
|
||||
Node(Node_impl<stringT, string_adaptorT>* const impl) : impl_(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() { }
|
||||
|
||||
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==(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_;
|
||||
return *this;
|
||||
|
|
@ -80,11 +75,11 @@ class Node : public Node_base
|
|||
void setNodeValue(const stringT& nodeValue) { impl_->setNodeValue(nodeValue); }
|
||||
|
||||
Type getNodeType() const { return impl_->getNodeType(); }
|
||||
|
||||
|
||||
Node getParentNode() const { return impl_->getParentNode(); }
|
||||
|
||||
const NodeList<stringT, string_adaptorT> getChildNodes() const { return NodeList<stringT, string_adaptorT>(impl_->getChildNodes()); }
|
||||
|
||||
|
||||
Node getFirstChild() const { return impl_->getFirstChild(); }
|
||||
Node getLastChild() const { return impl_->getLastChild(); }
|
||||
Node getPreviousSibling() const { return impl_->getPreviousSibling(); }
|
||||
|
|
@ -94,17 +89,17 @@ class Node : public Node_base
|
|||
|
||||
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 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_); }
|
||||
void purgeChild(Node& oldChild)
|
||||
{
|
||||
void purgeChild(Node& oldChild)
|
||||
{
|
||||
Node_impl<stringT, string_adaptorT>* child = *oldChild.impl_;
|
||||
oldChild = 0;
|
||||
|
||||
try {
|
||||
impl_->purgeChild(child);
|
||||
impl_->purgeChild(child);
|
||||
}
|
||||
catch(DOMException&)
|
||||
{
|
||||
|
|
@ -112,7 +107,7 @@ class Node : public Node_base
|
|||
throw;
|
||||
} // catch
|
||||
} // purge
|
||||
|
||||
|
||||
bool hasChildNodes() const { return impl_->hasChildNodes(); }
|
||||
|
||||
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
|
||||
// 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
|
||||
// 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
|
||||
bool hasNamespaceURI() const { return impl_->hasNamespaceURI(); }
|
||||
bool hasNamespaceURI() const { return impl_->hasNamespaceURI(); }
|
||||
bool hasPrefix() const { return impl_->hasPrefix(); }
|
||||
|
||||
bool hasAttributes() const { return impl_->hasAttributes(); }
|
||||
|
|
@ -177,11 +172,11 @@ class Node_impl
|
|||
virtual void setNodeValue(const stringT& nodeValue) = 0;
|
||||
|
||||
virtual Node_base::Type getNodeType() const = 0;
|
||||
|
||||
|
||||
virtual Node_impl<stringT, string_adaptorT>* getParentNode() 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>* getLastChild() const = 0;
|
||||
|
||||
|
|
@ -213,9 +208,9 @@ class Node_impl
|
|||
|
||||
// additional methods - since C++ std::string (and by implication
|
||||
// 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
|
||||
// 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
|
||||
virtual bool hasNamespaceURI() const = 0;
|
||||
virtual bool hasPrefix() const = 0;
|
||||
|
|
|
|||
|
|
@ -4,12 +4,6 @@
|
|||
#include <DOM/CharacterData.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 SimpleDOM
|
||||
|
|
@ -21,10 +15,10 @@ class CharacterDataImpl : virtual public DOM::CharacterData_impl<stringT, string
|
|||
{
|
||||
typedef ChildlessNodeImpl<stringT, string_adaptorT> NodeT;
|
||||
public:
|
||||
CharacterDataImpl(DocumentImpl<stringT, string_adaptorT>* ownerDoc, const stringT& data) :
|
||||
CharacterDataImpl(DocumentImpl<stringT, string_adaptorT>* ownerDoc, const stringT& data) :
|
||||
ChildlessNodeImpl<stringT, string_adaptorT>(ownerDoc),
|
||||
data_(data)
|
||||
{
|
||||
{
|
||||
} // CharacterDataImpl
|
||||
|
||||
virtual ~CharacterDataImpl() { }
|
||||
|
|
@ -39,9 +33,7 @@ class CharacterDataImpl : virtual public DOM::CharacterData_impl<stringT, string
|
|||
virtual void setData(const stringT& data)
|
||||
{
|
||||
NodeT::throwIfReadOnly();
|
||||
stringT oldValue = data_;
|
||||
setNodeValue(data);
|
||||
DISPATCH_DOM_CHARACTERDATA_MODIFIED_EVENT(oldValue, data_);
|
||||
} // setData
|
||||
|
||||
virtual int getLength() const
|
||||
|
|
@ -62,9 +54,7 @@ class CharacterDataImpl : virtual public DOM::CharacterData_impl<stringT, string
|
|||
virtual void appendData(const stringT& arg)
|
||||
{
|
||||
NodeT::throwIfReadOnly();
|
||||
stringT oldValue = data_;
|
||||
string_adaptorT::append(data_, arg);
|
||||
DISPATCH_DOM_CHARACTERDATA_MODIFIED_EVENT(oldValue, data_);
|
||||
} // appendData
|
||||
|
||||
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_))))
|
||||
throw DOM::DOMException(DOM::DOMException::INDEX_SIZE_ERR);
|
||||
|
||||
stringT oldValue = data_;
|
||||
string_adaptorT::insert(data_, offset, arg);
|
||||
DISPATCH_DOM_CHARACTERDATA_MODIFIED_EVENT(oldValue, data_);
|
||||
} // insertData
|
||||
|
||||
virtual void deleteData(int offset, int count)
|
||||
|
|
@ -88,9 +76,7 @@ class CharacterDataImpl : virtual public DOM::CharacterData_impl<stringT, string
|
|||
if(count < 0)
|
||||
throw DOM::DOMException(DOM::DOMException::INDEX_SIZE_ERR);
|
||||
|
||||
stringT oldValue = data_;
|
||||
string_adaptorT::replace(data_, offset, count, stringT());
|
||||
DISPATCH_DOM_CHARACTERDATA_MODIFIED_EVENT(oldValue, data_);
|
||||
} // deleteData
|
||||
|
||||
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)
|
||||
throw DOM::DOMException(DOM::DOMException::INDEX_SIZE_ERR);
|
||||
|
||||
stringT oldValue = data_;
|
||||
string_adaptorT::replace(data_, offset, count, arg);
|
||||
DISPATCH_DOM_CHARACTERDATA_MODIFIED_EVENT(oldValue, data_);
|
||||
} // replaceData
|
||||
|
||||
///////////////////////////////////////////////////////
|
||||
// DOM::Node methods
|
||||
virtual const stringT& getNodeValue() const
|
||||
virtual const stringT& getNodeValue() const
|
||||
{
|
||||
return data_;
|
||||
} // getNodeValue
|
||||
|
|
@ -118,9 +102,7 @@ class CharacterDataImpl : virtual public DOM::CharacterData_impl<stringT, string
|
|||
{
|
||||
NodeT::throwIfReadOnly();
|
||||
|
||||
stringT oldValue = data_;
|
||||
data_ = data;
|
||||
DISPATCH_DOM_CHARACTERDATA_MODIFIED_EVENT(oldValue, data_);
|
||||
} // setNodeValue
|
||||
private:
|
||||
stringT data_;
|
||||
|
|
@ -130,4 +112,3 @@ class CharacterDataImpl : virtual public DOM::CharacterData_impl<stringT, string
|
|||
} // namespace Arabica
|
||||
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ template<class stringT, class string_adaptorT = Arabica::default_string_adaptor<
|
|||
class DOMImplementation
|
||||
{
|
||||
public:
|
||||
static DOM::DOMImplementation<stringT, string_adaptorT> getDOMImplementation()
|
||||
static DOM::DOMImplementation<stringT, string_adaptorT> getDOMImplementation()
|
||||
{
|
||||
static DOMImplementationImpl<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
|
||||
{
|
||||
// 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)
|
||||
{
|
||||
if((feature == string_adaptorT::construct_from_utf8(names[n])) &&
|
||||
(string_adaptorT::empty(version) ||
|
||||
version == string_adaptorT::construct_from_utf8("1.0") ||
|
||||
(string_adaptorT::empty(version) ||
|
||||
version == string_adaptorT::construct_from_utf8("1.0") ||
|
||||
version == string_adaptorT::construct_from_utf8("2.0")))
|
||||
return true;
|
||||
} // while
|
||||
} // while
|
||||
|
||||
return false;
|
||||
} // hasFeature
|
||||
|
|
|
|||
|
|
@ -15,7 +15,6 @@
|
|||
#include <DOM/Simple/NotationImpl.hpp>
|
||||
#include <DOM/Simple/ElementByTagImpl.hpp>
|
||||
#include <DOM/Simple/NodeImpl.hpp>
|
||||
#include <DOM/Simple/DocumentEventImpl.hpp>
|
||||
|
||||
#include <set>
|
||||
#include <algorithm>
|
||||
|
|
@ -41,8 +40,7 @@ class valueIs : public std::unary_function<AttrImpl<stringT, string_adaptorT>*,
|
|||
|
||||
template<class stringT, class string_adaptorT>
|
||||
class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
|
||||
public NodeImplWithChildren<stringT, string_adaptorT>,
|
||||
virtual public DocumentEventImpl<stringT, string_adaptorT>
|
||||
public NodeImplWithChildren<stringT, string_adaptorT>
|
||||
|
||||
{
|
||||
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::DOMImplementation<stringT, string_adaptorT> DOMDOMImplementationT;
|
||||
|
||||
DocumentImpl() :
|
||||
DocumentImpl() :
|
||||
NodeWithChildrenT(0),
|
||||
documentElement_(0),
|
||||
documentType_(0),
|
||||
domImplementation_(),
|
||||
domImplementation_(),
|
||||
namespaceURI_(),
|
||||
qualifiedName_(),
|
||||
changesCount_(0),
|
||||
refCount_(0),
|
||||
empty_()
|
||||
{
|
||||
{
|
||||
NodeImplT::setOwnerDoc(this);
|
||||
} // DocumentBaseImpl
|
||||
|
||||
DocumentImpl(DOMDOMImplementationT domImpl) :
|
||||
DocumentImpl(DOMDOMImplementationT domImpl) :
|
||||
NodeWithChildrenT(0),
|
||||
documentElement_(0),
|
||||
documentType_(0),
|
||||
|
|
@ -80,14 +78,14 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
|
|||
qualifiedName_(),
|
||||
changesCount_(0),
|
||||
refCount_(0)
|
||||
{
|
||||
{
|
||||
NodeImplT::setOwnerDoc(this);
|
||||
} // DocumentBaseImpl
|
||||
|
||||
DocumentImpl(const stringT& namespaceURI,
|
||||
const stringT& qualifiedName,
|
||||
DOMDocumentType_implT* docType,
|
||||
DOMDOMImplementationT domImpl) :
|
||||
DOMDOMImplementationT domImpl) :
|
||||
NodeWithChildrenT(0),
|
||||
documentElement_(0),
|
||||
documentType_(0),
|
||||
|
|
@ -96,7 +94,7 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
|
|||
qualifiedName_(qualifiedName),
|
||||
changesCount_(0),
|
||||
refCount_(0)
|
||||
{
|
||||
{
|
||||
NodeImplT::setOwnerDoc(this);
|
||||
if(docType)
|
||||
{
|
||||
|
|
@ -106,8 +104,8 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
|
|||
} // if(docType)
|
||||
} // DocumentBaseImpl
|
||||
|
||||
virtual ~DocumentImpl()
|
||||
{
|
||||
virtual ~DocumentImpl()
|
||||
{
|
||||
for(typename std::set<NodeImplT*>::iterator n = orphans_.begin(); n != orphans_.end(); ++n)
|
||||
delete *n;
|
||||
} // ~DocumentImpl
|
||||
|
|
@ -150,7 +148,7 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
|
|||
|
||||
DOMElement_implT* createElement_nocheck(const stringT& tagName) const
|
||||
{
|
||||
ElementImplT* n =
|
||||
ElementImplT* n =
|
||||
new ElementImplT(const_cast<DocumentImpl*>(this), tagName);
|
||||
orphaned(n);
|
||||
return n;
|
||||
|
|
@ -192,7 +190,7 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
|
|||
} // createProcessingInstruction
|
||||
|
||||
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);
|
||||
orphaned(n);
|
||||
return n;
|
||||
|
|
@ -291,7 +289,7 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
|
|||
entity->getPublicId(),
|
||||
entity->getSystemId(),
|
||||
entity->getNotationName());
|
||||
}
|
||||
}
|
||||
break;
|
||||
case DOM::Node_base::ENTITY_REFERENCE_NODE:
|
||||
newNode = createEntityReference_nocheck(importedNode->getNodeName());
|
||||
|
|
@ -304,7 +302,7 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
|
|||
entity->getNodeName(),
|
||||
entity->getPublicId(),
|
||||
entity->getSystemId());
|
||||
}
|
||||
}
|
||||
break;
|
||||
case DOM::Node_base::PROCESSING_INSTRUCTION_NODE:
|
||||
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
|
||||
{
|
||||
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);
|
||||
orphaned(n);
|
||||
return n;
|
||||
|
|
@ -378,12 +376,12 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
|
|||
} // getElementById
|
||||
|
||||
////////////////////////////////////////////////////////
|
||||
// DOM Node methods
|
||||
// DOM Node methods
|
||||
virtual typename DOM::Node_base::Type getNodeType() const
|
||||
{
|
||||
return DOM::Node_base::DOCUMENT_NODE;
|
||||
} // getNodeType
|
||||
|
||||
|
||||
virtual DOMNode_implT* getParentNode() 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))
|
||||
throw DOM::DOMException(DOM::DOMException::HIERARCHY_REQUEST_ERR);
|
||||
if((newChild->getNodeType() == DOM::Node_base::ELEMENT_NODE) &&
|
||||
(documentElement_ != 0) &&
|
||||
if((newChild->getNodeType() == DOM::Node_base::ELEMENT_NODE) &&
|
||||
(documentElement_ != 0) &&
|
||||
(documentElement_ != oldChild))
|
||||
throw DOM::DOMException(DOM::DOMException::HIERARCHY_REQUEST_ERR);
|
||||
|
||||
|
||||
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_ = 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)
|
||||
{
|
||||
if((documentType_ == oldChild))
|
||||
if(documentType_ == oldChild)
|
||||
throw DOM::DOMException(DOM::DOMException::HIERARCHY_REQUEST_ERR);
|
||||
DOMNode_implT* result = NodeWithChildrenT::removeChild(oldChild);
|
||||
|
||||
|
||||
if(documentElement_ == oldChild)
|
||||
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));
|
||||
dt->setOwnerDoc(clone);
|
||||
clone->appendChild(dt);
|
||||
}
|
||||
}
|
||||
|
||||
if(deep)
|
||||
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_; }
|
||||
|
||||
void orphaned(NodeImplT* node) const
|
||||
{
|
||||
orphans_.insert(node);
|
||||
{
|
||||
orphans_.insert(node);
|
||||
} // orphaned
|
||||
|
||||
bool isOrphaned(NodeImplT* node) const
|
||||
|
|
@ -481,8 +479,8 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
|
|||
return orphans_.find(node) != orphans_.end();
|
||||
} // isOrphaned
|
||||
|
||||
void purge(NodeImplT* node)
|
||||
{
|
||||
void purge(NodeImplT* node)
|
||||
{
|
||||
orphans_.erase(node);
|
||||
delete node;
|
||||
} // purge
|
||||
|
|
@ -494,7 +492,7 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
|
|||
orphans_.erase(n);
|
||||
} // adopted
|
||||
|
||||
void setElementId(AttrImplT* attr)
|
||||
void setElementId(AttrImplT* attr)
|
||||
{
|
||||
idNodes_.insert(attr);
|
||||
} // setElementId
|
||||
|
|
@ -517,10 +515,10 @@ class DocumentImpl : public DOM::Document_impl<stringT, string_adaptorT>,
|
|||
void checkChildType(DOMNode_implT* child)
|
||||
{
|
||||
typename DOM::Node_base::Type type = child->getNodeType();
|
||||
if((type != DOM::Node_base::ELEMENT_NODE) &&
|
||||
(type != DOM::Node_base::PROCESSING_INSTRUCTION_NODE) &&
|
||||
(type != DOM::Node_base::COMMENT_NODE) &&
|
||||
(type != DOM::Node_base::DOCUMENT_TYPE_NODE))
|
||||
if((type != DOM::Node_base::ELEMENT_NODE) &&
|
||||
(type != DOM::Node_base::PROCESSING_INSTRUCTION_NODE) &&
|
||||
(type != DOM::Node_base::COMMENT_NODE) &&
|
||||
(type != DOM::Node_base::DOCUMENT_TYPE_NODE))
|
||||
throw DOM::DOMException(DOM::DOMException::HIERARCHY_REQUEST_ERR);
|
||||
} // checkChildType
|
||||
|
||||
|
|
|
|||
|
|
@ -25,21 +25,19 @@ class ElementImpl : public DOM::Element_impl<stringT, string_adaptorT>,
|
|||
typedef DOM::NodeList_impl<stringT, string_adaptorT> DOMNodeList_implT;
|
||||
typedef DOM::NamedNodeMap_impl<stringT, string_adaptorT> DOMNamedNodeMap_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:
|
||||
ElementImpl(DocumentImplT* ownerDoc, const stringT& tagName) :
|
||||
ElementImpl(DocumentImplT* ownerDoc, const stringT& tagName) :
|
||||
DOMElement_implT(),
|
||||
NodeT(ownerDoc),
|
||||
attributes_(ownerDoc),
|
||||
tagName_(ownerDoc->stringPool(tagName))
|
||||
{
|
||||
{
|
||||
attributes_.setOwnerElement(this);
|
||||
} // ElementImpl
|
||||
|
||||
virtual ~ElementImpl()
|
||||
{
|
||||
virtual ~ElementImpl()
|
||||
{
|
||||
} // ~ElementImpl
|
||||
|
||||
/////////////////////////////////////////////////////
|
||||
|
|
@ -51,37 +49,20 @@ class ElementImpl : public DOM::Element_impl<stringT, string_adaptorT>,
|
|||
return attributes_.getAttribute(name);
|
||||
} // getAttribute
|
||||
|
||||
virtual void setAttribute(const stringT& name, const stringT& value)
|
||||
virtual void setAttribute(const stringT& name, const stringT& value)
|
||||
{
|
||||
this->checkName(name);
|
||||
stringT oldValue = getAttribute(name);
|
||||
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
|
||||
|
||||
virtual void removeAttribute(const stringT& name)
|
||||
virtual void removeAttribute(const stringT& name)
|
||||
{
|
||||
stringT oldValue = getAttribute(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
|
||||
|
||||
virtual DOMAttr_implT* getAttributeNode(const stringT& name) const
|
||||
virtual DOMAttr_implT* getAttributeNode(const stringT& name) const
|
||||
{
|
||||
return attributes_.getAttributeNode(name);
|
||||
} // getAttributeNode
|
||||
|
|
@ -91,52 +72,32 @@ class ElementImpl : public DOM::Element_impl<stringT, string_adaptorT>,
|
|||
return attributes_.setAttributeNode(newAttr);
|
||||
} // setAttributeNode
|
||||
|
||||
virtual DOMAttr_implT* removeAttributeNode(DOMAttr_implT* oldAttr)
|
||||
virtual DOMAttr_implT* removeAttributeNode(DOMAttr_implT* oldAttr)
|
||||
{
|
||||
return attributes_.removeAttributeNode(oldAttr);
|
||||
} // removeAttributeNode
|
||||
|
||||
virtual DOMNodeList_implT* getElementsByTagName(const stringT& tagName) const
|
||||
virtual DOMNodeList_implT* getElementsByTagName(const stringT& tagName) const
|
||||
{
|
||||
return new ElementByTagListT(NodeT::ownerDoc_,
|
||||
const_cast<ElementImpl*>(this),
|
||||
tagName);
|
||||
} // 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);
|
||||
} // 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);
|
||||
stringT oldValue = getAttribute(qualifiedName);
|
||||
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
|
||||
|
||||
virtual void removeAttributeNS(const stringT& namespaceURI, const stringT& localName)
|
||||
{
|
||||
stringT oldValue = getAttributeNS(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
|
||||
|
||||
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);
|
||||
} // getAttributeNodeNS
|
||||
|
||||
virtual DOMAttr_implT* setAttributeNodeNS(DOMAttr_implT* newAttr)
|
||||
virtual DOMAttr_implT* setAttributeNodeNS(DOMAttr_implT* newAttr)
|
||||
{
|
||||
return attributes_.setAttributeNodeNS(newAttr);
|
||||
} // 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_,
|
||||
const_cast<ElementImpl*>(this),
|
||||
namespaceURI,
|
||||
namespaceURI,
|
||||
localName);
|
||||
} // getElementsByTagNameNS
|
||||
|
||||
virtual bool hasAttribute(const stringT& name) const
|
||||
virtual bool hasAttribute(const stringT& name) const
|
||||
{
|
||||
return attributes_.hasAttribute(name);
|
||||
} // 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);
|
||||
} // hasAttributeNS
|
||||
|
|
@ -233,12 +194,12 @@ class ElementImpl : public DOM::Element_impl<stringT, string_adaptorT>,
|
|||
virtual void checkChildType(DOMNode_implT* child)
|
||||
{
|
||||
typename DOM::Node_base::Type type = child->getNodeType();
|
||||
if((type != DOM::Node_base::ELEMENT_NODE) &&
|
||||
(type != DOM::Node_base::TEXT_NODE) &&
|
||||
(type != DOM::Node_base::COMMENT_NODE) &&
|
||||
(type != DOM::Node_base::PROCESSING_INSTRUCTION_NODE) &&
|
||||
(type != DOM::Node_base::CDATA_SECTION_NODE) &&
|
||||
(type != DOM::Node_base::ENTITY_REFERENCE_NODE))
|
||||
if((type != DOM::Node_base::ELEMENT_NODE) &&
|
||||
(type != DOM::Node_base::TEXT_NODE) &&
|
||||
(type != DOM::Node_base::COMMENT_NODE) &&
|
||||
(type != DOM::Node_base::PROCESSING_INSTRUCTION_NODE) &&
|
||||
(type != DOM::Node_base::CDATA_SECTION_NODE) &&
|
||||
(type != DOM::Node_base::ENTITY_REFERENCE_NODE))
|
||||
throw DOM::DOMException(DOM::DOMException::HIERARCHY_REQUEST_ERR);
|
||||
} // checkChildType
|
||||
|
||||
|
|
@ -251,4 +212,3 @@ class ElementImpl : public DOM::Element_impl<stringT, string_adaptorT>,
|
|||
} // namespace Arabica
|
||||
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -14,12 +14,7 @@
|
|||
#include <algorithm>
|
||||
#include <map>
|
||||
|
||||
#include <DOM/Events/MutationEvent.hpp>
|
||||
#include <DOM/Simple/EventTargetImpl.hpp>
|
||||
|
||||
//#include <iostream>
|
||||
|
||||
namespace Arabica
|
||||
namespace Arabica
|
||||
{
|
||||
namespace SimpleDOM
|
||||
{
|
||||
|
|
@ -28,8 +23,7 @@ namespace SimpleDOM
|
|||
template<class stringT, class string_adaptorT> class DocumentImpl;
|
||||
|
||||
template<class stringT, class string_adaptorT>
|
||||
class NodeImpl : virtual public DOM::Node_impl<stringT, string_adaptorT>,
|
||||
virtual public EventTargetImpl<stringT, string_adaptorT>
|
||||
class NodeImpl : virtual public DOM::Node_impl<stringT, string_adaptorT>
|
||||
{
|
||||
public:
|
||||
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::NamedNodeMap_impl<stringT, string_adaptorT> DOMNamedNodeMap_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) :
|
||||
parentNode_(0),
|
||||
|
|
@ -53,9 +43,9 @@ class NodeImpl : virtual public DOM::Node_impl<stringT, string_adaptorT>,
|
|||
{
|
||||
//std::cout << std::endl << "born " << this << std::endl;
|
||||
} // NodeImpl
|
||||
|
||||
virtual ~NodeImpl()
|
||||
{
|
||||
|
||||
virtual ~NodeImpl()
|
||||
{
|
||||
//std::cout << std::endl << "die " << this << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -66,7 +56,7 @@ class NodeImpl : virtual public DOM::Node_impl<stringT, string_adaptorT>,
|
|||
if(ownerDoc_)
|
||||
ownerDoc_->addRef();
|
||||
} // addRef
|
||||
virtual void releaseRef()
|
||||
virtual void releaseRef()
|
||||
{
|
||||
if(ownerDoc_)
|
||||
ownerDoc_->releaseRef();
|
||||
|
|
@ -80,11 +70,11 @@ class NodeImpl : virtual public DOM::Node_impl<stringT, string_adaptorT>,
|
|||
virtual void setNodeValue(const stringT& /*nodeValue*/) { }
|
||||
|
||||
virtual DOM::Node_base::Type getNodeType() const = 0;
|
||||
|
||||
|
||||
virtual DOMNode_implT* getParentNode() const { return parentNode_; }
|
||||
|
||||
virtual DOMNodeList_implT* getChildNodes() const = 0;
|
||||
|
||||
|
||||
virtual DOMNode_implT* getFirstChild() 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()
|
||||
{
|
||||
DOMNode_implT*child = getFirstChild();
|
||||
DOMNode_implT*child = getFirstChild();
|
||||
while(child != 0)
|
||||
{
|
||||
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)
|
||||
{
|
||||
DOMText_implT* textNode = dynamic_cast<DOMText_implT*>(child);
|
||||
while((next != 0) &&
|
||||
while((next != 0) &&
|
||||
(next->getNodeType() == DOM::Node_base::TEXT_NODE))
|
||||
{
|
||||
textNode->appendData(next->getNodeValue());
|
||||
removeChild(next);
|
||||
next = textNode->getNextSibling();
|
||||
} // while
|
||||
} // while
|
||||
if(string_adaptorT::empty(textNode->getData()))
|
||||
removeChild(textNode);
|
||||
}
|
||||
}
|
||||
else
|
||||
child->normalize();
|
||||
|
||||
child = next;
|
||||
} // while
|
||||
} // while
|
||||
|
||||
DOMNamedNodeMap_implT* attrs = getAttributes();
|
||||
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
|
||||
// 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
|
||||
// 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
|
||||
virtual bool hasNamespaceURI() const { return false; }
|
||||
virtual bool hasNamespaceURI() const { return false; }
|
||||
virtual bool hasPrefix() 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
|
||||
|
||||
template<class stringT, class string_adaptorT>
|
||||
class ChildlessNodeImpl : public NodeImpl<stringT, string_adaptorT>
|
||||
class ChildlessNodeImpl : public NodeImpl<stringT, string_adaptorT>
|
||||
{
|
||||
public:
|
||||
typedef DocumentImpl<stringT, string_adaptorT> DocumentImplT;
|
||||
|
|
@ -256,12 +246,12 @@ class ChildlessNodeImpl : public NodeImpl<stringT, string_adaptorT>
|
|||
ChildlessNodeImpl(DocumentImplT* ownerDoc) :
|
||||
NodeImpl<stringT, string_adaptorT>(ownerDoc)
|
||||
{
|
||||
} // ChildlessNodeImpl
|
||||
} // ChildlessNodeImpl
|
||||
|
||||
///////////////////////////////////////////////////////
|
||||
// Node methods
|
||||
virtual DOMNodeList_implT* getChildNodes() const { return 0; }
|
||||
|
||||
|
||||
virtual DOMNode_implT* getFirstChild() 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 DOM::Node_impl<stringT, string_adaptorT> DOMNode_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) :
|
||||
NodeImplT(ownerDoc)
|
||||
{
|
||||
} // NodeImplWithChildren
|
||||
|
||||
virtual ~NodeImplWithChildren()
|
||||
{
|
||||
virtual ~NodeImplWithChildren()
|
||||
{
|
||||
for(typename NodeListT::iterator i = nodes_.begin(); i != nodes_.end(); ++i)
|
||||
delete (*i);
|
||||
} // ~NodeImpl
|
||||
|
|
@ -324,18 +310,18 @@ class NodeImplWithChildren : public NodeImpl<stringT, string_adaptorT>,
|
|||
{
|
||||
NodeImplT::addRef();
|
||||
} // addRef
|
||||
virtual void releaseRef()
|
||||
virtual void releaseRef()
|
||||
{
|
||||
NodeImplT::releaseRef();
|
||||
} // releaseRef
|
||||
|
||||
///////////////////////////////////////////////////////
|
||||
// Node methods
|
||||
virtual DOMNodeList_implT* getChildNodes() const
|
||||
{
|
||||
return const_cast<DOMNodeList_implT*>(static_cast<const DOMNodeList_implT*>(this));
|
||||
virtual DOMNodeList_implT* getChildNodes() const
|
||||
{
|
||||
return const_cast<DOMNodeList_implT*>(static_cast<const DOMNodeList_implT*>(this));
|
||||
} // getChildNodes
|
||||
|
||||
|
||||
virtual DOMNode_implT* getFirstChild() const
|
||||
{
|
||||
if(nodes_.size())
|
||||
|
|
@ -352,13 +338,13 @@ class NodeImplWithChildren : public NodeImpl<stringT, string_adaptorT>,
|
|||
|
||||
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));
|
||||
} // insertBefore
|
||||
|
||||
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));
|
||||
} // replaceChild
|
||||
|
||||
|
|
@ -377,8 +363,8 @@ class NodeImplWithChildren : public NodeImpl<stringT, string_adaptorT>,
|
|||
do_purgeChild(dynamic_cast<NodeImplT*>(oldChild));
|
||||
} // purgeChild
|
||||
|
||||
virtual bool hasChildNodes() const
|
||||
{
|
||||
virtual bool hasChildNodes() const
|
||||
{
|
||||
return nodes_.size() != 0;
|
||||
} // hasChildNodes
|
||||
|
||||
|
|
@ -423,14 +409,14 @@ class NodeImplWithChildren : public NodeImpl<stringT, string_adaptorT>,
|
|||
newChild->setPrev(prev);
|
||||
newChild->setNext(refChild);
|
||||
refChild->setPrev(newChild);
|
||||
}
|
||||
else
|
||||
}
|
||||
else
|
||||
{
|
||||
if(!nodes_.empty())
|
||||
{
|
||||
(*nodes_.rbegin())->setNext(newChild);
|
||||
newChild->setPrev(*nodes_.rbegin());
|
||||
} //
|
||||
} //
|
||||
nodes_.push_back(newChild);
|
||||
}
|
||||
|
||||
|
|
@ -438,19 +424,6 @@ class NodeImplWithChildren : public NodeImpl<stringT, string_adaptorT>,
|
|||
|
||||
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;
|
||||
} // insertBefore
|
||||
|
||||
|
|
@ -488,19 +461,6 @@ class NodeImplWithChildren : public NodeImpl<stringT, string_adaptorT>,
|
|||
|
||||
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;
|
||||
} // replaceChild
|
||||
|
||||
|
|
@ -508,19 +468,6 @@ class NodeImplWithChildren : public NodeImpl<stringT, string_adaptorT>,
|
|||
{
|
||||
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));
|
||||
|
||||
NodeImplT* prev = oldChild->getPrev();
|
||||
|
|
@ -574,9 +521,9 @@ class NodeImplWithChildren : public NodeImpl<stringT, string_adaptorT>,
|
|||
{
|
||||
child->setOwnerDoc(NodeImplT::getOwnerDoc());
|
||||
return;
|
||||
} //
|
||||
} //
|
||||
|
||||
if(child->getNodeType() == DOM::Node_base::DOCUMENT_NODE)
|
||||
if(child->getNodeType() == DOM::Node_base::DOCUMENT_NODE)
|
||||
{
|
||||
if(childDoc != dynamic_cast<DocumentImplT*>(this))
|
||||
throw DOM::DOMException(DOM::DOMException::WRONG_DOCUMENT_ERR);
|
||||
|
|
|
|||
7851
m4/libtool.m4
vendored
7851
m4/libtool.m4
vendored
File diff suppressed because it is too large
Load diff
369
m4/ltoptions.m4
vendored
369
m4/ltoptions.m4
vendored
|
|
@ -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
123
m4/ltsugar.m4
vendored
|
|
@ -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
23
m4/ltversion.m4
vendored
|
|
@ -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
1
missing
|
|
@ -1 +0,0 @@
|
|||
/usr/share/automake-1.11/missing
|
||||
Loading…
Reference in a new issue